storefront-layouts-staging 1.0.0-staging.0

package/dist/lib/payaza-checkout.js

@@ -0,0 +1,717 @@
+/**
+ * Payaza Checkout SDK Integration
+ * Based on Payaza Web SDK documentation: https://docs.payaza.africa/developers/apis/sdks/web-sdk
+ *
+ * Implementation uses npm package: payaza_staging_sdk
+ * Method: setup(config).showPopup()
+ */
+import PayazaCheckout from 'payaza_staging_sdk';
+import { normalizePhoneForPayaza } from '../lib/utils/phone-format.js';
+/** Map backend payazaConnectionMode (or legacy environment values) to SDK connection mode. */
+export function normalizeConnectionMode(value) {
+    if (value === 'Test' || value === 'test')
+        return 'Test';
+    return 'Live';
+}
+export function validateAndNormalizeCurrency(currency) {
+    if (!currency || typeof currency !== 'string') {
+        throw new Error('Currency is required and must be a string');
+    }
+    // Normalize: trim whitespace and convert to uppercase
+    const normalized = currency.trim().toUpperCase();
+    // Validate: must be exactly 3 uppercase letters (ISO 4217 format)
+    const iso4217Pattern = /^[A-Z]{3}$/;
+    if (!iso4217Pattern.test(normalized)) {
+        throw new Error(`Invalid currency format: "${currency}". Must be a 3-letter ISO 4217 code (e.g., USD, NGN, KES, GHS)`);
+    }
+    return normalized;
+}
+/**
+ * Validate and normalize currency with fallback
+ * @param currency - Currency code to validate
+ * @param fallback - Fallback currency if validation fails (default: 'USD')
+ * @returns Validated uppercase ISO 4217 currency code or fallback
+ */
+export function validateAndNormalizeCurrencyWithFallback(currency, fallback = 'USD') {
+    try {
+        return validateAndNormalizeCurrency(currency);
+    }
+    catch (error) {
+        console.warn(`[Currency] Invalid currency "${currency}", using fallback "${fallback}":`, error);
+        try {
+            return validateAndNormalizeCurrency(fallback);
+        }
+        catch {
+            console.error(`[Currency] Fallback currency "${fallback}" is also invalid, using USD`);
+            return 'USD';
+        }
+    }
+}
+/**
+ * Extract currency from items with fallback logic
+ * Handles mixed currencies by using the most common currency, or first item's currency
+ * All currencies are validated and normalized to ISO 4217 format
+ */
+export function getCurrencyFromItems(items, fallbackCurrency) {
+    if (!items || items.length === 0) {
+        return validateAndNormalizeCurrencyWithFallback(fallbackCurrency, 'USD');
+    }
+    // Extract currencies from items and validate/normalize them
+    const currencies = [];
+    for (const item of items) {
+        if (item.product?.currency) {
+            try {
+                const validated = validateAndNormalizeCurrency(item.product.currency);
+                currencies.push(validated);
+            }
+            catch (error) {
+                console.warn(`[Currency] Invalid currency "${item.product.currency}" in product, skipping:`, error);
+            }
+        }
+    }
+    if (currencies.length === 0) {
+        return validateAndNormalizeCurrencyWithFallback(fallbackCurrency, 'USD');
+    }
+    // If all items have the same currency, use it
+    const uniqueCurrencies = Array.from(new Set(currencies));
+    if (uniqueCurrencies.length === 1) {
+        return uniqueCurrencies[0];
+    }
+    // If mixed currencies, find the most common one
+    const currencyCounts = {};
+    currencies.forEach(currency => {
+        currencyCounts[currency] = (currencyCounts[currency] || 0) + 1;
+    });
+    const mostCommonCurrency = Object.entries(currencyCounts).reduce((a, b) => currencyCounts[a[0]] > currencyCounts[b[0]] ? a : b)[0];
+    return mostCommonCurrency;
+}
+/**
+ * Remove all Payaza SDK DOM nodes (loader overlay + invisible iframe).
+ * The SDK appends a fullscreen fixed iframe at max z-index; if checkout never
+ * loads, only the spinner is removed and the invisible iframe blocks all clicks.
+ */
+export function teardownPayazaCheckoutDom() {
+    if (typeof document === 'undefined' || !document.body)
+        return;
+    document.querySelectorAll('style').forEach((styleEl) => {
+        if (styleEl.textContent?.includes('payaza-loading-spinner')) {
+            styleEl.remove();
+        }
+    });
+    document.querySelectorAll('div').forEach((div) => {
+        if (div.innerHTML.includes('payaza-loading-spinner')) {
+            div.remove();
+        }
+    });
+    document.querySelectorAll('iframe[src*="payaza.africa"], iframe[src*="shopaza.africa"]').forEach((iframe) => {
+        iframe.remove();
+    });
+    if (document.body.style.overflow === 'hidden') {
+        document.body.style.overflow = '';
+    }
+}
+const PAYAZA_IFRAME_SELECTOR = 'iframe[src*="payaza.africa"], iframe[src*="shopaza.africa"]';
+/**
+ * Payaza checkout is served without Cross-Origin-Resource-Policy. When the host
+ * page sets COEP credentialless, the iframe must have the `credentialless` attribute
+ * or the embed is blocked (DevTools: "Cross-Origin-Resource-Policy header not set").
+ */
+function patchPayazaIframeForCoep(iframe) {
+    if (!iframe.hasAttribute('credentialless')) {
+        iframe.setAttribute('credentialless', '');
+    }
+}
+function patchPayazaIframesInDom() {
+    if (typeof document === 'undefined')
+        return;
+    document.querySelectorAll(PAYAZA_IFRAME_SELECTOR).forEach((node) => {
+        patchPayazaIframeForCoep(node);
+    });
+}
+function observePayazaIframeInsertion() {
+    if (typeof document === 'undefined' || !document.body) {
+        return () => { };
+    }
+    patchPayazaIframesInDom();
+    const observer = new MutationObserver(() => {
+        patchPayazaIframesInDom();
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    return () => observer.disconnect();
+}
+/**
+ * Initialize Payaza checkout using SDK
+ * Uses setup() function from payaza-web-sdk npm package as per official documentation
+ */
+export const initiatePayazaCheckout = async (config) => {
+    try {
+        // Validate currency before proceeding
+        if (!config.currency) {
+            throw new Error('Currency is required for Payaza checkout');
+        }
+        // Validate and normalize currency to ISO 4217 format
+        let validatedCurrency;
+        try {
+            validatedCurrency = validateAndNormalizeCurrency(config.currency);
+        }
+        catch {
+            throw new Error(`Invalid currency code: ${config.currency}. Currency must be a valid 3-letter ISO 4217 code (e.g., USD, NGN, KES, GHS)`);
+        }
+        console.log('[Payaza] Initiating checkout with npm package...');
+        console.log('[Payaza] SDK verified ready, proceeding with checkout setup');
+        if (!Number.isFinite(config.amount) || config.amount <= 0) {
+            throw new Error('Invalid payment amount. Please refresh and try again.');
+        }
+        if (!config.email?.trim()) {
+            throw new Error('Email is required for payment.');
+        }
+        if (!config.firstName?.trim()) {
+            throw new Error('First name is required for payment.');
+        }
+        if (!config.lastName?.trim()) {
+            throw new Error('Last name is required for payment.');
+        }
+        const normalizedPhone = config.phone ? normalizePhoneForPayaza(config.phone) : '';
+        // Generate transaction reference
+        const reference = config.reference || `PL${Math.floor((Math.random() * 10000000) + 1)}`;
+        console.log('[Payaza] Transaction reference:', reference);
+        // Determine connection mode — backend config is authoritative; default Live
+        if (!config.publicKey) {
+            throw new Error('Payment gateway not configured. Please contact support.');
+        }
+        const connectionMode = config.connectionMode
+            ? normalizeConnectionMode(config.connectionMode)
+            : PayazaCheckout.LIVE_CONNECTION_MODE;
+        console.log('[Payaza] Connection mode:', connectionMode, config.connectionMode ? '(from backend config)' : '(default Live)');
+        // Build comprehensive additional_details metadata
+        // This data will be available in Payaza webhooks and transaction responses
+        const additionalDetails = {
+            // Merge any custom metadata first
+            ...(config.metadata || {}),
+        };
+        console.log('[Payaza] Building checkout configuration...', {
+            amount: config.amount,
+            currency: validatedCurrency,
+            email: config.email,
+            connectionMode,
+        });
+        // Core order identifiers
+        if (config.storeId) {
+            additionalDetails.storeId = config.storeId;
+        }
+        if (config.orderId) {
+            additionalDetails.orderId = config.orderId;
+        }
+        if (config.orderNumber) {
+            additionalDetails.orderNumber = config.orderNumber;
+        }
+        // Customer information
+        if (config.email) {
+            additionalDetails.customerEmail = config.email;
+        }
+        if (config.firstName) {
+            additionalDetails.customerFirstName = config.firstName;
+        }
+        if (config.lastName) {
+            additionalDetails.customerLastName = config.lastName;
+        }
+        if (normalizedPhone) {
+            additionalDetails.customerPhone = normalizedPhone;
+        }
+        // Shipping address information
+        if (config.shippingAddress) {
+            additionalDetails.shippingAddress = {
+                firstName: config.shippingAddress.firstName,
+                lastName: config.shippingAddress.lastName,
+                address: config.shippingAddress.address,
+                city: config.shippingAddress.city,
+                state: config.shippingAddress.state,
+                country: config.shippingAddress.country,
+                zipCode: config.shippingAddress.zipCode,
+            };
+        }
+        // Transaction details
+        additionalDetails.amount = config.amount;
+        additionalDetails.currency = validatedCurrency;
+        if (config.description) {
+            additionalDetails.description = config.description;
+        }
+        // Timestamp for tracking
+        additionalDetails.timestamp = new Date().toISOString();
+        if (config.merchantReference) {
+            additionalDetails.merchantReference = config.merchantReference;
+        }
+        // Setup Payaza checkout with correct configuration
+        // Ensure currency_code is validated ISO 4217 format
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const payazaConfig = {
+            merchant_key: config.publicKey,
+            connection_mode: connectionMode,
+            checkout_amount: config.amount,
+            currency_code: validatedCurrency, // Use validated ISO 4217 currency code
+            currency: validatedCurrency, // Required by npm package
+            email_address: config.email,
+            first_name: config.firstName || '', // Required field
+            last_name: config.lastName || '', // Required field
+            phone_number: normalizedPhone,
+            transaction_reference: reference,
+            additional_details: additionalDetails,
+            // Required by interface, but we'll override with setCallback/setOnClose
+            onClose: () => { },
+            callback: () => { },
+        };
+        if (config.merchantReference) {
+            payazaConfig.merchant_reference = config.merchantReference;
+        }
+        if (config.callbackUrl) {
+            payazaConfig.callback_url = config.callbackUrl;
+        }
+        // Create checkout instance
+        console.log('[Payaza] Calling setup() from payaza-web-sdk...');
+        const payazaCheckout = PayazaCheckout.setup(payazaConfig);
+        console.log('[Payaza] PayazaCheckout instance created successfully');
+        // Track payment success state to prevent misleading "Payment canceled" message
+        // when checkout window closes after successful payment
+        let paymentSuccessful = false;
+        let closeHandled = false;
+        const PAYAZA_CLOSE_CHECK_MS = 1500;
+        const PAYAZA_CLOSE_CHECK_MAX_MS = 5 * 60 * 1000; // 5 minutes
+        const PAYAZA_LOADER_TIMEOUT_MS = 30000; // 30 seconds
+        const popupOpenedAt = Date.now();
+        let closeCheckIntervalId = null;
+        let loaderTimeoutId = null;
+        let checkoutLoadedFired = false;
+        const removePayazaLoaderDom = () => {
+            teardownPayazaCheckoutDom();
+        };
+        const clearLoaderTimeout = () => {
+            if (loaderTimeoutId) {
+                clearTimeout(loaderTimeoutId);
+                loaderTimeoutId = null;
+            }
+        };
+        const markCheckoutLoaded = () => {
+            if (checkoutLoadedFired)
+                return;
+            checkoutLoadedFired = true;
+            clearLoaderTimeout();
+            config.onCheckoutLoaded?.();
+        };
+        const hasPayazaLoaderInDom = () => {
+            if (typeof document === 'undefined')
+                return false;
+            let found = false;
+            document.querySelectorAll('style').forEach((styleEl) => {
+                if (styleEl.textContent?.includes('payaza-loading-spinner')) {
+                    found = true;
+                }
+            });
+            document.querySelectorAll('div').forEach((div) => {
+                if (div.innerHTML.includes('payaza-loading-spinner')) {
+                    found = true;
+                }
+            });
+            return found;
+        };
+        const clearCloseCheckInterval = () => {
+            if (closeCheckIntervalId) {
+                clearInterval(closeCheckIntervalId);
+                closeCheckIntervalId = null;
+            }
+        };
+        let stopIframeObserver = null;
+        const handleClose = () => {
+            if (closeHandled)
+                return;
+            closeHandled = true;
+            stopIframeObserver?.();
+            stopIframeObserver = null;
+            clearCloseCheckInterval();
+            // Only call onClose when payment was not successful (user closed/canceled)
+            // When payment succeeded, SDK closes popup too - avoid misleading "Payment canceled" toast
+            if (!paymentSuccessful && config.onClose)
+                config.onClose();
+            paymentSuccessful = false;
+        };
+        // Set callback for payment response
+        payazaCheckout.setCallback((callbackResponse) => {
+            // TO BE REMOVED FOR PRODUCTION - Temporary logging for debugging
+            console.log('=== PAYAZA CHECKOUT SDK CALLBACK DATA (TO BE REMOVED FOR PRODUCTION) ===');
+            console.log('Full callback response:', JSON.stringify(callbackResponse, null, 2));
+            console.log('=== END OF CALLBACK DATA ===');
+            // Parse the callback response structure
+            // Payaza returns: { type: "success", status: 201, data: { ... } } for success
+            // Payaza returns: { type: "error", status: 400/500, data: { message, errors: [...] } } for errors
+            const isErrorResponse = callbackResponse.type === 'error' ||
+                (callbackResponse.status && callbackResponse.status >= 400 && callbackResponse.status < 600);
+            const isSuccessResponse = callbackResponse.type === 'success' ||
+                (callbackResponse.status !== undefined &&
+                    callbackResponse.status >= 200 &&
+                    callbackResponse.status < 300);
+            // Handle error responses first
+            if (isErrorResponse) {
+                const errorData = callbackResponse.data;
+                let errorMessage = 'Payment failed';
+                // Extract error message from response
+                if (errorData?.message) {
+                    errorMessage = errorData.message;
+                }
+                else if (errorData?.errors && Array.isArray(errorData.errors) && errorData.errors.length > 0) {
+                    // Handle validation errors
+                    const validationErrors = errorData.errors.map((err) => {
+                        if (err.field && err.errors && Array.isArray(err.errors)) {
+                            return `${err.field}: ${err.errors.join(', ')}`;
+                        }
+                        return JSON.stringify(err);
+                    });
+                    errorMessage = `Validation error: ${validationErrors.join('; ')}`;
+                }
+                else if (typeof errorData === 'string') {
+                    errorMessage = errorData;
+                }
+                console.error('[Payaza Callback] Payment error:', {
+                    type: callbackResponse.type,
+                    status: callbackResponse.status,
+                    message: errorMessage,
+                    data: errorData,
+                });
+                clearCloseCheckInterval();
+                clearLoaderTimeout();
+                removePayazaLoaderDom();
+                if (config.onError) {
+                    config.onError(errorMessage);
+                }
+                return;
+            }
+            // Handle success responses
+            if (isSuccessResponse && callbackResponse.data) {
+                // Full success response with transaction details
+                // PayazaCallbackResponse.data is { message: string, [key: string]: any }
+                const responseData = callbackResponse.data;
+                const payazaNativeRef = responseData.payaza_reference || '';
+                const payazaReturnedRef = responseData.transaction_reference || payazaNativeRef || '';
+                const internalRef = reference;
+                // Prefer our TRX-* reference for DB lookup when Payaza returns P-C-* or another external ref
+                const transactionRef = payazaReturnedRef.startsWith('TRX-')
+                    ? payazaReturnedRef
+                    : internalRef.startsWith('TRX-')
+                        ? internalRef
+                        : payazaReturnedRef || payazaNativeRef || internalRef;
+                const callbackAdditionalDetails = {
+                    storeId: config.storeId,
+                    orderId: config.orderId,
+                    orderNumber: config.orderNumber,
+                    merchantReference: config.merchantReference || config.orderNumber,
+                    internalTransactionReference: internalRef,
+                    payazaReference: payazaNativeRef || (payazaReturnedRef.startsWith('P-C-') ? payazaReturnedRef : undefined),
+                };
+                // Build PayazaSuccessData from response data
+                const successData = {
+                    message: responseData.message || 'Payment successful',
+                    payaza_reference: payazaNativeRef || (payazaReturnedRef.startsWith('P-C-') ? payazaReturnedRef : ''),
+                    transaction_reference: payazaReturnedRef || internalRef,
+                    transaction_fee: responseData.transaction_fee || 0,
+                    transaction_total_amount: responseData.transaction_total_amount || config.amount,
+                    currency: responseData.currency || { name: '', code: validatedCurrency, unicode: '', html_value: '', enabled: true },
+                    customer: responseData.customer || { customer_id: '', email_address: config.email, first_name: config.firstName || '', last_name: config.lastName || '', mobile_number: config.phone || '' },
+                    merchant_reference: config.merchantReference || config.orderNumber,
+                    additional_details: callbackAdditionalDetails,
+                };
+                const fullCallback = {
+                    type: callbackResponse.type || 'success',
+                    status: callbackResponse.status || 201,
+                    data: successData,
+                };
+                console.log('[Payaza Callback] Transaction successful:', {
+                    transactionRef,
+                    payazaReference: successData.payaza_reference,
+                    amount: successData.transaction_total_amount,
+                    fee: successData.transaction_fee,
+                    currency: successData.currency?.code,
+                });
+                // Mark payment as successful BEFORE calling onSuccess
+                // This ensures onClose knows payment succeeded even if it fires immediately after
+                paymentSuccessful = true;
+                clearCloseCheckInterval();
+                // Call the success handler with full callback data
+                if (config.onSuccess) {
+                    config.onSuccess({
+                        status: 'success',
+                        transactionRef,
+                        message: successData.message || 'Payment successful',
+                        callbackData: fullCallback,
+                    });
+                }
+            }
+            else if (isSuccessResponse) {
+                // Fallback for minimal response (no transaction_reference in data)
+                const responseData = callbackResponse.data || {};
+                const payazaReturnedRef = responseData?.transaction_reference || responseData?.payaza_reference || '';
+                const transactionRef = payazaReturnedRef.startsWith('TRX-')
+                    ? payazaReturnedRef
+                    : reference.startsWith('TRX-')
+                        ? reference
+                        : payazaReturnedRef || reference;
+                const callbackAdditionalDetails = {
+                    storeId: config.storeId,
+                    orderId: config.orderId,
+                    orderNumber: config.orderNumber,
+                    merchantReference: config.merchantReference || config.orderNumber,
+                    internalTransactionReference: reference,
+                    payazaReference: payazaReturnedRef.startsWith('P-C-') ? payazaReturnedRef : undefined,
+                };
+                const successData = {
+                    message: responseData?.message || 'Payment successful',
+                    payaza_reference: responseData?.payaza_reference || (payazaReturnedRef.startsWith('P-C-') ? payazaReturnedRef : ''),
+                    transaction_reference: payazaReturnedRef || reference,
+                    transaction_fee: responseData?.transaction_fee || 0,
+                    transaction_total_amount: responseData?.transaction_total_amount || config.amount,
+                    currency: responseData?.currency || { name: '', code: validatedCurrency, unicode: '', html_value: '', enabled: true },
+                    customer: responseData?.customer || { customer_id: '', email_address: config.email, first_name: config.firstName || '', last_name: config.lastName || '', mobile_number: config.phone || '' },
+                    merchant_reference: config.merchantReference || config.orderNumber,
+                    additional_details: callbackAdditionalDetails,
+                };
+                const fullCallback = {
+                    type: 'success',
+                    status: callbackResponse.status || 201,
+                    data: successData,
+                };
+                console.log('[Payaza Callback] Transaction reference (minimal response):', transactionRef);
+                paymentSuccessful = true;
+                clearCloseCheckInterval();
+                if (config.onSuccess) {
+                    config.onSuccess({
+                        status: 'success',
+                        transactionRef,
+                        message: 'Payment successful',
+                        callbackData: fullCallback,
+                    });
+                }
+            }
+            else {
+                // Unknown response type - log and treat as error
+                console.warn('[Payaza Callback] Unknown response type:', {
+                    type: callbackResponse.type,
+                    status: callbackResponse.status,
+                    data: callbackResponse.data,
+                });
+                clearCloseCheckInterval();
+                clearLoaderTimeout();
+                removePayazaLoaderDom();
+                if (config.onError) {
+                    config.onError('Received unexpected response from payment gateway. Please try again.');
+                }
+            }
+        });
+        // Set onClose handler: always call config.onClose() so UI loading state clears
+        payazaCheckout.setOnClose(() => {
+            console.log('[Payaza] Checkout closed', { paymentSuccessful });
+            handleClose();
+        });
+        // Show the popup
+        console.log('[Payaza] Showing checkout popup');
+        try {
+            stopIframeObserver = observePayazaIframeInsertion();
+            payazaCheckout.showPopup();
+            patchPayazaIframesInDom();
+            console.log('[Payaza] Checkout popup opened successfully');
+            // Fallback: poll for Payaza loader removal (actual load) and iframe close.
+            if (typeof document !== 'undefined' && document.querySelector) {
+                const checkLoadedAndClose = setInterval(() => {
+                    const iframe = document.querySelector(PAYAZA_IFRAME_SELECTOR);
+                    if (iframe) {
+                        patchPayazaIframeForCoep(iframe);
+                    }
+                    const elapsed = Date.now() - popupOpenedAt;
+                    if (elapsed > PAYAZA_CLOSE_CHECK_MAX_MS) {
+                        clearInterval(checkLoadedAndClose);
+                        closeCheckIntervalId = null;
+                        return;
+                    }
+                    if (!checkoutLoadedFired && iframe) {
+                        const opacity = parseFloat(window.getComputedStyle(iframe).opacity || '0');
+                        if (opacity >= 1 || !hasPayazaLoaderInDom()) {
+                            markCheckoutLoaded();
+                        }
+                    }
+                    if (!iframe && !closeHandled && !paymentSuccessful) {
+                        console.log('[Payaza] Fallback: Payaza iframe no longer in DOM, waiting for SDK callback...');
+                        setTimeout(() => {
+                            if (!closeHandled && !paymentSuccessful) {
+                                console.log('[Payaza] Fallback: no success callback received, treating checkout as closed');
+                                handleClose();
+                            }
+                        }, 2500);
+                    }
+                }, PAYAZA_CLOSE_CHECK_MS);
+                closeCheckIntervalId = checkLoadedAndClose;
+                loaderTimeoutId = setTimeout(() => {
+                    if (closeHandled || checkoutLoadedFired)
+                        return;
+                    const loaderStillVisible = hasPayazaLoaderInDom();
+                    const iframePresent = Boolean(typeof document !== 'undefined' &&
+                        document.querySelector('iframe[src*="payaza.africa"], iframe[src*="shopaza.africa"]'));
+                    if (!loaderStillVisible && !iframePresent)
+                        return;
+                    stopIframeObserver?.();
+                    stopIframeObserver = null;
+                    console.error('[Payaza] Loader timeout: checkout overlay did not clear', {
+                        keyPrefix: config.publicKey?.substring(0, 8),
+                        amount: config.amount,
+                        currency: validatedCurrency,
+                        connectionMode,
+                        email: config.email,
+                        reference,
+                        loaderStillVisible,
+                        iframePresent,
+                    });
+                    teardownPayazaCheckoutDom();
+                    closeHandled = true;
+                    clearCloseCheckInterval();
+                    clearLoaderTimeout();
+                    checkoutLoadedFired = true;
+                    config.onCheckoutLoaded?.();
+                    if (config.onError) {
+                        config.onError('Payment window failed to load. This may be caused by browser security settings or a blocked connection to Payaza. Please try again.');
+                    }
+                }, PAYAZA_LOADER_TIMEOUT_MS);
+            }
+        }
+        catch (popupError) {
+            console.error('[Payaza] Failed to show popup:', popupError);
+            // Call onError if popup fails to open
+            if (config.onError) {
+                config.onError('Failed to open payment popup. Please check if popups are blocked in your browser.');
+            }
+            throw new Error('Failed to open payment popup. Please check if popups are blocked in your browser.');
+        }
+        // Return success - actual payment status comes via callback
+        return {
+            status: 'success',
+            transactionRef: reference,
+            message: 'Checkout popup opened',
+        };
+    }
+    catch (error) {
+        console.error('[Payaza] Checkout initiation error:', {
+            error,
+            message: error instanceof Error ? error.message : 'Unknown error',
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        // Throw error instead of returning error object - let the caller handle it
+        // This ensures errors are properly propagated and not masked
+        throw error instanceof Error ? error : new Error('Failed to initialize checkout');
+    }
+};
+/**
+ * Generate checkout config from cart items
+ */
+export const generateCheckoutConfig = (items, customerEmail, publicKey, options) => {
+    const itemsTotal = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+    const requestedTotal = options?.totalAmount != null ? Number(options.totalAmount) : NaN;
+    const totalAmount = (Number.isFinite(requestedTotal) && requestedTotal >= 0)
+        ? requestedTotal
+        : itemsTotal;
+    const itemCount = items.reduce((sum, item) => sum + item.quantity, 0);
+    // Extract currency from items or use provided currency with fallback chain
+    // Fallback chain: options.currency → getCurrencyFromItems() → 'USD'
+    // CRITICAL: Payaza only accepts ISO 4217 currency codes (e.g., 'NGN', 'USD'), NOT currency symbols (e.g., '₦', '$')
+    // All currency values must be validated and normalized to ISO format before use
+    let currency;
+    try {
+        if (options?.currency) {
+            // Validate that provided currency is an ISO code, not a symbol
+            currency = validateAndNormalizeCurrency(options.currency);
+        }
+        else {
+            // Try to get currency from items
+            const itemsCurrency = getCurrencyFromItems(items);
+            currency = validateAndNormalizeCurrency(itemsCurrency);
+        }
+        // Double-check: Ensure currency is a valid 3-letter ISO code
+        if (!currency || currency.length !== 3 || !/^[A-Z]{3}$/.test(currency)) {
+            throw new Error(`Invalid currency format: "${currency}". Must be a 3-letter ISO 4217 code.`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error('[Checkout Config] Currency validation failed:', {
+            providedCurrency: options?.currency,
+            error: errorMessage,
+            fallback: 'USD'
+        });
+        // Always fallback to USD if validation fails
+        currency = 'USD';
+    }
+    // Build comprehensive payer description
+    const customerName = options?.firstName && options?.lastName
+        ? `${options.firstName} ${options.lastName}`
+        : options?.firstName || options?.lastName || 'Customer';
+    // Build shipping address string
+    const shippingParts = [];
+    if (options?.shippingAddress) {
+        const addr = options.shippingAddress;
+        if (addr.address)
+            shippingParts.push(addr.address);
+        if (addr.city)
+            shippingParts.push(addr.city);
+        if (addr.state)
+            shippingParts.push(addr.state);
+        if (addr.zipCode)
+            shippingParts.push(addr.zipCode);
+        if (addr.country)
+            shippingParts.push(addr.country);
+    }
+    const shippingAddressStr = shippingParts.length > 0 ? shippingParts.join(', ') : 'Not provided';
+    // Build comprehensive description
+    let description = '';
+    if (options?.orderNumber) {
+        description = `Order #${options.orderNumber} - ${customerName} (${customerEmail})\n`;
+    }
+    else {
+        description = `Order - ${customerName} (${customerEmail})\n`;
+    }
+    description += `Items: ${itemCount} | Total: ${currency} ${totalAmount.toFixed(2)}\n`;
+    description += `Shipping: ${shippingAddressStr}`;
+    // Truncate if too long (Payaza may have limits)
+    const maxDescriptionLength = 500;
+    if (description.length > maxDescriptionLength) {
+        description = description.substring(0, maxDescriptionLength - 3) + '...';
+    }
+    return {
+        publicKey,
+        connectionMode: options?.connectionMode
+            ? normalizeConnectionMode(options.connectionMode)
+            : undefined,
+        amount: totalAmount,
+        currency,
+        email: customerEmail,
+        firstName: options?.firstName,
+        lastName: options?.lastName,
+        phone: options?.phone,
+        description,
+        callbackUrl: options?.callbackUrl,
+        storeId: options?.storeId,
+        orderId: options?.orderId,
+        orderNumber: options?.orderNumber,
+        merchantReference: options?.merchantReference,
+        shippingAddress: options?.shippingAddress,
+        metadata: {
+            // Cart items information
+            items: items.map(item => ({
+                name: item.product.name,
+                quantity: item.quantity,
+                price: item.price,
+                currency: item.product.currency,
+            })),
+            // Order summary
+            itemCount: itemCount,
+            totalAmount: totalAmount,
+            // Customer information
+            customerName: customerName,
+            customerEmail: customerEmail,
+            // Shipping information
+            shippingAddress: shippingAddressStr,
+        },
+    };
+};