@justifi/webcomponents 6.0.4 → 6.0.6-rc.1

package/dist/cjs/{justifi-checkout-summary_7.cjs.entry.js → justifi-apple-pay_8.cjs.entry.js}

@@ -1,38 +1,904 @@
 'use strict';
 
-var index = require('./index-CoKhq0yT.js');
-var parts = require('./parts-9jMf1erK.js');
-var utils = require('./utils-ChCUZgUy.js');
-var checkout_store = require('./checkout.store-WVXAN_mi.js');
-var styledHost = require('./styled-host-BeBLN_42.js');
+var index = require('./index-Bhtk1qkX.js');
+var Api = require('./Api-CjtvTD2_.js');
+var styledHost = require('./styled-host-BSooSIhA.js');
 require('./event-types-YOY5TKUN.js');
-var header1 = require('./header-1-8mY0uvLp.js');
-var insuranceState = require('./insurance-state-CN0jLsMn.js');
-var header3 = require('./header-3-BkMrxDLW.js');
-var checkPkgVersion = require('./check-pkg-version-DBsrbl8J.js');
-require('./config-state-B5-AuTAI.js');
+var skeleton = require('./skeleton-BvdAh448.js');
+var checkout_store = require('./checkout.store-Bswr7kNY.js');
+var parts = require('./parts-Pb06tUMp.js');
+var utils = require('./utils-Bab-tddY.js');
+var header1 = require('./header-1-D3r87SC6.js');
+var insuranceState = require('./insurance-state-JbqYvJN3.js');
+var header3 = require('./header-3-BFQJJgBb.js');
+var checkPkgVersion = require('./check-pkg-version-BqQyunnf.js');
+require('./config-state-C7babhLh.js');
 require('./dinero-BwNN_k7x.js');
 var ComponentError = require('./ComponentError-D4OLnOkg.js');
-var Refund = require('./Refund-CFOz9QoU.js');
+var Refund = require('./Refund-BnhHNKLz.js');
 require('./Pagination-Dediz133.js');
 require('./Business-DCRzZf0w.js');
 require('./Dispute-CruQTF6_.js');
 var utils$1 = require('./utils-DvUQQLmR.js');
-var checkout_service = require('./checkout.service-DRV9oDxT.js');
-var Api = require('./Api-DHhR05W5.js');
+var checkout_service = require('./checkout.service-Bc8L9ixO.js');
 var index$1 = require('./index-C2ITzalN.js');
 var paymentMethodOptionUtils = require('./payment-method-option-utils-WYHIHy-l.js');
-require('./index-B8q7TYrk.js');
-require('./package-Cuc8l3LN.js');
+require('./index-CWM5ions.js');
+require('./package-CeJ5geYu.js');
 require('./helpers-B5OCqlIM.js');
 require('./state-options-CIT9xdTz.js');
 
+var ApplePaySessionStatus;
+(function (ApplePaySessionStatus) {
+    ApplePaySessionStatus["STATUS_SUCCESS"] = "STATUS_SUCCESS";
+    ApplePaySessionStatus["STATUS_FAILURE"] = "STATUS_FAILURE";
+})(ApplePaySessionStatus || (ApplePaySessionStatus = {}));
+var ApplePayButtonType;
+(function (ApplePayButtonType) {
+    ApplePayButtonType["PLAIN"] = "plain";
+    ApplePayButtonType["BUY"] = "buy";
+    ApplePayButtonType["SET_UP"] = "set-up";
+    ApplePayButtonType["DONATE"] = "donate";
+    ApplePayButtonType["CHECK_OUT"] = "check-out";
+    ApplePayButtonType["BOOK"] = "book";
+    ApplePayButtonType["SUBSCRIBE"] = "subscribe";
+})(ApplePayButtonType || (ApplePayButtonType = {}));
+var ApplePayButtonStyle;
+(function (ApplePayButtonStyle) {
+    ApplePayButtonStyle["BLACK"] = "black";
+    ApplePayButtonStyle["WHITE"] = "white";
+    ApplePayButtonStyle["WHITE_OUTLINE"] = "white-outline";
+})(ApplePayButtonStyle || (ApplePayButtonStyle = {}));
+var ApplePayMerchantCapability;
+(function (ApplePayMerchantCapability) {
+    ApplePayMerchantCapability["SUPPORTS_3DS"] = "supports3DS";
+    ApplePayMerchantCapability["SUPPORTS_EMV"] = "supportsEMV";
+    ApplePayMerchantCapability["SUPPORTS_CREDIT"] = "supportsCredit";
+    ApplePayMerchantCapability["SUPPORTS_DEBIT"] = "supportsDebit";
+})(ApplePayMerchantCapability || (ApplePayMerchantCapability = {}));
+class ApplePayConfig {
+    constructor(data) {
+        this.merchantIdentifier = data.merchantIdentifier;
+        this.displayName = data.displayName;
+        this.initiative = data.initiative;
+        this.initiativeContext = data.initiativeContext;
+        this.buttonType = data.buttonType || ApplePayButtonType.PLAIN;
+        this.buttonStyle = data.buttonStyle || ApplePayButtonStyle.BLACK;
+        this.buttonLocale = data.buttonLocale || 'en-US';
+    }
+    get isValid() {
+        return !!(this.merchantIdentifier &&
+            this.displayName &&
+            this.initiative &&
+            this.initiativeContext);
+    }
+}
+class ApplePayPaymentRequest {
+    constructor(data) {
+        this.countryCode = data.countryCode;
+        this.currencyCode = data.currencyCode;
+        this.merchantCapabilities = data.merchantCapabilities;
+        this.supportedNetworks = data.supportedNetworks;
+        this.total = data.total;
+        this.lineItems = data.lineItems;
+        this.shippingMethods = data.shippingMethods;
+        this.applicationData = data.applicationData;
+        this.supportedCountries = data.supportedCountries;
+    }
+    get isValid() {
+        var _a, _b, _c, _d;
+        return !!(this.countryCode &&
+            this.currencyCode &&
+            ((_a = this.merchantCapabilities) === null || _a === void 0 ? void 0 : _a.length) &&
+            ((_b = this.supportedNetworks) === null || _b === void 0 ? void 0 : _b.length) &&
+            ((_c = this.total) === null || _c === void 0 ? void 0 : _c.label) &&
+            ((_d = this.total) === null || _d === void 0 ? void 0 : _d.amount));
+    }
+}
+class ApplePayHelpers {
+    static isApplePaySupported() {
+        var _a;
+        return (typeof window !== 'undefined' &&
+            'ApplePaySession' in window &&
+            ((_a = window.ApplePaySession) === null || _a === void 0 ? void 0 : _a.supportsVersion(3)));
+    }
+    static canMakePayments() {
+        var _a;
+        if (!this.isApplePaySupported()) {
+            return false;
+        }
+        return ((_a = window.ApplePaySession) === null || _a === void 0 ? void 0 : _a.canMakePayments()) || false;
+    }
+    static async canMakePaymentsWithActiveCard(merchantIdentifier) {
+        var _a;
+        if (!this.isApplePaySupported()) {
+            return false;
+        }
+        try {
+            return ((await ((_a = window.ApplePaySession) === null || _a === void 0 ? void 0 : _a.canMakePaymentsWithActiveCard(merchantIdentifier))) || false);
+        }
+        catch (error) {
+            console.error('Error checking Apple Pay active card:', error);
+            return false;
+        }
+    }
+    static formatAmount(amount) {
+        return (amount / 100).toFixed(2);
+    }
+    static parseAmount(amount) {
+        return Math.round(parseFloat(amount) * 100);
+    }
+    static createLineItem(label, amount, type = 'final') {
+        return {
+            label,
+            amount: this.formatAmount(amount),
+            type,
+        };
+    }
+    static getDefaultSupportedNetworks() {
+        return ['amex', 'discover', 'masterCard', 'visa'];
+    }
+    static getDefaultMerchantCapabilities() {
+        return [
+            ApplePayMerchantCapability.SUPPORTS_3DS,
+            ApplePayMerchantCapability.SUPPORTS_EMV,
+            ApplePayMerchantCapability.SUPPORTS_CREDIT,
+            ApplePayMerchantCapability.SUPPORTS_DEBIT,
+        ];
+    }
+}
+
+// Centralized error codes for Apple Pay service
+var ApplePayServiceErrorCode;
+(function (ApplePayServiceErrorCode) {
+    ApplePayServiceErrorCode["UNAVAILABLE"] = "UNAVAILABLE";
+    ApplePayServiceErrorCode["SESSION_ERROR"] = "SESSION_ERROR";
+    ApplePayServiceErrorCode["MERCHANT_VALIDATION_ERROR"] = "MERCHANT_VALIDATION_ERROR";
+    ApplePayServiceErrorCode["PAYMENT_PROCESSING_ERROR"] = "PAYMENT_PROCESSING_ERROR";
+    ApplePayServiceErrorCode["USER_CANCELLED"] = "USER_CANCELLED";
+})(ApplePayServiceErrorCode || (ApplePayServiceErrorCode = {}));
+class ApplePayService {
+    constructor() {
+        this.api = Api.Api();
+    }
+    /**
+     * Initialize Apple Pay configuration
+     */
+    initialize(applePayConfig) {
+        this.applePayConfig = new ApplePayConfig(applePayConfig);
+        if (!this.applePayConfig.isValid) {
+            throw new Error('Invalid Apple Pay configuration provided');
+        }
+    }
+    /**
+     * Validate merchant with Apple Pay servers via API
+     */
+    async validateMerchant(authToken, accountId) {
+        const endpoint = 'apple_pay/merchant_session';
+        try {
+            const response = await this.api.post({
+                endpoint,
+                authToken,
+                headers: {
+                    'Sub-Account': accountId,
+                },
+            });
+            return response;
+        }
+        catch (error) {
+            console.error('Backend validation failed:', error);
+            throw new Error('Merchant validation failed');
+        }
+    }
+    /**
+     * Process Apple Pay payment via API (fixed to match original logic)
+     */
+    async processPayment(authToken, accountId, payload) {
+        const endpoint = 'apple_pay/process_token';
+        const result = await this.api.post({
+            endpoint,
+            authToken,
+            body: payload,
+            headers: {
+                'Sub-Account': accountId,
+            },
+        });
+        return {
+            success: result.id && !!result.data.token,
+            data: result,
+        };
+    }
+    /**
+     * Check if Apple Pay is available on this device/browser
+     */
+    isAvailable() {
+        return (ApplePayHelpers.isApplePaySupported() && ApplePayHelpers.canMakePayments());
+    }
+    /**
+     * Check if the user has an active card for the merchant
+     */
+    async canMakePaymentsWithActiveCard() {
+        if (!this.applePayConfig) {
+            throw new Error('Apple Pay not initialized. Call initialize() first.');
+        }
+        return await ApplePayHelpers.canMakePaymentsWithActiveCard(this.applePayConfig.merchantIdentifier);
+    }
+    /**
+     * Start Apple Pay session
+     */
+    async startPaymentSession(paymentRequest, authToken, accountId) {
+        // Begin verbose diagnostics for easier debugging in the field
+        console.groupCollapsed('[ApplePayService] startPaymentSession called');
+        console.log('[ApplePayService] raw paymentRequest:', JSON.stringify(paymentRequest, null, 2));
+        console.log('[ApplePayService] has authToken:', Boolean(authToken));
+        console.log('[ApplePayService] accountId:', accountId);
+        console.log('[ApplePayService] has config:', Boolean(this.applePayConfig));
+        if (!this.applePayConfig) {
+            console.error('[ApplePayService] Missing applePayConfig. Did you call initialize()?');
+            console.groupEnd();
+            throw new Error('Apple Pay not initialized. Call initialize() first.');
+        }
+        // if (!this.isAvailable()) {
+        //   throw new Error('Apple Pay is not available on this device/browser');
+        // }
+        const request = new ApplePayPaymentRequest(paymentRequest);
+        console.log('[ApplePayService] created ApplePayPaymentRequest:', request);
+        if (!request.isValid) {
+            const missingFields = [];
+            if (!request.countryCode)
+                missingFields.push('countryCode');
+            if (!request.currencyCode)
+                missingFields.push('currencyCode');
+            if (!request.merchantCapabilities ||
+                request.merchantCapabilities.length === 0)
+                missingFields.push('merchantCapabilities');
+            if (!request.supportedNetworks || request.supportedNetworks.length === 0)
+                missingFields.push('supportedNetworks');
+            if (!request.total || !request.total.label || !request.total.amount)
+                missingFields.push('total');
+            console.error('[ApplePayService] Payment request is invalid. Missing/invalid:', missingFields);
+            console.groupEnd();
+            throw new Error('Invalid payment request provided');
+        }
+        this.currentPaymentRequest = request;
+        return new Promise((resolve, reject) => {
+            try {
+                console.log('[ApplePayService] About to instantiate ApplePaySession');
+                // Defensive checks for Apple Pay environment
+                if (typeof window === 'undefined' || !('ApplePaySession' in window)) {
+                    console.error('[ApplePayService] ApplePaySession not available on window');
+                    console.groupEnd();
+                    return reject({
+                        success: false,
+                        error: {
+                            code: ApplePayServiceErrorCode.UNAVAILABLE,
+                            message: 'ApplePaySession API is not available in this environment',
+                        },
+                    });
+                }
+                this.currentSession = new window.ApplePaySession(3, request);
+                console.log('[ApplePayService] ApplePaySession instantiated:', this.currentSession);
+                this.setupSessionEventHandlers(resolve, reject, authToken, accountId);
+                console.log('[ApplePayService] Event handlers set. Beginning session...');
+                this.currentSession.begin();
+                console.log('[ApplePayService] Session.begin() called');
+                console.groupEnd();
+            }
+            catch (error) {
+                console.error('[ApplePayService] Exception while starting session:', error);
+                console.groupEnd();
+                reject({
+                    success: false,
+                    error: {
+                        code: ApplePayServiceErrorCode.SESSION_ERROR,
+                        message: error instanceof Error
+                            ? error.message
+                            : 'Failed to start Apple Pay session',
+                    },
+                });
+            }
+        });
+    }
+    /**
+     * Abort current Apple Pay session
+     */
+    abortPaymentSession() {
+        if (this.currentSession) {
+            this.currentSession.abort();
+            this.currentSession = undefined;
+            this.currentPaymentRequest = undefined;
+        }
+    }
+    /**
+     * Setup Apple Pay session event handlers
+     */
+    setupSessionEventHandlers(resolve, reject, authToken, accountId) {
+        if (!this.currentSession ||
+            !this.applePayConfig ||
+            !this.currentPaymentRequest) {
+            console.error('[ApplePayService] setupSessionEventHandlers called without required state', {
+                hasSession: Boolean(this.currentSession),
+                hasConfig: Boolean(this.applePayConfig),
+                hasPaymentRequest: Boolean(this.currentPaymentRequest),
+            });
+            return;
+        }
+        this.currentSession.onvalidatemerchant = async () => {
+            console.groupCollapsed('[ApplePayService] onvalidatemerchant');
+            try {
+                console.log('[ApplePayService] accountId:', accountId);
+                if (!authToken) {
+                    console.error('[ApplePayService] Missing authToken for merchant validation');
+                    throw new Error('Authentication token not provided.');
+                }
+                const merchantSession = await this.validateMerchant(authToken, accountId);
+                console.log('[ApplePayService] merchantSession received');
+                try {
+                    this.currentSession.completeMerchantValidation(merchantSession);
+                    console.log('[ApplePayService] completeMerchantValidation called');
+                }
+                catch (completionError) {
+                    console.error('Error calling completeMerchantValidation:', completionError);
+                    throw completionError;
+                }
+            }
+            catch (error) {
+                console.error('=== MERCHANT VALIDATION ERROR ===');
+                console.error('Error during merchant validation:', error);
+                if (error && error.stack) {
+                    console.error('Error stack:', error.stack);
+                }
+                this.currentSession.abort();
+                reject({
+                    success: false,
+                    error: {
+                        code: ApplePayServiceErrorCode.MERCHANT_VALIDATION_ERROR,
+                        message: error instanceof Error
+                            ? error.message
+                            : 'Merchant validation failed',
+                    },
+                });
+            }
+            console.groupEnd();
+        };
+        this.currentSession.onpaymentauthorized = async (event) => {
+            var _a;
+            console.groupCollapsed('[ApplePayService] onpaymentauthorized');
+            try {
+                const payment = event.payment;
+                console.log('[ApplePayService] payment payload snapshot:', {
+                    hasToken: Boolean(payment === null || payment === void 0 ? void 0 : payment.token),
+                    tokenType: ((_a = payment === null || payment === void 0 ? void 0 : payment.token) === null || _a === void 0 ? void 0 : _a.paymentData) ? 'paymentData' : 'raw',
+                });
+                const paymentPayload = Object.assign(Object.assign({}, payment.token), { product_details: {
+                        name: this.currentPaymentRequest.total.label,
+                        price: ApplePayHelpers.parseAmount(this.currentPaymentRequest.total.amount),
+                        description: this.currentPaymentRequest.total.label,
+                    } });
+                console.log('[ApplePayService] paymentPayload prepared');
+                const paymentResult = await this.processPayment(authToken, accountId, paymentPayload);
+                console.log('[ApplePayService] processPayment result:', paymentResult);
+                if (paymentResult.success) {
+                    this.currentSession.completePayment({
+                        status: ApplePaySessionStatus.STATUS_SUCCESS,
+                    });
+                    console.log('[ApplePayService] Payment success; resolving');
+                    resolve({
+                        success: true,
+                        token: payment.token,
+                        paymentMethodId: paymentResult.data.id,
+                    });
+                }
+                else {
+                    console.error('PSP reported payment failure:', paymentResult.data);
+                    this.currentSession.completePayment({
+                        status: ApplePaySessionStatus.STATUS_FAILURE,
+                    });
+                    reject({
+                        success: false,
+                        error: {
+                            code: ApplePayServiceErrorCode.PAYMENT_PROCESSING_ERROR,
+                            message: 'Payment processing failed',
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                console.error('=== PAYMENT PROCESSING ERROR ===');
+                console.error('Error processing payment:', error);
+                if (error && error.stack) {
+                    console.error('Error stack:', error.stack);
+                }
+                this.currentSession.completePayment({
+                    status: ApplePaySessionStatus.STATUS_FAILURE,
+                });
+                reject({
+                    success: false,
+                    error: {
+                        code: ApplePayServiceErrorCode.PAYMENT_PROCESSING_ERROR,
+                        message: error instanceof Error
+                            ? error.message
+                            : 'Payment processing failed',
+                    },
+                });
+            }
+            finally {
+                console.log('[ApplePayService] Cleaning up session state');
+                this.currentSession = undefined;
+                this.currentPaymentRequest = undefined;
+            }
+            console.groupEnd();
+        };
+        this.currentSession.onpaymentmethodselected = () => {
+            console.groupCollapsed('[ApplePayService] onpaymentmethodselected');
+            const paymentUpdate = {
+                newTotal: this.currentPaymentRequest.total,
+                newLineItems: this.currentPaymentRequest.lineItems || [],
+            };
+            try {
+                this.currentSession.completePaymentMethodSelection(paymentUpdate);
+                console.log('[ApplePayService] completePaymentMethodSelection called');
+            }
+            catch (error) {
+                console.error('Error completing payment method selection:', error);
+                this.currentSession.abort();
+            }
+            console.groupEnd();
+        };
+        this.currentSession.onshippingmethodselected = () => {
+            console.groupCollapsed('[ApplePayService] onshippingmethodselected');
+            this.currentSession.completeShippingMethodSelection({
+                status: ApplePaySessionStatus.STATUS_SUCCESS,
+                newTotal: this.currentPaymentRequest.total,
+                newLineItems: this.currentPaymentRequest.lineItems || [],
+            });
+            console.log('[ApplePayService] completeShippingMethodSelection called');
+            console.groupEnd();
+        };
+        this.currentSession.oncancel = (event) => {
+            console.groupCollapsed('[ApplePayService] oncancel');
+            if (event.sessionError) {
+                console.error(event.sessionError);
+                switch (event.sessionError.code) {
+                    case 'unknown':
+                        console.error('Unknown error - likely merchant validation issue');
+                        console.error('This usually means:');
+                        console.error('1. Merchant certificate is invalid or expired');
+                        console.error('2. Merchant identifier mismatch');
+                        console.error('3. Backend validation endpoint issues');
+                        break;
+                    case 'invalidMerchantSession':
+                        console.error('Invalid merchant session provided');
+                        console.error('Check that the merchant session from backend is valid');
+                        break;
+                    case 'userCancel':
+                        console.error('User cancelled the payment');
+                        break;
+                    default:
+                        console.error('Other error code:', event.sessionError.code);
+                }
+            }
+            this.currentSession = undefined;
+            this.currentPaymentRequest = undefined;
+            reject({
+                success: false,
+                error: {
+                    code: ApplePayServiceErrorCode.USER_CANCELLED,
+                    message: 'User cancelled the Apple Pay session',
+                },
+            });
+            console.groupEnd();
+        };
+        if ('onerror' in this.currentSession) {
+            this.currentSession.onerror = (error) => {
+                console.groupCollapsed('[ApplePayService] onerror');
+                console.error('=== APPLE PAY SESSION ERROR ===');
+                console.error('Session error:', error);
+                this.currentSession = undefined;
+                this.currentPaymentRequest = undefined;
+                reject({
+                    success: false,
+                    error: {
+                        code: ApplePayServiceErrorCode.SESSION_ERROR,
+                        message: 'Apple Pay session error occurred',
+                    },
+                });
+                console.groupEnd();
+            };
+        }
+    }
+    /**
+     * Create a basic payment request
+     */
+    static createPaymentRequest(amount, label, countryCode = 'US', currencyCode = 'USD') {
+        return {
+            countryCode,
+            currencyCode,
+            merchantCapabilities: ApplePayHelpers.getDefaultMerchantCapabilities(),
+            supportedNetworks: ApplePayHelpers.getDefaultSupportedNetworks(),
+            total: ApplePayHelpers.createLineItem(label, amount),
+        };
+    }
+    /**
+     * Get current configuration
+     */
+    getApplePayConfig() {
+        return this.applePayConfig;
+    }
+}
+
+const ApplePaySkeleton = (props) => {
+    const { isLoading } = props;
+    if (!isLoading) {
+        return null;
+    }
+    return (index.h("div", { class: 'container-fluid p-0' }, index.h("div", { class: 'row mb-3' }, index.h("div", { class: 'col-12 align-content-center' }, index.h(skeleton.Skeleton, { height: '44px', width: '100%', styles: { borderRadius: "8px" } })))));
+};
+
+const ProcessingSpinner = () => (index.h("div", { class: 'processing-overlay' }, index.h("div", { class: 'spinner' }), index.h("span", null, "Processing...")));
+const ApplePayButton = (props) => {
+    const getApplePayButtonClass = () => {
+        let classes = "apple-pay-button";
+        switch (props.buttonStyle) {
+            case ApplePayButtonStyle.WHITE:
+                classes += " apple-pay-button-white";
+                break;
+            case ApplePayButtonStyle.WHITE_OUTLINE:
+                classes += " apple-pay-button-white-outline";
+                break;
+            case ApplePayButtonStyle.BLACK:
+            default:
+                classes += " apple-pay-button-black";
+                break;
+        }
+        switch (props.buttonType) {
+            case ApplePayButtonType.BUY:
+                classes += " apple-pay-button-type-buy";
+                break;
+            case ApplePayButtonType.DONATE:
+                classes += " apple-pay-button-type-donate";
+                break;
+            case ApplePayButtonType.PLAIN:
+            default:
+                classes += " apple-pay-button-type-plain";
+                break;
+        }
+        if (props.disabled || props.isProcessing || !props.isAvailable) {
+            classes += " disabled";
+        }
+        return classes;
+    };
+    const getButtonStyles = () => {
+        return {
+            width: props.width || "200px",
+            height: props.height || "48px",
+        };
+    };
+    const handleClick = () => {
+        if (!props.disabled &&
+            !props.isProcessing &&
+            props.isAvailable &&
+            props.clickHandler) {
+            props.clickHandler();
+        }
+    };
+    return (index.h("div", { class: 'apple-pay-button-container' }, index.h("button", Object.assign({ class: getApplePayButtonClass(), style: getButtonStyles(), onClick: handleClick, disabled: props.disabled || props.isProcessing || !props.isAvailable, "aria-label": 'Pay with Apple Pay', type: 'button' }, props), props.isProcessing && ProcessingSpinner()), index.h("style", null, `
+          .apple-pay-button-container {
+            display: inline-block;
+            position: relative;
+          }
+
+          /* Apple Pay CSS classes - these are the official Apple Pay button styles */
+          .apple-pay-button {
+            display: inline-block;
+            -webkit-appearance: -apple-pay-button;
+            -apple-pay-button-type: plain; /* default */
+            -apple-pay-button-style: black; /* default */
+            border-radius: 8px;
+            cursor: pointer;
+            border: none;
+            outline: none;
+            transition: opacity 0.2s ease;
+            position: relative;
+          }
+
+          /* Button styles */
+          .apple-pay-button.apple-pay-button-black {
+            -apple-pay-button-style: black;
+          }
+
+          .apple-pay-button.apple-pay-button-white {
+            -apple-pay-button-style: white;
+          }
+
+          .apple-pay-button.apple-pay-button-white-outline {
+            -apple-pay-button-style: white-outline;
+          }
+
+          /* Button types */
+          .apple-pay-button.apple-pay-button-type-plain {
+            -apple-pay-button-type: plain;
+          }
+
+          .apple-pay-button.apple-pay-button-type-buy {
+            -apple-pay-button-type: buy;
+          }
+
+          .apple-pay-button.apple-pay-button-type-donate {
+            -apple-pay-button-type: donate;
+          }
+
+          /* Hover and disabled states */
+          .apple-pay-button:hover:not(.disabled) {
+            opacity: 0.9;
+          }
+
+          .apple-pay-button.disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+          }
+
+          /* Processing overlay */
+          .processing-overlay {
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+            background: rgba(0, 0, 0, 0.8);
+            color: white;
+            border-radius: 8px;
+            font-size: 14px;
+            font-weight: 500;
+          }
+
+          .spinner {
+            width: 16px;
+            height: 16px;
+            border: 2px solid rgba(255, 255, 255, 0.3);
+            border-top: 2px solid #fff;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+          }
+
+          @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+          }
+
+          /* Responsive design */
+          @media (max-width: 480px) {
+            .apple-pay-button {
+              width: 100% !important;
+              min-width: 200px;
+            }
+          }
+        `)));
+};
+
+const ApplePay = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.applePayStarted = index.createEvent(this, "applePayStarted");
+        this.applePayCompleted = index.createEvent(this, "applePayCompleted");
+        this.applePayCancelled = index.createEvent(this, "applePayCancelled");
+        this.applePayError = index.createEvent(this, "applePayError");
+        this.countryCode = "US";
+        this.merchantIdentifier = "merchant.com.staging-justifi.checkout-dev";
+        this.merchantDisplayName = "JustiFi Checkout";
+        this.initiativeContext = "dev-checkout.justifi-staging.com";
+        this.buttonType = ApplePayButtonType.PLAIN;
+        this.buttonStyle = ApplePayButtonStyle.BLACK;
+        this.disabled = false;
+        this.showSkeleton = true;
+        this.isLoading = true;
+        this.isProcessing = false;
+        this.isAvailable = false;
+        this.canMakePayments = false;
+        this.isConfigValid = true;
+        this.error = null;
+        this.handleApplePayClick = async () => {
+            var _a, _b;
+            if (this.isProcessing || this.disabled || !this.isAvailable) {
+                return;
+            }
+            try {
+                this.isProcessing = true;
+                this.error = null;
+                this.applePayStarted.emit();
+                console.groupCollapsed('[ApplePay Component] handleApplePayClick');
+                console.log('[ApplePay Component] click context:', {
+                    isProcessing: this.isProcessing,
+                    disabled: this.disabled,
+                    isAvailable: this.isAvailable,
+                    canMakePayments: this.canMakePayments,
+                    hasService: Boolean(this.applePayService),
+                });
+                const paymentRequest = {
+                    countryCode: this.countryCode,
+                    currencyCode: checkout_store.checkoutStore.paymentCurrency,
+                    merchantCapabilities: [
+                        ApplePayMerchantCapability.SUPPORTS_3DS,
+                        ApplePayMerchantCapability.SUPPORTS_CREDIT,
+                        ApplePayMerchantCapability.SUPPORTS_DEBIT,
+                    ],
+                    supportedNetworks: ApplePayHelpers.getDefaultSupportedNetworks(),
+                    total: ApplePayHelpers.createLineItem(checkout_store.checkoutStore.paymentDescription, checkout_store.checkoutStore.paymentAmount),
+                };
+                console.log("[ApplePay Component] paymentRequest", paymentRequest);
+                console.log('[ApplePay Component] identifiers snapshot:', {
+                    authTokenLength: checkout_store.checkoutStore.authToken ? String(checkout_store.checkoutStore.authToken).length : 0,
+                    accountId: checkout_store.checkoutStore.accountId,
+                });
+                const result = await this.applePayService.startPaymentSession(paymentRequest, checkout_store.checkoutStore.authToken, checkout_store.checkoutStore.accountId);
+                console.log("[ApplePay Component] startPaymentSession result", result);
+                if (result.success) {
+                    this.applePayCompleted.emit({
+                        success: true,
+                        token: result.token,
+                        paymentMethodId: result.paymentMethodId,
+                    });
+                }
+                else {
+                    this.applePayCompleted.emit({
+                        success: false,
+                        error: result.error,
+                    });
+                    this.applePayError.emit({
+                        error: ((_a = result.error) === null || _a === void 0 ? void 0 : _a.message) || "Payment failed",
+                        code: ((_b = result.error) === null || _b === void 0 ? void 0 : _b.code) || ApplePay.ErrorCode.PAYMENT_FAILED,
+                    });
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Payment failed";
+                this.error = errorMessage;
+                this.applePayError.emit({ error: errorMessage, code: ApplePay.ErrorCode.PAYMENT_FAILED });
+                this.applePayCompleted.emit({
+                    success: false,
+                    error: errorMessage,
+                });
+            }
+            finally {
+                this.isProcessing = false;
+                console.groupEnd();
+            }
+        };
+    }
+    async initializeApplePay() {
+        try {
+            this.isLoading = true;
+            this.error = null;
+            this.isConfigValid = true;
+            console.groupCollapsed('[ApplePay Component] initializeApplePay');
+            console.log('[ApplePay Component] checkout state snapshot:', {
+                paymentAmount: checkout_store.checkoutStore.paymentAmount,
+                paymentCurrency: checkout_store.checkoutStore.paymentCurrency,
+                hasAuthToken: Boolean(checkout_store.checkoutStore.authToken),
+                accountId: checkout_store.checkoutStore.accountId,
+            });
+            const hasRequiredConfig = Boolean(checkout_store.checkoutStore.paymentAmount) &&
+                Boolean(checkout_store.checkoutStore.paymentCurrency) &&
+                Boolean(checkout_store.checkoutStore.authToken);
+            if (!hasRequiredConfig) {
+                this.error = "Missing required Apple Pay configuration";
+                this.isConfigValid = false;
+                console.error("Apple Pay config error: missing required values", {
+                    paymentAmount: checkout_store.checkoutStore.paymentAmount,
+                    paymentCurrency: checkout_store.checkoutStore.paymentCurrency,
+                    hasAuthToken: Boolean(checkout_store.checkoutStore.authToken),
+                    accountId: checkout_store.checkoutStore.accountId,
+                });
+                this.applePayError.emit({ error: this.error, code: ApplePay.ErrorCode.CONFIG_ERROR });
+                this.isLoading = false;
+                console.groupEnd();
+                return;
+            }
+            this.isAvailable = ApplePayHelpers.isApplePaySupported();
+            this.canMakePayments = ApplePayHelpers.canMakePayments();
+            console.log('[ApplePay Component] support check:', {
+                isAvailable: this.isAvailable,
+                canMakePayments: this.canMakePayments,
+                hasApplePaySessionOnWindow: typeof window !== 'undefined' && 'ApplePaySession' in window,
+            });
+            if (!this.isAvailable) {
+                this.error = "Apple Pay is not supported on this device";
+                console.error(this.error);
+                this.applePayError.emit({ error: this.error, code: ApplePay.ErrorCode.NOT_SUPPORTED });
+                this.isLoading = false;
+                console.groupEnd();
+                return;
+            }
+            if (!this.canMakePayments) {
+                this.error = "Apple Pay is not available";
+                console.error(this.error);
+                this.applePayError.emit({ error: this.error, code: ApplePay.ErrorCode.NOT_AVAILABLE });
+                this.isLoading = false;
+                console.groupEnd();
+                return;
+            }
+            const applePayConfig = {
+                merchantIdentifier: this.merchantIdentifier,
+                displayName: this.merchantDisplayName,
+                initiative: "web",
+                initiativeContext: this.initiativeContext,
+                buttonType: this.buttonType,
+                buttonStyle: this.buttonStyle,
+            };
+            console.log('[ApplePay Component] initializing service with config:', applePayConfig);
+            this.applePayService = new ApplePayService();
+            this.applePayService.initialize(applePayConfig);
+            const hasActiveCard = await this.applePayService.canMakePaymentsWithActiveCard();
+            if (!hasActiveCard) {
+                console.warn("No Apple Pay cards available, but continuing...");
+            }
+        }
+        catch (error) {
+            console.error("Apple Pay initialization error:", error);
+            this.error =
+                error instanceof Error
+                    ? error.message
+                    : "Failed to initialize Apple Pay";
+            this.applePayError.emit({ error: this.error, code: ApplePay.ErrorCode.INITIALIZATION_ERROR });
+        }
+        finally {
+            this.isLoading = false;
+            console.groupEnd();
+        }
+    }
+    async isSupported() {
+        return this.isAvailable && this.canMakePayments;
+    }
+    async getPaymentMethods() {
+        if (!this.isAvailable) {
+            return [];
+        }
+        return ApplePayHelpers.getDefaultSupportedNetworks();
+    }
+    async abort() {
+        this.applePayService.abortPaymentSession();
+        this.isProcessing = false;
+        this.applePayCancelled.emit();
+    }
+    render() {
+        if (!checkout_store.checkoutStore.applePayEnabled) {
+            // Render nothing when Apple Pay is disabled at the checkout settings level
+            console.log('[ApplePay Component] Apple Pay disabled in checkout settings; not rendering');
+            return null;
+        }
+        const isReady = !this.isLoading &&
+            this.isAvailable &&
+            this.canMakePayments &&
+            this.isConfigValid;
+        return (index.h(styledHost.StyledHost, null, checkout_store.checkoutStore.checkoutLoaded && (index.h("script", { async: true, src: 'https://applepay.cdn-apple.com/jsapi/1.latest/apple-pay-sdk.js', onLoad: () => {
+                console.log('[ApplePay Component] Apple Pay SDK script loaded');
+                this.initializeApplePay();
+            } })), index.h("div", { class: 'apple-pay-container' }, index.h(ApplePaySkeleton, { isLoading: this.isLoading }), isReady && (index.h(ApplePayButton, { buttonType: this.buttonType, buttonStyle: this.buttonStyle, disabled: this.disabled, isProcessing: this.isProcessing, isAvailable: this.isAvailable, clickHandler: this.handleApplePayClick }))), index.h("style", null, `
+            .apple-pay-container {
+              width: 100%;
+            }
+          `)));
+    }
+};
+// Centralized error codes for the Apple Pay component layer
+ApplePay.ErrorCode = {
+    CONFIG_ERROR: 'CONFIG_ERROR',
+    NOT_SUPPORTED: 'NOT_SUPPORTED',
+    NOT_AVAILABLE: 'NOT_AVAILABLE',
+    INITIALIZATION_ERROR: 'INITIALIZATION_ERROR',
+    PAYMENT_FAILED: 'PAYMENT_FAILED',
+};
+
 const Summary = class {
     constructor(hostRef) {
         index.registerInstance(this, hostRef);
     }
     render() {
-        return (index.h(styledHost.StyledHost, { key: '3161e6f6a196c79d684574cafbc90bcf741b2150' }, index.h("section", { key: '594b4485ed4fd9d7c1ee7f4556f071139f92ef0c' }, index.h("div", { key: '5c2d14677dda6fc7ddcb074d4887b839385dca3a' }, index.h("div", { key: 'fb850cd7e9c11741349710696dd4e6241c98e805', part: parts.text }, checkout_store.checkoutStore === null || checkout_store.checkoutStore === void 0 ? void 0 : checkout_store.checkoutStore.paymentDescription), index.h("div", { key: '959014d7fa2a9c97bae0c986313a604930c1e0f3' }, index.h("span", { key: '14ab0932a083568419b1c36c95f9072c73962b11', part: parts.text }, "Total"), "\u00A0", index.h("span", { key: '08a9e00332253070ae984b77eb2a9bab88eb3472', part: parts.text }, utils.formatCurrency(+(checkout_store.checkoutStore === null || checkout_store.checkoutStore === void 0 ? void 0 : checkout_store.checkoutStore.totalAmount))))))));
+        return (index.h(styledHost.StyledHost, { key: 'abd92b499208321582b08a490c78c9167be2ebd4' }, index.h("section", { key: '38e15cef5a19a43249d7ecf3d4eb4ea8e032f248' }, index.h("div", { key: '747f811012ed9707265369e59dbde8cd7ad3bca6' }, index.h("div", { key: '8575f50759664d5c64d235025699c81f055267ca', part: parts.text }, checkout_store.checkoutStore === null || checkout_store.checkoutStore === void 0 ? void 0 : checkout_store.checkoutStore.paymentDescription), index.h("div", { key: 'af77776bbe21bce77586447bbf445e4c5d8c1165' }, index.h("span", { key: '5cdaaec454118197b3e37a942d83907e72444342', part: parts.text }, "Total"), "\u00A0", index.h("span", { key: 'ccc35217ac9740d5a00b7abbcec4133848afcc28', part: parts.text }, utils.formatCurrency(+(checkout_store.checkoutStore === null || checkout_store.checkoutStore === void 0 ? void 0 : checkout_store.checkoutStore.totalAmount))))))));
     }
 };
 
@@ -48,7 +914,7 @@ const Header = class {
     }
     render() {
         const HeaderComponent = this.levels[this.level];
-        return (index.h(styledHost.StyledHost, { key: 'eb3651b698897193d34a6c6456cd57dd0bd0bc43' }, index.h(HeaderComponent, { key: '39caee687f93d3d4d90e62d9fbcae318eaa8022e', text: this.text, class: this.class })));
+        return (index.h(styledHost.StyledHost, { key: 'e1d39365c2ff2c291a42b53d6bcbe1d97d602778' }, index.h(HeaderComponent, { key: '0b8c8c3a42ff2151e3b293cafeeaeda72e94d767', text: this.text, class: this.class })));
     }
 };
 
@@ -250,7 +1116,7 @@ const ModularCheckout = class {
         }
     }
     updateStore(checkout) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         checkout_store.checkoutStore.accountId = checkout.account_id;
         checkout_store.checkoutStore.checkoutLoaded = true;
         checkout_store.checkoutStore.paymentMethods = checkout.payment_methods.map((paymentMethod) => new index$1.PaymentMethod(paymentMethod));
@@ -261,11 +1127,12 @@ const ModularCheckout = class {
         checkout_store.checkoutStore.bnplEnabled = checkout.payment_settings.bnpl_payments;
         checkout_store.checkoutStore.insuranceEnabled = checkout.payment_settings.insurance_payments;
         checkout_store.checkoutStore.bankAccountVerification = (_a = checkout.payment_settings) === null || _a === void 0 ? void 0 : _a.bank_account_verification;
-        checkout_store.checkoutStore.bnplProviderClientId = (_b = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _b === void 0 ? void 0 : _b.provider_client_id;
-        checkout_store.checkoutStore.bnplProviderMode = (_c = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _c === void 0 ? void 0 : _c.provider_mode;
-        checkout_store.checkoutStore.bnplProviderApiVersion = (_d = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _d === void 0 ? void 0 : _d.provider_api_version;
+        checkout_store.checkoutStore.applePayEnabled = Boolean((_b = checkout.payment_settings) === null || _b === void 0 ? void 0 : _b.apple_payments);
+        checkout_store.checkoutStore.bnplProviderClientId = (_c = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _c === void 0 ? void 0 : _c.provider_client_id;
+        checkout_store.checkoutStore.bnplProviderMode = (_d = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _d === void 0 ? void 0 : _d.provider_mode;
+        checkout_store.checkoutStore.bnplProviderApiVersion = (_e = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _e === void 0 ? void 0 : _e.provider_api_version;
         checkout_store.checkoutStore.bnplProviderCheckoutUrl =
-            (_e = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _e === void 0 ? void 0 : _e.provider_checkout_url;
+            (_f = checkout === null || checkout === void 0 ? void 0 : checkout.bnpl) === null || _f === void 0 ? void 0 : _f.provider_checkout_url;
     }
     emitCheckoutChanged() {
         const detail = {
@@ -476,7 +1343,7 @@ const ModularCheckout = class {
         });
     }
     render() {
-        return index.h(index.Host, { key: 'dbe1fe78f8206fef2e3f4f51628d716786dea858' });
+        return index.h(index.Host, { key: '63acafa8f4819ac63e564807779976e352ccbdfb' });
     }
     get hostEl() { return index.getElement(this); }
 };
@@ -1417,7 +2284,7 @@ const TokenizePaymentMethod = class {
         return paymentMethodType === index$1.PAYMENT_METHODS.NEW_CARD ? (index.h("justifi-card-form", { ref: (el) => (this.paymentMethodFormRef = el) })) : (index.h("justifi-bank-account-form", { ref: (el) => (this.paymentMethodFormRef = el) }));
     }
     render() {
-        return (index.h(styledHost.StyledHost, { key: '5fc5dad15215fe24b421f4d6c13355fb849b8a76' }, index.h("form", { key: '0e0330e5b11ee3ae0bef9e092fa2fb2a0a6af3e7' }, index.h("fieldset", { key: 'ee4c026ccda62a249e019a9e105e40ea465fc400' }, index.h("div", { key: '15a8a86fa5be8a545745260d76a8c3b2569d6a0e', class: "row gy-3" }, index.h("div", { key: 'bbbeed6ee96311394a876b4beb206e8e335184c2', class: "col-12" }, this.availablePaymentMethods.map((method) => this.renderPaymentMethodOption(method))), index.h("div", { key: 'da2a2009abe4348e25a5fc712557e81e9f6c4c1f', class: "col-12" }, index.h("justifi-button", { key: '050939c757999383226f281ee0eff1ec178be203', text: this.submitButtonText, variant: "primary", type: "submit", clickHandler: (e) => this.tokenizePaymentMethod(e), isLoading: this.isLoading, "data-testid": "submit-button", hidden: this.computedHideSubmitButton })))))));
+        return (index.h(styledHost.StyledHost, { key: 'bf221d17739bf70c3f581f3b9791a725e76c3f35' }, index.h("form", { key: 'df117d42d4160f31df1fca5d6903967cc48ad573' }, index.h("fieldset", { key: '550e670feffb405c669d44c44eb9073f535c6cb6' }, index.h("div", { key: '8eff7d3ab19618da54161220b92641bf19bfa82d', class: "row gy-3" }, index.h("div", { key: 'bf9d19e92be74abf48ce65c97efb3f9df52d4c3c', class: "col-12" }, this.availablePaymentMethods.map((method) => this.renderPaymentMethodOption(method))), index.h("div", { key: 'eef1f4e1e03c2263efb51ae94085c5a3d73a9166', class: "col-12" }, index.h("justifi-button", { key: 'f0e5697e658236610da45c34e64a8cbb3f0f9d95', 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 index.getElement(this); }
     static get watchers() { return {
@@ -1426,6 +2293,7 @@ const TokenizePaymentMethod = class {
     }; }
 };
 
+exports.justifi_apple_pay = ApplePay;
 exports.justifi_checkout_summary = Summary;
 exports.justifi_header = Header;
 exports.justifi_modular_checkout = ModularCheckout;