@justifi/webcomponents 6.0.0-rc.5 → 6.0.0-rc.7

package/dist/esm/justifi-checkout-summary_7.entry.js

@@ -0,0 +1,1414 @@
+import { r as registerInstance, h, c as createEvent, H as Host, g as getElement } from './index-Bn7inNWG.js';
+import { z as text, r as radioListItem } from './parts-RvUQ__Pq.js';
+import { f as formatCurrency } from './utils-lb8p1Exq.js';
+import { c as checkoutStore, o as onChange } from './checkout.store-sQSQqMAD.js';
+import { S as StyledHost } from './styled-host-CTAGIN84.js';
+import './event-types-CZfYo5-1.js';
+import { H as Header1 } from './header-1-3M9If0gM.js';
+import { H as Header2, b as insuranceValuesOn, h as hasInsuranceValueChanged, i as insuranceValues } from './insurance-state-CTalqbNa.js';
+import { H as Header3 } from './header-3-CWa41YWq.js';
+import { J as JustifiAnalytics, c as checkPkgVersion } from './check-pkg-version-ggwQhM0h.js';
+import './config-state-DZeVYerv.js';
+import './dinero-HXpYMWUU.js';
+import { C as ComponentErrorSeverity, a as ComponentErrorCodes, b as ComponentErrorMessages } from './ComponentError-Cjcsf8ku.js';
+import { I as ICheckoutStatus } from './Refund-kKW8S1h6.js';
+import './Pagination-CLHwhyvu.js';
+import './Business-BCoP0TAV.js';
+import './Dispute-BH0Xfn-F.js';
+import { g as getErrorCode, a as getErrorMessage } from './utils-BeQLScSm.js';
+import { C as CheckoutService } from './checkout.service-KDp7tISm.js';
+import { A as Api } from './Api-C1I68Tfr.js';
+import { C as CardBrandLabels } from './payment-method-option-utils-lUHAQVFl.js';
+import './index-B_KxSZIF.js';
+import './package-VsM6ERNV.js';
+import './helpers-Mu7LQT-w.js';
+import './state-options-BX8GieXu.js';
+
+const Summary = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+    }
+    render() {
+        return (h(StyledHost, { key: 'db0b903a05629cd6197bb14336fd91881373cbf1' }, h("section", { key: '2e1213c4be75677a98fdf98de077201ebff1d3a6' }, h("div", { key: '26c3bfc8672511dd5af823426e69b6c0d28dd274' }, h("div", { key: '8c9a282d63903b66cf3f93e316bd56f245b9bc1f', part: text }, checkoutStore === null || checkoutStore === void 0 ? void 0 : checkoutStore.paymentDescription), h("div", { key: '0729b8adef6ae7bb7a536ad4b5443ed24608ce56' }, h("span", { key: '863ee5dc8a0c662a8074a69d388081ec9fc3fb89', part: text }, "Total"), "\u00A0", h("span", { key: '05bf10634b2a166c6b5720beaf0ab76accb8befe', part: text }, formatCurrency(+(checkoutStore === null || checkoutStore === void 0 ? void 0 : checkoutStore.totalAmount))))))));
+    }
+};
+
+const Header = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.levels = {
+            h1: Header1,
+            h2: Header2,
+            h3: Header3,
+        };
+        this.level = 'h1';
+    }
+    render() {
+        const HeaderComponent = this.levels[this.level];
+        return (h(StyledHost, { key: '002dfd5dd8fa47304d9e468e28bdbeb56723913b' }, h(HeaderComponent, { key: '63110d45f87268510cc309d8081f191ef8d4cd8b', text: this.text, class: this.class })));
+    }
+};
+
+const makeGetCheckout = ({ authToken, checkoutId, service }) => async ({ onSuccess, onError }) => {
+    var _a;
+    try {
+        const response = await service.fetchCheckout(authToken, checkoutId);
+        if (!response.error) {
+            const checkout = response.data;
+            onSuccess({ checkout });
+        }
+        else {
+            const responseError = getErrorMessage(response.error);
+            const code = getErrorCode((_a = response.error) === null || _a === void 0 ? void 0 : _a.code);
+            return onError({
+                error: responseError,
+                code,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    catch (error) {
+        const code = getErrorCode(error === null || error === void 0 ? void 0 : error.code);
+        return onError({
+            error: error.message || error,
+            code,
+            severity: ComponentErrorSeverity.ERROR,
+        });
+    }
+};
+const makeCheckoutComplete = ({ authToken, checkoutId, service }) => async ({ payment, onSuccess, onError }) => {
+    var _a;
+    try {
+        const response = await service.complete(authToken, checkoutId, payment);
+        if (!response.error) {
+            const checkout = response.data;
+            onSuccess({ checkout });
+        }
+        else {
+            const responseError = getErrorMessage(response.error);
+            const code = getErrorCode((_a = response.error) === null || _a === void 0 ? void 0 : _a.code);
+            return onError({
+                error: responseError,
+                code,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+    }
+    catch (error) {
+        const code = getErrorCode(error === null || error === void 0 ? void 0 : error.code);
+        return onError({
+            error: error.message || error,
+            code,
+            severity: ComponentErrorSeverity.ERROR,
+        });
+    }
+};
+
+var PAYMENT_MODE;
+(function (PAYMENT_MODE) {
+    PAYMENT_MODE["ECOM"] = "ecom";
+    PAYMENT_MODE["BNPL"] = "bnpl";
+    PAYMENT_MODE["APPLE_PAY"] = "apple_pay";
+})(PAYMENT_MODE || (PAYMENT_MODE = {}));
+// Maps the backend payment method types to the frontend payment method types
+var PAYMENT_METHOD_TYPES;
+(function (PAYMENT_METHOD_TYPES) {
+    PAYMENT_METHOD_TYPES["CARD"] = "card";
+    PAYMENT_METHOD_TYPES["BANK_ACCOUNT"] = "bank_account";
+    PAYMENT_METHOD_TYPES["APPLE_PAY"] = "apple_pay";
+    PAYMENT_METHOD_TYPES["GOOGLE_PAY"] = "google_pay";
+    PAYMENT_METHOD_TYPES["SEZZLE"] = "sezzle";
+    PAYMENT_METHOD_TYPES["PLAID"] = "plaid";
+})(PAYMENT_METHOD_TYPES || (PAYMENT_METHOD_TYPES = {}));
+// Available payment methods for the modular checkout component (differentiates between saved and new payment methods)
+var PAYMENT_METHODS;
+(function (PAYMENT_METHODS) {
+    PAYMENT_METHODS["SAVED_CARD"] = "saved_card";
+    PAYMENT_METHODS["NEW_CARD"] = "new_card";
+    PAYMENT_METHODS["SAVED_BANK_ACCOUNT"] = "saved_bank_account";
+    PAYMENT_METHODS["NEW_BANK_ACCOUNT"] = "new_bank_account";
+    PAYMENT_METHODS["APPLE_PAY"] = "apple_pay";
+    PAYMENT_METHODS["GOOGLE_PAY"] = "google_pay";
+    PAYMENT_METHODS["SEZZLE"] = "sezzle";
+    PAYMENT_METHODS["PLAID"] = "plaid";
+})(PAYMENT_METHODS || (PAYMENT_METHODS = {}));
+
+const ModularCheckout = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.errorEvent = createEvent(this, "error-event");
+        this.submitEvent = createEvent(this, "submit-event");
+        this.paymentMethodChangedEvent = createEvent(this, "payment-method-changed");
+        this.savePaymentMethod = false;
+        this.handleApplePayCompleted = (event) => {
+            const { success, token, paymentMethodId, error } = event.detail;
+            if (success && token) {
+                checkoutStore.paymentToken = paymentMethodId;
+                checkoutStore.selectedPaymentMethod = PAYMENT_METHODS.APPLE_PAY;
+                this.submitCheckout();
+            }
+            else {
+                console.error("Apple Pay completed but failed:", error);
+                this.errorEvent.emit({
+                    message: (error === null || error === void 0 ? void 0 : error.message) || "Apple Pay payment failed",
+                    errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                    severity: ComponentErrorSeverity.ERROR,
+                });
+            }
+        };
+        this.handleApplePayError = (event) => {
+            const { error } = event.detail;
+            console.error("Apple Pay error:", error);
+            this.errorEvent.emit({
+                message: error || "Apple Pay error occurred",
+                errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        };
+        this.handleApplePayCancelled = () => {
+            checkoutStore.paymentToken = undefined;
+            checkoutStore.selectedPaymentMethod = undefined;
+        };
+    }
+    savePaymentMethodChanged(newValue) {
+        checkoutStore.savePaymentMethod = newValue;
+    }
+    connectedCallback() {
+        this.observer = new MutationObserver(() => {
+            this.queryFormRefs();
+            this.setupApplePayListeners(); // set up again listeners when DOM changes
+        });
+        this.observer.observe(this.hostEl, {
+            childList: true,
+            subtree: true,
+        });
+        checkoutStore.checkoutId = this.checkoutId;
+        const config = {
+            authToken: this.authToken,
+            checkoutId: this.checkoutId,
+            service: new CheckoutService(),
+        };
+        this.getCheckout = makeGetCheckout(config);
+        this.completeCheckout = makeCheckoutComplete(config);
+        onChange("selectedPaymentMethod", (newValue) => {
+            this.paymentMethodChangedEvent.emit(newValue);
+        });
+    }
+    componentWillLoad() {
+        this.analytics = new JustifiAnalytics(this);
+        checkPkgVersion();
+        checkoutStore.authToken = this.authToken;
+        checkoutStore.savePaymentMethod = this.savePaymentMethod;
+        this.fetchCheckout();
+        // Refresh the checkout data when insurance values actually change (not on initial load)
+        insuranceValuesOn("set", (key) => {
+            const value = insuranceValues[key];
+            if (value !== undefined && hasInsuranceValueChanged(key, value)) {
+                this.fetchCheckout();
+            }
+        });
+    }
+    componentDidLoad() {
+        this.queryFormRefs();
+        this.setupApplePayListeners();
+    }
+    disconnectedCallback() {
+        var _a;
+        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.removeApplePayListeners();
+    }
+    fetchCheckout() {
+        if (!this.authToken || !this.checkoutId) {
+            this.errorEvent.emit({
+                message: ComponentErrorMessages.NOT_AUTHENTICATED,
+                errorCode: ComponentErrorCodes.NOT_AUTHENTICATED,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+            return;
+        }
+        if (this.getCheckout) {
+            this.getCheckout({
+                onSuccess: ({ checkout }) => {
+                    if (checkout.status === ICheckoutStatus.completed) {
+                        this.errorEvent.emit({
+                            message: ComponentErrorMessages.CHECKOUT_ALREADY_COMPLETED,
+                            errorCode: ComponentErrorCodes.CHECKOUT_ALREADY_COMPLETED,
+                            severity: ComponentErrorSeverity.ERROR,
+                        });
+                        return;
+                    }
+                    else if (checkout.status === ICheckoutStatus.expired) {
+                        this.errorEvent.emit({
+                            message: ComponentErrorMessages.CHECKOUT_EXPIRED,
+                            errorCode: ComponentErrorCodes.CHECKOUT_EXPIRED,
+                            severity: ComponentErrorSeverity.ERROR,
+                        });
+                        return;
+                    }
+                    this.updateStore(checkout);
+                },
+                onError: (error) => {
+                    this.errorEvent.emit({
+                        message: error.message,
+                        errorCode: ComponentErrorCodes.FETCH_ERROR,
+                        severity: ComponentErrorSeverity.ERROR,
+                    });
+                },
+            });
+        }
+    }
+    updateStore(checkout) {
+        var _a, _b, _c, _d, _e;
+        checkoutStore.accountId = checkout.account_id;
+        checkoutStore.paymentMethods = checkout.payment_methods;
+        checkoutStore.paymentMethodGroupId = checkout.payment_method_group_id;
+        checkoutStore.paymentDescription = checkout.payment_description;
+        checkoutStore.totalAmount = checkout.total_amount;
+        checkoutStore.paymentAmount = checkout.payment_amount;
+        checkoutStore.bnplEnabled = checkout.payment_settings.bnpl_payments;
+        checkoutStore.insuranceEnabled = checkout.payment_settings.insurance_payments;
+        checkoutStore.bankAccountVerification = (_a = checkout.payment_settings) === null || _a === void 0 ? void 0 : _a.bank_account_verification;
+        checkoutStore.bnplProviderClientId = (_b = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _b === void 0 ? void 0 : _b.provider_client_id;
+        checkoutStore.bnplProviderMode = (_c = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _c === void 0 ? void 0 : _c.provider_mode;
+        checkoutStore.bnplProviderApiVersion = (_d = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _d === void 0 ? void 0 : _d.provider_api_version;
+        checkoutStore.bnplProviderCheckoutUrl =
+            (_e = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _e === void 0 ? void 0 : _e.provider_checkout_url;
+    }
+    queryFormRefs() {
+        this.billingFormRef = this.hostEl.querySelector("justifi-billing-form, justifi-bank-account-billing-form-simple, justifi-card-billing-form-simple, justifi-billing-form-full");
+        this.applePayRef = this.hostEl.querySelector("justifi-apple-pay");
+        this.paymentMethodFormRef =
+            this.hostEl.querySelector('justifi-card-form, justifi-bank-account-form, justifi-tokenize-payment-method');
+        this.insuranceFormRef = this.hostEl.querySelector('justifi-season-interruption-insurance');
+    }
+    setupApplePayListeners() {
+        if (this.applePayRef) {
+            this.applePayRef.addEventListener("applePayCompleted", this.handleApplePayCompleted);
+            this.applePayRef.addEventListener("applePayError", this.handleApplePayError);
+            this.applePayRef.addEventListener("applePayCancelled", this.handleApplePayCancelled);
+        }
+    }
+    removeApplePayListeners() {
+        if (this.applePayRef) {
+            this.applePayRef.removeEventListener("applePayCompleted", this.handleApplePayCompleted);
+            this.applePayRef.removeEventListener("applePayError", this.handleApplePayError);
+            this.applePayRef.removeEventListener("applePayCancelled", this.handleApplePayCancelled);
+        }
+    }
+    async tokenizePaymentMethod(tokenizeArgs) {
+        var _a, _b, _c;
+        const billingInfoValues = (_b = (await ((_a = this.billingFormRef) === null || _a === void 0 ? void 0 : _a.getValues()))) !== null && _b !== void 0 ? _b : {};
+        const combinedBillingInfo = Object.assign(Object.assign({}, tokenizeArgs), billingInfoValues);
+        const paymentMethodMetadata = Object.assign({ accountId: checkoutStore.accountId, payment_method_group_id: undefined }, combinedBillingInfo);
+        if (checkoutStore.savePaymentMethod) {
+            paymentMethodMetadata.payment_method_group_id =
+                checkoutStore.paymentMethodGroupId;
+        }
+        const tokenizeResult = await ((_c = this.paymentMethodFormRef) === null || _c === void 0 ? void 0 : _c.tokenize({
+            clientId: this.authToken,
+            paymentMethodMetadata,
+            account: checkoutStore.accountId,
+        }));
+        if (tokenizeResult.error) {
+            return tokenizeResult;
+        }
+        checkoutStore.paymentToken = tokenizeResult.id;
+        return tokenizeResult.id;
+    }
+    // if validation fails, the error will be emitted by the component
+    async validate() {
+        const promises = [];
+        if (checkoutStore.insuranceEnabled && this.insuranceFormRef) {
+            promises.push(this.insuranceFormRef.validate());
+        }
+        // For new card/bank account, validate payment method + billing.
+        if (checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.NEW_CARD ||
+            checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.NEW_BANK_ACCOUNT) {
+            if (this.paymentMethodFormRef)
+                promises.push(this.paymentMethodFormRef.validate());
+            if (this.billingFormRef)
+                promises.push(this.billingFormRef.validate());
+        }
+        if (promises.length === 0)
+            return true;
+        try {
+            const results = await Promise.all(promises);
+            // Normalize different validator return shapes:
+            // - boolean -> use it directly
+            // - object  -> look for isValid; treat missing isValid as falsey only if explicitly false
+            const resultsAreValid = results.every(r => typeof r === 'boolean' ? r : (r === null || r === void 0 ? void 0 : r.isValid) !== false);
+            if (!resultsAreValid) {
+                this.errorEvent.emit({
+                    message: 'Validation error',
+                    errorCode: ComponentErrorCodes.VALIDATION_ERROR,
+                    severity: ComponentErrorSeverity.ERROR,
+                });
+                return false;
+            }
+            return true;
+        }
+        catch (_a) {
+            // If any validator throws/rejects, consider the whole validation failed.
+            return false;
+        }
+    }
+    async submitCheckout(submitCheckoutArgs) {
+        const isValid = await this.validate();
+        const shouldTokenize = checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.NEW_CARD || checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.NEW_BANK_ACCOUNT;
+        if (shouldTokenize) {
+            const tokenizeResult = await this.tokenizePaymentMethod(submitCheckoutArgs);
+            if (tokenizeResult.error) {
+                this.errorEvent.emit({
+                    message: tokenizeResult.error.message,
+                    errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                    severity: ComponentErrorSeverity.ERROR,
+                });
+                return;
+            }
+        }
+        if (!isValid) {
+            this.errorEvent.emit({
+                message: "Please fill in all required fields.",
+                errorCode: ComponentErrorCodes.VALIDATION_ERROR,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+            return;
+        }
+        if (!checkoutStore.paymentToken) {
+            this.errorEvent.emit({
+                message: 'Payment token not found.',
+                errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+        }
+        let payment;
+        const MAP_PAYMENT_METHOD_TO_PAYMENT_MODE = {
+            [PAYMENT_METHODS.NEW_CARD]: PAYMENT_MODE.ECOM,
+            [PAYMENT_METHODS.NEW_BANK_ACCOUNT]: PAYMENT_MODE.ECOM,
+            [PAYMENT_METHODS.SAVED_BANK_ACCOUNT]: PAYMENT_MODE.ECOM,
+            [PAYMENT_METHODS.SAVED_CARD]: PAYMENT_MODE.ECOM,
+            [PAYMENT_METHODS.SEZZLE]: PAYMENT_MODE.BNPL,
+            [PAYMENT_METHODS.PLAID]: PAYMENT_MODE.ECOM,
+            [PAYMENT_METHODS.APPLE_PAY]: PAYMENT_MODE.APPLE_PAY,
+        };
+        payment = {
+            payment_mode: MAP_PAYMENT_METHOD_TO_PAYMENT_MODE[checkoutStore.selectedPaymentMethod],
+            payment_token: checkoutStore.paymentToken,
+        };
+        this.completeCheckout({
+            payment,
+            onSuccess: ({ checkout }) => {
+                this.submitEvent.emit({
+                    checkout,
+                    message: "Checkout completed successfully",
+                });
+            },
+            onError: (error) => {
+                this.errorEvent.emit({
+                    message: error.message,
+                    errorCode: ComponentErrorCodes.COMPLETE_CHECKOUT_ERROR,
+                    severity: ComponentErrorSeverity.ERROR,
+                });
+            },
+        });
+    }
+    render() {
+        return h(Host, { key: '7c698fd98c705a66564b649d3488239ca51c6165' });
+    }
+    get hostEl() { return getElement(this); }
+    static get watchers() { return {
+        "savePaymentMethod": ["savePaymentMethodChanged"]
+    }; }
+};
+
+const plaidIconSvg = 'data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjQ4IiB2aWV3Qm94PSIwIDAgMjggMjkiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgY2xhc3M9ImNzcy0xcmRhajhtIj48ZyBmaWxsPSIjMTExIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiPjxwYXRoIGQ9Ik0yNS43NjI5IDI2LjI2MjhMMjggMTcuNTMwOUwyNC45NjkxIDE0LjUwMDFMMjcuOTk5OSAxMS40NjkxTDI1Ljc2MjggMi43MzcwNkwxNy4wMzA5IDAuNUwxNC4wMDAxIDMuNTMxTDEwLjk2OSAwLjUwMDE0TDIuMjM3MDYgMi43MzczNEwwIDExLjQ2OTFMMy4wMzEyOCAxNC40OTk5TDAuMDAwMTQgMTcuNTMxTDIuMjM3MiAyNi4yNjI5TDEwLjk2OTEgMjguNUwxNC4wMDAxIDI1LjQ2OUwxNy4wMzEgMjguNDk5OUwyNS43NjI5IDI2LjI2MjhaTTE1LjczMjEgMjMuNzM3MUwxOC42MTg2IDIwLjg1MDVMMjIuMjkxMiAyNC41MjMzTDE3LjY5NTYgMjUuNzAwN0wxNS43MzIxIDIzLjczNzFaTTExLjExMzYgOS44ODE1NEwxNC4wMDAzIDYuOTk1MDJMMTYuODg2OCA5Ljg4MTRMMTQuMDAwMSAxMi43Njc5TDExLjExMzYgOS44ODE1NFpNMTIuMjY4MiAxNC41TDkuMzgxNTQgMTcuMzg2NUw2LjQ5NTAyIDE0LjVMOS4zODE1NCAxMS42MTM1TDEyLjI2ODIgMTQuNVpNMTguNjE4NyAxMS42MTMzTDIxLjUwNTMgMTQuNUwxOC42MTg2IDE3LjM4NjVMMTUuNzMyMSAxNC41TDE4LjYxODcgMTEuNjEzM1pNMTYuODg2NyAxOS4xMTg2TDE0LjAwMDEgMjIuMDA1MUwxMS4xMTM1IDE5LjExODVMMTQuMDAwMSAxNi4yMzE5TDE2Ljg4NjcgMTkuMTE4NlpNMTAuMzA0NCAyNS43MDA3TDUuNzA4NjQgMjQuNTIzM0w5LjM4MTU0IDIwLjg1MDRMMTIuMjY4MiAyMy43MzcxTDEwLjMwNDQgMjUuNzAwN1pNNC43NjMwOCAxNi4yMzE5TDcuNjQ5NiAxOS4xMTg1TDMuOTc2NyAyMi43OTE0TDIuNzk5MyAxOC4xOTU3TDQuNzYzMDggMTYuMjMxOVpNMy45NzY3IDYuMjA4MzZMNy42NDk3NCA5Ljg4MTRMNC43NjMwOCAxMi43NjgxTDIuNzk5MyAxMC44MDQxTDMuOTc2NyA2LjIwODM2Wk0xMi4yNjgzIDUuMjYyOTRMOS4zODE2OCA4LjE0OTZMNS43MDg5MiA0LjQ3NjdMMTAuMzA0NyAzLjI5OTNMMTIuMjY4MyA1LjI2Mjk0Wk0xNy42OTU5IDMuMjk5M0wyMi4yOTE1IDQuNDc2N0wxOC42MTg2IDguMTQ5NDZMMTUuNzMyMSA1LjI2Mjk0TDE3LjY5NTkgMy4yOTkzWk0yMy4yMzcyIDEyLjc2ODFMMjAuMzUwNSA5Ljg4MTRMMjQuMDIzMyA2LjIwODc4TDI1LjIwMDcgMTAuODA0NkwyMy4yMzcyIDEyLjc2ODFaTTI0LjAyMzMgMjIuNzkxNEwyMC4zNTA1IDE5LjExODZMMjMuMjM3MiAxNi4yMzIxTDI1LjIwMDcgMTguMTk1N0wyNC4wMjMzIDIyLjc5MTRaIj48L3BhdGg+PC9nPjwvc3ZnPgo=';
+
+const api = Api();
+class PlaidService {
+    async getLinkToken(authToken, accountId, checkoutId, signal) {
+        const endpoint = `plaid/${accountId}/link`;
+        const body = { checkout_id: checkoutId };
+        return api.post({ endpoint, body, authToken, signal });
+    }
+    async tokenizeBankAccount(authToken, accountId, publicToken, linkTokenId, paymentMethodGroupId, signal) {
+        const endpoint = `plaid/${accountId}/tokenize`;
+        const body = { public_token: publicToken };
+        if (linkTokenId) {
+            body.link_token_id = linkTokenId;
+        }
+        if (paymentMethodGroupId) {
+            body.payment_method_group_id = paymentMethodGroupId;
+        }
+        return api.post({ endpoint, body, authToken, signal });
+    }
+}
+
+// Plaid-specific error codes
+var PlaidErrorCodes;
+(function (PlaidErrorCodes) {
+    PlaidErrorCodes["PLAID_SDK_LOAD_FAILED"] = "plaid-sdk-load-failed";
+    PlaidErrorCodes["PLAID_LINK_INIT_FAILED"] = "plaid-link-init-failed";
+    PlaidErrorCodes["PLAID_LINK_TOKEN_FAILED"] = "plaid-link-token-failed";
+    PlaidErrorCodes["PLAID_AUTHENTICATION_FAILED"] = "plaid-authentication-failed";
+    PlaidErrorCodes["PLAID_BANK_NOT_SUPPORTED"] = "plaid-bank-not-supported";
+    PlaidErrorCodes["PLAID_TOKEN_EXPIRED"] = "plaid-token-expired";
+    PlaidErrorCodes["PLAID_NETWORK_ERROR"] = "plaid-network-error";
+    PlaidErrorCodes["PLAID_USER_CANCELLED"] = "plaid-user-cancelled";
+    PlaidErrorCodes["PLAID_TIMEOUT"] = "plaid-timeout";
+    PlaidErrorCodes["PLAID_INVALID_CREDENTIALS"] = "plaid-invalid-credentials";
+    PlaidErrorCodes["PLAID_ACCOUNT_LOCKED"] = "plaid-account-locked";
+    PlaidErrorCodes["PLAID_MAINTENANCE"] = "plaid-maintenance";
+    PlaidErrorCodes["PLAID_RATE_LIMITED"] = "plaid-rate-limited";
+})(PlaidErrorCodes || (PlaidErrorCodes = {}));
+// Plaid error message mapping
+const PLAID_ERROR_MESSAGES = {
+    [PlaidErrorCodes.PLAID_SDK_LOAD_FAILED]: 'Unable to load Plaid. Please refresh the page and try again.',
+    [PlaidErrorCodes.PLAID_LINK_INIT_FAILED]: 'Unable to initialize bank connection. Please try again.',
+    [PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED]: 'Unable to connect to bank service. Please try again.',
+    [PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED]: 'Bank authentication failed. Please try again.',
+    [PlaidErrorCodes.PLAID_BANK_NOT_SUPPORTED]: 'Your bank is not currently supported. Please try a different payment method.',
+    [PlaidErrorCodes.PLAID_TOKEN_EXPIRED]: 'Your bank session has expired. Please reconnect your account.',
+    [PlaidErrorCodes.PLAID_NETWORK_ERROR]: 'Network connection issue. Please check your internet connection and try again.',
+    [PlaidErrorCodes.PLAID_USER_CANCELLED]: 'Bank connection was cancelled. Click to try again.',
+    [PlaidErrorCodes.PLAID_TIMEOUT]: 'Bank connection timed out. Please try again.',
+    [PlaidErrorCodes.PLAID_INVALID_CREDENTIALS]: 'Invalid bank credentials. Please check your username and password.',
+    [PlaidErrorCodes.PLAID_ACCOUNT_LOCKED]: 'Your bank account is temporarily locked. Please contact your bank.',
+    [PlaidErrorCodes.PLAID_MAINTENANCE]: 'Bank service is temporarily unavailable. Please try again later.',
+    [PlaidErrorCodes.PLAID_RATE_LIMITED]: 'Too many connection attempts. Please wait a moment and try again.',
+};
+// Plaid error severity mapping
+const PLAID_ERROR_SEVERITY = {
+    [PlaidErrorCodes.PLAID_SDK_LOAD_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_LINK_INIT_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_BANK_NOT_SUPPORTED]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_TOKEN_EXPIRED]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_NETWORK_ERROR]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_USER_CANCELLED]: ComponentErrorSeverity.INFO,
+    [PlaidErrorCodes.PLAID_TIMEOUT]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_INVALID_CREDENTIALS]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_ACCOUNT_LOCKED]: ComponentErrorSeverity.ERROR,
+    [PlaidErrorCodes.PLAID_MAINTENANCE]: ComponentErrorSeverity.WARNING,
+    [PlaidErrorCodes.PLAID_RATE_LIMITED]: ComponentErrorSeverity.WARNING,
+};
+const PlaidPaymentMethod = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.paymentMethodOptionSelected = createEvent(this, "paymentMethodOptionSelected");
+        this.plaidError = createEvent(this, "plaidError");
+        this.plaidErrorRecovered = createEvent(this, "plaidErrorRecovered");
+        this.isAuthenticating = false;
+        this.publicToken = null;
+        this.linkToken = null;
+        this.linkTokenId = null;
+        this.error = null;
+        this.plaidLink = null;
+        this.isSelected = false;
+        this.retryCount = 0;
+        this.isRetrying = false;
+        this.plaidService = new PlaidService();
+        this.maxRetries = 3;
+        this.retryDelay = 2000; // 2 seconds
+        this.timeoutId = null;
+        this.abortController = null;
+        this.hasLoggedDisabledWarning = false;
+        this.waitForStoreAndInitialize = () => {
+            // Check if store has necessary data
+            if (checkoutStore.authToken && checkoutStore.accountId && checkoutStore.checkoutId) {
+                this.initializePlaidLink();
+            }
+            else {
+                // Wait a bit and try again
+                setTimeout(() => {
+                    this.waitForStoreAndInitialize();
+                }, 100);
+            }
+        };
+        this.onPaymentMethodOptionClick = (e) => {
+            e.preventDefault();
+            // Update local selection state
+            this.isSelected = true;
+            // Update store selection
+            checkoutStore.selectedPaymentMethod = PAYMENT_METHODS.PLAID;
+            // Emit selection event
+            this.paymentMethodOptionSelected.emit(PAYMENT_METHODS.PLAID);
+            // If there's an error, clear it and try to initialize again
+            if (this.error) {
+                this.clearError();
+                this.waitForStoreAndInitialize();
+                return;
+            }
+            // If Plaid Link is ready and no public token exists, open Plaid Link
+            if (this.plaidLink && !this.publicToken && !this.isAuthenticating) {
+                this.openPlaidLink();
+            }
+        };
+        this.initializePlaidLink = async () => {
+            try {
+                // Check if Plaid is available globally
+                if (typeof window.Plaid === 'undefined') {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_SDK_LOAD_FAILED,
+                        message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                        severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                        retryable: true,
+                        userAction: 'Refresh the page and try again'
+                    });
+                    return;
+                }
+                // Get link token from backend
+                await this.getLinkToken();
+                if (!this.linkToken) {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED,
+                        message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED],
+                        severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED],
+                        retryable: true,
+                        userAction: 'Click to try again'
+                    });
+                    return;
+                }
+                // Initialize Plaid Link
+                const Plaid = window.Plaid;
+                this.plaidLink = Plaid.create({
+                    token: this.linkToken,
+                    onSuccess: this.handlePlaidSuccess,
+                    onExit: this.handlePlaidExit,
+                    onEvent: this.handlePlaidEvent,
+                    onLoad: this.handlePlaidLoad,
+                });
+            }
+            catch (error) {
+                this.handleError({
+                    code: PlaidErrorCodes.PLAID_LINK_INIT_FAILED,
+                    message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_LINK_INIT_FAILED],
+                    severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_LINK_INIT_FAILED],
+                    originalError: error,
+                    retryable: true,
+                    userAction: 'Click to try again'
+                });
+            }
+        };
+        this.getLinkToken = async () => {
+            var _a, _b, _c, _d, _e;
+            try {
+                if (!checkoutStore.authToken || !checkoutStore.accountId) {
+                    this.handleError({
+                        code: PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED,
+                        message: 'Missing authentication. Please refresh the page and try again.',
+                        severity: ComponentErrorSeverity.ERROR,
+                        retryable: false,
+                        userAction: 'Refresh the page'
+                    });
+                    return;
+                }
+                // Create abort controller for timeout handling
+                this.abortController = new AbortController();
+                // Set timeout for the request
+                this.timeoutId = setTimeout(() => {
+                    var _a;
+                    (_a = this.abortController) === null || _a === void 0 ? void 0 : _a.abort();
+                }, 30000); // 30 second timeout
+                const response = await this.plaidService.getLinkToken(checkoutStore.authToken, checkoutStore.accountId, checkoutStore.checkoutId, this.abortController.signal);
+                // Clear timeout
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                if (response.error) {
+                    const errorMessage = typeof response.error === 'string'
+                        ? response.error
+                        : response.error.message || 'Failed to get link token';
+                    throw new Error(errorMessage);
+                }
+                // Some backends may return an id along with the link token
+                this.linkToken = response.data.link_token;
+                // Try to capture link token id if present in envelope
+                this.linkTokenId = (response === null || response === void 0 ? void 0 : response.id) || ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.id) || null;
+            }
+            catch (error) {
+                // Clear timeout
+                if (this.timeoutId) {
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                let errorCode = PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED;
+                let message = PLAID_ERROR_MESSAGES[errorCode];
+                let retryable = true;
+                // Handle specific error types
+                if (error.name === 'AbortError') {
+                    errorCode = PlaidErrorCodes.PLAID_TIMEOUT;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+                else if (((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('network')) || ((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('fetch'))) {
+                    errorCode = PlaidErrorCodes.PLAID_NETWORK_ERROR;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+                else if (((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('401')) || ((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('unauthorized'))) {
+                    errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                    message = 'Authentication failed. Please refresh the page and try again.';
+                    retryable = false;
+                }
+                this.handleError({
+                    code: errorCode,
+                    message: message,
+                    severity: PLAID_ERROR_SEVERITY[errorCode],
+                    originalError: error,
+                    retryable,
+                    userAction: retryable ? 'Click to try again' : 'Refresh the page'
+                });
+            }
+        };
+        this.mapApiErrorToPlaidError = (apiError) => {
+            if (typeof apiError === 'string') {
+                if (apiError.includes('rate_limit'))
+                    return PlaidErrorCodes.PLAID_RATE_LIMITED;
+                if (apiError.includes('maintenance'))
+                    return PlaidErrorCodes.PLAID_MAINTENANCE;
+                if (apiError.includes('not_authenticated'))
+                    return PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+            }
+            if (apiError === null || apiError === void 0 ? void 0 : apiError.code) {
+                switch (apiError.code) {
+                    case 'rate_limited': return PlaidErrorCodes.PLAID_RATE_LIMITED;
+                    case 'maintenance': return PlaidErrorCodes.PLAID_MAINTENANCE;
+                    case 'not_authenticated': return PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                    case 'invalid_parameter': return PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED;
+                    default: return PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED;
+                }
+            }
+            return PlaidErrorCodes.PLAID_LINK_TOKEN_FAILED;
+        };
+        this.openPlaidLink = () => {
+            if (this.plaidLink && this.linkToken) {
+                this.isAuthenticating = true;
+                this.clearError();
+                this.plaidLink.open();
+            }
+        };
+        this.handlePlaidSuccess = (publicToken, _metadata) => {
+            this.publicToken = publicToken;
+            this.isAuthenticating = false;
+            this.clearError();
+            this.retryCount = 0; // Reset retry count on success
+            // Ensure the component remains selected after successful authentication
+            if (!this.isSelected) {
+                this.isSelected = true;
+                checkoutStore.selectedPaymentMethod = PAYMENT_METHODS.PLAID;
+            }
+            // Emit success event for parent components
+            this.plaidErrorRecovered.emit({
+                code: 'plaid-success',
+                message: 'Bank account connected successfully',
+                severity: ComponentErrorSeverity.INFO
+            });
+            // Immediately exchange the public token for a payment method token via backend
+            this.exchangePublicTokenForPaymentMethod();
+        };
+        this.exchangePublicTokenForPaymentMethod = async () => {
+            var _a;
+            if (!this.publicToken) {
+                console.error('[PlaidPaymentMethod] exchange: missing publicToken');
+                return;
+            }
+            if (!checkoutStore.authToken || !checkoutStore.accountId) {
+                console.error('[PlaidPaymentMethod] exchange: missing auth/account context');
+                return;
+            }
+            try {
+                const response = await this.plaidService.tokenizeBankAccount(checkoutStore.authToken, checkoutStore.accountId, this.publicToken, this.linkTokenId || undefined, checkoutStore.savePaymentMethod ? checkoutStore.paymentMethodGroupId : undefined);
+                if (response === null || response === void 0 ? void 0 : response.error) {
+                    console.error('[PlaidPaymentMethod] exchange: backend error', response.error);
+                    return;
+                }
+                // Extract token from payment method response
+                const paymentMethod = response === null || response === void 0 ? void 0 : response.data;
+                const token = ((_a = paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.bank_account) === null || _a === void 0 ? void 0 : _a.token) || (paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.token) || (paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.id);
+                if (!token) {
+                    console.error('[PlaidPaymentMethod] exchange: no token in response');
+                    return;
+                }
+                // Save for downstream submit flows
+                checkoutStore.paymentToken = token;
+            }
+            catch (err) {
+                console.error('[PlaidPaymentMethod] exchange: exception', {
+                    message: (err === null || err === void 0 ? void 0 : err.message) || String(err),
+                });
+            }
+        };
+        this.handlePlaidExit = (err, _metadata) => {
+            this.isAuthenticating = false;
+            if (err) {
+                this.handlePlaidError(err);
+            }
+        };
+        this.handlePlaidEvent = (eventName, metadata) => {
+            // Handle specific events if needed
+            switch (eventName) {
+                case 'OPEN':
+                    this.isAuthenticating = true;
+                    break;
+                case 'CLOSE':
+                    this.isAuthenticating = false;
+                    break;
+                case 'ERROR':
+                    this.handlePlaidError(metadata);
+                    break;
+            }
+        };
+        this.handlePlaidLoad = () => {
+        };
+        this.handlePlaidError = (error) => {
+            let errorCode = PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED;
+            let message = PLAID_ERROR_MESSAGES[errorCode];
+            let retryable = true;
+            let userAction = 'Click to try again';
+            // Map Plaid error codes to our error codes
+            if (error.error_code) {
+                switch (error.error_code) {
+                    case 'INVALID_CREDENTIALS':
+                        errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'ITEM_LOGIN_REQUIRED':
+                        errorCode = PlaidErrorCodes.PLAID_INVALID_CREDENTIALS;
+                        message = 'Your bank requires re-authentication. Please try again.';
+                        retryable = true;
+                        break;
+                    case 'ITEM_LOCKED':
+                        errorCode = PlaidErrorCodes.PLAID_ACCOUNT_LOCKED;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = false;
+                        userAction = 'Contact your bank';
+                        break;
+                    case 'INSTITUTION_NOT_RESPONDING':
+                        errorCode = PlaidErrorCodes.PLAID_MAINTENANCE;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'RATE_LIMIT_EXCEEDED':
+                        errorCode = PlaidErrorCodes.PLAID_RATE_LIMITED;
+                        message = PLAID_ERROR_MESSAGES[errorCode];
+                        retryable = true;
+                        break;
+                    case 'INVALID_REQUEST':
+                        errorCode = PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED;
+                        message = 'Invalid request. Please try again.';
+                        retryable = true;
+                        break;
+                    case 'PLAID_ERROR':
+                        errorCode = PlaidErrorCodes.PLAID_AUTHENTICATION_FAILED;
+                        message = error.error_message || 'Bank authentication failed. Please try again.';
+                        retryable = true;
+                        break;
+                    default:
+                        // Use the error message from Plaid if available
+                        if (error.error_message) {
+                            message = error.error_message;
+                        }
+                        break;
+                }
+            }
+            // Handle specific error messages
+            if (error.error_message) {
+                const lowerMessage = error.error_message.toLowerCase();
+                if (lowerMessage.includes('not supported') || lowerMessage.includes('unsupported')) {
+                    errorCode = PlaidErrorCodes.PLAID_BANK_NOT_SUPPORTED;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = false;
+                    userAction = 'Try a different payment method';
+                }
+                else if (lowerMessage.includes('expired') || lowerMessage.includes('timeout')) {
+                    errorCode = PlaidErrorCodes.PLAID_TOKEN_EXPIRED;
+                    message = PLAID_ERROR_MESSAGES[errorCode];
+                    retryable = true;
+                }
+            }
+            this.handleError({
+                code: errorCode,
+                message,
+                severity: PLAID_ERROR_SEVERITY[errorCode],
+                originalError: error,
+                retryable,
+                userAction
+            });
+            this.isAuthenticating = false;
+        };
+        this.handleError = (plaidError) => {
+            this.error = plaidError;
+            // Emit error event for parent components
+            this.plaidError.emit({
+                code: plaidError.code,
+                message: plaidError.message,
+                severity: plaidError.severity,
+                data: {
+                    originalError: plaidError.originalError,
+                    retryable: plaidError.retryable,
+                    userAction: plaidError.userAction,
+                    retryCount: this.retryCount
+                }
+            });
+            console.error('Plaid error:', plaidError);
+            // Auto-retry for retryable errors if under max retries
+            if (plaidError.retryable && this.retryCount < this.maxRetries) {
+                this.scheduleRetry();
+            }
+        };
+        this.scheduleRetry = () => {
+            if (this.isRetrying)
+                return;
+            this.isRetrying = true;
+            this.retryCount++;
+            setTimeout(() => {
+                this.isRetrying = false;
+                this.clearError();
+                this.waitForStoreAndInitialize();
+            }, this.retryDelay * this.retryCount); // Exponential backoff
+        };
+        this.clearError = () => {
+            if (this.error) {
+                this.error = null;
+                this.retryCount = 0;
+            }
+        };
+        // Watch for store changes to sync component state
+        this.syncWithStore = () => {
+            const shouldBeSelected = checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.PLAID;
+            if (this.isSelected !== shouldBeSelected) {
+                this.isSelected = shouldBeSelected;
+            }
+        };
+    }
+    onSelectionChange(newValue) {
+        // Ensure store is updated when component selection changes
+        if (newValue && checkoutStore.selectedPaymentMethod !== PAYMENT_METHODS.PLAID) {
+            checkoutStore.selectedPaymentMethod = PAYMENT_METHODS.PLAID;
+        }
+    }
+    componentDidRender() {
+        if (!this.scriptRef)
+            return;
+        this.scriptRef.onload = () => {
+            // Wait for store to be populated before initializing
+            this.waitForStoreAndInitialize();
+        };
+        // Add error handler for script loading failures
+        this.scriptRef.onerror = () => {
+            this.handleError({
+                code: PlaidErrorCodes.PLAID_SDK_LOAD_FAILED,
+                message: PLAID_ERROR_MESSAGES[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                severity: PLAID_ERROR_SEVERITY[PlaidErrorCodes.PLAID_SDK_LOAD_FAILED],
+                retryable: true,
+                userAction: 'Refresh the page and try again'
+            });
+        };
+    }
+    componentWillLoad() {
+        // Initialize selection state based on store
+        this.isSelected = checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.PLAID;
+    }
+    async resolvePaymentMethod() {
+        if (!this.publicToken) {
+            return { validationError: true };
+        }
+        return {
+            token: this.publicToken,
+            data: {
+                type: 'bank_account',
+                plaid_public_token: this.publicToken
+            }
+        };
+    }
+    // Returns a usable payment method token for checkout completion.
+    // Will perform the backend exchange if the token is not yet present in the store.
+    async getPaymentToken() {
+        if (checkoutStore.paymentToken) {
+            return checkoutStore.paymentToken;
+        }
+        await this.exchangePublicTokenForPaymentMethod();
+        return checkoutStore.paymentToken;
+    }
+    // Method to handle external selection changes (e.g., from other payment methods)
+    async setSelected(selected) {
+        this.isSelected = selected;
+        if (selected) {
+            checkoutStore.selectedPaymentMethod = PAYMENT_METHODS.PLAID;
+        }
+    }
+    // Method to check if component is currently selected
+    async isCurrentlySelected() {
+        return this.isSelected;
+    }
+    // Method to handle external deselection (when another payment method is selected)
+    async deselect() {
+        this.isSelected = false;
+        // Don't clear the public token or error state as they might be needed if user reselects
+    }
+    // Method to reset component state (useful for testing or error recovery)
+    async reset() {
+        this.publicToken = null;
+        this.clearError();
+        this.isAuthenticating = false;
+        this.linkToken = null;
+        this.plaidLink = null;
+        this.retryCount = 0;
+        this.isRetrying = false;
+        // Clear any pending timeouts
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+        // Abort any pending requests
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+    }
+    // Method to check if component is ready for authentication
+    async isReadyForAuthentication() {
+        return !!(this.plaidLink && this.linkToken && !this.isAuthenticating);
+    }
+    // Method to manually retry after an error
+    async retry() {
+        if (this.error && this.error.retryable) {
+            this.clearError();
+            this.waitForStoreAndInitialize();
+        }
+    }
+    // Method to get current error information
+    async getErrorInfo() {
+        return this.error;
+    }
+    componentDidLoad() {
+        // Set up store change listener to keep component in sync
+        const unsubscribe = onChange('selectedPaymentMethod', this.syncWithStore);
+        // Store unsubscribe function for cleanup
+        this.unsubscribeFromStore = unsubscribe;
+    }
+    disconnectedCallback() {
+        // Clean up store subscription
+        if (this.unsubscribeFromStore) {
+            this.unsubscribeFromStore();
+        }
+        // Clean up timeouts and abort controllers
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+        }
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    render() {
+        // Only allow use if enabled in checkout settings
+        if (checkoutStore.bankAccountVerification !== true) {
+            if (!this.hasLoggedDisabledWarning) {
+                // Log once per component lifecycle
+                console.warn('[PlaidPaymentMethod] bank_account_verification is disabled. Component will not render.');
+                this.hasLoggedDisabledWarning = true;
+            }
+            return null;
+        }
+        const plaidLogo = (h("img", { class: "plaid-logo-img", src: plaidIconSvg, alt: "Plaid", title: "Plaid", style: {
+                display: 'inline',
+                width: '20px',
+                height: '20px',
+                marginLeft: '5px',
+                marginTop: '-2px',
+            } }));
+        const renderErrorState = () => {
+            if (!this.error)
+                return null;
+            const errorClass = this.error.severity === ComponentErrorSeverity.ERROR
+                ? 'text-danger'
+                : this.error.severity === ComponentErrorSeverity.WARNING
+                    ? 'text-warning'
+                    : 'text-info';
+            return (h("div", { class: `${errorClass} mt-2` }, h("small", null, this.error.message), h("br", null), h("small", { class: "text-muted" }, this.error.userAction, this.error.retryable && this.retryCount < this.maxRetries && (h("span", null, " \u2022 Auto-retry in progress...")))));
+        };
+        const renderStatusState = () => {
+            if (this.error)
+                return null;
+            if (this.isAuthenticating) {
+                return (h("div", { class: "text-info mt-2" }, h("small", null, "Connecting to your bank...")));
+            }
+            if (this.publicToken) {
+                return (h("div", { class: "text-success mt-2" }, h("small", null, "\u2713 Bank account connected successfully")));
+            }
+            if (this.isSelected && !this.publicToken && !this.error && !this.isAuthenticating) {
+                return (h("div", { class: "text-muted mt-2" }, h("small", null, "Click to connect your bank account")));
+            }
+            return null;
+        };
+        return (h(StyledHost, { class: "payment-method" }, h("script", { src: "https://cdn.plaid.com/link/v2/stable/link-initialize.js", async: true, ref: (el) => (this.scriptRef = el) }), h("div", { class: "radio-list-item p-3", part: radioListItem, onClick: this.onPaymentMethodOptionClick, title: "Pay with Plaid" }, h("form-control-radio", { name: "paymentMethodType", value: PAYMENT_METHODS.PLAID, checked: this.isSelected, label: h("div", null, h("div", null, "Pay with Bank Account ", plaidLogo, " "), renderErrorState(), renderStatusState()) }))));
+    }
+    static get watchers() { return {
+        "isSelected": ["onSelectionChange"]
+    }; }
+};
+
+const SavedPaymentMethods = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.onPaymentMethodOptionClick = (paymentMethod) => (e) => {
+            e.preventDefault();
+            const SELECTED_PAYMENT_METHODS = {
+                [PAYMENT_METHOD_TYPES.CARD]: PAYMENT_METHODS.SAVED_CARD,
+                [PAYMENT_METHOD_TYPES.BANK_ACCOUNT]: PAYMENT_METHODS.SAVED_BANK_ACCOUNT,
+            };
+            checkoutStore.selectedPaymentMethod = SELECTED_PAYMENT_METHODS[paymentMethod.type];
+            checkoutStore.paymentToken = paymentMethod.id;
+        };
+        this.isAllowedPaymentMethod = (paymentMethod) => {
+            if (paymentMethod.type === PAYMENT_METHOD_TYPES.CARD && checkoutStore.disableCreditCard) {
+                return false;
+            }
+            if (paymentMethod.type === PAYMENT_METHOD_TYPES.BANK_ACCOUNT && checkoutStore.disableBankAccount) {
+                return false;
+            }
+            return true;
+        };
+    }
+    componentWillLoad() {
+        if (!checkoutStore.paymentMethods.length) {
+            console.warn('No saved payment methods available.');
+        }
+        if (checkoutStore.disablePaymentMethodGroup) {
+            console.warn('Payment method group is disabled.');
+        }
+    }
+    render() {
+        if (checkoutStore.disablePaymentMethodGroup) {
+            return null;
+        }
+        return (h(StyledHost, null, h("div", { class: "saved-payment-methods" }, checkoutStore.paymentMethods.length ? checkoutStore.paymentMethods
+            .filter(this.isAllowedPaymentMethod)
+            .map((paymentMethod) => (h("div", { class: "radio-list-item p-3", part: radioListItem, onClick: this.onPaymentMethodOptionClick(paymentMethod) }, h("form-control-radio", { name: "paymentMethodType", value: paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.id, checked: checkoutStore.paymentToken === (paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.id), label: `${CardBrandLabels[paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.brand] || ''} *${paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.acct_last_four}` })))) : null)));
+    }
+};
+
+const sezzleLogo = (h("img", { class: "sezzle-smart-button-logo-img", src: "https://media.sezzle.com/branding/2.0/Sezzle_Logo_FullColor.svg", alt: "Sezzle", style: {
+        display: 'inline',
+        width: '80px',
+        marginLeft: '5px',
+        marginTop: '-5px',
+    } }));
+const SezzlePaymentMethod = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.paymentMethodOptionSelected = createEvent(this, "paymentMethodOptionSelected");
+        this.paymentMethodOptionId = PAYMENT_METHODS.SEZZLE;
+        this.onPaymentMethodOptionClick = (e) => {
+            e.preventDefault();
+            checkoutStore.selectedPaymentMethod = this.paymentMethodOptionId;
+            this.paymentMethodOptionSelected.emit(this.paymentMethodOptionId);
+        };
+        this.initializeSezzleCheckout = () => {
+            let resolveSezzlePromise;
+            this.sezzlePromise = new Promise((resolve) => { resolveSezzlePromise = resolve; });
+            const amount = Number(checkoutStore.paymentAmount);
+            const Checkout = window.Checkout;
+            const checkout = new Checkout({
+                mode: 'popup',
+                publicKey: checkoutStore.bnplProviderClientId,
+                apiMode: checkoutStore.bnplProviderMode,
+                apiVersion: checkoutStore.bnplProviderApiVersion,
+            });
+            checkout.sezzleButtonElement = this.sezzleButtonRef;
+            checkout.init({
+                onClick: function (event) {
+                    event.preventDefault();
+                    checkout.startCheckout({
+                        checkout_url: checkoutStore.bnplProviderCheckoutUrl,
+                    });
+                },
+                onComplete: (event) => resolveSezzlePromise({ bnpl: event.data }),
+                onCancel: (event) => resolveSezzlePromise({ bnpl: event.data }),
+                onFailure: (event) => resolveSezzlePromise({ bnpl: event.data }),
+            });
+            this.sezzleCheckout = checkout;
+            this.installmentPlan = this.sezzleCheckout.getInstallmentPlan(amount);
+        };
+    }
+    componentDidRender() {
+        if (!this.scriptRef)
+            return;
+        this.scriptRef.onload = () => {
+            this.sezzleButtonRef = document.createElement('button');
+            this.initializeSezzleCheckout();
+        };
+    }
+    async resolvePaymentMethod(insuranceValidation) {
+        if (!insuranceValidation.isValid) {
+            return { validationError: true };
+        }
+        this.sezzleButtonRef.click();
+        return this.sezzlePromise;
+    }
+    render() {
+        var _a, _b;
+        if (!checkoutStore.bnplEnabled || checkoutStore.disableBnpl) {
+            console.warn('justifi-sezzle-payment-method: BNPL is not enabled for this account.');
+            return null;
+        }
+        return (h(StyledHost, { class: "payment-method" }, h("script", { src: "https://checkout-sdk.sezzle.com/checkout.min.js", async: true, ref: (el) => (this.scriptRef = el) }), h("div", { class: "radio-list-item p-3", part: radioListItem, onClick: this.onPaymentMethodOptionClick }, h("form-control-radio", { name: "paymentMethodType", value: this.paymentMethodOptionId, checked: checkoutStore.selectedPaymentMethod === PAYMENT_METHODS.SEZZLE, label: h("div", null, h("div", null, "Buy now, pay later with ", sezzleLogo), this.installmentPlan && (h("small", null, h("span", null, (_a = this.installmentPlan) === null || _a === void 0 ? void 0 : _a.installments.length), "\u00A0", h("span", null, this.installmentPlan.schedule, " payments of"), "\u00A0", h("span", { class: "fw-bold" }, formatCurrency((_b = this.installmentPlan) === null || _b === void 0 ? void 0 : _b.installments[0].amountInCents))))) }))));
+    }
+};
+
+// Constants
+const PAYMENT_METHOD_TYPE_LABELS = {
+    [PAYMENT_METHODS.NEW_BANK_ACCOUNT]: 'New bank account',
+    [PAYMENT_METHODS.NEW_CARD]: 'New credit or debit card',
+};
+const ERROR_MESSAGES = {
+    AUTH_TOKEN_REQUIRED: 'Auth token is required when using the tokenize-payment-method component not slotted in justifi-modular-checkout',
+    ACCOUNT_ID_REQUIRED: 'Account ID is required when using the tokenize-payment-method component not slotted in justifi-modular-checkout',
+    FORM_NOT_READY: 'Payment form not ready',
+    VALIDATION_ERROR: 'Validation error',
+};
+const TokenizePaymentMethod = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.errorEvent = createEvent(this, "error-event");
+        this.submitEvent = createEvent(this, "submit-event");
+        this.computedHideSubmitButton = false;
+        this.isLoading = false;
+        this.submitButtonText = 'Submit';
+    }
+    paymentMethodsChanged() {
+        this.setDefaultSelectedPaymentMethod();
+    }
+    connectedCallback() {
+        this.setDefaultSelectedPaymentMethod();
+        this.setComputedHideSubmitButton();
+    }
+    disconnectedCallback() {
+        var _a;
+        (_a = this.analytics) === null || _a === void 0 ? void 0 : _a.cleanup();
+        if (this.unsubscribeFromStore) {
+            this.unsubscribeFromStore();
+        }
+    }
+    componentWillLoad() {
+        checkPkgVersion();
+        this.analytics = new JustifiAnalytics(this);
+    }
+    handleRadioClick(event) {
+        this.selectedPaymentMethod = event.detail;
+        checkoutStore.selectedPaymentMethod = event.detail;
+    }
+    async fillBillingForm(fields) {
+        var _a;
+        (_a = this.billingFormRef) === null || _a === void 0 ? void 0 : _a.fill(fields);
+    }
+    async tokenizePaymentMethod(event) {
+        event === null || event === void 0 ? void 0 : event.preventDefault();
+        this.validateRequiredProps();
+        this.isLoading = true;
+        try {
+            const validation = await this.validate();
+            if (!validation.isValid) {
+                this.errorEvent.emit({
+                    errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                    message: ERROR_MESSAGES.VALIDATION_ERROR,
+                });
+                this.isLoading = false;
+                return;
+            }
+            const tokenizeResponse = await this.resolvePaymentMethod({ isValid: true });
+            if (tokenizeResponse.error) {
+                this.emitError({
+                    errorCode: tokenizeResponse.error.code,
+                    message: tokenizeResponse.error.message,
+                });
+            }
+            this.submitEvent.emit({ response: tokenizeResponse });
+            return tokenizeResponse;
+        }
+        catch (error) {
+            const errorResponse = this.createErrorResponse(ComponentErrorCodes.TOKENIZE_ERROR, error.message);
+            this.emitError({
+                errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                message: error.message,
+            });
+            this.submitEvent.emit({ response: errorResponse });
+            return errorResponse;
+        }
+        finally {
+            this.isLoading = false;
+        }
+    }
+    async validate() {
+        if (!this.areFormsReady()) {
+            return { isValid: false, errors: { general: ERROR_MESSAGES.FORM_NOT_READY } };
+        }
+        const [billingValidation, paymentMethodValidation] = await Promise.all([
+            this.billingFormRef.validate(),
+            this.paymentMethodFormRef.validate(),
+        ]);
+        const result = {
+            isValid: billingValidation.isValid && paymentMethodValidation.isValid,
+            errors: Object.assign(Object.assign({}, billingValidation.errors), paymentMethodValidation.errors),
+        };
+        return result;
+    }
+    async tokenize() {
+        try {
+            const billingFormFieldValues = await this.billingFormRef.getValues();
+            const config = {
+                clientId: this.authToken || checkoutStore.authToken,
+                account: this.accountId || checkoutStore.accountId,
+                paymentMethodMetadata: this.buildPaymentMethodMetadata(billingFormFieldValues),
+            };
+            return await this.paymentMethodFormRef.tokenize(config);
+        }
+        catch (error) {
+            return error;
+        }
+    }
+    // 9. Local methods
+    validateRequiredProps() {
+        if (!this.authToken && !checkoutStore.authToken) {
+            this.emitError({
+                errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                message: ERROR_MESSAGES.AUTH_TOKEN_REQUIRED,
+            });
+        }
+        if (!this.accountId && !checkoutStore.accountId) {
+            this.emitError({
+                errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                message: ERROR_MESSAGES.ACCOUNT_ID_REQUIRED,
+            });
+        }
+    }
+    setDefaultSelectedPaymentMethod() {
+        if (this.selectedPaymentMethod) {
+            return;
+        }
+        if (!this.disableCreditCard) {
+            this.selectedPaymentMethod = PAYMENT_METHODS.NEW_CARD;
+        }
+        else if (!this.disableBankAccount) {
+            this.selectedPaymentMethod = PAYMENT_METHODS.NEW_BANK_ACCOUNT;
+        }
+    }
+    setComputedHideSubmitButton() {
+        // If hideSubmitButton prop is explicitly set, use that value
+        if (this.hideSubmitButton !== undefined) {
+            this.computedHideSubmitButton = this.hideSubmitButton;
+            return;
+        }
+        // Otherwise, auto-detect if component is slotted within modular-checkout
+        const isWithinModularCheckout = this.isSlottedWithinModularCheckout();
+        this.computedHideSubmitButton = isWithinModularCheckout;
+    }
+    isSlottedWithinModularCheckout() {
+        var _a;
+        let parent = (_a = this.host) === null || _a === void 0 ? void 0 : _a.parentElement;
+        while (parent) {
+            if (parent.tagName === 'JUSTIFI-MODULAR-CHECKOUT') {
+                return true;
+            }
+            parent = parent.parentElement;
+        }
+        return false;
+    }
+    get availablePaymentMethods() {
+        const methods = [];
+        if (!this.disableCreditCard) {
+            methods.push(PAYMENT_METHODS.NEW_CARD);
+        }
+        if (!this.disableBankAccount) {
+            methods.push(PAYMENT_METHODS.NEW_BANK_ACCOUNT);
+        }
+        return methods;
+    }
+    areFormsReady() {
+        return !!(this.billingFormRef && this.paymentMethodFormRef);
+    }
+    emitError(errorData) {
+        this.errorEvent.emit(Object.assign(Object.assign({}, errorData), { severity: ComponentErrorSeverity.ERROR }));
+    }
+    createErrorResponse(code, message) {
+        return {
+            error: {
+                code: code,
+                message,
+                decline_code: undefined,
+            },
+        };
+    }
+    async resolvePaymentMethod(insuranceValidation) {
+        if (!this.areFormsReady()) {
+            return this.createErrorResponse('form_not_ready', ERROR_MESSAGES.FORM_NOT_READY);
+        }
+        try {
+            const validation = await this.validate();
+            if (!validation.isValid || !insuranceValidation.isValid) {
+                const errorMessage = Object.values(validation.errors)[0] || ERROR_MESSAGES.VALIDATION_ERROR;
+                return {
+                    validationError: true,
+                    error: {
+                        code: 'validation_error',
+                        message: String(errorMessage),
+                        decline_code: undefined,
+                    },
+                };
+            }
+            const result = await this.performTokenization();
+            return result;
+        }
+        catch (error) {
+            return { error };
+        }
+    }
+    async performTokenization() {
+        var _a, _b;
+        const tokenizeResponse = await this.tokenize();
+        if (tokenizeResponse.error) {
+            return { error: tokenizeResponse.error };
+        }
+        const tokenizeResponseData = tokenizeResponse.data;
+        return {
+            token: ((_a = tokenizeResponseData.card) === null || _a === void 0 ? void 0 : _a.token) || ((_b = tokenizeResponseData.bank_account) === null || _b === void 0 ? void 0 : _b.token),
+            data: tokenizeResponseData,
+        };
+    }
+    buildPaymentMethodMetadata(billingFormFieldValues) {
+        return this.shouldSavePaymentMethod
+            ? Object.assign(Object.assign({}, billingFormFieldValues), { payment_method_group_id: this.paymentMethodGroupID }) : Object.assign({}, billingFormFieldValues);
+    }
+    get paymentMethodGroupID() {
+        return this.paymentMethodGroupId || checkoutStore.paymentMethodGroupId;
+    }
+    get shouldSavePaymentMethod() {
+        return !!(this.paymentMethodGroupId || checkoutStore.savePaymentMethod);
+    }
+    get shouldHideRadioInput() {
+        return this.disableCreditCard || this.disableBankAccount;
+    }
+    renderPaymentMethodOption(paymentMethodType) {
+        const isSelected = this.selectedPaymentMethod === paymentMethodType;
+        return (h("div", { class: "payment-method" }, h("justifi-radio-list-item", { name: "paymentMethodType", value: paymentMethodType, checked: isSelected, label: PAYMENT_METHOD_TYPE_LABELS[paymentMethodType], hidden: this.shouldHideRadioInput }), isSelected && this.renderSelectedPaymentMethodForm(paymentMethodType)));
+    }
+    renderSelectedPaymentMethodForm(paymentMethodId) {
+        return (h("div", { class: "mt-4 pb-4" }, this.renderPaymentMethodForm(paymentMethodId), h("div", { class: "mt-4" }, h("justifi-billing-form", { ref: (el) => (this.billingFormRef = el), hideCardBillingForm: this.hideCardBillingForm, hideBankAccountBillingForm: this.hideBankAccountBillingForm, paymentMethodType: paymentMethodId })), h("div", { class: "mt-4" }, h("justifi-save-new-payment-method", { hidden: !this.paymentMethodGroupID }))));
+    }
+    renderPaymentMethodForm(paymentMethodId) {
+        return paymentMethodId === PAYMENT_METHODS.NEW_CARD ? (h("justifi-card-form", { ref: (el) => (this.paymentMethodFormRef = el) })) : (h("justifi-bank-account-form", { ref: (el) => (this.paymentMethodFormRef = el) }));
+    }
+    render() {
+        return (h(StyledHost, { key: 'a11012d80460057b0dc16dc6a470ad57bad12ca2' }, h("form", { key: '76c8f50a5394f80b171295337a4382a4713d5ec1' }, h("fieldset", { key: '955f99016cb495628afe016037a154fcc39f5ac3' }, h("div", { key: 'a80324943093aa2df3804f5358fb904b5540d92c', class: "row gy-3" }, h("div", { key: 'b5fc2d063e2a859f52c4914ea669b35134d7d256', class: "col-12" }, this.availablePaymentMethods.map((method) => this.renderPaymentMethodOption(method))), h("div", { key: 'f2a759d16742c346bd7833c72916b2a058a1be34', class: "col-12" }, h("justifi-button", { key: 'ab6238aa25cc9dae2851b4156b7c2ac88802b4fd', text: this.submitButtonText, variant: "primary", type: "submit", clickHandler: (e) => this.tokenizePaymentMethod(e), isLoading: this.isLoading, "data-testid": "submit-button", hidden: this.computedHideSubmitButton })))))));
+    }
+    get host() { return getElement(this); }
+    static get watchers() { return {
+        "disableCreditCard": ["paymentMethodsChanged"],
+        "disableBankAccount": ["paymentMethodsChanged"]
+    }; }
+};
+
+export { Summary as justifi_checkout_summary, Header as justifi_header, ModularCheckout as justifi_modular_checkout, PlaidPaymentMethod as justifi_plaid_payment_method, SavedPaymentMethods as justifi_saved_payment_methods, SezzlePaymentMethod as justifi_sezzle_payment_method, TokenizePaymentMethod as justifi_tokenize_payment_method };