@4site/engrid-scripts 0.19.1

package/dist/event-tickets.js

@@ -0,0 +1,24 @@
+export class EventTickets {
+    constructor() {
+        // --------------------------------------------
+        // Format ticket amounts as currency.
+        const ticketCostElements = document.getElementsByClassName("en__ticket__field--cost");
+        const ticketCurrencyElements = document.getElementsByClassName("en__ticket__currency");
+        for (const ticketCurrencyElement of ticketCurrencyElements) {
+            ticketCurrencyElement.classList.add("en__ticket__currency__hidden");
+        }
+        for (const ticketCostElement of ticketCostElements) {
+            const ticketAmountElement = ticketCostElement.getElementsByClassName("en__ticket__price")[0];
+            const ticketCurrencyElement = ticketCostElement.getElementsByClassName("en__ticket__currency")[0];
+            const formatterOptions = {
+                style: "currency",
+                currency: ticketCurrencyElement.innerText,
+            };
+            let ticketAmountAsCurrency = Intl.NumberFormat(undefined, formatterOptions).format(Number(ticketAmountElement.innerText));
+            if (ticketAmountAsCurrency.slice(-3) === ".00") {
+                ticketAmountAsCurrency = ticketAmountAsCurrency.slice(0, -3);
+            }
+            ticketAmountElement.innerText = ticketAmountAsCurrency;
+        }
+    }
+}

package/dist/events/country.d.ts

@@ -0,0 +1,12 @@
+export declare class Country {
+    private _onCountryChange;
+    private _country;
+    private _field;
+    private static instance;
+    constructor();
+    static getInstance(): Country;
+    get countryField(): HTMLElement | null;
+    get onCountryChange(): import("strongly-typed-events").ISimpleEvent<string>;
+    get country(): string;
+    set country(value: string);
+}

package/dist/events/country.js

@@ -0,0 +1,42 @@
+import { SimpleEventDispatcher } from "strongly-typed-events";
+import { ENGrid } from "../engrid";
+export class Country {
+    constructor() {
+        this._onCountryChange = new SimpleEventDispatcher();
+        this._country = "";
+        this._field = null;
+        // Run only if it is a Page with a Country field
+        this._field = document.getElementById("en__field_supporter_country");
+        if (!this._field) {
+            return;
+        }
+        document.addEventListener("change", (e) => {
+            const element = e.target;
+            if (element && element.name == "supporter.country") {
+                this.country = element.value;
+            }
+        });
+        // Set the country to the current value on the field
+        this.country = ENGrid.getFieldValue("supporter.country");
+    }
+    static getInstance() {
+        if (!Country.instance) {
+            Country.instance = new Country();
+        }
+        return Country.instance;
+    }
+    get countryField() {
+        return this._field;
+    }
+    get onCountryChange() {
+        return this._onCountryChange.asEvent();
+    }
+    get country() {
+        return this._country;
+    }
+    // Every time we set a country, trigger the onCountryChange event
+    set country(value) {
+        this._country = value;
+        this._onCountryChange.dispatch(this._country);
+    }
+}

package/dist/events/donation-amount.d.ts

@@ -0,0 +1,16 @@
+export declare class DonationAmount {
+    private _onAmountChange;
+    private _amount;
+    private _radios;
+    private _other;
+    private _dispatch;
+    private static instance;
+    private constructor();
+    static getInstance(radios?: string, other?: string): DonationAmount;
+    get amount(): number;
+    set amount(value: number);
+    get onAmountChange(): import("strongly-typed-events").ISimpleEvent<number>;
+    load(): void;
+    setAmount(amount: number, dispatch?: boolean): void;
+    clearOther(): void;
+}

package/dist/events/donation-amount.js

@@ -0,0 +1,119 @@
+import { SimpleEventDispatcher } from "strongly-typed-events";
+import { ENGrid } from "..";
+export class DonationAmount {
+    constructor(radios = "transaction.donationAmt", other = "transaction.donationAmt.other") {
+        this._onAmountChange = new SimpleEventDispatcher();
+        this._amount = 0;
+        this._radios = "";
+        this._other = "";
+        this._dispatch = true;
+        this._other = other;
+        this._radios = radios;
+        // Watch Radios Inputs for Changes
+        document.addEventListener("change", (e) => {
+            const element = e.target;
+            if (element) {
+                if (element.name == radios) {
+                    this.amount = parseFloat(element.value);
+                }
+                else if (element.name == other) {
+                    const cleanedAmount = ENGrid.cleanAmount(element.value);
+                    element.value =
+                        cleanedAmount % 1 != 0
+                            ? cleanedAmount.toFixed(2)
+                            : cleanedAmount.toString();
+                    this.amount = cleanedAmount;
+                }
+            }
+        });
+        // Watch Other Amount Field
+        const otherField = document.querySelector(`[name='${this._other}']`);
+        if (otherField) {
+            otherField.addEventListener("keyup", (e) => {
+                this.amount = ENGrid.cleanAmount(otherField.value);
+            });
+        }
+    }
+    static getInstance(radios = "transaction.donationAmt", other = "transaction.donationAmt.other") {
+        if (!DonationAmount.instance) {
+            DonationAmount.instance = new DonationAmount(radios, other);
+        }
+        return DonationAmount.instance;
+    }
+    get amount() {
+        return this._amount;
+    }
+    // Every time we set an amount, trigger the onAmountChange event
+    set amount(value) {
+        this._amount = value || 0;
+        if (this._dispatch)
+            this._onAmountChange.dispatch(this._amount);
+    }
+    get onAmountChange() {
+        return this._onAmountChange.asEvent();
+    }
+    // Set amount var with currently selected amount
+    load() {
+        const currentAmountField = document.querySelector('input[name="' + this._radios + '"]:checked');
+        if (currentAmountField) {
+            let currentAmountValue = parseFloat(currentAmountField.value || "");
+            if (currentAmountValue > 0) {
+                this.amount = parseFloat(currentAmountField.value);
+            }
+            else {
+                const otherField = document.querySelector('input[name="' + this._other + '"]');
+                currentAmountValue = ENGrid.cleanAmount(otherField.value);
+                this.amount = currentAmountValue;
+            }
+        }
+        else if (ENGrid.checkNested(window.EngagingNetworks, "require", "_defined", "enjs", "getDonationTotal") &&
+            ENGrid.checkNested(window.EngagingNetworks, "require", "_defined", "enjs", "getDonationFee")) {
+            const total = window.EngagingNetworks.require._defined.enjs.getDonationTotal() -
+                window.EngagingNetworks.require._defined.enjs.getDonationFee();
+            if (total) {
+                this.amount = total;
+            }
+        }
+    }
+    // Force a new amount
+    setAmount(amount, dispatch = true) {
+        // Run only if it is a Donation Page with a Donation Amount field
+        if (!document.getElementsByName(this._radios).length) {
+            return;
+        }
+        // Set dispatch to be checked by the SET method
+        this._dispatch = dispatch;
+        // Search for the current amount on radio boxes
+        let found = Array.from(document.querySelectorAll('input[name="' + this._radios + '"]')).filter((el) => el instanceof HTMLInputElement && parseInt(el.value) == amount);
+        // We found the amount on the radio boxes, so check it
+        if (found.length) {
+            const amountField = found[0];
+            amountField.checked = true;
+            // Clear OTHER text field
+            this.clearOther();
+        }
+        else {
+            const otherField = document.querySelector('input[name="' + this._other + '"]');
+            if (otherField) {
+                const enFieldOtherAmountRadio = document.querySelector(`.en__field--donationAmt.en__field--withOther .en__field__item:nth-last-child(2) input[name="${this._radios}"]`);
+                if (enFieldOtherAmountRadio) {
+                    enFieldOtherAmountRadio.checked = true;
+                }
+                otherField.value = parseFloat(amount.toString()).toFixed(2);
+                const otherWrapper = otherField.parentNode;
+                otherWrapper.classList.remove("en__field__item--hidden");
+            }
+        }
+        // Set the new amount and trigger all live variables
+        this.amount = amount;
+        // Revert dispatch to default value (true)
+        this._dispatch = true;
+    }
+    // Clear Other Field
+    clearOther() {
+        const otherField = document.querySelector('input[name="' + this._other + '"]');
+        otherField.value = "";
+        const otherWrapper = otherField.parentNode;
+        otherWrapper.classList.add("en__field__item--hidden");
+    }
+}

package/dist/events/donation-frequency.d.ts

@@ -0,0 +1,17 @@
+export declare class DonationFrequency {
+    private _onFrequencyChange;
+    private _frequency;
+    private _recurring;
+    private _dispatch;
+    private static instance;
+    private constructor();
+    static getInstance(): DonationFrequency;
+    get frequency(): string;
+    set frequency(value: string);
+    get recurring(): string;
+    set recurring(value: string);
+    get onFrequencyChange(): import("strongly-typed-events").ISimpleEvent<string>;
+    load(): void;
+    setRecurrency(recurr: string, dispatch?: boolean): void;
+    setFrequency(freq: string, dispatch?: boolean): void;
+}

package/dist/events/donation-frequency.js

@@ -0,0 +1,115 @@
+import { SimpleEventDispatcher } from "strongly-typed-events";
+import { ENGrid } from "../engrid";
+export class DonationFrequency {
+    constructor() {
+        this._onFrequencyChange = new SimpleEventDispatcher();
+        this._frequency = "onetime";
+        this._recurring = "n";
+        this._dispatch = true;
+        // Watch the Radios for Changes
+        document.addEventListener("change", (e) => {
+            const element = e.target;
+            if (element && element.name == "transaction.recurrpay") {
+                this.recurring = element.value;
+                // When this element is a radio, that means you're between onetime and monthly only
+                if (element.type == "radio") {
+                    this.frequency =
+                        element.value.toLowerCase() == "n" ? "onetime" : "monthly";
+                    // This field is hidden when transaction.recurrpay is radio
+                    ENGrid.setFieldValue("transaction.recurrfreq", this.frequency.toUpperCase());
+                }
+            }
+            if (element && element.name == "transaction.recurrfreq") {
+                this.frequency = element.value;
+            }
+        });
+        //Thank you page handling for utility classes
+        if (ENGrid.getGiftProcess()) {
+            ENGrid.setBodyData("transaction-recurring-frequency", sessionStorage.getItem("engrid-transaction-recurring-frequency") ||
+                "onetime");
+            ENGrid.setBodyData("transaction-recurring", window.pageJson.recurring ? "y" : "n");
+        }
+    }
+    static getInstance() {
+        if (!DonationFrequency.instance) {
+            DonationFrequency.instance = new DonationFrequency();
+        }
+        return DonationFrequency.instance;
+    }
+    get frequency() {
+        return this._frequency;
+    }
+    // Every time we set a frequency, trigger the onFrequencyChange event
+    set frequency(value) {
+        this._frequency = value.toLowerCase() || "onetime";
+        if (this._dispatch)
+            this._onFrequencyChange.dispatch(this._frequency);
+        ENGrid.setBodyData("transaction-recurring-frequency", this._frequency);
+        sessionStorage.setItem("engrid-transaction-recurring-frequency", this._frequency);
+    }
+    get recurring() {
+        return this._recurring;
+    }
+    set recurring(value) {
+        this._recurring = value.toLowerCase() || "n";
+        ENGrid.setBodyData("transaction-recurring", this._recurring);
+    }
+    get onFrequencyChange() {
+        return this._onFrequencyChange.asEvent();
+    }
+    // Set amount var with currently selected amount
+    load() {
+        var _a;
+        this.frequency =
+            ENGrid.getFieldValue("transaction.recurrfreq") ||
+                sessionStorage.getItem("engrid-transaction-recurring-frequency") ||
+                "onetime";
+        const recurrField = ENGrid.getField("transaction.recurrpay");
+        if (recurrField) {
+            this.recurring = ENGrid.getFieldValue("transaction.recurrpay");
+        }
+        else if (ENGrid.checkNested(window.EngagingNetworks, "require", "_defined", "enjs", "getSupporterData")) {
+            this.recurring =
+                ((_a = window.EngagingNetworks.require._defined.enjs
+                    .getSupporterData("recurrpay")) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "n";
+        }
+        // ENGrid.enParseDependencies();
+    }
+    // Force a new recurrency
+    setRecurrency(recurr, dispatch = true) {
+        // Run only if it is a Donation Page with a Recurrency
+        if (!document.getElementsByName("transaction.recurrpay").length) {
+            return;
+        }
+        // Set dispatch to be checked by the SET method
+        this._dispatch = dispatch;
+        ENGrid.setFieldValue("transaction.recurrpay", recurr.toUpperCase());
+        // Revert dispatch to default value (true)
+        this._dispatch = true;
+    }
+    // Force a new frequency
+    setFrequency(freq, dispatch = true) {
+        // Run only if it is a Donation Page with a Frequency
+        if (!document.getElementsByName("transaction.recurrfreq").length) {
+            return;
+        }
+        // Set dispatch to be checked by the SET method
+        this._dispatch = dispatch;
+        // Search for the current amount on radio boxes
+        let found = Array.from(document.querySelectorAll('input[name="transaction.recurrfreq"]')).filter((el) => el instanceof HTMLInputElement && el.value == freq.toUpperCase());
+        // We found the amount on the radio boxes, so check it
+        if (found.length) {
+            const freqField = found[0];
+            freqField.checked = true;
+            this.frequency = freq.toLowerCase();
+            if (this.frequency === "onetime") {
+                this.setRecurrency("N", dispatch);
+            }
+            else {
+                this.setRecurrency("Y", dispatch);
+            }
+        }
+        // Revert dispatch to default value (true)
+        this._dispatch = true;
+    }
+}

package/dist/events/en-form.d.ts

@@ -0,0 +1,20 @@
+export declare class EnForm {
+    private logger;
+    private _onSubmit;
+    private _onValidate;
+    private _onError;
+    submit: boolean;
+    submitPromise: boolean | Promise<any>;
+    validate: boolean;
+    validatePromise: boolean | Promise<any>;
+    private static instance;
+    private constructor();
+    static getInstance(): EnForm;
+    dispatchSubmit(): void;
+    dispatchValidate(): void;
+    dispatchError(): void;
+    submitForm(): void;
+    get onSubmit(): import("strongly-typed-events").ISignal;
+    get onError(): import("strongly-typed-events").ISignal;
+    get onValidate(): import("strongly-typed-events").ISignal;
+}

package/dist/events/en-form.js

@@ -0,0 +1,52 @@
+import { SignalDispatcher } from "strongly-typed-events";
+import { EngridLogger } from "..";
+export class EnForm {
+    constructor() {
+        this.logger = new EngridLogger("EnForm");
+        this._onSubmit = new SignalDispatcher();
+        this._onValidate = new SignalDispatcher();
+        this._onError = new SignalDispatcher();
+        this.submit = true;
+        this.submitPromise = false;
+        this.validate = true;
+        this.validatePromise = false;
+    }
+    static getInstance() {
+        if (!EnForm.instance) {
+            EnForm.instance = new EnForm();
+        }
+        return EnForm.instance;
+    }
+    dispatchSubmit() {
+        this._onSubmit.dispatch();
+        this.logger.log("dispatchSubmit");
+    }
+    dispatchValidate() {
+        this._onValidate.dispatch();
+        this.logger.log("dispatchValidate");
+    }
+    dispatchError() {
+        this._onError.dispatch();
+        this.logger.log("dispatchError");
+    }
+    submitForm() {
+        const enForm = document.querySelector("form .en__submit button");
+        if (enForm) {
+            // Add submitting class to modal
+            const enModal = document.getElementById("enModal");
+            if (enModal)
+                enModal.classList.add("is-submitting");
+            enForm.click();
+            this.logger.log("submitForm");
+        }
+    }
+    get onSubmit() {
+        return this._onSubmit.asEvent();
+    }
+    get onError() {
+        return this._onError.asEvent();
+    }
+    get onValidate() {
+        return this._onValidate.asEvent();
+    }
+}

package/dist/events/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./en-form";
+export * from "./donation-amount";
+export * from "./donation-frequency";
+export * from "./processing-fees";
+export * from "./remember-me-events";
+export * from "./country";

package/dist/events/index.js

@@ -0,0 +1,6 @@
+export * from "./en-form";
+export * from "./donation-amount";
+export * from "./donation-frequency";
+export * from "./processing-fees";
+export * from "./remember-me-events";
+export * from "./country";

package/dist/events/processing-fees.d.ts

@@ -0,0 +1,20 @@
+import { EnForm } from "./en-form";
+import { DonationAmount } from "./donation-amount";
+export declare class ProcessingFees {
+    private _onFeeChange;
+    _amount: DonationAmount;
+    _form: EnForm;
+    private _fee;
+    private _field;
+    private _subscribe?;
+    private static instance;
+    constructor();
+    static getInstance(): ProcessingFees;
+    get onFeeChange(): import("strongly-typed-events").ISimpleEvent<number>;
+    get fee(): number;
+    set fee(value: number);
+    calculateFees(amount?: number): any;
+    private addFees;
+    private removeFees;
+    private isENfeeCover;
+}

package/dist/events/processing-fees.js

@@ -0,0 +1,92 @@
+import { SimpleEventDispatcher } from "strongly-typed-events";
+import { EnForm } from "./en-form";
+import { DonationAmount } from "./donation-amount";
+export class ProcessingFees {
+    constructor() {
+        this._onFeeChange = new SimpleEventDispatcher();
+        this._amount = DonationAmount.getInstance();
+        this._form = EnForm.getInstance();
+        this._fee = 0;
+        this._field = null;
+        // console.log('%c Processing Fees Constructor', 'font-size: 30px; background-color: #000; color: #FF0');
+        // Run only if it is a Donation Page with a Donation Amount field
+        if (!document.getElementsByName("transaction.donationAmt").length) {
+            return;
+        }
+        this._field = this.isENfeeCover()
+            ? document.querySelector("#en__field_transaction_feeCover")
+            : document.querySelector('input[name="supporter.processing_fees"]');
+        // Watch the Radios for Changes
+        if (this._field instanceof HTMLInputElement) {
+            // console.log('%c Processing Fees Start', 'font-size: 30px; background-color: #000; color: #FF0');
+            this._field.addEventListener("change", (e) => {
+                if (this._field instanceof HTMLInputElement &&
+                    this._field.checked &&
+                    !this._subscribe) {
+                    this._subscribe = this._form.onSubmit.subscribe(() => this.addFees());
+                }
+                this._onFeeChange.dispatch(this.fee);
+                // // console.log('%c Processing Fees Script Applied', 'font-size: 30px; background-color: #000; color: #FF0');
+            });
+        }
+        // this._amount = amount;
+    }
+    static getInstance() {
+        if (!ProcessingFees.instance) {
+            ProcessingFees.instance = new ProcessingFees();
+        }
+        return ProcessingFees.instance;
+    }
+    get onFeeChange() {
+        return this._onFeeChange.asEvent();
+    }
+    get fee() {
+        return this.calculateFees();
+    }
+    // Every time we set a frequency, trigger the onFrequencyChange event
+    set fee(value) {
+        this._fee = value;
+        this._onFeeChange.dispatch(this._fee);
+    }
+    calculateFees(amount = 0) {
+        var _a;
+        if (this._field instanceof HTMLInputElement && this._field.checked) {
+            if (this.isENfeeCover()) {
+                return amount > 0
+                    ? window.EngagingNetworks.require._defined.enjs.feeCover.fee(amount)
+                    : window.EngagingNetworks.require._defined.enjs.getDonationFee();
+            }
+            const fees = Object.assign({
+                processingfeepercentadded: "0",
+                processingfeefixedamountadded: "0",
+            }, (_a = this._field) === null || _a === void 0 ? void 0 : _a.dataset);
+            const amountToFee = amount > 0 ? amount : this._amount.amount;
+            const processing_fee = (parseFloat(fees.processingfeepercentadded) / 100) * amountToFee +
+                parseFloat(fees.processingfeefixedamountadded);
+            return Math.round(processing_fee * 100) / 100;
+        }
+        return 0;
+    }
+    // Add Fees to Amount
+    addFees() {
+        if (this._form.submit && !this.isENfeeCover()) {
+            this._amount.setAmount(this._amount.amount + this.fee, false);
+        }
+    }
+    // Remove Fees From Amount
+    removeFees() {
+        if (!this.isENfeeCover())
+            this._amount.setAmount(this._amount.amount - this.fee);
+    }
+    // Check if this is a Processing Fee from EN
+    isENfeeCover() {
+        if ("feeCover" in window.EngagingNetworks) {
+            for (const key in window.EngagingNetworks.feeCover) {
+                if (window.EngagingNetworks.feeCover.hasOwnProperty(key)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

package/dist/events/remember-me-events.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This class is responsible for managing events related to the "Remember Me" functionality.
+ * It uses the Singleton design pattern to ensure only one instance of this class exists.
+ * It provides methods for dispatching load and clear events, and getters for accessing these events.
+ */
+export declare class RememberMeEvents {
+    private logger;
+    private _onLoad;
+    private _onClear;
+    hasData: boolean;
+    private static instance;
+    private constructor();
+    static getInstance(): RememberMeEvents;
+    dispatchLoad(hasData: boolean): void;
+    dispatchClear(): void;
+    get onLoad(): import("strongly-typed-events").ISimpleEvent<boolean>;
+    get onClear(): import("strongly-typed-events").ISignal;
+}

package/dist/events/remember-me-events.js

@@ -0,0 +1,36 @@
+/**
+ * This class is responsible for managing events related to the "Remember Me" functionality.
+ * It uses the Singleton design pattern to ensure only one instance of this class exists.
+ * It provides methods for dispatching load and clear events, and getters for accessing these events.
+ */
+import { SignalDispatcher, SimpleEventDispatcher } from "strongly-typed-events";
+import { EngridLogger } from "..";
+export class RememberMeEvents {
+    constructor() {
+        this.logger = new EngridLogger("RememberMeEvents");
+        this._onLoad = new SimpleEventDispatcher();
+        this._onClear = new SignalDispatcher();
+        this.hasData = false;
+    }
+    static getInstance() {
+        if (!RememberMeEvents.instance) {
+            RememberMeEvents.instance = new RememberMeEvents();
+        }
+        return RememberMeEvents.instance;
+    }
+    dispatchLoad(hasData) {
+        this.hasData = hasData;
+        this._onLoad.dispatch(hasData);
+        this.logger.log(`dispatchLoad: ${hasData}`);
+    }
+    dispatchClear() {
+        this._onClear.dispatch();
+        this.logger.log("dispatchClear");
+    }
+    get onLoad() {
+        return this._onLoad.asEvent();
+    }
+    get onClear() {
+        return this._onClear.asEvent();
+    }
+}

package/dist/exit-intent-lightbox.d.ts

@@ -0,0 +1,14 @@
+export declare class ExitIntentLightbox {
+    private options;
+    private opened;
+    private dataLayer;
+    private logger;
+    constructor();
+    private watchForTriggers;
+    private triggerDelay;
+    private triggerTimeout;
+    private watchMouse;
+    private watchDocumentVisibility;
+    private open;
+    private close;
+}