@tagadapay/plugin-sdk 2.6.2 → 2.6.6

package/dist/react/components/GooglePayButton.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { CheckoutData } from '../hooks/useCheckout';
+interface GooglePayButtonProps {
+    className?: string;
+    disabled?: boolean;
+    onSuccess?: (payment: any) => void;
+    onError?: (error: string) => void;
+    onCancel?: () => void;
+    checkout: CheckoutData | null;
+}
+export declare const GooglePayButton: React.FC<GooglePayButtonProps>;
+export default GooglePayButton;

package/dist/react/components/GooglePayButton.js

@@ -0,0 +1,340 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import GooglePayButtonReact from '@google-pay/button-react';
+import { useCallback, useEffect, useState } from 'react';
+import { useExpressPaymentMethods } from '../hooks/useExpressPaymentMethods';
+import { useOrderSummary } from '../hooks/useOrderSummary';
+import { usePayment } from '../hooks/usePayment';
+import { useShippingRates } from '../hooks/useShippingRates';
+import { Button } from './Button';
+const basistheoryPublicKey = process.env.NEXT_PUBLIC_BASIS_THEORY_PUBLIC_API_KEY || '';
+const basistheoryTenantId = process.env.NEXT_PUBLIC_BASIS_THEORY_TENANT_ID || '0b283fa3-44a1-4535-adff-e99ad0a58a47';
+export const GooglePayButton = ({ className = '', disabled = false, onSuccess, onError, onCancel, checkout, }) => {
+    const { googlePayPaymentMethod, reComputeOrderSummary, handleAddExpressId, updateCheckoutSessionValues, updateCustomerEmail, shippingMethods, setError: setContextError, } = useExpressPaymentMethods();
+    const [processingPayment, setProcessingPayment] = useState(false);
+    const [pendingPaymentData, setPendingPaymentData] = useState(null);
+    const [googlePayError, setGooglePayError] = useState(null);
+    const checkoutSessionId = checkout?.checkoutSession?.id;
+    const { processApplePayPayment: processExpressPayment } = usePayment(); // Will create processGooglePayPayment method
+    const { orderSummary } = useOrderSummary({ sessionId: checkoutSessionId });
+    const { selectRate } = useShippingRates({ checkout: checkout || undefined });
+    // Don't render if no Google Pay payment method is enabled
+    if (!googlePayPaymentMethod) {
+        return null;
+    }
+    // Register express payment method
+    useEffect(() => {
+        handleAddExpressId('google_pay');
+    }, [handleAddExpressId]);
+    // Convert Google Pay address to internal Address format
+    const googlePayAddressToAddress = useCallback((googlePayAddress) => {
+        return {
+            address1: googlePayAddress.address1 || '',
+            address2: googlePayAddress.address2 || '',
+            lastName: googlePayAddress.name?.split(' ').slice(-1)[0] || '',
+            firstName: googlePayAddress.name?.split(' ').slice(0, -1).join(' ') || '',
+            city: googlePayAddress.locality || '',
+            state: googlePayAddress.administrativeArea || '',
+            country: googlePayAddress.countryCode || '',
+            postal: googlePayAddress.postalCode || '',
+            phone: googlePayAddress.phoneNumber || '',
+            email: '',
+        };
+    }, []);
+    // Tokenize Google Pay data using Basis Theory
+    const tokenizeGooglePayTokenWithBasisTheory = useCallback(async (paymentData) => {
+        try {
+            const googlePayTokenString = paymentData.paymentMethodData.tokenizationData.token;
+            const googlePayToken = JSON.parse(googlePayTokenString);
+            const response = await fetch('https://api.basistheory.com/google-pay', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'BT-API-KEY': basistheoryPublicKey,
+                },
+                body: JSON.stringify({
+                    google_payment_data: googlePayToken,
+                }),
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                console.error('Basis Theory API error:', errorData);
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            const jsonResponse = await response.json();
+            return jsonResponse?.token_intent || jsonResponse?.google_pay;
+        }
+        catch (error) {
+            console.error('Error tokenizing Google Pay data:', error);
+            throw error;
+        }
+    }, []);
+    // Charge payment in backend
+    const chargePayment = useCallback(async (token) => {
+        if (!checkoutSessionId) {
+            throw new Error('Checkout session ID is not available');
+        }
+        setProcessingPayment(true);
+        try {
+            // Use the payment hook to process the Google Pay payment
+            // Note: You'll need to implement processGooglePayPayment similar to processApplePayPayment
+            await processExpressPayment(checkoutSessionId, token, {
+                onSuccess: (payment) => {
+                    setProcessingPayment(false);
+                    if (onSuccess) {
+                        onSuccess(payment);
+                    }
+                },
+                onFailure: (error) => {
+                    setProcessingPayment(false);
+                    const errorMessage = error || 'Payment Failed';
+                    setGooglePayError(errorMessage);
+                    setContextError(errorMessage);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                },
+            });
+        }
+        catch (error) {
+            console.error('Error charging payment:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Payment Failed';
+            setProcessingPayment(false);
+            setGooglePayError(errorMessage);
+            setContextError(errorMessage);
+            if (onError) {
+                onError(errorMessage);
+            }
+            throw error;
+        }
+    }, [checkoutSessionId, processExpressPayment, onSuccess, onError, setContextError]);
+    // Process payment data
+    const onGooglePaymentData = useCallback(async (paymentData) => {
+        setProcessingPayment(true);
+        try {
+            // Extract billing address if available
+            let billingAddress;
+            if (paymentData.paymentMethodData.info?.billingAddress) {
+                billingAddress = googlePayAddressToAddress(paymentData.paymentMethodData.info.billingAddress);
+            }
+            // Extract shipping address if available
+            let shippingAddress;
+            if (paymentData.shippingAddress) {
+                shippingAddress = googlePayAddressToAddress(paymentData.shippingAddress);
+            }
+            // Update checkout session with addresses before processing payment
+            if (shippingAddress) {
+                await updateCheckoutSessionValues({
+                    data: {
+                        shippingAddress,
+                        billingAddress: billingAddress ?? null,
+                    },
+                });
+            }
+            // Update customer email if provided
+            if (paymentData.email) {
+                await updateCustomerEmail({
+                    data: {
+                        email: paymentData.email,
+                    },
+                });
+            }
+            const payToken = await tokenizeGooglePayTokenWithBasisTheory(paymentData);
+            await chargePayment(payToken);
+        }
+        catch (error) {
+            console.error('Error processing Google Pay payment:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Payment Failed';
+            setProcessingPayment(false);
+            setGooglePayError(errorMessage);
+            setContextError(errorMessage);
+            if (onError) {
+                onError(errorMessage);
+            }
+        }
+    }, [
+        googlePayAddressToAddress,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        tokenizeGooglePayTokenWithBasisTheory,
+        chargePayment,
+        onError,
+        setContextError,
+    ]);
+    // Effect to process payment data in background
+    useEffect(() => {
+        if (pendingPaymentData && !processingPayment) {
+            const processPaymentInBackground = async () => {
+                try {
+                    await onGooglePaymentData(pendingPaymentData);
+                }
+                catch (error) {
+                    console.error('Background payment processing failed:', error);
+                }
+                finally {
+                    setPendingPaymentData(null);
+                }
+            };
+            void processPaymentInBackground();
+        }
+    }, [pendingPaymentData, processingPayment, onGooglePaymentData]);
+    // Handle payment data changes during the flow
+    const handleGooglePayDataChanged = useCallback((intermediatePaymentData) => {
+        return new Promise((resolve) => {
+            const processCallback = async () => {
+                try {
+                    const paymentDataRequestUpdate = {};
+                    if (intermediatePaymentData.callbackTrigger === 'SHIPPING_ADDRESS') {
+                        const address = intermediatePaymentData.shippingAddress;
+                        const shippingAddress = {
+                            address1: address?.addressLines?.[0] || '',
+                            address2: address?.addressLines?.[1] || '',
+                            lastName: address?.name?.split(' ').slice(-1)[0] || '',
+                            firstName: address?.name?.split(' ').slice(0, -1).join(' ') || '',
+                            city: address?.locality || '',
+                            state: address?.administrativeArea || '',
+                            country: address?.countryCode || '',
+                            postal: address?.postalCode || '',
+                            phone: address?.phoneNumber || '',
+                            email: '',
+                        };
+                        await updateCheckoutSessionValues({
+                            data: { shippingAddress },
+                        });
+                        const newOrderSummary = await reComputeOrderSummary();
+                        if (newOrderSummary) {
+                            paymentDataRequestUpdate.newShippingOptionParameters = {
+                                defaultSelectedOptionId: newOrderSummary.shippingMethods[0]?.identifier || '',
+                                shippingOptions: newOrderSummary.shippingMethods.map((method) => ({
+                                    id: method.identifier,
+                                    label: method.label,
+                                    description: method.amount + ': ' + method.detail || '',
+                                })),
+                            };
+                            paymentDataRequestUpdate.newTransactionInfo = {
+                                totalPriceStatus: 'FINAL',
+                                totalPrice: newOrderSummary.total.amount,
+                                currencyCode: orderSummary?.currency || 'USD',
+                            };
+                        }
+                    }
+                    else if (intermediatePaymentData.callbackTrigger === 'SHIPPING_OPTION') {
+                        // Update shipping rate
+                        if (selectRate) {
+                            await selectRate(intermediatePaymentData.shippingOptionData.id);
+                        }
+                        const newOrderSummary = await reComputeOrderSummary();
+                        if (newOrderSummary) {
+                            paymentDataRequestUpdate.newTransactionInfo = {
+                                totalPriceStatus: 'FINAL',
+                                totalPrice: newOrderSummary.total.amount,
+                                currencyCode: orderSummary?.currency || 'USD',
+                            };
+                        }
+                    }
+                    else if (intermediatePaymentData.callbackTrigger === 'OFFER') {
+                        console.log('OFFER callback triggered, no action needed');
+                    }
+                    else if (intermediatePaymentData.callbackTrigger === 'INITIALIZE') {
+                        console.log('INITIALIZE callback triggered, no action needed');
+                    }
+                    resolve(paymentDataRequestUpdate);
+                }
+                catch (error) {
+                    console.error('Error in onPaymentDataChanged:', error);
+                    resolve({
+                        error: {
+                            reason: 'SHIPPING_ADDRESS_UNSERVICEABLE',
+                            message: 'Unable to calculate shipping for this address',
+                            intent: intermediatePaymentData.callbackTrigger,
+                        },
+                    });
+                }
+            };
+            void processCallback();
+        });
+    }, [updateCheckoutSessionValues, reComputeOrderSummary, selectRate, orderSummary]);
+    // Handle payment authorization
+    const handleGooglePayAuthorized = useCallback((paymentData) => {
+        setPendingPaymentData(paymentData);
+        return Promise.resolve({ transactionState: 'SUCCESS' });
+    }, []);
+    // Don't render if no order summary
+    if (!orderSummary) {
+        return null;
+    }
+    const minorUnitsToCurrencyString = (amountMinor, currency) => {
+        return (amountMinor / 100).toFixed(2);
+    };
+    const allowedCardNetworks = ['AMEX', 'DISCOVER', 'INTERAC', 'JCB', 'MASTERCARD', 'VISA'];
+    const allowedCardAuthMethods = ['PAN_ONLY', 'CRYPTOGRAM_3DS'];
+    const baseCardPaymentMethod = {
+        type: 'CARD',
+        parameters: {
+            allowedAuthMethods: allowedCardAuthMethods,
+            allowedCardNetworks: allowedCardNetworks,
+            billingAddressRequired: true,
+            billingAddressParameters: {
+                format: 'FULL',
+                phoneNumberRequired: true,
+            },
+        },
+    };
+    const tokenizationSpecification = {
+        type: 'PAYMENT_GATEWAY',
+        parameters: {
+            gateway: 'basistheory',
+            gatewayMerchantId: basistheoryTenantId,
+        },
+    };
+    const paymentRequest = {
+        apiVersion: 2,
+        apiVersionMinor: 0,
+        allowedPaymentMethods: [
+            {
+                ...baseCardPaymentMethod,
+                tokenizationSpecification,
+            },
+        ],
+        transactionInfo: {
+            totalPriceStatus: 'FINAL',
+            totalPrice: minorUnitsToCurrencyString(orderSummary.totalAdjustedAmount, orderSummary.currency),
+            currencyCode: orderSummary.currency,
+        },
+        merchantInfo: {
+            merchantName: googlePayPaymentMethod?.metadata?.merchantName ||
+                checkout?.checkoutSession?.store?.name ||
+                'Store',
+            merchantId: googlePayPaymentMethod?.metadata?.sandboxed
+                ? '12345678901234567890'
+                : googlePayPaymentMethod?.metadata?.merchantId || '12345678901234567890',
+        },
+        shippingAddressRequired: true,
+        shippingOptionRequired: true,
+        emailRequired: true,
+        callbackIntents: ['SHIPPING_OPTION', 'SHIPPING_ADDRESS', 'PAYMENT_AUTHORIZATION'],
+        shippingOptionParameters: {
+            defaultSelectedOptionId: shippingMethods.length > 0 ? shippingMethods[0].identifier : '',
+            shippingOptions: shippingMethods.map((method) => ({
+                id: method.identifier,
+                label: method.label,
+                description: method.amount + ': ' + method.detail || '',
+            })),
+        },
+    };
+    const environment = googlePayPaymentMethod?.metadata?.sandboxed ? 'TEST' : 'PRODUCTION';
+    return (_jsxs("div", { className: "w-full", children: [!processingPayment ? (_jsx(GooglePayButtonReact, { environment: environment, paymentRequest: paymentRequest, onPaymentAuthorized: handleGooglePayAuthorized, onPaymentDataChanged: handleGooglePayDataChanged, onError: (error) => {
+                    console.error('Google Pay error:', error);
+                    const errorMessage = 'Google Pay error: ' + error.statusMessage;
+                    setGooglePayError(errorMessage);
+                    setContextError(errorMessage);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                }, onCancel: () => {
+                    console.log('Google Pay payment cancelled');
+                    if (onCancel) {
+                        onCancel();
+                    }
+                }, existingPaymentMethodRequired: false, buttonColor: "black", buttonType: "plain", buttonSizeMode: "fill", buttonLocale: "en", className: `m-0 h-10 w-full rounded-sm p-0 text-base text-white ${className}` })) : (_jsx(Button, { type: "button", variant: "outline", size: "lg", className: "h-10 w-full bg-black text-base text-white shadow-sm hover:bg-black/80", disabled: true, children: _jsxs("div", { className: "flex items-center justify-center gap-3", children: [_jsx("div", { className: "h-5 w-5 animate-spin rounded-full border-2 border-white border-t-transparent" }), _jsx("span", { className: "font-medium", children: "Processing..." })] }) })), googlePayError && (_jsx("div", { className: "mt-2 rounded border border-red-200 bg-red-50 p-2 text-sm text-red-600", children: googlePayError }))] }));
+};
+export default GooglePayButton;

package/dist/react/components/index.d.ts

@@ -1,3 +1,4 @@
-export { default as DebugDrawer } from './DebugDrawer';
-export { default as Button } from './Button';
 export { default as ApplePayButton } from './ApplePayButton';
+export { default as Button } from './Button';
+export { default as DebugDrawer } from './DebugDrawer';
+export { default as GooglePayButton } from './GooglePayButton';

package/dist/react/components/index.js

@@ -1,3 +1,4 @@
-export { default as DebugDrawer } from './DebugDrawer';
-export { default as Button } from './Button';
 export { default as ApplePayButton } from './ApplePayButton';
+export { default as Button } from './Button';
+export { default as DebugDrawer } from './DebugDrawer';
+export { default as GooglePayButton } from './GooglePayButton';

package/dist/react/hooks/useApplePay.js

@@ -282,7 +282,9 @@ export function useApplePay(options = {}) {
                         // Tokenize the Apple Pay payment
                         const applePayToken = await tokenizeApplePay(event);
                         // Complete the Apple Pay session
-                        session.completePayment(window.ApplePaySession.STATUS_SUCCESS);
+                        session.completePayment({
+                            status: window.ApplePaySession.STATUS_SUCCESS,
+                        });
                         // Process the payment using the SDK's payment methods
                         await processApplePayPayment(checkoutSessionId, applePayToken, {
                             onSuccess: (payment) => {
@@ -298,7 +300,9 @@ export function useApplePay(options = {}) {
                     }
                     catch (error) {
                         console.error('Payment processing failed:', error);
-                        session.completePayment(window.ApplePaySession.STATUS_FAILURE);
+                        session.completePayment({
+                            status: window.ApplePaySession.STATUS_FAILURE,
+                        });
                         setProcessingPayment(false);
                         const errorMsg = error instanceof Error ? error.message : 'Payment processing failed';
                         setError(errorMsg);
@@ -317,7 +321,18 @@ export function useApplePay(options = {}) {
                             return;
                         }
                         const { lineItems: newLineItems, total: newTotal } = newOrderSummary;
-                        session.completeShippingMethodSelection(window.ApplePaySession.STATUS_SUCCESS, newTotal, newLineItems);
+                        session.completeShippingMethodSelection({
+                            newTotal: {
+                                label: newTotal.label,
+                                amount: newTotal.amount,
+                                type: 'final',
+                            },
+                            newLineItems: newLineItems.map(item => ({
+                                label: item.label,
+                                amount: item.amount,
+                                type: 'final',
+                            })),
+                        });
                     }
                     catch (error) {
                         console.error('Shipping method selection failed:', error);
@@ -343,7 +358,24 @@ export function useApplePay(options = {}) {
                         console.log('======= APPLE PAY ON SHIPPING CONTACT SELECTED ======');
                         console.log('newOrderSummary', newOrderSummary);
                         console.log(newLineItems, newTotal, newShippingMethods);
-                        session.completeShippingContactSelection(window.ApplePaySession.STATUS_SUCCESS, newShippingMethods, newTotal, newLineItems);
+                        session.completeShippingContactSelection({
+                            newShippingMethods: newShippingMethods.map(method => ({
+                                label: method.label,
+                                amount: method.amount,
+                                detail: method.detail,
+                                identifier: method.identifier,
+                            })),
+                            newTotal: {
+                                label: newTotal.label,
+                                amount: newTotal.amount,
+                                type: 'final',
+                            },
+                            newLineItems: newLineItems.map(item => ({
+                                label: item.label,
+                                amount: item.amount,
+                                type: 'final',
+                            })),
+                        });
                     }
                     catch (error) {
                         console.error('Shipping contact selection failed:', error);
@@ -351,12 +383,8 @@ export function useApplePay(options = {}) {
                     }
                 })();
             };
-            session.onerror = (event) => {
-                console.error('Apple Pay Session Error:', event);
-                const errorMsg = 'Apple Pay session error';
-                setError(errorMsg);
-                options.onError?.(errorMsg);
-            };
+            // Note: ApplePaySession doesn't have an onerror handler
+            // Error handling is done in the specific event handlers above
             session.oncancel = () => {
                 console.log('Payment cancelled by user');
                 setProcessingPayment(false);

package/dist/react/hooks/{useExpressPayment.d.ts → useExpressPaymentMethods.d.ts}

@@ -30,9 +30,17 @@ type ExpressShippingMethod = {
     identifier: string;
     detail: string;
 };
-export interface ExpressPaymentContextType {
+export interface ExpressPaymentMethodsContextType {
+    paymentMethods: PaymentMethod[] | undefined;
     applePayPaymentMethod?: PaymentMethod;
     googlePayPaymentMethod?: PaymentMethod;
+    paypalPaymentMethod?: PaymentMethod;
+    klarnaPaymentMethod?: PaymentMethod;
+    availableExpressPaymentMethodIds: string[];
+    setAvailableExpressPaymentMethodIds: (value: string[]) => void;
+    handleAddExpressId: (id: string) => void;
+    shippingMethods: ExpressShippingMethod[];
+    lineItems: ExpressOrderLineItem[];
     reComputeOrderSummary: () => Promise<{
         lineItems: ExpressOrderLineItem[];
         total: {
@@ -41,12 +49,6 @@ export interface ExpressPaymentContextType {
         };
         shippingMethods: ExpressShippingMethod[];
     } | undefined>;
-    loading?: boolean;
-    availableExpressPaymentMethodIds: string[];
-    setAvailableExpressPaymentMethodIds: (value: string[]) => void;
-    shippingMethods: ExpressShippingMethod[];
-    lineItems: ExpressOrderLineItem[];
-    handleAddExpressId: (id: string) => void;
     updateCheckoutSessionValues: (input: {
         data: {
             shippingAddress: Address;
@@ -58,14 +60,15 @@ export interface ExpressPaymentContextType {
             email: string;
         };
     }) => Promise<void>;
+    loading?: boolean;
     error: string | null;
     setError: (error: string | null) => void;
 }
-interface ExpressPaymentProviderProps {
+interface ExpressPaymentMethodsProviderProps {
     children: ReactNode;
     customerId?: string;
     checkout?: CheckoutData;
 }
-export declare const ExpressPaymentProvider: React.FC<ExpressPaymentProviderProps>;
-export declare const useExpressPayment: () => ExpressPaymentContextType;
+export declare const ExpressPaymentMethodsProvider: React.FC<ExpressPaymentMethodsProviderProps>;
+export declare const useExpressPaymentMethods: () => ExpressPaymentMethodsContextType;
 export {};

package/dist/react/hooks/{useExpressPayment.js → useExpressPaymentMethods.js}

@@ -3,8 +3,8 @@ import React, { createContext, useCallback, useContext, useMemo, useState } from
 import { useTagadaContext } from '../providers/TagadaProvider';
 import { useOrderSummary } from './useOrderSummary';
 import { useShippingRates } from './useShippingRates';
-const ExpressPaymentContext = createContext(undefined);
-export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
+const ExpressPaymentMethodsContext = createContext(undefined);
+export const ExpressPaymentMethodsProvider = ({ children, customerId, checkout, }) => {
     const { apiService } = useTagadaContext();
     const [availableExpressPaymentMethodIds, setAvailableExpressPaymentMethodIds] = useState([]);
     const [error, setError] = useState(null);
@@ -37,7 +37,7 @@ export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
         return () => {
             mounted = false;
         };
-    }, [apiService, checkoutSessionId]);
+    }, [apiService, checkoutSessionId, checkout]);
     const handleAddExpressId = (id) => {
         setAvailableExpressPaymentMethodIds((prev) => (prev.includes(id) ? prev : [...prev, id]));
     };
@@ -128,14 +128,20 @@ export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
             body: input,
         });
     }, [apiService, customerId]);
+    // Identify specific payment method types
     const enabledApplePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'apple_pay'), [paymentMethods]);
     const enabledGooglePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'google_pay'), [paymentMethods]);
+    const enabledPaypalPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'paypal'), [paymentMethods]);
+    const enabledKlarnaPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'klarna'), [paymentMethods]);
     const loading = !paymentMethods || isLoadingPaymentMethods || isLoadingOrderSummary;
     const contextValue = {
+        paymentMethods: paymentMethods || undefined,
         availableExpressPaymentMethodIds,
         setAvailableExpressPaymentMethodIds,
         applePayPaymentMethod: enabledApplePayPaymentMethod,
         googlePayPaymentMethod: enabledGooglePayPaymentMethod,
+        paypalPaymentMethod: enabledPaypalPaymentMethod,
+        klarnaPaymentMethod: enabledKlarnaPaymentMethod,
         shippingMethods,
         lineItems,
         reComputeOrderSummary,
@@ -146,13 +152,16 @@ export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
         error,
         setError,
     };
-    const hasAnyEnabled = Boolean(enabledApplePayPaymentMethod || enabledGooglePayPaymentMethod);
-    return (_jsx(ExpressPaymentContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
+    const hasAnyEnabled = Boolean(enabledApplePayPaymentMethod ||
+        enabledGooglePayPaymentMethod ||
+        enabledPaypalPaymentMethod ||
+        enabledKlarnaPaymentMethod);
+    return (_jsx(ExpressPaymentMethodsContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
 };
-export const useExpressPayment = () => {
-    const context = useContext(ExpressPaymentContext);
+export const useExpressPaymentMethods = () => {
+    const context = useContext(ExpressPaymentMethodsContext);
     if (context === undefined) {
-        throw new Error('useExpressPayment must be used within an ExpressPaymentProvider');
+        throw new Error('useExpressPaymentMethods must be used within an ExpressPaymentMethodsProvider');
     }
     return context;
 };

package/dist/react/hooks/useGoogleAutocomplete.d.ts

@@ -38,6 +38,8 @@ export interface ExtractedAddress {
     locality: string;
     administrativeAreaLevel1: string;
     administrativeAreaLevel1Long: string;
+    administrativeAreaLevel2: string;
+    administrativeAreaLevel2Long: string;
     country: string;
     postalCode: string;
 }

package/dist/react/hooks/useGoogleAutocomplete.js

@@ -155,6 +155,8 @@ export function useGoogleAutocomplete(options) {
             locality: '',
             administrativeAreaLevel1: '',
             administrativeAreaLevel1Long: '',
+            administrativeAreaLevel2: '',
+            administrativeAreaLevel2Long: '',
             country: '',
             postalCode: '',
         };
@@ -170,8 +172,13 @@ export function useGoogleAutocomplete(options) {
             if (types.includes('locality')) {
                 extracted.locality = component.long_name;
             }
-            if (types.includes('administrative_area_level_2') && !!!extracted.locality) {
-                extracted.locality = component.long_name;
+            if (types.includes('administrative_area_level_2')) {
+                extracted.administrativeAreaLevel2 = component.short_name;
+                extracted.administrativeAreaLevel2Long = component.long_name;
+                // Use level_2 as fallback for locality if locality is not set
+                if (!extracted.locality) {
+                    extracted.locality = component.long_name;
+                }
             }
             if (types.includes('administrative_area_level_1')) {
                 extracted.administrativeAreaLevel1 = component.short_name;
@@ -184,6 +191,15 @@ export function useGoogleAutocomplete(options) {
                 extracted.postalCode = component.long_name;
             }
         });
+        // For countries like France where administrative_area_level_1 (région) may be missing,
+        // use administrative_area_level_2 (département) as the primary state/province value
+        // We prefer the long_name (e.g., "Bouches-du-Rhône") over short_name (e.g., "13")
+        // because it's more likely to match our state database entries
+        if (!extracted.administrativeAreaLevel1 && extracted.administrativeAreaLevel2) {
+            // Use long name as the primary value (e.g., "Bouches-du-Rhône" instead of "13")
+            extracted.administrativeAreaLevel1 = extracted.administrativeAreaLevel2Long || extracted.administrativeAreaLevel2;
+            extracted.administrativeAreaLevel1Long = extracted.administrativeAreaLevel2Long;
+        }
         console.log('🏗️ Extracted address components:', extracted);
         return extracted;
     }, []);

package/dist/react/hooks/useGooglePay.d.ts

@@ -0,0 +1,22 @@
+interface UseGooglePayOptions {
+    onSuccess?: (payment: any) => void;
+    onError?: (error: string) => void;
+    onCancel?: () => void;
+    checkoutSessionId?: string;
+    customerId?: string;
+    storeName?: string;
+    currencyCode?: string;
+    merchantId?: string;
+    merchantName?: string;
+}
+export declare const useGooglePay: ({ onSuccess, onError, onCancel, checkoutSessionId, customerId, storeName, currencyCode, merchantId, merchantName, }: UseGooglePayOptions) => {
+    handleGooglePayAuthorized: (paymentData: any) => Promise<any>;
+    handleGooglePayDataChanged: (intermediatePaymentData: any) => Promise<any>;
+    processingPayment: boolean;
+    setProcessingPayment: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    googlePayError: string | null;
+    setGooglePayError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    isGooglePayAvailable: boolean;
+    paymentRequest: null;
+};
+export {};