@justifi/webcomponents 5.7.6 → 6.0.0-rc.1

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

@@ -0,0 +1,691 @@
+import { r as registerInstance, h, c as createEvent, H as Host, g as getElement } from './index-kpoIU4v_.js';
+import { D as text, r as radioListItem } from './parts-CfF8KKwx.js';
+import { f as formatCurrency } from './utils-lb8p1Exq.js';
+import { c as checkoutStore, o as onChange } from './checkout.store-B60siz2l.js';
+import { S as StyledHost } from './styled-host-B_XBaM7z.js';
+import './event-types-CZfYo5-1.js';
+import { H as Header1 } from './header-1-E-hEi3wF.js';
+import { H as Header2, b as insuranceValuesOn, h as hasInsuranceValueChanged, i as insuranceValues } from './insurance-state-CB4l8sOv.js';
+import { H as Header3 } from './header-3-Dm7M85kz.js';
+import { J as JustifiAnalytics, c as checkPkgVersion } from './check-pkg-version-Bb69ihTN.js';
+import './config-state-BrllxiM0.js';
+import './dinero-HXpYMWUU.js';
+import { C as ComponentErrorSeverity, a as ComponentErrorCodes, b as ComponentErrorMessages } from './ComponentError-Cjcsf8ku.js';
+import { I as ICheckoutStatus, k as PaymentMethodTypes } from './Refund-Di6J0oN2.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-XgGFa7H8.js';
+import { C as CardBrandLabels } from './payment-method-option-utils-lUHAQVFl.js';
+import './index-B9me4yN2.js';
+import './package-O3LY2Da6.js';
+import './Api-N_veT2p6.js';
+import './helpers-Mu7LQT-w.js';
+import './state-options-BX8GieXu.js';
+
+const Summary = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+    }
+    render() {
+        return (h(StyledHost, { key: 'fccb819d66329424af42e9c53effec29a6c9784d' }, h("section", { key: '0ee7a4e0579f7f222a9db82e6b4db6bb92542d9e' }, h("div", { key: 'bdf74b2bc5db35b96ca75d50783b790bb482a76e' }, h("div", { key: '851b481bd6beb1fcaadc106d27d131f8b07d1c9a', part: text }, checkoutStore === null || checkoutStore === void 0 ? void 0 : checkoutStore.paymentDescription), h("div", { key: '0b261bc0e2d65cf989778e02df51b3265816f7aa' }, h("span", { key: '0eee0017ddf25ae45d6b5c828071098f45e6e19d', part: text }, "Total"), "\u00A0", h("span", { key: 'd21576f14c3437f70a4b85b9dfc01107392d663a', 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: 'ae04a67a1eaf95d6d093fef23911ac4eb1523cfe' }, h(HeaderComponent, { key: '51b27dd180d113ebe9ac52f7ff10c494926f7cdf', 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,
+        });
+    }
+};
+
+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;
+    }
+    savePaymentMethodChanged(newValue) {
+        checkoutStore.savePaymentMethod = newValue;
+    }
+    connectedCallback() {
+        this.observer = new MutationObserver(() => {
+            this.queryFormRefs();
+        });
+        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() {
+        if (!this.authToken || !this.checkoutId) {
+            this.errorEvent.emit({
+                message: ComponentErrorMessages.NOT_AUTHENTICATED,
+                errorCode: ComponentErrorCodes.NOT_AUTHENTICATED,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+            return;
+        }
+        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();
+    }
+    disconnectedCallback() {
+        var _a;
+        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
+    }
+    fetchCheckout() {
+        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;
+        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.bnplProviderClientId = (_a = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _a === void 0 ? void 0 : _a.provider_client_id;
+        checkoutStore.bnplProviderMode = (_b = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _b === void 0 ? void 0 : _b.provider_mode;
+        checkoutStore.bnplProviderApiVersion = (_c = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _c === void 0 ? void 0 : _c.provider_api_version;
+        checkoutStore.bnplProviderCheckoutUrl = (_d = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _d === void 0 ? void 0 : _d.provider_checkout_url;
+    }
+    queryFormRefs() {
+        this.paymentMethodFormRef = this.hostEl.querySelector('justifi-card-form, justifi-bank-account-form');
+        this.billingFormRef = this.hostEl.querySelector('justifi-billing-form, justifi-bank-account-billing-form-simple, justifi-card-billing-form-simple, justifi-billing-form-full');
+        this.insuranceFormRef = this.hostEl.querySelector('justifi-season-interruption-insurance');
+        this.sezzlePaymentMethodRef = this.hostEl.querySelector('justifi-sezzle-payment-method');
+    }
+    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;
+        }
+        return (_c = this.paymentMethodFormRef) === null || _c === void 0 ? void 0 : _c.tokenize({
+            clientId: this.authToken,
+            paymentMethodMetadata,
+            account: checkoutStore.accountId,
+        });
+    }
+    async getPaymentMethod(submitCheckoutArgs) {
+        // If we have a payment token from the store (set by tokenize-payment-method), use it
+        if (checkoutStore.paymentToken) {
+            return checkoutStore.paymentToken;
+        }
+        // Fallback to the original tokenization logic for backward compatibility
+        if (!this.paymentMethodFormRef) {
+            return checkoutStore.selectedPaymentMethod;
+        }
+        const { error, id: token } = await this.tokenizePaymentMethod(submitCheckoutArgs);
+        if (error) {
+            this.errorEvent.emit({
+                errorCode: error.code,
+                message: error.message,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+            return undefined;
+        }
+        return token;
+    }
+    async validate() {
+        var _a, _b;
+        console.log('billing information form', this.billingFormRef);
+        console.log('payment method form', this.paymentMethodFormRef);
+        console.log('insurance form', this.insuranceFormRef);
+        console.log('sezzle payment method', this.sezzlePaymentMethodRef);
+        const promises = [
+            (_a = this.paymentMethodFormRef) === null || _a === void 0 ? void 0 : _a.validate(),
+            (_b = this.billingFormRef) === null || _b === void 0 ? void 0 : _b.validate()
+        ];
+        if (this.insuranceFormRef) {
+            promises.push(this.insuranceFormRef.validate());
+        }
+        const validationResults = await Promise.all(promises);
+        return validationResults.every(result => (result === null || result === void 0 ? void 0 : result.isValid) !== false);
+    }
+    async submitCheckout(submitCheckoutArgs) {
+        var _a;
+        const isValid = await this.validate();
+        if (!isValid) {
+            this.errorEvent.emit({
+                message: 'Please fill in all required fields.',
+                errorCode: ComponentErrorCodes.VALIDATION_ERROR,
+                severity: ComponentErrorSeverity.ERROR,
+            });
+            return;
+        }
+        let payment;
+        if (checkoutStore.selectedPaymentMethod === 'sezzle') {
+            const insuranceValidation = this.insuranceFormRef ? await this.insuranceFormRef.validate() : { isValid: true };
+            const sezzleResult = await this.sezzlePaymentMethodRef.resolvePaymentMethod(insuranceValidation);
+            if (sezzleResult.error) {
+                this.errorEvent.emit({
+                    message: sezzleResult.error.message,
+                    errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                    severity: ComponentErrorSeverity.ERROR,
+                });
+                return;
+            }
+            else if (((_a = sezzleResult.bnpl) === null || _a === void 0 ? void 0 : _a.status) === 'success') {
+                payment = {
+                    payment_mode: 'bnpl',
+                    payment_token: undefined,
+                };
+            }
+        }
+        else {
+            const paymentMethod = await this.getPaymentMethod(submitCheckoutArgs);
+            if (!paymentMethod) {
+                this.errorEvent.emit({
+                    message: 'Payment method tokenization failed.',
+                    errorCode: ComponentErrorCodes.TOKENIZE_ERROR,
+                    severity: ComponentErrorSeverity.ERROR,
+                });
+                return;
+            }
+            payment = {
+                payment_mode: 'ecom',
+                payment_token: paymentMethod,
+            };
+        }
+        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,
+                });
+            },
+        });
+    }
+    async setSelectedPaymentMethod(paymentMethodId) {
+        checkoutStore.selectedPaymentMethod = paymentMethodId;
+    }
+    render() {
+        return (h(Host, { key: 'd454d321b1a7a6e3b4097c94fbb05e02ce3e36a9' }));
+    }
+    get hostEl() { return getElement(this); }
+    static get watchers() { return {
+        "savePaymentMethod": ["savePaymentMethodChanged"]
+    }; }
+};
+
+const SavedPaymentMethods = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.onPaymentMethodOptionClick = (paymentMethodId) => (e) => {
+            e.preventDefault();
+            checkoutStore.selectedPaymentMethod = paymentMethodId;
+        };
+        this.isAllowedPaymentMethod = (paymentMethod) => {
+            if (paymentMethod.type === 'card' && checkoutStore.disableCreditCard) {
+                return false;
+            }
+            if (paymentMethod.type === '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 === null || paymentMethod === void 0 ? void 0 : paymentMethod.id) }, h("form-control-radio", { name: "paymentMethodType", value: paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.id, checked: checkoutStore.selectedPaymentMethod === (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 = '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 === this.paymentMethodOptionId, 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 = {
+    [PaymentMethodTypes.bankAccount]: 'New bank account',
+    [PaymentMethodTypes.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.isLoading = false;
+        this.computedHideSubmitButton = false;
+        this.submitButtonText = 'Submit';
+    }
+    componentWillLoad() {
+        checkPkgVersion();
+        this.analytics = new JustifiAnalytics(this);
+        this.validateRequiredProps();
+    }
+    connectedCallback() {
+        this.setDefaultSelectedPaymentMethod();
+        this.setComputedHideSubmitButton();
+    }
+    disconnectedCallback() {
+        var _a;
+        (_a = this.analytics) === null || _a === void 0 ? void 0 : _a.cleanup();
+    }
+    paymentMethodsChanged() {
+        this.setDefaultSelectedPaymentMethod();
+    }
+    handleRadioClick(event) {
+        this.selectedPaymentMethodId = 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.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(),
+        ]);
+        return {
+            isValid: billingValidation.isValid && paymentMethodValidation.isValid,
+            errors: Object.assign(Object.assign({}, billingValidation.errors), paymentMethodValidation.errors),
+        };
+    }
+    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.selectedPaymentMethodId) {
+            return;
+        }
+        if (!this.disableCreditCard) {
+            this.selectedPaymentMethodId = PaymentMethodTypes.card;
+        }
+        else if (!this.disableBankAccount) {
+            this.selectedPaymentMethodId = PaymentMethodTypes.bankAccount;
+        }
+    }
+    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(PaymentMethodTypes.card);
+        }
+        if (!this.disableBankAccount) {
+            methods.push(PaymentMethodTypes.bankAccount);
+        }
+        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,
+                    },
+                };
+            }
+            return await this.performTokenization();
+        }
+        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,
+        };
+    }
+    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;
+        }
+    }
+    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.selectedPaymentMethodId === 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("justifi-save-new-payment-method", { hidden: !this.paymentMethodGroupID })));
+    }
+    renderPaymentMethodForm(paymentMethodId) {
+        return paymentMethodId === PaymentMethodTypes.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: '11b857dea77d2f753e400cfaf021db51326ffc36' }, h("form", { key: 'fd1c625c62b1699157b24834e15c4c6e0bc93b84' }, h("fieldset", { key: 'febf7db57a5ceda457e21287c20df817b101b45d' }, h("div", { key: '1089c358094a3f0cea1c97b807779c7eb6e9e692', class: "row gy-3" }, h("div", { key: 'f564fbfec389008e352f9de54fdb604be56d8826', class: "col-12" }, this.availablePaymentMethods.map((method) => this.renderPaymentMethodOption(method))), h("div", { key: 'e3e7f46529d1a659f387fb6df0914c168d556e27', class: "col-12" }, h("justifi-button", { key: 'd729f38c5b55c174de479ab57da56defd327366b', 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, SavedPaymentMethods as justifi_saved_payment_methods, SezzlePaymentMethod as justifi_sezzle_payment_method, TokenizePaymentMethod as justifi_tokenize_payment_method };