@tagadapay/plugin-sdk 2.6.4 → 2.6.8

package/README.md

@@ -15,6 +15,7 @@ A comprehensive React SDK for building plugins on the TagadaPay platform. Create
 - **[useCheckout (V2)](#usecheckout)** - TanStack Query-based checkout management
 - **[useOffers (V2)](#useoffers)** - Dynamic pricing with automatic caching
 - **[useProducts (V2)](#useproducts)** - Product data management
+- **[useStoreConfig (V2)](#usestoreconfig)** - Store configuration with automatic caching
 - **[usePayment (V2)](#usepayment)** - Payment processing with 3DS support
 - **[V2 Utility Functions](#v2-utility-functions--advanced-features)** - Enhanced utilities and TanStack Query integration
 
@@ -708,6 +709,44 @@ const {
 } = useProducts({ storeId, enabled });
 ```
 
+#### useStoreConfig()
+
+Hook for fetching store configuration with automatic caching.
+
+```typescript
+const {
+  // Query data
+  storeConfig, // StoreConfig | undefined
+  isLoading, // boolean
+  error, // Error | null
+  isSuccess, // boolean
+
+  // Actions
+  refetch, // () => Promise<void>
+} = useStoreConfig({ storeId, enabled });
+```
+
+**Example:**
+
+```tsx
+import { useStoreConfig } from '@tagadapay/plugin-sdk/v2';
+
+function StoreInfo() {
+  const { storeConfig, isLoading } = useStoreConfig();
+
+  if (isLoading) return <div>Loading...</div>;
+
+  return (
+    <div>
+      <h1>{storeConfig?.storeName}</h1>
+      <p>Currency: {storeConfig?.currency}</p>
+    </div>
+  );
+}
+```
+
+See [useStoreConfig documentation](./docs/README-useStoreConfig.md) for more details.
+
 #### useOrder()
 
 Hook for order management and tracking.

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/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 {};

package/dist/react/hooks/useGooglePay.js

@@ -0,0 +1,32 @@
+import { useCallback, useEffect, useState } from 'react';
+export const useGooglePay = ({ onSuccess, onError, onCancel, checkoutSessionId, customerId, storeName = 'Store', currencyCode = 'USD', merchantId = '12345678901234567890', merchantName = 'Store', }) => {
+    const [processingPayment, setProcessingPayment] = useState(false);
+    const [googlePayError, setGooglePayError] = useState(null);
+    const [isGooglePayAvailable, setIsGooglePayAvailable] = useState(false);
+    // Check if Google Pay is available on this device
+    useEffect(() => {
+        if (typeof window !== 'undefined' && window.google?.payments?.api) {
+            setIsGooglePayAvailable(true);
+        }
+    }, []);
+    // The actual implementation will be done by the consumer
+    // This hook just provides state management
+    const handleGooglePayAuthorized = useCallback((paymentData) => {
+        // This will be implemented by the consumer
+        return Promise.resolve({ transactionState: 'SUCCESS' });
+    }, []);
+    const handleGooglePayDataChanged = useCallback((intermediatePaymentData) => {
+        // This will be implemented by the consumer
+        return Promise.resolve({});
+    }, []);
+    return {
+        handleGooglePayAuthorized,
+        handleGooglePayDataChanged,
+        processingPayment,
+        setProcessingPayment,
+        googlePayError,
+        setGooglePayError,
+        isGooglePayAvailable,
+        paymentRequest: null, // Will be provided by consumer
+    };
+};

package/dist/react/index.d.ts

@@ -43,6 +43,7 @@ export { usePaymentPolling } from './hooks/usePaymentPolling';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export { useApplePay } from './hooks/useApplePay';
+export { useGooglePay } from './hooks/useGooglePay';
 export { ExpressPaymentMethodsProvider, useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export type { ExpressPaymentMethodsContextType } from './hooks/useExpressPaymentMethods';
 export type { AuthState, Currency, Customer, CustomerInfos, Environment, EnvironmentConfig, Locale, Order, OrderAddress, OrderItem, OrderSummary, PickupPoint, Session, Store } from './types';
@@ -59,5 +60,5 @@ export type { Payment, PaymentPollingHook, PollingOptions } from './hooks/usePay
 export type { PaymentInstrument, ThreedsChallenge, ThreedsHook, ThreedsOptions, ThreedsProvider, ThreedsSession } from './hooks/useThreeds';
 export type { ApplePayToken, CardPaymentMethod, PaymentHook, PaymentInstrumentResponse, PaymentOptions, PaymentResponse } from './hooks/usePayment';
 export type { ApplePayAddress, ApplePayConfig, ApplePayLineItem, ApplePayPaymentAuthorizedEvent, ApplePayPaymentRequest, ApplePayPaymentToken, ApplePayValidateMerchantEvent, BasisTheorySessionRequest, BasisTheoryTokenizeRequest, PayToken, UseApplePayOptions, UseApplePayResult } from './types/apple-pay';
-export { ApplePayButton, Button } from './components';
+export { ApplePayButton, Button, GooglePayButton } from './components';
 export { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits } from './utils/money';

package/dist/react/index.js

@@ -45,10 +45,12 @@ export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 // Apple Pay hooks exports
 export { useApplePay } from './hooks/useApplePay';
+// Google Pay hooks exports
+export { useGooglePay } from './hooks/useGooglePay';
 // Express Payment context exports
 // Express Payment Methods (extended functionality)
 export { ExpressPaymentMethodsProvider, useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 // Component exports
-export { ApplePayButton, Button } from './components';
+export { ApplePayButton, Button, GooglePayButton } from './components';
 // Utility exports
 export { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits } from './utils/money';