@4site/engrid-scripts 0.19.1

package/dist/show-hide-radio-checkboxes.js

@@ -0,0 +1,161 @@
+import { ENGrid, EngridLogger } from ".";
+export class ShowHideRadioCheckboxes {
+    // Create default data attributes on all fields
+    createDataAttributes() {
+        this.elements.forEach((item) => {
+            if (item instanceof HTMLInputElement) {
+                let inputValue = item.value.replace(/\W/g, "");
+                document
+                    .querySelectorAll("." + this.classes + inputValue)
+                    .forEach((el) => {
+                    // Consider toggling "hide" class so these fields can be displayed when in a debug state
+                    if (el instanceof HTMLElement) {
+                        const fields = el.querySelectorAll("input[type='text'], input[type='number'], input[type='email'], select, textarea");
+                        if (fields.length > 0) {
+                            fields.forEach((field) => {
+                                if (field instanceof HTMLInputElement ||
+                                    field instanceof HTMLSelectElement) {
+                                    if (!field.hasAttribute("data-original-value")) {
+                                        field.setAttribute("data-original-value", field.value);
+                                    }
+                                    if (!field.hasAttribute("data-value")) {
+                                        field.setAttribute("data-value", field.value);
+                                    }
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        });
+    }
+    // Hide All Divs
+    hideAll() {
+        this.elements.forEach((item, index) => {
+            if (item instanceof HTMLInputElement)
+                this.hide(item);
+        });
+    }
+    // Hide Single Element Div
+    hide(item) {
+        let inputValue = item.value.replace(/\W/g, "");
+        document.querySelectorAll("." + this.classes + inputValue).forEach((el) => {
+            // Consider toggling "hide" class so these fields can be displayed when in a debug state
+            if (el instanceof HTMLElement) {
+                this.toggleValue(el, "hide");
+                el.style.display = "none";
+                this.logger.log("Hiding", el);
+            }
+        });
+    }
+    // Show Single Element Div
+    show(item) {
+        let inputValue = item.value.replace(/\W/g, "");
+        document.querySelectorAll("." + this.classes + inputValue).forEach((el) => {
+            // Consider toggling "hide" class so these fields can be displayed when in a debug state
+            if (el instanceof HTMLElement) {
+                this.toggleValue(el, "show");
+                el.style.display = "";
+                this.logger.log("Showing", el);
+            }
+        });
+        if (item.type == "checkbox" && !item.checked) {
+            this.hide(item);
+        }
+    }
+    // Take the field values and add to a data attribute on the field
+    toggleValue(item, type) {
+        if (type == "hide" && !ENGrid.isVisible(item))
+            return;
+        this.logger.log(`toggleValue: ${type}`);
+        const fields = item.querySelectorAll("input[type='text'], input[type='number'], input[type='email'], select, textarea");
+        if (fields.length > 0) {
+            fields.forEach((field) => {
+                var _a;
+                if (field instanceof HTMLInputElement ||
+                    field instanceof HTMLSelectElement) {
+                    if (field.name) {
+                        const fieldValue = ENGrid.getFieldValue(field.name);
+                        const originalValue = field.getAttribute("data-original-value");
+                        const dataValue = (_a = field.getAttribute("data-value")) !== null && _a !== void 0 ? _a : "";
+                        if (type === "hide") {
+                            field.setAttribute("data-value", fieldValue);
+                            ENGrid.setFieldValue(field.name, originalValue);
+                        }
+                        else {
+                            ENGrid.setFieldValue(field.name, dataValue);
+                        }
+                    }
+                }
+            });
+        }
+    }
+    getSessionState() {
+        var _a;
+        try {
+            const plainState = (_a = window.sessionStorage.getItem(`engrid_ShowHideRadioCheckboxesState`)) !== null && _a !== void 0 ? _a : "";
+            return JSON.parse(plainState);
+        }
+        catch (err) {
+            return [];
+        }
+    }
+    storeSessionState() {
+        const state = this.getSessionState();
+        [...this.elements].forEach((element) => {
+            var _a, _b;
+            if (!(element instanceof HTMLInputElement))
+                return;
+            if (element.type == "radio" && element.checked) {
+                //remove other items that have the same "class" property
+                state.forEach((item, index) => {
+                    if (item.class == this.classes) {
+                        state.splice(index, 1);
+                    }
+                });
+                //add the current item, with the currently active value
+                state.push({
+                    page: ENGrid.getPageID(),
+                    class: this.classes,
+                    value: element.value,
+                });
+                this.logger.log("storing radio state", state[state.length - 1]);
+            }
+            if (element.type == "checkbox") {
+                //remove other items that have the same "class" property
+                state.forEach((item, index) => {
+                    if (item.class == this.classes) {
+                        state.splice(index, 1);
+                    }
+                });
+                //add the current item, with the first checked value or "N" if none are checked
+                state.push({
+                    page: ENGrid.getPageID(),
+                    class: this.classes,
+                    value: (_b = (_a = [...this.elements].find((el) => el.checked)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : "N", // First checked value or "N" if none
+                });
+                this.logger.log("storing checkbox state", state[state.length - 1]);
+            }
+        });
+        window.sessionStorage.setItem(`engrid_ShowHideRadioCheckboxesState`, JSON.stringify(state));
+    }
+    constructor(elements, classes) {
+        this.logger = new EngridLogger("ShowHideRadioCheckboxes", "black", "lightblue", "👁");
+        this.elements = document.getElementsByName(elements);
+        this.classes = classes;
+        this.createDataAttributes();
+        this.hideAll();
+        this.storeSessionState();
+        for (let i = 0; i < this.elements.length; i++) {
+            let element = this.elements[i];
+            if (element.checked) {
+                this.show(element);
+            }
+            element.addEventListener("change", (e) => {
+                this.hideAll();
+                this.show(element);
+                this.storeSessionState();
+            });
+        }
+    }
+}

package/dist/show-if-amount.d.ts

@@ -0,0 +1,15 @@
+import { DonationAmount } from "./events";
+export declare class ShowIfAmount {
+    _amount: DonationAmount;
+    private _elements;
+    private logger;
+    constructor();
+    private init;
+    private getClassNameByOperand;
+    private lessthan;
+    private lessthanorequalto;
+    private equalto;
+    private greaterthanorequalto;
+    private greaterthan;
+    private between;
+}

package/dist/show-if-amount.js

@@ -0,0 +1,117 @@
+import { ENGrid, EngridLogger } from ".";
+import { DonationAmount } from "./events";
+export class ShowIfAmount {
+    constructor() {
+        this._amount = DonationAmount.getInstance();
+        this.logger = new EngridLogger("ShowIfAmount", "yellow", "black", "👀");
+        this._elements = document.querySelectorAll('[class*="showifamount"]');
+        if (this._elements.length > 0) {
+            this._amount.onAmountChange.subscribe(() => this.init());
+            this.init();
+            return;
+        }
+        this.logger.log("Show If Amount: NO ELEMENTS FOUND");
+    }
+    init() {
+        //If we are on a thank you page, use the window.pageJson.amount
+        const amount = ENGrid.getGiftProcess()
+            ? window.pageJson.amount
+            : this._amount.amount;
+        this._elements.forEach((element) => {
+            this.lessthan(amount, element);
+            this.lessthanorequalto(amount, element);
+            this.equalto(amount, element);
+            this.greaterthanorequalto(amount, element);
+            this.greaterthan(amount, element);
+            this.between(amount, element);
+        });
+    }
+    getClassNameByOperand(classList, operand) {
+        let myClass = null;
+        classList.forEach((className) => {
+            if (className.includes(`showifamount-${operand}-`)) {
+                myClass = className;
+            }
+        });
+        return myClass;
+    }
+    lessthan(amount, element) {
+        const showifamountClass = this.getClassNameByOperand(element.classList, "lessthan");
+        if (showifamountClass) {
+            let amountCheck = showifamountClass.split("-").slice(-1)[0];
+            if (amount < Number(amountCheck)) {
+                this.logger.log("(lessthan):", element);
+                element.classList.add("engrid-open");
+            }
+            else {
+                element.classList.remove("engrid-open");
+            }
+        }
+    }
+    lessthanorequalto(amount, element) {
+        const showifamountClass = this.getClassNameByOperand(element.classList, "lessthanorequalto");
+        if (showifamountClass) {
+            let amountCheck = showifamountClass.split("-").slice(-1)[0];
+            if (amount <= Number(amountCheck)) {
+                this.logger.log("(lessthanorequalto):", element);
+                element.classList.add("engrid-open");
+            }
+            else {
+                element.classList.remove("engrid-open");
+            }
+        }
+    }
+    equalto(amount, element) {
+        const showifamountClass = this.getClassNameByOperand(element.classList, "equalto");
+        if (showifamountClass) {
+            let amountCheck = showifamountClass.split("-").slice(-1)[0];
+            if (amount == Number(amountCheck)) {
+                this.logger.log("(equalto):", element);
+                element.classList.add("engrid-open");
+            }
+            else {
+                element.classList.remove("engrid-open");
+            }
+        }
+    }
+    greaterthanorequalto(amount, element) {
+        const showifamountClass = this.getClassNameByOperand(element.classList, "greaterthanorequalto");
+        if (showifamountClass) {
+            let amountCheck = showifamountClass.split("-").slice(-1)[0];
+            if (amount >= Number(amountCheck)) {
+                this.logger.log("(greaterthanorequalto):", element);
+                element.classList.add("engrid-open");
+            }
+            else {
+                element.classList.remove("engrid-open");
+            }
+        }
+    }
+    greaterthan(amount, element) {
+        const showifamountClass = this.getClassNameByOperand(element.classList, "greaterthan");
+        if (showifamountClass) {
+            let amountCheck = showifamountClass.split("-").slice(-1)[0];
+            if (amount > Number(amountCheck)) {
+                this.logger.log("(greaterthan):", element);
+                element.classList.add("engrid-open");
+            }
+            else {
+                element.classList.remove("engrid-open");
+            }
+        }
+    }
+    between(amount, element) {
+        const showifamountClass = this.getClassNameByOperand(element.classList, "between");
+        if (showifamountClass) {
+            let amountCheckMin = showifamountClass.split("-").slice(-2, -1)[0];
+            let amountCheckMax = showifamountClass.split("-").slice(-1)[0];
+            if (amount > Number(amountCheckMin) && amount < Number(amountCheckMax)) {
+                this.logger.log("(between):", element);
+                element.classList.add("engrid-open");
+            }
+            else {
+                element.classList.remove("engrid-open");
+            }
+        }
+    }
+}

package/dist/show-if-present.d.ts

@@ -0,0 +1,7 @@
+export declare class ShowIfPresent {
+    private logger;
+    private elements;
+    constructor();
+    private shouldRun;
+    private run;
+}

package/dist/show-if-present.js

@@ -0,0 +1,79 @@
+/**
+ * This class contains the logic for special classes that can be used to hide elements if
+ * certain supporter questions are present or absent.
+ * Typically, this can be used to hide elements when an opt in question is not rendered on the page
+ * because the supporter came from a campaign link and is already opted in, so EN doesn't render
+ * the question on the page.
+ *
+ * The class names are of the format:
+ * engrid__supporterquestions{id}-present -- show this element when the supporter question is present
+ * engrid__supporterquestions{id}-absent -- show this element when the supporter question is absent
+ *
+ * The {id} is the id of the supporter question. This can be found by inspecting the element on the page.
+ *
+ * It's also possible to combine multiple questions using the following format. These examples show 2 questions,
+ * but you can use as many as you like:
+ * engrid__supporterquestions{id1}__supporterquestions{id2}-present -- show this element when EITHER question is present
+ * engrid__supporterquestions{id1}__supporterquestions{id2}-absent -- show this element when EITHER question is absent
+ */
+import { EngridLogger } from "./logger";
+export class ShowIfPresent {
+    constructor() {
+        this.logger = new EngridLogger("ShowIfPresent", "yellow", "black", "👀");
+        this.elements = [];
+        if (this.shouldRun()) {
+            this.run();
+        }
+    }
+    shouldRun() {
+        // Check if we have any elements on the page that match the pattern for this functionality
+        // e.g. engrid__supporterquestions{id}__supporterquestions{id}-present, etc.
+        this.elements = [
+            ...document.querySelectorAll('[class*="engrid__supporterquestions"]'),
+        ].filter((el) => {
+            const classNames = el.className.split(" ");
+            return classNames.some((className) => /^engrid__supporterquestions\d+(__supporterquestions\d+)*-(present|absent)$/.test(className));
+        });
+        return this.elements.length > 0;
+    }
+    run() {
+        const actions = [];
+        // Create an array of actions for each element we have
+        this.elements.forEach((el) => {
+            // Mapping to an object with the class name, field name(s), and type
+            const classNames = el.className.split(" ");
+            const matchingClass = classNames.find((className) => /^engrid__supporterquestions\d+(__supporterquestions\d+)*-(present|absent)$/.test(className));
+            if (!matchingClass)
+                return null;
+            const typeIndex = matchingClass.lastIndexOf("-");
+            const type = matchingClass.substring(typeIndex + 1);
+            // Getting an array of the matching input names
+            // e.g. engrid__supporterquestions12345-present => ['supporter.questions.12345']
+            // e.g. engrid__supporterquestions12345__supporterquestions67890-present => ['supporter.questions.12345', 'supporter.questions.67890']
+            const inputIds = matchingClass
+                .substring(8, typeIndex)
+                .split("__")
+                .map((id) => `supporter.questions.${id.substring(18)}`);
+            actions.push({
+                class: matchingClass,
+                fieldNames: inputIds,
+                type: type,
+            });
+        });
+        //Process the actions
+        actions.forEach((action) => {
+            const inputElements = action.fieldNames.map((fieldName) => document.getElementsByName(fieldName)[0]);
+            const elements = document.querySelectorAll(`.${action.class}`);
+            const areAllInputsPresent = inputElements.every((input) => !!input);
+            const areAllInputsAbsent = inputElements.every((input) => !input);
+            // Hide the elements based on AND conditions
+            if ((action.type === "present" && areAllInputsAbsent) ||
+                (action.type === "absent" && areAllInputsPresent)) {
+                this.logger.log(`Conditions not met, hiding elements with class ${action.class}`);
+                elements.forEach((el) => {
+                    el.style.display = "none";
+                });
+            }
+        });
+    }
+}

package/dist/skip-link.d.ts

@@ -0,0 +1,4 @@
+export declare class SkipToMainContentLink {
+    constructor();
+    private insertSkipLinkSpan;
+}

package/dist/skip-link.js

@@ -0,0 +1,36 @@
+// Javascript that adds an accessible "Skip Link" button after the <body> opening that jumps to
+// the first <title> or <h1> field in a "body-" section, or the first <h1> if none are found
+// in those sections
+// Depends on _engrid-skip-link.scss
+import { ENGrid } from ".";
+export class SkipToMainContentLink {
+    constructor() {
+        const firstTitleInEngridBody = document.querySelector("div[class*='body-'] title");
+        const firstH1InEngridBody = document.querySelector("div[class*='body-'] h1");
+        const firstTitle = document.querySelector("title");
+        const firstH1 = document.querySelector("h1");
+        if (firstTitleInEngridBody && firstTitleInEngridBody.parentElement) {
+            firstTitleInEngridBody.parentElement.insertAdjacentHTML("beforebegin", '<span id="skip-link"></span>');
+            this.insertSkipLinkSpan();
+        }
+        else if (firstH1InEngridBody && firstH1InEngridBody.parentElement) {
+            firstH1InEngridBody.parentElement.insertAdjacentHTML("beforebegin", '<span id="skip-link"></span>');
+            this.insertSkipLinkSpan();
+        }
+        else if (firstTitle && firstTitle.parentElement) {
+            firstTitle.parentElement.insertAdjacentHTML("beforebegin", '<span id="skip-link"></span>');
+            this.insertSkipLinkSpan();
+        }
+        else if (firstH1 && firstH1.parentElement) {
+            firstH1.parentElement.insertAdjacentHTML("beforebegin", '<span id="skip-link"></span>');
+            this.insertSkipLinkSpan();
+        }
+        else {
+            if (ENGrid.debug)
+                console.log("This page contains no <title> or <h1> and a 'Skip to main content' link was not added");
+        }
+    }
+    insertSkipLinkSpan() {
+        document.body.insertAdjacentHTML("afterbegin", '<a class="skip-link" href="#skip-link">Skip to main content</a>');
+    }
+}

package/dist/src-defer.d.ts

@@ -0,0 +1,6 @@
+export declare class SrcDefer {
+    imgSrcDefer: NodeListOf<Element>;
+    videoBackground: NodeListOf<Element>;
+    videoBackgroundSource: NodeListOf<Element>;
+    constructor();
+}

package/dist/src-defer.js

@@ -0,0 +1,70 @@
+// Build Notes: Add the vanilla Javascript version inline inside the page template right before </body>
+// In the event the vanilla javascript is not inlined we should still process any assets with a data-src still defined on it. Plus we only process background video via this JS file as to not block the page with a large video file downloading.
+// // 4Site's simplified image lazy loader
+// var srcDefer = document.querySelectorAll("img[data-src]");
+// window.addEventListener('DOMContentLoaded', (event) => {
+//   for (var i = 0; i < srcDefer.length; i++) {
+//     let dataSrc = srcDefer[i].getAttribute("data-src");
+//     if (dataSrc) {
+//       srcDefer[i].setAttribute("decoding", "async"); // Gets image processing off the main working thread
+//       srcDefer[i].setAttribute("loading", "lazy"); // Lets the browser determine when the asset should be downloaded
+//       srcDefer[i].setAttribute("src", dataSrc); // Sets the src which will cause the browser to retrieve the asset
+//       srcDefer[i].setAttribute("data-engrid-data-src-processed", "true"); // Sets an attribute to mark that it has been processed by ENGrid
+//       srcDefer[i].removeAttribute("data-src"); // Removes the data-source
+//     }
+//   }
+// });
+export class SrcDefer {
+    constructor() {
+        // Find all images and videos with a data-src defined
+        this.imgSrcDefer = document.querySelectorAll("img[data-src]");
+        this.videoBackground = document.querySelectorAll("video");
+        this.videoBackgroundSource = document.querySelectorAll("video source");
+        // Process images
+        for (let i = 0; i < this.imgSrcDefer.length; i++) {
+            let img = this.imgSrcDefer[i];
+            if (img) {
+                img.setAttribute("decoding", "async"); // Gets image processing off the main working thread, and decodes the image asynchronously to reduce delay in presenting other content
+                img.setAttribute("loading", "lazy"); // Lets the browser determine when the asset should be downloaded using it's native lazy loading
+                let imgDataSrc = img.getAttribute("data-src");
+                if (imgDataSrc) {
+                    img.setAttribute("src", imgDataSrc); // Sets the src which will cause the browser to retrieve the asset
+                }
+                img.setAttribute("data-engrid-data-src-processed", "true"); // Sets an attribute to mark that it has been processed by ENGrid
+                img.removeAttribute("data-src"); // Removes the data-source
+            }
+        }
+        // Process video
+        for (let i = 0; i < this.videoBackground.length; i++) {
+            let video = this.videoBackground[i];
+            // Process one or more defined sources in the <video> tag
+            this.videoBackgroundSource = video.querySelectorAll("source");
+            if (this.videoBackgroundSource) {
+                // loop through all the sources
+                for (let j = 0; j < this.videoBackgroundSource.length; j++) {
+                    let videoSource = this.videoBackgroundSource[j];
+                    if (videoSource) {
+                        let videoBackgroundSourcedDataSrc = videoSource.getAttribute("data-src");
+                        if (videoBackgroundSourcedDataSrc) {
+                            videoSource.setAttribute("src", videoBackgroundSourcedDataSrc);
+                            videoSource.setAttribute("data-engrid-data-src-processed", "true"); // Sets an attribute to mark that it has been processed by ENGrid
+                            videoSource.removeAttribute("data-src"); // Removes the data-source
+                        }
+                    }
+                }
+                // To get the browser to request the video asset defined we need to remove the <video> tag and re-add it
+                let videoBackgroundParent = video.parentNode; // Determine the parent of the <video> tag
+                let copyOfVideoBackground = video; // Copy the <video> tag
+                if (videoBackgroundParent && copyOfVideoBackground) {
+                    videoBackgroundParent.replaceChild(copyOfVideoBackground, video); // Replace the <video> with the copy of itself
+                    // Update the video to auto play, mute, loop
+                    video.muted = true; // Mute the video by default
+                    video.controls = false; // Hide the browser controls
+                    video.loop = true; // Loop the video
+                    video.playsInline = true; // Encourage the user agent to display video content within the element's playback area
+                    video.play(); // Plays the video
+                }
+            }
+        }
+    }
+}

package/dist/supporter-hub.d.ts

@@ -0,0 +1,9 @@
+export declare class SupporterHub {
+    private logger;
+    private _form;
+    constructor();
+    shoudRun(): boolean;
+    watch(): void;
+    creditCardUpdate(overlay: HTMLDivElement): void;
+    amountLabelUpdate(overlay: HTMLDivElement): void;
+}

package/dist/supporter-hub.js

@@ -0,0 +1,75 @@
+// Component that adds 4Site Special Features to the Supporter Hub Page
+import { ENGrid, EngridLogger, EnForm } from ".";
+export class SupporterHub {
+    constructor() {
+        this.logger = new EngridLogger("SupporterHub", "black", "pink", "🛖");
+        this._form = EnForm.getInstance();
+        if (!this.shoudRun())
+            return;
+        this.logger.log("Enabled");
+        this.watch();
+    }
+    shoudRun() {
+        return ("pageJson" in window &&
+            "pageType" in window.pageJson &&
+            window.pageJson.pageType === "supporterhub");
+    }
+    watch() {
+        const form = ENGrid.enForm;
+        // Create a observer to watch the Form for overlays
+        const observer = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                if (mutation.type === "childList") {
+                    mutation.addedNodes.forEach((node) => {
+                        if (node.nodeName === "DIV") {
+                            const overlay = node;
+                            if (overlay.classList.contains("en__hubOverlay") ||
+                                overlay.classList.contains("en__hubPledge__panels")) {
+                                this.logger.log("Overlay found");
+                                this.creditCardUpdate(node);
+                                this.amountLabelUpdate(node);
+                            }
+                        }
+                    });
+                }
+            });
+        });
+        // Start observing the Link ID #plaid-link-button
+        observer.observe(form, {
+            childList: true,
+            subtree: true,
+        });
+        // Run the Credit Card Update function in case the overlay is already present on page load
+        const hubOverlay = document.querySelector(".en__hubOverlay");
+        if (hubOverlay) {
+            this.creditCardUpdate(hubOverlay);
+            this.amountLabelUpdate(hubOverlay);
+        }
+    }
+    creditCardUpdate(overlay) {
+        window.setTimeout(() => {
+            // Check if the overlay has Credit Card field and Update Button
+            const ccField = overlay.querySelector("#en__hubPledge__field--ccnumber"), updateButton = overlay.querySelector(".en__hubUpdateCC__toggle");
+            if (ccField && updateButton) {
+                // When field gets focus, click the update button
+                ccField.addEventListener("focus", () => {
+                    this.logger.log("Credit Card field focused");
+                    updateButton.click();
+                });
+            }
+        }, 300);
+    }
+    amountLabelUpdate(overlay) {
+        window.setTimeout(() => {
+            // Check if the overlay has Amounts, and set the currency symbol updated attribute
+            const amountContainer = overlay.querySelector(".en__field--donationAmt");
+            if (amountContainer) {
+                amountContainer
+                    .querySelectorAll(".en__field__element--radio .en__field__item")
+                    .forEach((node) => {
+                    node.setAttribute("data-engrid-currency-symbol-updated", "true");
+                });
+            }
+        }, 300);
+    }
+}

package/dist/swap-amounts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Example:
+ * window.EngridAmounts = {
+ *   "onetime": {
+ *     amounts: {
+ *       "10": 10,
+ *       "30": 30,
+ *       "50": 50,
+ *       "100": 100,
+ *       "Other": "other",
+ *     },
+ *     default: 30,
+ *   },
+ *   "monthly": {
+ *     amounts: {
+ *       "5": 5,
+ *       "15": 15,
+ *       "25": 25,
+ *       "30": 30,
+ *       "Other": "other",
+ *     },
+ *     default: 15,
+ *   },
+ * };
+ */
+import { DonationAmount } from ".";
+export declare class SwapAmounts {
+    private logger;
+    _amount: DonationAmount;
+    private _frequency;
+    private defaultChange;
+    private swapped;
+    constructor();
+    swapAmounts(): void;
+    loadEnAmounts(amountArray: {
+        amounts: [string, number];
+        default: number;
+    }): {
+        selected: boolean;
+        label: string;
+        value: string;
+    }[];
+    shouldRun(): boolean;
+    ignoreCurrentValue(): boolean;
+}