1var Alpaca; 2(function (Alpaca) { 3 var Forms2; 4 (function (Forms2) { 5 var _a; 6 (() => { 7 var functionName = "CustomEvent"; 8 if (typeof window[functionName] === "function") 9 return; 10 function customEvent(event, params) { 11 params = params || { bubbles: false, cancelable: false, detail: null }; 12 var evt = document.createEvent("CustomEvent"); 13 evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail); 14 return evt; 15 } 16 window[functionName] = customEvent; 17 })(); 18 function show(node) { 19 if (!node) 20 return; 21 node.style.display = "block"; 22 } 23 function hide(node) { 24 if (!node) 25 return; 26 node.style.display = "none"; 27 } 28 function undoHide(node) { 29 if (!node) 30 return; 31 node.style.removeProperty("display"); 32 } 33 function isVisible(node) { 34 if (!node) 35 return false; 36 let hidden = node.style.display === "none"; 37 if (hidden) 38 return false; 39 let parent = node.parentElement; 40 if (parent) { 41 return isVisible(parent); 42 } 43 return true; 44 } 45 function forEach(list, callback) { 46 Array.prototype.forEach.call(list, callback); 47 } 48 function closest(node, pattern) { 49 return node.closest(pattern); 50 } 51 const Pages = (selector, parent) => { 52 const getPages = () => Array.from(parent.querySelectorAll(selector)); 53 let currentPage = 0; 54 return { 55 current: () => getPages()[currentPage], 56 next: () => getPages()[++currentPage], 57 prev: () => getPages()[--currentPage], 58 }; 59 }; 60 class FormInstance { 61 init(form) { 62 this.validateFieldPipeline = []; 63 } 64 } 65 Forms2.FormInstance = FormInstance; 66 class Form { 67 constructor() { 68 this.fieldTypes = []; 69 this.customDataHandlers = []; 70 } 71 init() { 72 this.getFieldValuePipeline = []; 73 this.validateFieldPipeline = []; 74 this.setupFieldPipeline = []; 75 this.scrollElementIntoViewFunction = []; 76 this.scrollToNewForm = false; 77 this.formInstances = {}; 78 this.ruleConditionFunctions = {}; 79 this.ruleActionPrepareFunctions = {}; 80 this.ruleActionExecuteFunctions = {}; 81 } 82 scrollIntoView() { 83 var formElement = document.querySelector(".alpaca-form"); 84 var successMessage = formElement.querySelector(".success-message"); 85 var firstError = formElement.querySelector('.error'); 86 var page = formElement.querySelector('.page'); 87 88 if (successMessage) { 89 this.scrollElementIntoView(successMessage, false); 90 } else if (firstError) { 91 if (page) { 92 page.classList.remove('active'); 93 firstError.closest('.page').classList.add('active'); 94 } else { 95 this.scrollElementIntoView(firstError, false); 96 } 97 } else if(this.scrollToNewForm) { 98 console.log("scrollToNewForm", this.scrollToNewForm); 99 document.dispatchEvent(new CustomEvent("alpaca:forms:scrollToNewForm", { detail: { formElement: formElement } })); 100 this.scrollToNewForm = false; 101 } 102 } 103 scrollElementIntoView(element, smooth) { 104 var args = { 105 element: element, 106 smooth: smooth 107 }; 108 this.scrollElementIntoViewFunction(args); 109 } 110 switchToPage(page) { 111 var args = { 112 nextPage: page 113 }; 114 var activePage = args.nextPage.id; 115 args.nextPage.closest('.pages').dataset.activePageId = activePage; 116 this.switchToPageFunction(args); 117 } 118 getActivePage(form) { 119 var pages = form.querySelector('.pages'); 120 if (!pages) 121 return; 122 const activePageId = pages.dataset["activePageId"]; 123 return document.getElementById(activePageId); 124 } 125 getValidators(form) { 126 let data = form.dataset["validators"]; 127 if (!data) 128 return []; 129 return JSON.parse(data); 130 } 131 getRules(form) { 132 let data = form.dataset["rules"]; 133 if (!data) 134 return []; 135 return JSON.parse(data); 136 } 137 getFormInstance(id) { 138 if ((id instanceof String)) { 139 return this.formInstances[String(id)]; 140 } 141 else { 142 return this.formInstances[id.id]; 143 } 144 } 145 pushToGoogleAnalytics(customData) { 146 var dataLayer = window["dataLayer"]; 147 if (!!dataLayer) { 148 if (!!customData && !!customData.ga) { 149 var ga = customData.ga; 150 for (var i = 0; i < ga.length; i++) { 151 dataLayer.push(ga[i]); 152 } 153 return true; 154 } 155 } 156 return false; 157 } 158 async triggerCustomData(customData, formNode) { 159 if (!customData) 160 return; 161 let args = { 162 form: this, 163 formNode: formNode, 164 customData: null, 165 }; 166 for (var i = 0; i < this.customDataHandlers.length; i++) { 167 let handlerEntry = this.customDataHandlers[i]; 168 let propertyName = handlerEntry.propertyName; 169 let property = customData[propertyName]; 170 if (property) { 171 args.customData = property; 172 try { 173 await handlerEntry.handler(args); 174 } catch (ex) { 175 console.log(ex); 176 } 177 } 178 } 179 } 180 submitFormByAjax(formData, formNode, ajaxUrl, resetStatusAction) { 181 formData.append(formNode.id + 'AlpacaPageUrl', window.location.href); 182 this.scrollToNewForm = true; 183 184 let args = { 185 form: this, 186 ajaxUrl: ajaxUrl, 187 formData: formData, 188 formNode: formNode, 189 resetStatusAction: resetStatusAction 190 }; 191 let wturl = formNode.dataset["wturl"]; 192 if (wturl) { 193 let url = wturl + "?fid=" + formNode.id + "&domain=" + window.location.hostname; 194 let xhr = new XMLHttpRequest(); 195 xhr.onload = () => { 196 if (xhr.status >= 200 && xhr.status < 300) { 197 this.loadAjaxFunction(args); 198 } 199 else { 200 console.log('The request failed!'); 201 } 202 }; 203 xhr.open('POST', url, true); 204 xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8'); 205 xhr.send(formData); 206 } 207 else { 208 this.loadAjaxFunction(args); 209 } 210 } 211 validateForm(form, focus, element) { 212 var targets = element ? element.querySelectorAll('.field') : form.querySelectorAll('.field');
213 var validators = this.getValidators(form); 214 var summaryMessages = []; 215 var serverSideErrorMessages = []; 216 var summaryMessageContainer = form.querySelector('.validation-summary'); 217 var summaryMessageList = form.querySelector('.validation-summary-list'); 218 if (summaryMessageList) { 219 forEach(summaryMessageList.querySelectorAll("li.server-side-error"), (li) => { 220 serverSideErrorMessages.push(li.innerHTML); 221 }); 222 } 223 var isValid = true; 224 forEach(targets, (z) => { 225 if (!isVisible(z)) 226 return; 227 if (!focus || (z.classList.contains('error') || focus.id === z.id)) { 228 if (!this.validate(z, form, validators, summaryMessages)) { 229 isValid = false; 230 } 231 } 232 }); 233 this.updateRules(form, focus); 234 if (summaryMessages.length > 0 || serverSideErrorMessages.length > 0) { 235 summaryMessageList.innerHTML = this.formatServerSideErrorMessagesElements(serverSideErrorMessages) + this.formatErrorMessagesElements(summaryMessages); 236 show(summaryMessageContainer); 237 } 238 else { 239 hide(summaryMessageContainer); 240 } 241 document.dispatchEvent(new CustomEvent("alpaca:forms:form-validated", { detail: { form: form, isValid: isValid } })); 242 if (isValid) { 243 let formCustomData = form.dataset["custom"] ? JSON.parse(form.dataset["custom"]) : {}; 244 if (formCustomData.autoSubmit && !form.classList.contains("autosubmitted") && !!focus) { 245 if (this.validateForm(form, null)) { 246 var ajaxUrl = formCustomData.autoSubmit; 247 form.classList.add("autosubmitted"); // only submit once 248 console.log("submit"); 249 250 const resetStatusAction = () => { 251 form.classList.remove("autosubmitted"); 252 } 253 254 let formData = new FormData(form); 255 formData.append(formCustomData.autoSubmitKey, formCustomData.autoSubmitValue); 256 this.submitFormByAjax(formData, form, ajaxUrl, resetStatusAction); 257 } 258 } 259 } 260 return isValid; 261 } 262 getFieldValidatorsIds(field) { 263 var _a; 264 return ((_a = field.dataset["validators"]) === null || _a === void 0 ? void 0 : _a.split(' ').filter(f => f !== '')) || []; 265 } 266 validate(target, formNode, validators, summaryMessages) { 267 var id = target.id; 268 var value = this.getFieldValue(id); 269 let validatorIds = this.getFieldValidatorsIds(target); 270 var errorMessages = []; 271 var infoMessages = []; 272 for (var v of validatorIds) { 273 let args = { 274 form: this, 275 validator: validators.filter(f => f.Id == v)[0], 276 value: value, 277 fieldId: id, 278 errorMessages: errorMessages, 279 summaryMessages: summaryMessages, 280 infoMessages: infoMessages, 281 abort: false 282 }; 283 if (args.validator) { 284 this.runPipeline(this.validateFieldPipeline, args); 285 } 286 } 287 this.checkRecaptcha(target, errorMessages); 288 this.appendMessages(target, infoMessages, errorMessages); 289 let hasErrors = errorMessages.length > 0;
290 this.markFieldWithValidationError(target, hasErrors); 291 return !hasErrors; 292 } 293 updateRules(form, focus) { 294 var rules = this.getRules(form); 295 if (!rules) 296 return; 297 for (var i = 0; i < rules.length; i++) { 298 this.prepareRule(rules[i], form, focus); 299 } 300 for (var i = 0; i < rules.length; i++) { 301 this.updateRule(rules[i], form, focus); 302 } 303 } 304 compare(comp, value1, value2) { 305 var v1 = value1.toLowerCase(); 306 var v2 = value2.toLowerCase(); 307 switch (comp) { 308 case "Equals": 309 return value1 === value2; 310 case "CaseInsensitivelyEquals": 311 return v1 === v2; 312 case "NotEqual": 313 return value1 !== value2; 314 case "NotCaseInsensitivelyEquals": 315 return v1 !== v2; 316 case "Contains": 317 return v1.indexOf(v2) >= 0; 318 case "MatchesRegularExpression": 319 return new RegExp(value2, "i").test(value1); 320 case "StartsWith": 321 return v1.substring(0, v2.length) === v2; 322 case "EndsWith": 323 return v1.substring(v1.length - v2.length, v1.length) === v2; 324 default: 325 return false; 326 } 327 } 328 checkCondition(condition, formNode) { 329 var type = condition.Type; 330 if (type === "true") 331 return true;
332 if (type === "false") 333 return false; 334 if (type === "and") 335 return this.checkCondition(condition.Left, formNode) && this.checkCondition(condition.Right, formNode); 336 if (type === "or") 337 return this.checkCondition(condition.Left, formNode) || this.checkCondition(condition.Right, formNode); 338 if (type === "not") 339 return !this.checkCondition(condition.Operand, formNode); 340 var ruleConditionFunction = this.ruleConditionFunctions[type]; 341 if (ruleConditionFunction) { 342 var args = { condition: condition, form: this, formNode: formNode }; 343 return ruleConditionFunction(args); 344 } 345 return false; 346 } 347 prepareAction(action, formNode) { 348 var type = action.Type; 349 var ruleActionPrepareFunction = this.ruleActionPrepareFunctions[type]; 350 if (ruleActionPrepareFunction) { 351 var args = { action: action, form: this, formNode: formNode }; 352 ruleActionPrepareFunction(args); 353 } 354 } 355 executeAction(action, formNode) { 356 var type = action.Type; 357 var ruleActionExecuteFunction = this.ruleActionExecuteFunctions[type]; 358 if (ruleActionExecuteFunction) { 359 var args = { action: action, form: this, formNode: formNode }; 360 ruleActionExecuteFunction(args); 361 } 362 } 363 prepareRule(rule, form, focus) { 364 for (var i = 0; i < rule.Actions.length; i++) { 365 this.prepareAction(rule.Actions[i], form); 366 } 367 } 368 updateRule(rule, form, focus) { 369 if (this.checkCondition(rule.Condition, form)) { 370 for (var i = 0; i < rule.Actions.length; i++) { 371 this.executeAction(rule.Actions[i], form); 372 } 373 } 374 } 375 checkRecaptcha(target, errorMessages) { 376 if (target.classList.contains('google-recaptcha')) { 377 var recaptchaResponse = (target.querySelector('.g-recaptcha-response')), recaptchaSelector = document.querySelector('.google-recaptcha'), errorMessage = recaptchaSelector.dataset['required']; 378 if (!recaptchaResponse || recaptchaResponse.value.length === 0) { 379 errorMessages.push(errorMessage); 380 } 381 } 382 } 383 getFieldValue(id) { 384 if (!id) { 385 return null; 386 } 387 var element = document.querySelector('#' + id) 388 if (!element) 389 throw new Error("Field '" + id + "' does not exist in the form"); 390 var args = { 391 id: id, 392 value: null, 393 elem: element, 394 abort: false 395 }; 396 this.runPipeline(this.getFieldValuePipeline, args); 397 return args.value; 398 } 399 appendMessages(target, infoMessages, errorMessages) { 400 var validationMessageContainer = document.getElementById("validation-" + target.id.substr(6)); 401 if (!validationMessageContainer) 402 validationMessageContainer = document.getElementById("validation"); // todo this doesn't make sense 403 if (validationMessageContainer) 404 validationMessageContainer.innerHTML = this.formatValidationMessages(infoMessages, errorMessages); 405 } 406 runPipeline(pipeline, args) { 407 for (let processor of pipeline) { 408 processor(args); 409 if (args.abort) 410 break; 411 } 412 } 413 getUniqueMessages(messages) { 414 var uniqueMessages = []; 415 var n = {}; 416 for (var i = 0; i < messages.length; i++) { 417 var msg = messages[i]; 418 if (msg.length > 0 && !n[msg]) { 419 n[msg] = true; 420 uniqueMessages.push(msg); 421 } 422 } 423 return uniqueMessages; 424 } 425 formatServerSideErrorMessagesElements(messages) { 426 var uniqueMessages = this.getUniqueMessages(messages); 427 return uniqueMessages.map(x => `<li class="error server-side-error">${x}</li>`).join(""); 428 } 429 formatErrorMessagesElements(messages) { 430 var uniqueMessages = this.getUniqueMessages(messages); 431 return uniqueMessages.map(x => `<li class="error">${x}</li>`).join(""); 432 } 433 formatInfoMessagesElements(messages) { 434 var uniqueMessages = this.getUniqueMessages(messages); 435 return uniqueMessages.map(x => `<li class="info">${x}</li>`).join(""); 436 } 437 formatValidationMessages(infoMessages, errorMessages) { 438 var list = this.formatInfoMessagesElements(infoMessages) + this.formatErrorMessagesElements(errorMessages); 439 if (list.length === 0) 440 return ""; 441 return "<ul>
441" + list + "</ul>"; 442 } 443 markFieldWithValidationError(field, hasErrors) { 444 if (hasErrors) { 445 field.classList.add("error"); 446 field.classList.remove("valid"); 447 448 const fieldInput = field.querySelector("input:not([type=hidden]), select, textarea"); 449 fieldInput && fieldInput.setAttribute("aria-invalid", "true"); 450 } 451 else { 452 field.classList.add("valid"); 453 field.classList.remove("error"); 454 455 const fieldInput = field.querySelector("input:not([type=hidden]), select, textarea"); 456 fieldInput && fieldInput.removeAttribute("aria-invalid"); 457 } 458 } 459 /* 460 * selector must match the "field" element 461 * todo more help here 462 */ 463 registerFieldType(selector, handlers) { 464 this.fieldTypes.push({ selector: selector, handlers: handlers }); 465 } 466 registerCustomDataHandler(propertyName, handler) { 467 this.customDataHandlers.push({ propertyName: propertyName, handler: handler }); 468 } 469 } 470 Forms2.Form = Form; 471 class RadioField { 472 init(form) { 473 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 474 } 475 getFieldValue(args) { 476 let id = args.id.substring("field_".length); 477 let field = args.elem; 478 if (field.querySelectorAll("input[name='" + id + "'][type='radio']").length > 0) { 479 var radioField = field.querySelector("input[name='" + id + "']:checked"); 480 if (radioField) { 481 args.value = radioField.value; 482 } 483 args.abort = true; 484 } 485 } 486 } 487 Forms2.RadioField = RadioField; 488 class MultiselectionField { 489 init(form) { 490 form.registerFieldType('.field.multiselection', { 491 getFieldValue: args => this.getFieldValue(args) 492 }); 493 } 494 getFieldValue(args) { 495 const selectedCheckboxes = args.fieldNode.querySelectorAll("input[type='checkbox']:checked"); 496 const selectedValues = []; 497 for (let index = 0; index < selectedCheckboxes.length; ++index) { 498 selectedValues.push(selectedCheckboxes[index].value); 499 } 500 if (selectedValues.length > 0) { 501 return JSON.stringify(selectedValues); 502 } 503 } 504 } 505 Forms2.MultiselectionField = MultiselectionField; 506 class CheckboxField { 507 init(form) { 508 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 509 } 510 getFieldValue(args) { 511 let id = args.id.substring("field_".length); 512 var el = document.getElementById(id); 513 if (el && el.type === "checkbox") { 514 args.value = el.checked; 515 args.abort = true; 516 } 517 } 518 } 519 Forms2.CheckboxField = CheckboxField; 520 class DateField { 521 init(form) { 522 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 523 } 524 getFieldValue(args) { 525 let id = args.id.substring("field_".length); 526 var el = args.elem.querySelector("select[name='" + id + "_d']"); 527 if (el) { 528 var d = el.value; 529 var m = args.elem.querySelector("select[name='" + id + "_m']").value; 530 var y = args.elem.querySelector("select[name='" + id + "_y']").value; 531 //var date = Date.parse(jQuery('input', args.elem).val()); 532 if (d && m && y) 533 args.value = new Date(y + "-" + m + "-" + d); 534 args.abort = true; 535 } 536 } 537 } 538 Forms2.DateField = DateField; 539 class DatePickerField { 540 init(form) { 541 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 542 } 543 getFieldValue(args) { 544 let id = args.id.substring("field_".length); 545 var el = args.elem.querySelector("input[type='date'][name='" + id + "']"); 546 if (el) { 547 args.value = el.value ? new Date(el.value) : null; 548 args.abort = true; 549 } 550 } 551 } 552 Forms2.DatePickerField = DatePickerField; 553 class DropdownField { 554 init(form) { 555 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 556 } 557 getFieldValue(args) { 558 let id = args.id.substring("field_".length); 559 var el = args.elem.querySelector("select[name='" + id + "']"); 560 if (el) { 561 args.value = el.value; 562 args.abort = true; 563 } 564 } 565 } 566 Forms2.DropdownField = DropdownField; 567 class GenericField { 568 init(form) { 569 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 570 } 571 getFieldValue(args) { 572 var input = args.elem.querySelector('input'); 573 if (input) { 574 args.value = input.value; 575 } 576 } 577 } 578 Forms2.GenericField = GenericField; 579 class Textarea { 580 init(form) { 581 form.getFieldValuePipeline.push(args => this.getFieldValue(args)); 582 } 583 getFieldValue(args) { 584 var textarea = args.elem.querySelector('textarea'); 585 if (textarea) { 586 args.value = textarea.value; // todo checken 587 args.abort = true; 588 } 589 } 590 } 591 Forms2.Textarea = Textarea; 592 class HiddenField { 593 init(form) { 594 form.registerFieldType('.field.hidden-field', { 595 getFieldValue: args => this.getFieldValue(args) 596 }); 597 } 598 getFieldValue(args) { 599 return args.fieldNode.value; 600 } 601 } 602 Forms2.HiddenField = HiddenField; 603 class FileUpload { 604 init(form) { 605 form.registerFieldType('.field.file-upload', { 606 getFieldValue: args => this.getFieldValue(args), 607 setupField: args => this.setupField(args) 608 }); 609 } 610 setupField(args) { 611 var instance = new FileUpload.FieldInstance(); 612 instance.init(args.global, args.fieldNode); 613 } 614 getFieldValue(args) { 615 var files = args.fieldNode.querySelectorAll(".alpaca-file-container"); 616 if (files.length > 0) { 617 var values = [];
618 forEach(files, e => { 619 var input = e.querySelector('input[type="file"]'); 620 if (input.value) { 621 let file = input.files[0]; 622 values.push({ 623 name: file.name, 624 size: file.size 625 }); 626 } 627 }); 628 return values; 629 } 630 } 631 } 632 FileUpload.FieldInstance = (_a = class FieldInstance { 633 constructor() { 634 this.fileInputContainerSelector = ".alpaca-file-container"; 635 } 636 init(form, fieldElement) { 637 this.fieldElement = fieldElement; 638 this.form = form; 639 let fileInput = fieldElement.querySelector(this.fileInputContainerSelector); 640 this.fileInputShadowCopy = fileInput.cloneNode(true); 641 let fileInstance = new FieldInstance.FileInstance(this, fileInput); 642 this.filesContainerElement = fieldElement.querySelector(".alpaca-files-container"); 643 this.maxNumberOfFiles = parseInt(this.filesContainerElement.dataset["maximumNumberOfFiles"]); 644 fileInstance.bindEvents(); 645 } 646 validate() { 647 this.form.validateForm(closest(this.fieldElement, ".alpaca-form"), this.fieldElement); 648 } 649 ensureEmptyFileInput() { 650 let containers = this.fieldElement.querySelectorAll(this.fileInputContainerSelector); 651 var lastHasFile = containers.length == 0 || 652 new FieldInstance.FileInstance(this, containers[containers.length - 1]).hasFile(); 653 if (lastHasFile && containers.length < this.maxNumberOfFiles) { 654 let clone = this.fileInputShadowCopy.cloneNode(true); 655 this.filesContainerElement.appendChild(clone); 656 let newInstance = new FieldInstance.FileInstance(this, clone); 657 newInstance.bindEvents(); 658 } 659 } 660 }, 661 _a.FileInstance = class FileInstance { 662 constructor(fileUpload, containerElement) { 663 this.fileUpload = fileUpload; 664 this.containerElement = containerElement; 665 this.input = containerElement.querySelector("input[type='file']"); 666 this.displayText = containerElement.querySelector("input[type='text']"); 667 this.fileSizeText = containerElement.querySelector(".file-size"); 668 this.browseButton = containerElement.querySelector(".alpaca-browse-file-button"); 669 this.clearFile = containerElement.querySelector(".alpaca-remove-file"); 670 } 671 bindEvents() { 672 this.input.addEventListener("change", event => this.onChange(event)); 673 this.browseButton.addEventListener("click", event => this.openDialog(event)); 674 this.clearFile.addEventListener("click", event => this.onRemove(event)); 675 } 676 onChange(event) { 677 if (!this.hasFile()) { 678 this.remove(); 679 return; 680 } 681 show(this.clearFile); 682 this.setDisplayName(this.getFileName()); 683 this.setFileSize(this.getFileSize()); 684 this.fileUpload.ensureEmptyFileInput(); 685 this.fileUpload.validate(); 686 } 687 remove() { 688 this.containerElement.remove(); 689 this.fileUpload.ensureEmptyFileInput(); 690 this.fileUpload.validate(); 691 } 692 getFileName() { 693 let file = this.input.files[0]; 694 if (!file) 695 return ""; 696 return file.name; 697 } 698 getFileSize() { 699 let file = this.input.files[0]; 700 if (!file) 701 return ""; 702 let fileSizeInBytes = file.size; 703 let i = -1; 704 let byteUnits = [' kB', ' MB', ' GB', ' TB', 'PB', 'EB', 'ZB', 'YB']; 705 do { 706 fileSizeInBytes = fileSizeInBytes / 1024; 707 i++; 708 } while (fileSizeInBytes > 1024); 709 return Math.max(fileSizeInBytes, 0.1).toFixed(1) + byteUnits[i]; 710 } 711 setDisplayName(name) { 712 this.displayText.value = name; 713 } 714 setFileSize(size) { 715 var element = this.fileSizeText; 716 if (!element) 717 return element; 718 element.innerText = size; 719 } 720 hasFile() { 721 return !!this.getFileName(); 722 } 723 openDialog(event) { 724 event.preventDefault(); 725 this.input.click(); 726 } 727 onRemove(event) { 728 event.preventDefault(); 729 this.remove(); 730 } 731 }, 732 _a); 733 Forms2.FileUpload = FileUpload; 734 class FieldValidator { 735 addErrorMessages(args) { 736 args.errorMessages.push(args.validator.ErrorMessage); 737 args.summaryMessages.push(args.validator.SummaryMessage); 738 } 739 addCustomErrorMessages(args, errorMessage, summaryMessage) { 740 args.errorMessages.push(errorMessage); 741 args.summaryMessages.push(summaryMessage); 742 } 743 addInfoMessages(args, message) { 744 args.infoMessages.push(message); 745 } 746 } 747 Forms2.FieldValidator = FieldValidator; 748 class RequiredValidator extends FieldValidator { 749 init(form) { 750 form.validateFieldPipeline.push(args => this.validate(args)); 751 } 752 validate(args) { 753 if (args.validator.Type === "Required" && (!args.value || (Array.isArray(args.value) && args.value.length === 0))) { 754 super.addErrorMessages(args); 755 } 756 } 757 } 758 Forms2.RequiredValidator = RequiredValidator; 759 class RegexValidator extends FieldValidator { 760 init(form) { 761 form.validateFieldPipeline.push(args => this.validate(args)); 762 } 763 validate(args) { 764 if (args.validator.Type === "Regex") { 765 if (args.value && !(new RegExp(args.validator.Regex, args.validator.IsCaseSensitive ? "" : "i").test(args.value))) 766 super.addErrorMessages(args); 767 } 768 } 769 } 770 Forms2.RegexValidator = RegexValidator; 771 class MinimumAgeValidator extends FieldValidator { 772 init(form) { 773 form.validateFieldPipeline.push(args => this.validate(args)); 774 } 775 validate(args) { 776 if (args.validator.Type === "MinimumAge") { 777 var date = args.value; 778 if (date && date instanceof Date) { 779 var maximumDate = new Date(); 780 maximumDate.setFullYear(maximumDate.getFullYear() - args.validator.MinimumAge); 781 if (maximumDate.getTime() < date.getTime()) 782 super.addErrorMessages(args); 783 } 784 } 785 } 786 } 787 Forms2.MinimumAgeValidator = MinimumAgeValidator; 788 class TextLengthValidator extends FieldValidator { 789 init(form) { 790 form.validateFieldPipeline.push(args => this.validate(args)); 791 form.setupFieldPipeline.push(args => this.setup(args)); 792 } 793 validate(args) { 794 if (args.validator.Type === "TextLength") { 795 let length = args.value ? args.value.length : 0; 796 if (length < args.validator.MinimumLength || length > args.validator.MaximumLength) { 797 args.errorMessages.push(this.replace(args.validator.ErrorMessage, args
797)); 798 args.summaryMessages.push(this.replace(args.validator.SummaryMessage, args)); 799 } 800 else { 801 super.addInfoMessages(args, this.replace(args.validator.PreviewText, args)); 802 } 803 } 804 } 805 setup(args) { 806 if (args.validator.Type === "TextLength") { 807 var field = document.querySelector('#' + args.fieldId), lastExec = 0, timeoutId = null, delay = 300; 808 args.value = args.form.getFieldValue(args.fieldId); 809 args.form.appendMessages(field, [this.replace(args.validator.PreviewText, args)], []); 810 let eventHandler = () => { 811 var elapsed = +new Date() - lastExec; 812 if (timeoutId) 813 clearTimeout(timeoutId); 814 if (elapsed < delay) { 815 timeoutId = setTimeout(() => { 816 lastExec = +new Date(); 817 args.form.validateForm(closest(field, ".alpaca-form"), field); 818 }, delay); 819 } 820 else { 821 lastExec = +new Date(); 822 args.form.validateForm(closest(field, ".alpaca-form"), field); 823 } 824 }; 825 var inputField = field.querySelector("input,textarea"); 826 inputField.addEventListener('input', eventHandler); 827 inputField.addEventListener('propertychange', eventHandler); 828 inputField.addEventListener('paste', eventHandler); 829 } 830 } 831 replace(str, args) { 832 var length = args.value ? args.value.length : 0, 833 minLength = args.validator.MinimumLength, 834 maxLength = args.validator.MaximumLength; 835 return str 836 .replace("[[chars]]", length) 837 .replace("[[chars-max]]", maxLength) 838 .replace("[[chars-min]]", minLength) 839 .replace("[[chars-remaining]]", maxLength - length) 840 .replace("[[chars-needed]]", length - minLength) 841 .replace("[[chars-above-max]]", length - maxLength) 842 .replace("[[chars-below-min]]", minLength - length); 843 } 844 } 845 Forms2.TextLengthValidator = TextLengthValidator; 846 class FileSizeValidator extends FieldValidator { 847 init(form) { 848 form.validateFieldPipeline.push(args => this.validate(args)); 849 } 850 validate(args) { 851 if (args.validator.Type === "FileSize") { 852 var maximumSize = args.validator.SizeLimit; 853 var forAllFilesTogether = args.validator.ForAllFilesTogether; 854 var files = args.value; 855 if (!files) 856 return; 857 858 if (forAllFilesTogether) { 859 // Validate total combined size of all files 860 let totalSize = 0; 861 for (var i = 0; i < files.length; ++i) { 862 totalSize += files[i].size; 863 } 864 if (totalSize <= maximumSize) { 865 let text = args.validator.FileSizePreviewMessage; 866 super.addInfoMessages(args, this.formatText(text, totalSize, maximumSize)); 867 } 868 else { 869 super.addCustomErrorMessages(args, this.formatText(args.validator.ErrorMessage, totalSize, maximumSize), this.formatText(args.validator.SummaryMessage, totalSize, maximumSize)); 870 } 871 } 872 else { 873 // Validate each file individually against the size limit 874 for (var i = 0; i < files.length; ++i) { 875 if (files[i].size > maximumSize) { 876 super.addCustomErrorMessages(args, 877 this.formatText(args.validator.ErrorMessage, files[i].size, maximumSize), 878 this.formatText(args.validator.SummaryMessage, files[i].size, maximumSize)); 879 return; 880 } 881 } 882 } 883 } 884 } 885 roundUp(size) { 886 return Math.ceil(size / 1024 / 1024 * 100) / 100; 887 } 888 round(size) { 889 return Math.round(size / 1024 / 1024 * 100) / 100; 890 } 891 formatText(text, size, maxSize) { 892 return text 893 .replace("[[currentSize]]", "<span class='total-size'>" + this.roundUp(size) + "</span>") 894 .replace("[[maximumAllowedSize]]", "<span class='allowed-size'>" + this.round(maxSize) + "</span>"); 895 } 896 } 897 Forms2.FileSizeValidator = FileSizeValidator; 898 class FileNameValidator extends FieldValidator { 899 init(form) { 900 form.validateFieldPipeline.push(args => this.validate(args)); 901 } 902 validate(args) { 903 if (args.validator.Type === "FileName") { 904 let value = args.value; 905 if (value) { 906 for (let i = 0; i < value.length; i++) { 907 if (!new RegExp(args.validator.Regex, "i").test(value[i].name)) { 908 super.addErrorMessages(args); 909 break; 910 } 911 } 912 } 913 } 914 } 915 } 916 Forms2.FileNameValidator = FileNameValidator; 917 class EqualsOtherFieldValidator extends FieldValidator { 918 init(form) { 919 form.validateFieldPipeline.push(args => this.validate(args)); 920 } 921 validate(args) { 922 if (args.validator.Type === "EqualsOtherField") { 923 let value = args.form.getFieldValue("field_" + args.validator.ReferenceField); 924 if (args.value != value) 925 super.addErrorMessages(args); 926 } 927 } 928 } 929 Forms2.EqualsOtherFieldValidator = EqualsOtherFieldValidator; 930 class NotEqualsOtherFieldValidator extends FieldValidator { 931 init(form) { 932 form.validateFieldPipeline.push(args => this.validate(args)); 933 } 934 validate(args) { 935 if (args.validator.Type === "NotEqualsOtherField") { 936 let value = args.form.getFieldValue("field_" + args.validator.ReferenceField); 937 if (args.value == value) 938 super.addErrorMessages(args); 939 } 940 } 941 } 942 Forms2.NotEqualsOtherFieldValidator = NotEqualsOtherFieldValidator; 943 class FormScrolling { 944 init(form) { 945 form.scrollElementIntoViewFunction = this.scroll; 946 } 947 scroll(args) { 948 if (args.smooth) { 949 args.element.scrollIntoView({ behavior: "smooth" }); 950 } 951 else { 952 args.element.scrollIntoView(); 953 } 954 } 955 } 956 Forms2.FormScrolling = FormScrolling; 957 class SwitchToPage { 958 init(form) { 959 form.switchToPageFunction = this.switch; 960 } 961 switch(args) { 962 const pages = args.nextPage.parentNode.querySelectorAll('.page');
963 pages.forEach(function (page) { 964 page.style.display = "none"; 965 }); 966 args.nextPage.style.display = "block"; 967 } 968 } 969 Forms2.SwitchToPage = SwitchToPage; 970 class AjaxLoader { 971 init(form) { 972 form.loadAjaxFunction = this.load; 973 form.handleXmlHttpRequestOnload = this.processXmlHttpRequestResponse; 974 } 975 load(args) { 976 let xhr = new XMLHttpRequest(); 977 xhr.onload = async () => { 978 args.form.handleXmlHttpRequestOnload(args, xhr); 979 }; 980 xhr.open('POST', args.ajaxUrl, true); 981 xhr.send(args.formData); 982 } 983 async processXmlHttpRequestResponse(args, xhr) { 984 let formNode = args.formNode; 985 function setNewFormContent(content) { 986 var parent = formNode.parentElement; 987 parent.innerHTML = content; 988 parent.querySelectorAll('script').forEach(function(script) { 989 var newScript = document.createElement('script'); 990 if (script.src) newScript.src = script.src; 991 else newScript.textContent = script.textContent; 992 document.body.appendChild(newScript); 993 }); 994 // reinit(parent.querySelector(".alpaca-form")); 995 } 996 function executeAction(result) { 997 let counter = 0; 998 return () => { 999 if (counter === 0) { 1000 counter++; 1001 if (result.type === "redirect") 1002 document.location.href = result.url; 1003 else if (result.type === "reloadpage") 1004 document.location.reload(); 1005 } 1006 }; 1007 } 1008 if (xhr.status >= 200 && xhr.status < 300) { 1009 var response = xhr.responseText; 1010 if (response.charAt(0) === "{") { 1011 try { 1012 var result = JSON.parse(response); 1013 document.dispatchEvent(new CustomEvent("alpaca:forms:submitted", { detail: { customData: result } })); 1014 await args.form.triggerCustomData(result.customData, formNode); 1015 if (result.type === "redirect" || result.type === "reloadpage") { 1016 const execActionSingletone = executeAction(result); 1017 if (args.form.pushToGoogleAnalytics(result.customData)) { 1018 window["dataLayer"].push(execActionSingletone); 1019 return; 1020 } 1021 else { 1022 execActionSingletone(); 1023 return; 1024 } 1025 } 1026 if (result.type === "loadform") { 1027 args.form.pushToGoogleAnalytics(result.customData); 1028 setNewFormContent(result.form); 1029 return; 1030 } 1031 if (result.type === "stayoncurrentpage") { 1032 if (args.resetStatusAction) { 1033 args.resetStatusAction(); 1034 } 1035 return; 1036 } 1037 } 1038 catch (ex) { 1039 console.log(ex); 1040 } 1041 } 1042 setNewFormContent(response); 1043 } 1044 else { 1045 console.log('The request failed!'); 1046 } 1047 } 1048 } 1049 Forms2.AjaxLoader = AjaxLoader; 1050 class RuleActionHidePart { 1051 init(form) { 1052 var name = "HidePart"; 1053 form.ruleActionPrepareFunctions[name] = (args) => { 1054 let id = args.action.Part; 1055 let elementById = document.getElementById(id); 1056 undoHide(elementById); 1057 undoHide(document.getElementById("field_" + id)); 1058 elementById && (elementById.dataset.show = "true"); 1059 }; 1060 form.ruleActionExecuteFunctions[name] = (args) => { 1061 let id = args.action.Part; 1062 let elementById = document.getElementById(id); 1063 hide(elementById); 1064 hide(document.getElementById("field_" + id)); 1065 elementById && (elementById.dataset.show = "false"); 1066 }; 1067 } 1068 } 1069 Forms2.RuleActionHidePart = RuleActionHidePart; 1070 class RuleConditionFieldComparesToValue { 1071 init(form) { 1072 form.ruleConditionFunctions["FieldComparesToValue"] = (args) => { 1073 let value = args.form.getFieldValue("field_" + args.condition.Field); 1074 value = value + ""; 1075 return args.form.compare(args.condition.Compare, value, args.condition.Value); 1076 }; 1077 } 1078 } 1079 Forms2.RuleConditionFieldComparesToValue = RuleConditionFieldComparesToValue; 1080 class RuleConditionCheckboxIsChecked { 1081 init(form) { 1082 form.ruleConditionFunctions["CheckboxIsChecked"] = (args) => { 1083 let value = args.form.getFieldValue("field_" + args.condition.Field); 1084 return !!value; 1085 }; 1086 } 1087 } 1088 Forms2.RuleConditionCheckboxIsChecked = RuleConditionCheckboxIsChecked; 1089 function reinit(param) { 1090 var form = Forms2.globalFormInstance; 1091 function dispatch(formNode) { 1092 form.formInstances[formNode.id] = new FormInstance(); 1093 document.dispatchEvent(new CustomEvent("alpaca:forms:ready", { detail: { form: form, formNode: formNode } })); 1094 } 1095 if (param instanceof String) { 1096 let node = document.querySelector(param); 1097 let forms = node.querySelectorAll(".alpaca-form");
1098 forEach(forms, dispatch); 1099 } 1100 else { 1101 var node = param; 1102 let forms = node.querySelectorAll(".alpaca-form"); 1103 forEach(forms, dispatch); 1104 if (node.classList.contains("alpaca-form")) { 1105 dispatch(node); 1106 } 1107 } 1108 } 1109 Forms2.reinit = reinit; 1110 function initById(formId) { 1111 const isInitialized = !!Forms2.globalFormInstance; 1112 if (!isInitialized) { 1113 let ids = window["alpacaFormIdsToInit"] || (window["alpacaFormIdsToInit"] = []); 1114 ids.push(formId); 1115 return; 1116 } 1117 reinit(document.getElementById(formId)); 1118 } 1119 Forms2.initById = initById; 1120 function registerFormExtension(formId, object) { 1121 var form = Forms2.globalFormInstance; 1122 var formInstance = form.getFormInstance(formId); 1123 object.init(formInstance); 1124 } 1125 Forms2.registerFormExtension = registerFormExtension; 1126 function addGlobalEvents() { 1127 document.addEventListener('alpaca:forms:init', (event) => { 1128 let args = event.detail; 1129 var form = args.form; 1130 new FormScrolling().init(form); 1131 new SwitchToPage().init(form); 1132 new AjaxLoader().init(form); 1133 new DateField().init(form); 1134 new DatePickerField().init(form); 1135 new DropdownField().init(form); 1136 new MultiselectionField().init(form); 1137 new RadioField().init(form); 1138 new CheckboxField().init(form); 1139 new Textarea().init(form); 1140 new GenericField().init(form); 1141 new HiddenField().init(form); 1142 new FileUpload().init(form); 1143 new RequiredValidator().init(form); 1144 new EqualsOtherFieldValidator().init(form); 1145 new NotEqualsOtherFieldValidator().init(form); 1146 new FileNameValidator().init(form); 1147 new FileSizeValidator().init(form); 1148 new RegexValidator().init(form); 1149 new TextLengthValidator().init(form); 1150 new MinimumAgeValidator().init(form); 1151 new RuleActionHidePart().init(form); 1152 new RuleConditionCheckboxIsChecked().init(form); 1153 new RuleConditionFieldComparesToValue().init(form); 1154 // new setup method for Fields 1155 form.getFieldValuePipeline.push(args => { 1156 var fieldNode = args.elem; 1157 for (var i = 0; i < form.fieldTypes.length; i++) { 1158 let fieldType = form.fieldTypes[i]; 1159 let getFieldValue = fieldType.handlers.getFieldValue; 1160 if (getFieldValue && fieldNode.matches(fieldType.selector)) { 1161 var fieldId = fieldNode.id; 1162 var id = fieldId.substr("field_".length); 1163 args.value = getFieldValue({ 1164 global: form, 1165 id: id, 1166 fieldId: fieldId, 1167 //formNode: formNode, 1168 fieldNode: fieldNode 1169 }); 1170 args.abort = true; 1171 } 1172 } 1173 }); 1174 }); 1175 document.addEventListener('alpaca:forms:ready', async event => { 1176 let args = event.detail; 1177 var form = args.form; 1178 var formNode = (args.formNode); 1179 var pages = Pages('.page:not([data-show="false"])', formNode); 1180 var successMessage = formNode.querySelector(".success-message"); 1181 if (formNode.classList.contains("success-message")) 1182 successMessage = formNode; 1183 if (successMessage) { 1184 await form.triggerCustomData(JSON.parse(successMessage.dataset["custom"]), formNode); 1185 } 1186 let formCustomData = formNode.dataset["custom"] ? JSON.parse(formNode.dataset["custom"]) : {}; 1187 if (formCustomData && Object.keys(formCustomData).length !== 0) 1188 form.pushToGoogleAnalytics(formCustomData); 1189 function addFormEvents(selector, event, eventListener) {
1190 forEach(formNode.querySelectorAll(selector), element => { 1191 element.addEventListener(event, eventListener); 1192 }); 1193 } 1194 ; 1195 addFormEvents("*[data-delegate-click]", "click", event => { 1196 event.preventDefault(); 1197 var element = event.currentTarget; 1198 var clickSelector = element.dataset["delegateClick"].toString(); 1199 formNode.querySelector(clickSelector).click(); 1200 }); 1201 addFormEvents("*[data-delegate-click-global]", "click", event => { 1202 event.preventDefault(); 1203 var element = event.currentTarget; 1204 var clickSelector = element.dataset["delegateClickGlobal"].toString(); 1205 document.querySelector(clickSelector).click(); 1206 }); 1207 function changeFocus(id) { 1208 if (id == form.previousFocusedFieldId) 1209 return; 1210 var field = document.getElementById(form.previousFocusedFieldId); 1211 form.previousFocusedFieldId = id; 1212 if (!field) 1213 return; 1214 if (!form.validateForm(closest(field, ".alpaca-form"), field)) { 1215 } 1216 } 1217 addFormEvents(".field", "focusin", event => changeFocus(event.currentTarget.id)); 1218 addFormEvents(".field", "focusout", event => changeFocus(null)); 1219 addFormEvents(".field.droplist select, .field.checkbox input, .field.radio input, .field.hidden-field", "change", event => { 1220 var element = event.currentTarget; 1221 var field = closest(element, ".field"); 1222 if (!field) 1223 return; 1224 form.validateForm(closest(field, ".alpaca-form"), field); 1225 }); 1226 addFormEvents("input[type=radio]", "change", event => { 1227 var element = event.currentTarget; 1228 var radioGroup = closest(element, '.radio-group'); 1229 if (element.checked && radioGroup) { 1230 var label = radioGroup.querySelector("label.checked"); 1231 label && label.classList.remove('checked'); 1232 element.parentElement.classList.add('checked'); 1233 } 1234 }); 1235 addFormEvents(".next", "click", event => { 1236 event.preventDefault(); 1237 let currentPage = event.currentTarget.closest('.alpaca-form .page'); 1238 if (!currentPage || !(form.validateForm(formNode, this.fieldElement, currentPage))) { 1239 form.scrollElementIntoView(currentPage.querySelector('.error'), true); 1240 return; 1241 } 1242 let nextPage = pages.next(); 1243 form.switchToPage(nextPage); 1244 }); 1245 addFormEvents(".prev", "click", event => { 1246 event.preventDefault(); 1247 let prevPage = pages.prev(); 1248 if (!prevPage) 1249 return; 1250 form.switchToPage(prevPage); 1251 }); 1252 addFormEvents(".page", "keydown", event => { 1253 if (event.which === 13) { 1254 event.preventDefault(); 1255 const activePage = form.getActivePage(formNode); 1256 activePage.querySelector('.next, button[type=submit]').click(); 1257 } 1258 }); 1259 formNode.addEventListener("submit", event => { 1260 var element = event.currentTarget; 1261 if (!form.validateForm(element, null)) { 1262 form.scrollElementIntoView(element.querySelector('.error'), true); 1263 event.preventDefault(); 1264 return; 1265 } 1266 let wturl = element.dataset["wturl"]; 1267 if (wturl) { 1268 var formData = new FormData(formNode);
1269 let url = wturl + "?fid=" + element.id + "&domain=" + window.location.hostname; 1270 let xhr = new XMLHttpRequest(); 1271 xhr.onload = () => { 1272 if (xhr.status >= 200 && xhr.status < 300) { 1273 form.loadAjaxFunction(args); 1274 } 1275 else { 1276 console.log('The request failed!'); 1277 } 1278 }; 1279 xhr.open('POST', url, false); 1280 xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8'); 1281 xhr.send(formData); 1282 } 1283 }); 1284 addFormEvents("button[data-ajax-url]", "click", async (event) => { 1285 event.preventDefault(); 1286 let button = event.currentTarget; 1287 button.disabled = true; 1288 let disableValidation = button.dataset["disableValidation"]; 1289 if (!disableValidation) { 1290 if (!form.validateForm(formNode, null)) { 1291 form.scrollElementIntoView(formNode.querySelector('.error'), true); 1292 button.disabled = false; 1293 return; 1294 } 1295 var allow = await asyncValidation(); 1296 if (!allow) { 1297 form.scrollElementIntoView(formNode.querySelector('.error'), true); 1298 button.disabled = false; 1299 return; 1300 } 1301 } 1302 let ajaxUrl = button.dataset["ajaxUrl"].toString(); 1303 let spinner = document.getElementById(button.name + "-spinner"); 1304 if (spinner) { 1305 show(spinner); 1306 hide(button); 1307 } 1308 1309 const resetStatusAction = () => { 1310 button.disabled = false; 1311 1312 if (spinner) { 1313 hide(spinner); 1314 show(button); 1315 } 1316 }; 1317 1318 let formData = new FormData(formNode); 1319 formData.append(button.name, button.value); 1320 form.submitFormByAjax(formData, formNode, ajaxUrl, resetStatusAction); 1321 }); 1322 var validators = form.getValidators(formNode); 1323 forEach(formNode.querySelectorAll(".field"), (field) => { 1324 let validatorIds = form.getFieldValidatorsIds(field); 1325 var id = field.id; 1326 for (var v of validatorIds) { 1327 var args = { 1328 validator: validators.filter(f => f.Id === v)[0], 1329 fieldId: id, 1330 form: form, 1331 abort: false 1332 }; 1333 if (args.validator) { 1334 form.runPipeline(form.setupFieldPipeline, args); 1335 } 1336 } 1337 }); 1338 var clientScriptEncoded = formNode.dataset["clientScripts"]; 1339 if (clientScriptEncoded) { 1340 var clientScript = atob(clientScriptEncoded); 1341 var clientScriptTag = document.createElement('script'); 1342 clientScriptTag.type = 'text/javascript'; 1343 clientScriptTag.innerHTML = clientScript; 1344 formNode.appendChild(clientScriptTag); 1345 } 1346 setTimeout(() => { 1347 form.scrollIntoView(); 1348 }, 1); 1349 async function asyncValidation() { 1350 for (var i = 0; i < form.fieldTypes.length; i++) { 1351 let fieldType = form.fieldTypes[i];
1352 let checkField = fieldType.handlers.asyncValidation; 1353 if (checkField) { 1354 var fieldNodes = Array.from(formNode.querySelectorAll(fieldType.selector)); 1355 var errorMessages = []; 1356 for (var fieldNode of fieldNodes) { 1357 if (!isVisible(fieldNode)) 1358 continue; 1359 let valid = await checkField({ 1360 global: form, 1361 formNode: formNode, 1362 fieldNode: fieldNode, 1363 addErrorMessages: (errorMessage, summaryMessage) => { 1364 errorMessages.push(errorMessage); 1365 form.appendMessages(fieldNode, "", errorMessages); 1366 }, 1367 }); 1368 if (!valid) { 1369 form.markFieldWithValidationError(fieldNode, true); 1370 return false; 1371 } 1372 } 1373 } 1374 } 1375 return true; 1376 } 1377 // new setup method for fields 1378 for (var i = 0; i < form.fieldTypes.length; i++) { 1379 let fieldType = form.fieldTypes[i]; 1380 let setupField = fieldType.handlers.setupField; 1381 if (setupField) { 1382 var fieldNodes = formNode.querySelectorAll(fieldType.selector); 1383 forEach(fieldNodes, fieldNode => { 1384 setupField({ 1385 global: form, 1386 formNode: formNode, 1387 fieldNode: fieldNode 1388 }); 1389 }); 1390 } 1391 } 1392 form.updateRules(formNode, null); 1393 if (pages.current()) 1394 form.switchToPage(pages.current()); 1395 }); 1396 } 1397 function initialize() { 1398 if (Forms2.globalFormInstance) // for Bauhaus, because ready is called more than once 1399 return; 1400 addGlobalEvents(); 1401 var form = new Form(); 1402 Forms2.globalFormInstance = form; 1403 form.init(); 1404 document.dispatchEvent(new CustomEvent('alpaca:forms:init', { detail: { form: form } })); 1405 document.dispatchEvent(new CustomEvent('alpaca:forms:override', { detail: { form: form } })); 1406 var idsToInit = window["alpacaFormIdsToInit"]; 1407 if (idsToInit) { 1408 for (var i = 0; i < idsToInit.length; i++) { 1409 initById(idsToInit[i]); 1410 } 1411 window["alpacaFormIdsToInit"] = []; 1412 } 1413 } 1414 if (document.readyState === "interactive" || document.readyState === "complete") { 1415 initialize(); 1416 } 1417 else { 1418 document.addEventListener("DOMContentLoaded", () => initialize()); 1419 } 1420 })(Forms2 = Alpaca.Forms2 || (Alpaca.Forms2 = {})); 1421})(Alpaca || (Alpaca = {})); 1422; 1423//# sourceMappingURL=alpaca-forms-native.js.map
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.