@4site/engrid-scripts 0.19.1

package/dist/en-validators.js

@@ -0,0 +1,89 @@
+// This component uses EN's Custom Validators on the client side to validate form fields.
+// It's currently behind a feature flag, so it's not enabled by default.
+// To enable it, add the following to your options:
+// ENValidators: true
+import { EnForm, ENGrid, EngridLogger } from ".";
+export class ENValidators {
+    constructor() {
+        this._form = EnForm.getInstance();
+        this._enElements = null;
+        this.logger = new EngridLogger("ENValidators", "white", "darkolivegreen", "🧐");
+        if (!this.loadValidators()) {
+            // This is an error to flag a racing condition. If the script is loaded before the validators are loaded, it will not work.
+            this.logger.error("Not Loaded");
+            return;
+        }
+        if (!this.shouldRun()) {
+            // If there's no custom validators, get out
+            this.logger.log("Not Needed");
+            return;
+        }
+        this._form.onValidate.subscribe(this.enOnValidate.bind(this));
+    }
+    loadValidators() {
+        if (!ENGrid.checkNested(window.EngagingNetworks, "require", "_defined", "enValidation", "validation", "validators")) {
+            return false;
+        }
+        // Loop through the array validators and add them to this._enElements
+        const validators = window.EngagingNetworks.require._defined.enValidation.validation
+            .validators;
+        this._enElements = validators.reduce((acc, validator) => {
+            if ("type" in validator && validator.type === "CUST") {
+                const container = document.querySelector(".en__field--" + validator.field);
+                const field = container
+                    ? container.querySelector("input, select, textarea")
+                    : null;
+                if (field) {
+                    field.addEventListener("input", this.liveValidate.bind(this, container, field, validator.regex, validator.message));
+                    acc.push({
+                        container: container,
+                        field: field,
+                        regex: validator.regex,
+                        message: validator.message,
+                    });
+                }
+            }
+            return acc;
+        }, []);
+        return true;
+    }
+    // Should we run the script?
+    shouldRun() {
+        return (ENGrid.getOption("ENValidators") &&
+            this._enElements &&
+            this._enElements.length > 0);
+    }
+    // Don't submit the form if any of the fields are invalid
+    enOnValidate() {
+        if (!this._enElements || this._form.validate === false) {
+            return;
+        }
+        this._enElements.forEach((element) => {
+            const fieldValidation = this.liveValidate(element.container, element.field, element.regex, element.message);
+            if (!fieldValidation) {
+                this._form.validate = false;
+                element.field.focus();
+                return;
+            }
+        });
+        this._form.validate = true;
+    }
+    // Validate the field on the fly
+    liveValidate(container, field, regex, message) {
+        const value = ENGrid.getFieldValue(field.getAttribute("name") || "");
+        // Do not validate empty fields, that's the job of the required validator
+        if (value === "") {
+            return true;
+        }
+        this.logger.log(`Live Validate ${field.getAttribute("name")} with ${regex}`);
+        // compare the value of the field with the regex
+        if (!value.match(regex)) {
+            // If the value is not valid, add the error message
+            ENGrid.setError(container, message);
+            return false;
+        }
+        // If the value is valid, remove the error message
+        ENGrid.removeError(container);
+        return true;
+    }
+}

package/dist/engrid.d.ts

@@ -0,0 +1,49 @@
+import { Options } from ".";
+export declare abstract class ENGrid {
+    constructor();
+    static get enForm(): HTMLFormElement;
+    static get debug(): boolean;
+    static get demo(): boolean;
+    static getUrlParameter(name: string): string | true | Object[] | null;
+    static getField(name: string): Element | null;
+    static getFieldValue(name: string): string;
+    static setFieldValue(name: string, value: unknown, parseENDependencies?: boolean, dispatchEvents?: boolean): void;
+    static createHiddenInput(name: string, value?: string): HTMLInputElement;
+    static enParseDependencies(): void;
+    static getGiftProcess(): any;
+    static getPageCount(): any;
+    static getPageNumber(): any;
+    static getPageID(): any;
+    static getClientID(): any;
+    static getDataCenter(): "us" | "ca";
+    static getPageType(): "DONATION" | "ECARD" | "SURVEY" | "EMAILTOTARGET" | "ADVOCACY" | "SUBSCRIBEFORM" | "SUPPORTERHUB" | "UNSUBSCRIBE" | "TWEETPAGE" | "UNKNOWN";
+    static setBodyData(dataName: string, value: string | boolean): void;
+    static getBodyData(dataName: string): string | null;
+    static hasBodyData(dataName: string): boolean;
+    static getOption<K extends keyof Options>(key: K): Options[K] | null;
+    static loadJS(url: string, onload?: (() => void) | null, head?: boolean): void;
+    static formatNumber(number: string | number, decimals?: number, dec_point?: string, thousands_sep?: string): string;
+    static cleanAmount(amount: string): number;
+    static disableSubmit(label?: string): boolean;
+    static enableSubmit(): boolean;
+    static formatDate(date: Date, format?: string): string;
+    /**
+     * Check if the provided object has ALL the provided properties
+     * Example: checkNested(EngagingNetworks, 'require', '_defined', 'enjs', 'checkSubmissionFailed')
+     * will return true if EngagingNetworks.require._defined.enjs.checkSubmissionFailed is defined
+     */
+    static checkNested(obj: any, ...args: string[]): boolean;
+    static deepMerge(target: any, source: any): any;
+    static setError(element: string | HTMLElement, errorMessage: string): void;
+    static removeError(element: string | HTMLElement): void;
+    static isVisible(element: HTMLElement): boolean;
+    static getCurrencySymbol(): string;
+    static getCurrencyCode(): string;
+    static addHtml(html: string | HTMLElement, target?: string, position?: string): void;
+    static removeHtml(target: string): void;
+    static slugify(text: string): string;
+    static watchForError(callback: Function): void;
+    static getPaymentType(): string;
+    static setPaymentType(paymentType: string): void;
+    static isInViewport(element: HTMLElement): boolean;
+}

package/dist/engrid.js

@@ -0,0 +1,547 @@
+export class ENGrid {
+    constructor() {
+        if (!ENGrid.enForm) {
+            throw new Error("Engaging Networks Form Not Found!");
+        }
+    }
+    static get enForm() {
+        return document.querySelector("form.en__component");
+    }
+    static get debug() {
+        return !!this.getOption("Debug");
+    }
+    static get demo() {
+        return this.getUrlParameter("mode") === "DEMO";
+    }
+    // Return any parameter from the URL
+    static getUrlParameter(name) {
+        const searchParams = new URLSearchParams(window.location.search);
+        // Add support for array on the name ending with []
+        if (name.endsWith("[]")) {
+            let values = [];
+            searchParams.forEach((value, key) => {
+                if (key.startsWith(name.replace("[]", ""))) {
+                    values.push(new Object({ [key]: value }));
+                }
+            });
+            return values.length > 0 ? values : null;
+        }
+        if (searchParams.has(name)) {
+            return searchParams.get(name) || true;
+        }
+        return null;
+    }
+    static getField(name) {
+        // Get the field by name
+        return document.querySelector(`[name="${name}"]`);
+    }
+    // Return the field value from its name. It works on any field type.
+    // Multiple values (from checkboxes or multi-select) are returned as single string
+    // Separated by ,
+    static getFieldValue(name) {
+        return new FormData(this.enForm).getAll(name).join(",");
+    }
+    // Set a value to any field. If it's a dropdown, radio or checkbox, it selects the proper option matching the value
+    static setFieldValue(name, value, parseENDependencies = true, dispatchEvents = false) {
+        if (value === ENGrid.getFieldValue(name))
+            return;
+        document.getElementsByName(name).forEach((field) => {
+            if ("type" in field) {
+                switch (field.type) {
+                    case "select-one":
+                    case "select-multiple":
+                        for (const option of field.options) {
+                            if (option.value == value) {
+                                option.selected = true;
+                                if (dispatchEvents) {
+                                    field.dispatchEvent(new Event("change", { bubbles: true }));
+                                }
+                            }
+                        }
+                        break;
+                    case "checkbox":
+                    case "radio":
+                        if (field.value == value) {
+                            field.checked = true;
+                            if (dispatchEvents) {
+                                field.dispatchEvent(new Event("change", { bubbles: true }));
+                            }
+                        }
+                        break;
+                    case "textarea":
+                    case "text":
+                    default:
+                        field.value = value;
+                        if (dispatchEvents) {
+                            field.dispatchEvent(new Event("change", { bubbles: true }));
+                            field.dispatchEvent(new Event("blur", { bubbles: true }));
+                        }
+                }
+                field.setAttribute("engrid-value-changed", "");
+            }
+        });
+        if (parseENDependencies)
+            this.enParseDependencies();
+        return;
+    }
+    // Create a hidden input field
+    static createHiddenInput(name, value = "") {
+        var _a;
+        const formBlock = document.createElement("div");
+        formBlock.classList.add("en__component", "en__component--formblock", "hide");
+        const textField = document.createElement("div");
+        textField.classList.add("en__field", "en__field--text");
+        const textElement = document.createElement("div");
+        textElement.classList.add("en__field__element", "en__field__element--text");
+        const inputField = document.createElement("input");
+        inputField.classList.add("en__field__input", "en__field__input--text", "engrid-added-input");
+        inputField.setAttribute("name", name);
+        inputField.setAttribute("type", "hidden");
+        inputField.setAttribute("value", value);
+        textElement.appendChild(inputField);
+        textField.appendChild(textElement);
+        formBlock.appendChild(textField);
+        const submitElement = document.querySelector(".en__submit");
+        if (submitElement) {
+            const lastFormComponent = submitElement.closest(".en__component");
+            if (lastFormComponent) {
+                // Insert the new field after the submit button
+                (_a = lastFormComponent.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(formBlock, lastFormComponent.nextSibling);
+            }
+        }
+        else {
+            ENGrid.enForm.appendChild(formBlock);
+        }
+        return inputField;
+    }
+    // Trigger EN Dependencies
+    static enParseDependencies() {
+        var _a, _b, _c, _d, _e, _f;
+        if (window.EngagingNetworks &&
+            typeof ((_e = (_d = (_c = (_b = (_a = window.EngagingNetworks) === null || _a === void 0 ? void 0 : _a.require) === null || _b === void 0 ? void 0 : _b._defined) === null || _c === void 0 ? void 0 : _c.enDependencies) === null || _d === void 0 ? void 0 : _d.dependencies) === null || _e === void 0 ? void 0 : _e.parseDependencies) === "function") {
+            const customDependencies = [];
+            if ("dependencies" in window.EngagingNetworks) {
+                const amountContainer = document.querySelector(".en__field--donationAmt");
+                if (amountContainer) {
+                    let amountID = ((_f = [...amountContainer.classList.values()]
+                        .filter((v) => v.startsWith("en__field--") && Number(v.substring(11)) > 0)
+                        .toString()
+                        .match(/\d/g)) === null || _f === void 0 ? void 0 : _f.join("")) || "";
+                    if (amountID) {
+                        window.EngagingNetworks.dependencies.forEach((dependency) => {
+                            if ("actions" in dependency && dependency.actions.length > 0) {
+                                let amountIdFound = false;
+                                dependency.actions.forEach((action) => {
+                                    if ("target" in action && action.target == amountID) {
+                                        amountIdFound = true;
+                                    }
+                                });
+                                if (!amountIdFound) {
+                                    customDependencies.push(dependency);
+                                }
+                            }
+                        });
+                        if (customDependencies.length > 0) {
+                            window.EngagingNetworks.require._defined.enDependencies.dependencies.parseDependencies(customDependencies);
+                            if (ENGrid.getOption("Debug"))
+                                console.log("EN Dependencies Triggered", customDependencies);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Return the status of the gift process (true if a donation has been made, otherwise false)
+    static getGiftProcess() {
+        if ("pageJson" in window)
+            return window.pageJson.giftProcess;
+        return null;
+    }
+    // Return the page count
+    static getPageCount() {
+        if ("pageJson" in window)
+            return window.pageJson.pageCount;
+        return null;
+    }
+    // Return the current page number
+    static getPageNumber() {
+        if ("pageJson" in window)
+            return window.pageJson.pageNumber;
+        return null;
+    }
+    // Return the current page ID
+    static getPageID() {
+        if ("pageJson" in window)
+            return window.pageJson.campaignPageId;
+        return 0;
+    }
+    // Return the client ID
+    static getClientID() {
+        if ("pageJson" in window)
+            return window.pageJson.clientId;
+        return 0;
+    }
+    //returns 'us or 'ca' based on the client ID
+    static getDataCenter() {
+        return ENGrid.getClientID() >= 10000 ? "us" : "ca";
+    }
+    // Return the current page type
+    static getPageType() {
+        if ("pageJson" in window && "pageType" in window.pageJson) {
+            switch (window.pageJson.pageType) {
+                case "donation":
+                case "premiumgift":
+                    return "DONATION";
+                    break;
+                case "e-card":
+                    return "ECARD";
+                    break;
+                case "otherdatacapture":
+                case "survey":
+                    return "SURVEY";
+                    break;
+                case "emailtotarget":
+                    return "EMAILTOTARGET";
+                    break;
+                case "advocacypetition":
+                    return "ADVOCACY";
+                    break;
+                case "emailsubscribeform":
+                    return "SUBSCRIBEFORM";
+                    break;
+                case "supporterhub":
+                    return "SUPPORTERHUB";
+                    break;
+                case "unsubscribe":
+                    return "UNSUBSCRIBE";
+                    break;
+                case "tweetpage":
+                    return "TWEETPAGE";
+                    break;
+                default:
+                    return "UNKNOWN";
+            }
+        }
+        else {
+            return "UNKNOWN";
+        }
+    }
+    // Set body engrid data attributes
+    static setBodyData(dataName, value) {
+        const body = document.querySelector("body");
+        // If value is boolean
+        if (typeof value === "boolean" && value === false) {
+            body.removeAttribute(`data-engrid-${dataName}`);
+            return;
+        }
+        body.setAttribute(`data-engrid-${dataName}`, value.toString());
+    }
+    // Get body engrid data attributes
+    static getBodyData(dataName) {
+        const body = document.querySelector("body");
+        return body.getAttribute(`data-engrid-${dataName}`);
+    }
+    // Check if body has engrid data attributes
+    static hasBodyData(dataName) {
+        const body = document.querySelector("body");
+        return body.hasAttribute(`data-engrid-${dataName}`);
+    }
+    // Return the option value
+    static getOption(key) {
+        return window.EngridOptions[key] || null;
+    }
+    // Load an external script
+    static loadJS(url, onload = null, head = true) {
+        const scriptTag = document.createElement("script");
+        scriptTag.src = url;
+        scriptTag.onload = onload;
+        if (head) {
+            document.head.appendChild(scriptTag);
+            return;
+        }
+        document.body.appendChild(scriptTag);
+        return;
+    }
+    // Format a number
+    static formatNumber(number, decimals = 2, dec_point = ".", thousands_sep = ",") {
+        // Strip all characters but numerical ones.
+        number = (number + "").replace(/[^0-9+\-Ee.]/g, "");
+        const n = !isFinite(+number) ? 0 : +number;
+        const prec = !isFinite(+decimals) ? 0 : Math.abs(decimals);
+        const sep = typeof thousands_sep === "undefined" ? "," : thousands_sep;
+        const dec = typeof dec_point === "undefined" ? "." : dec_point;
+        let s = [];
+        const toFixedFix = function (n, prec) {
+            const k = Math.pow(10, prec);
+            return "" + Math.round(n * k) / k;
+        };
+        // Fix for IE parseFloat(0.55).toFixed(0) = 0;
+        s = (prec ? toFixedFix(n, prec) : "" + Math.round(n)).split(".");
+        if (s[0].length > 3) {
+            s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
+        }
+        if ((s[1] || "").length < prec) {
+            s[1] = s[1] || "";
+            s[1] += new Array(prec - s[1].length + 1).join("0");
+        }
+        return s.join(dec);
+    }
+    // Clean an Amount
+    static cleanAmount(amount) {
+        // Split the number
+        const valueArray = amount.replace(/[^0-9,\.]/g, "").split(/[,.]+/);
+        const delimArray = amount.replace(/[^.,]/g, "").split("");
+        // Handle values with no decimal places and non-numeric values
+        if (valueArray.length === 1) {
+            return parseInt(valueArray[0]) || 0;
+        }
+        // Ignore invalid numbers
+        if (valueArray
+            .map((x, index) => {
+            return index > 0 && index + 1 !== valueArray.length && x.length !== 3
+                ? true
+                : false;
+        })
+            .includes(true)) {
+            return 0;
+        }
+        // Multiple commas is a bad thing? So edgy.
+        if (delimArray.length > 1 && !delimArray.includes(".")) {
+            return 0;
+        }
+        // Handle invalid decimal and comma formatting
+        if ([...new Set(delimArray.slice(0, -1))].length > 1) {
+            return 0;
+        }
+        // If there are cents
+        if (valueArray[valueArray.length - 1].length <= 2) {
+            const cents = valueArray.pop() || "00";
+            return parseInt(cents) > 0
+                ? parseFloat(Number(parseInt(valueArray.join("")) + "." + cents).toFixed(2))
+                : parseInt(valueArray.join(""));
+        }
+        return parseInt(valueArray.join(""));
+    }
+    static disableSubmit(label = "") {
+        const submit = document.querySelector(".en__submit button");
+        if (!submit)
+            return false;
+        submit.dataset.originalText = submit.innerHTML;
+        let submitButtonProcessingHTML = "<span class='loader-wrapper'><span class='loader loader-quart'></span><span class='submit-button-text-wrapper'>" +
+            label +
+            "</span></span>";
+        submit.disabled = true;
+        submit.innerHTML = submitButtonProcessingHTML;
+        return true;
+    }
+    static enableSubmit() {
+        const submit = document.querySelector(".en__submit button");
+        if (!submit)
+            return false;
+        if (submit.dataset.originalText) {
+            submit.disabled = false;
+            submit.innerHTML = submit.dataset.originalText;
+            delete submit.dataset.originalText;
+            return true;
+        }
+        return false;
+    }
+    static formatDate(date, format = "MM/DD/YYYY") {
+        const dateAray = date
+            .toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        })
+            .split("/");
+        const dateString = format
+            .replace(/YYYY/g, dateAray[2])
+            .replace(/MM/g, dateAray[0])
+            .replace(/DD/g, dateAray[1])
+            .replace(/YY/g, dateAray[2].substr(2, 2));
+        return dateString;
+    }
+    /**
+     * Check if the provided object has ALL the provided properties
+     * Example: checkNested(EngagingNetworks, 'require', '_defined', 'enjs', 'checkSubmissionFailed')
+     * will return true if EngagingNetworks.require._defined.enjs.checkSubmissionFailed is defined
+     */
+    static checkNested(obj, ...args) {
+        for (let i = 0; i < args.length; i++) {
+            if (!obj || !obj.hasOwnProperty(args[i])) {
+                return false;
+            }
+            obj = obj[args[i]];
+        }
+        return true;
+    }
+    // Deep merge two objects
+    static deepMerge(target, source) {
+        for (const key in source) {
+            if (source[key] instanceof Object)
+                Object.assign(source[key], ENGrid.deepMerge(target[key], source[key]));
+        }
+        Object.assign(target || {}, source);
+        return target;
+    }
+    static setError(element, errorMessage) {
+        const errorElement = typeof element === "string" ? document.querySelector(element) : element;
+        if (errorElement) {
+            errorElement.classList.add("en__field--validationFailed");
+            let errorMessageElement = errorElement.querySelector(".en__field__error");
+            if (!errorMessageElement) {
+                errorMessageElement = document.createElement("div");
+                errorMessageElement.classList.add("en__field__error");
+                errorMessageElement.innerHTML = errorMessage;
+                errorElement.insertBefore(errorMessageElement, errorElement.firstChild);
+            }
+            else {
+                errorMessageElement.innerHTML = errorMessage;
+            }
+        }
+    }
+    static removeError(element) {
+        const errorElement = typeof element === "string" ? document.querySelector(element) : element;
+        if (errorElement) {
+            errorElement.classList.remove("en__field--validationFailed");
+            const errorMessageElement = errorElement.querySelector(".en__field__error");
+            if (errorMessageElement) {
+                errorElement.removeChild(errorMessageElement);
+            }
+        }
+    }
+    static isVisible(element) {
+        if (!element) {
+            return false;
+        }
+        return !!(element.offsetWidth ||
+            element.offsetHeight ||
+            element.getClientRects().length);
+    }
+    static getCurrencySymbol() {
+        const currencyField = ENGrid.getField("transaction.paycurrency");
+        if (currencyField) {
+            // Check if the selected currency field option have a data-currency-symbol attribute
+            const selectedOption = currencyField.tagName === "SELECT"
+                ? currencyField.options[currencyField.selectedIndex]
+                : currencyField;
+            if (selectedOption.dataset.currencySymbol) {
+                return selectedOption.dataset.currencySymbol;
+            }
+            const currencyArray = {
+                USD: "$",
+                EUR: "€",
+                GBP: "£",
+                AUD: "$",
+                CAD: "$",
+                JPY: "¥",
+            };
+            return currencyArray[currencyField.value] || "$";
+        }
+        return ENGrid.getOption("CurrencySymbol") || "$";
+    }
+    static getCurrencyCode() {
+        const currencyField = ENGrid.getField("transaction.paycurrency");
+        if (currencyField) {
+            return currencyField.value || "USD";
+        }
+        return ENGrid.getOption("CurrencyCode") || "USD";
+    }
+    static addHtml(html, target = "body", position = "before") {
+        var _a, _b;
+        const targetElement = document.querySelector(target);
+        if (typeof html === "object") {
+            html = html.outerHTML;
+        }
+        if (targetElement) {
+            const htmlElement = document.createRange().createContextualFragment(html);
+            if (position === "before") {
+                (_a = targetElement.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(htmlElement, targetElement);
+            }
+            else {
+                (_b = targetElement.parentNode) === null || _b === void 0 ? void 0 : _b.insertBefore(htmlElement, targetElement.nextSibling);
+            }
+        }
+    }
+    static removeHtml(target) {
+        const targetElement = document.querySelector(target);
+        if (targetElement) {
+            targetElement.remove();
+        }
+    }
+    static slugify(text) {
+        return text
+            .toString()
+            .toLowerCase()
+            .replace(/\s+/g, "-") // Replace spaces with -
+            .replace(/[^\w\-]+/g, "") // Remove all non-word chars
+            .replace(/\-\-+/g, "-") // Replace multiple - with single -
+            .replace(/^-+/, "") // Trim - from start of text
+            .replace(/-+$/, ""); // Trim - from end of text
+    }
+    // This function is used to run a callback function when an error is displayed on the page
+    static watchForError(callback) {
+        const errorElement = document.querySelector(".en__errorList");
+        const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+        // Avoid duplicate callbacks
+        let callbackType = callback.toString();
+        if (callbackType.indexOf("function") === 0) {
+            callbackType = callbackType.replace("function ", "");
+        }
+        if (callbackType.indexOf("(") > 0) {
+            callbackType = callbackType.substring(0, callbackType.indexOf("("));
+        }
+        // Remove invalid characters
+        callbackType = callbackType.replace(/[^a-zA-Z0-9]/g, "");
+        // Limit to 20 characters and add prefix
+        callbackType = callbackType.substring(0, 20);
+        callbackType = "engrid" + capitalize(callbackType);
+        if (errorElement && !errorElement.dataset[callbackType]) {
+            errorElement.dataset[callbackType] = "true";
+            const observer = new MutationObserver(function (mutations) {
+                mutations.forEach(function (mutation) {
+                    if (mutation.type === "childList" && mutation.addedNodes.length > 0) {
+                        callback();
+                    }
+                });
+            });
+            observer.observe(errorElement, { childList: true });
+        }
+    }
+    // Get the Payment Type
+    static getPaymentType() {
+        return ENGrid.getFieldValue("transaction.paymenttype");
+    }
+    // Set the Payment Type
+    static setPaymentType(paymentType) {
+        const enFieldPaymentType = ENGrid.getField("transaction.paymenttype");
+        if (enFieldPaymentType) {
+            const paymentTypeOption = Array.from(enFieldPaymentType.options).find((option) => paymentType.toLowerCase() === "card"
+                ? ["card", "visa", "vi"].includes(option.value.toLowerCase())
+                : paymentType.toLowerCase() === option.value.toLowerCase());
+            if (paymentTypeOption) {
+                paymentTypeOption.selected = true;
+                enFieldPaymentType.value = paymentTypeOption.value;
+            }
+            else {
+                enFieldPaymentType.value = paymentType;
+            }
+            const event = new Event("change", {
+                bubbles: true,
+                cancelable: true,
+            });
+            enFieldPaymentType.dispatchEvent(event);
+        }
+    }
+    static isInViewport(element) {
+        const rect = element.getBoundingClientRect();
+        return (rect.top >= 0 &&
+            rect.left >= 0 &&
+            rect.bottom <=
+                (window.innerHeight ||
+                    document.documentElement.clientHeight) /* or $(window).height() */ &&
+            rect.right <=
+                (window.innerWidth ||
+                    document.documentElement.clientWidth) /* or $(window).width() */);
+    }
+}

package/dist/event-tickets.d.ts

@@ -0,0 +1,3 @@
+export declare class EventTickets {
+    constructor();
+}