@tagadapay/plugin-sdk 2.3.5 → 2.3.8

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

@@ -0,0 +1,2 @@
+import { UseApplePayOptions, UseApplePayResult } from '../types/apple-pay';
+export declare function useApplePay(options?: UseApplePayOptions): UseApplePayResult;

package/dist/react/hooks/useApplePay.js

@@ -0,0 +1,192 @@
+import { useCallback, useState } from 'react';
+import { getBasisTheoryApiKey } from '../config/payment';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { usePayment } from './usePayment';
+export function useApplePay(options = {}) {
+    const [processingPayment, setProcessingPayment] = useState(false);
+    const [error, setError] = useState(null);
+    const { createApplePayPaymentInstrument, processApplePayPayment } = usePayment();
+    const { environment, apiService } = useTagadaContext();
+    // Get API key from environment
+    const apiKey = getBasisTheoryApiKey(environment?.environment || 'local');
+    // Check if Apple Pay is available
+    const isApplePayAvailable = (() => {
+        if (typeof window === 'undefined')
+            return false;
+        // Check if ApplePaySession is available
+        const hasApplePaySession = !!window.ApplePaySession;
+        if (!hasApplePaySession) {
+            // In development, simulate Apple Pay availability for UI testing
+            const isDevelopment = process.env.NODE_ENV === 'development' ||
+                window.location.hostname === 'localhost' ||
+                window.location.hostname.includes('127.0.0.1');
+            if (isDevelopment) {
+                console.log('Development mode: Simulating Apple Pay availability for UI testing');
+                return true;
+            }
+            return false;
+        }
+        try {
+            // Check basic Apple Pay support
+            return window.ApplePaySession.canMakePayments();
+        }
+        catch (error) {
+            console.warn('Apple Pay availability check failed:', error);
+            return false;
+        }
+    })();
+    // Debug logging
+    console.log('Apple Pay availability check:', {
+        hasWindow: typeof window !== 'undefined',
+        hasApplePaySession: typeof window !== 'undefined' && !!window.ApplePaySession,
+        canMakePayments: typeof window !== 'undefined' && window.ApplePaySession && window.ApplePaySession.canMakePayments(),
+        isDevelopment: process.env.NODE_ENV === 'development' ||
+            (typeof window !== 'undefined' && (window.location.hostname === 'localhost' || window.location.hostname.includes('127.0.0.1'))),
+        isAvailable: isApplePayAvailable,
+        note: !window.ApplePaySession ? 'Apple Pay not available in this browser. Use Safari on iOS/macOS for real Apple Pay support.' : 'Apple Pay API detected'
+    });
+    const validateMerchant = useCallback(async () => {
+        try {
+            const response = await fetch('https://api.basistheory.com/apple-pay/session', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'BT-API-KEY': apiKey,
+                },
+                body: JSON.stringify({
+                    display_name: 'Tagada Pay Store',
+                    domain: typeof window !== 'undefined' ? window.location.host : 'localhost',
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            const merchantSession = await response.json();
+            return merchantSession;
+        }
+        catch (err) {
+            console.error('Merchant validation error:', err);
+            throw err;
+        }
+    }, [apiKey]);
+    const tokenizeApplePay = useCallback(async (event) => {
+        try {
+            const response = await fetch('https://api.basistheory.com/apple-pay', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'BT-API-KEY': apiKey,
+                },
+                body: JSON.stringify({
+                    apple_payment_data: event.payment.token,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            const result = await response.json();
+            return result.apple_pay; // Basis Theory returns the Apple Pay token in the apple_pay field
+        }
+        catch (error) {
+            console.error('Apple Pay tokenization error:', error);
+            throw error;
+        }
+    }, [apiKey]);
+    const handleApplePayClick = useCallback((checkoutSessionId, lineItems, total, config = {}) => {
+        if (!isApplePayAvailable) {
+            const errorMsg = 'Apple Pay is not available on this device';
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+            return;
+        }
+        const request = {
+            countryCode: config.countryCode || 'US',
+            currencyCode: 'USD', // This should be passed as a parameter
+            supportedNetworks: config.supportedNetworks || ['visa', 'masterCard', 'amex', 'discover'],
+            merchantCapabilities: config.merchantCapabilities || ['supports3DS'],
+            total,
+            lineItems,
+        };
+        try {
+            const session = new window.ApplePaySession(3, request);
+            session.onvalidatemerchant = (event) => {
+                void (async () => {
+                    try {
+                        console.log('Merchant validation requested for:', event.validationURL);
+                        const merchantSession = await validateMerchant();
+                        session.completeMerchantValidation(merchantSession);
+                    }
+                    catch (error) {
+                        console.error('Merchant validation failed:', error);
+                        session.abort();
+                        const errorMsg = 'Merchant validation failed';
+                        setError(errorMsg);
+                        options.onError?.(errorMsg);
+                    }
+                })();
+            };
+            session.onpaymentauthorized = (event) => {
+                void (async () => {
+                    try {
+                        setProcessingPayment(true);
+                        setError(null);
+                        // Tokenize the Apple Pay payment
+                        const applePayToken = await tokenizeApplePay(event);
+                        // Complete the Apple Pay session
+                        session.completePayment(window.ApplePaySession.STATUS_SUCCESS);
+                        // Process the payment using the SDK's payment methods
+                        await processApplePayPayment(checkoutSessionId, applePayToken, {
+                            onSuccess: (payment) => {
+                                setProcessingPayment(false);
+                                options.onSuccess?.(payment);
+                            },
+                            onFailure: (errorMsg) => {
+                                setProcessingPayment(false);
+                                setError(errorMsg);
+                                options.onError?.(errorMsg);
+                            },
+                        });
+                    }
+                    catch (error) {
+                        console.error('Payment processing failed:', error);
+                        session.completePayment(window.ApplePaySession.STATUS_FAILURE);
+                        setProcessingPayment(false);
+                        const errorMsg = error instanceof Error ? error.message : 'Payment processing failed';
+                        setError(errorMsg);
+                        options.onError?.(errorMsg);
+                    }
+                })();
+            };
+            session.onerror = (event) => {
+                console.error('Apple Pay Session Error:', event);
+                const errorMsg = 'Apple Pay session error';
+                setError(errorMsg);
+                options.onError?.(errorMsg);
+            };
+            session.oncancel = () => {
+                console.log('Payment cancelled by user');
+                setProcessingPayment(false);
+                options.onCancel?.();
+            };
+            session.begin();
+        }
+        catch (error) {
+            console.error('Failed to start Apple Pay session:', error);
+            const errorMsg = 'Failed to start Apple Pay session';
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+        }
+    }, [
+        isApplePayAvailable,
+        validateMerchant,
+        tokenizeApplePay,
+        processApplePayPayment,
+        options,
+    ]);
+    return {
+        handleApplePayClick,
+        processingPayment,
+        applePayError: error,
+        isApplePayAvailable,
+    };
+}

package/dist/react/hooks/useCheckout.js

@@ -179,6 +179,10 @@ export function useCheckout(options = {}) {
         }
     }, [apiService, currentCurrency, isSessionInitialized]);
     const refresh = useCallback(async () => {
+        console.log('🔄 [useCheckout] Refreshing checkout data...', {
+            checkoutToken: currentCheckoutTokenRef.current?.substring(0, 8) + '...',
+            timestamp: new Date().toISOString(),
+        });
         if (!currentCheckoutTokenRef.current) {
             throw new Error('No checkout session to refresh');
         }

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

@@ -0,0 +1,72 @@
+export interface OrderSummaryItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    orderLineItemProduct?: {
+        name: string | null;
+    } | null;
+    orderLineItemVariant?: {
+        name: string | null;
+        imageUrl: string | null;
+    } | null;
+    product?: {
+        name: string;
+        description: string;
+    };
+    quantity: number;
+    amount: number;
+    adjustedAmount: number;
+    currency: string;
+    recurring?: boolean | null;
+    interval?: 'day' | 'week' | 'month' | 'year' | null;
+    intervalCount?: number | null;
+    subscriptionSettings?: {
+        trial?: {
+            duration: number;
+            durationType: 'day' | 'week' | 'month' | 'year';
+        } | null;
+    } | null;
+    adjustments?: {
+        type: string;
+        amount: number;
+        description: string;
+    }[];
+}
+export interface OrderSummaryData {
+    totalAdjustedAmount: number;
+    currency: string;
+    shippingCost: number;
+    shippingCostIsFree: boolean;
+    subtotalAdjustedAmount: number;
+    totalPromotionAmount: number;
+    totalTaxAmount: number;
+    items: OrderSummaryItem[];
+    adjustments?: {
+        type: string;
+        amount: number;
+        description: string;
+    }[];
+}
+export interface UseOrderSummaryOptions {
+    sessionId?: string;
+    disabled?: boolean;
+}
+export interface UseOrderSummaryResult {
+    orderSummary: OrderSummaryData | undefined;
+    isLoading: boolean;
+    isRefetching: boolean;
+    error: Error | null;
+    total: number;
+    currency: string;
+    refetch: () => Promise<void>;
+}
+export declare function useOrderSummary({ sessionId, disabled, }?: UseOrderSummaryOptions): UseOrderSummaryResult;
+/**
+ * Simplified hook that just returns the total and currency
+ * Reuses the data from useOrderSummary
+ */
+export declare function useOrderTotal(options?: UseOrderSummaryOptions): {
+    total: number;
+    currency: string;
+    isLoading: boolean;
+};

package/dist/react/hooks/useOrderSummary.js

@@ -0,0 +1,85 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useOrderSummary({ sessionId, disabled = false, } = {}) {
+    const { apiService } = useTagadaContext();
+    const [orderSummary, setOrderSummary] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isRefetching, setIsRefetching] = useState(false);
+    const [error, setError] = useState(null);
+    const isMountedRef = useRef(true);
+    useEffect(() => {
+        isMountedRef.current = true;
+        return () => {
+            isMountedRef.current = false;
+        };
+    }, []);
+    const fetchOrderSummary = useCallback(async () => {
+        if (!sessionId || disabled) {
+            return;
+        }
+        try {
+            setError(null);
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${sessionId}/order-summary`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: { checkoutSessionId: sessionId }
+            });
+            if (isMountedRef.current) {
+                setOrderSummary(response);
+            }
+        }
+        catch (err) {
+            if (isMountedRef.current) {
+                setError(err instanceof Error ? err : new Error('Failed to fetch order summary'));
+            }
+        }
+    }, [sessionId, disabled, apiService]);
+    const refetch = useCallback(async () => {
+        if (!sessionId || disabled) {
+            return;
+        }
+        setIsRefetching(true);
+        try {
+            await fetchOrderSummary();
+        }
+        finally {
+            if (isMountedRef.current) {
+                setIsRefetching(false);
+            }
+        }
+    }, [sessionId, disabled, fetchOrderSummary]);
+    // Initial fetch
+    useEffect(() => {
+        if (sessionId && !disabled && isMountedRef.current) {
+            setIsLoading(true);
+            fetchOrderSummary().finally(() => {
+                if (isMountedRef.current) {
+                    setIsLoading(false);
+                }
+            });
+        }
+    }, [sessionId, disabled, fetchOrderSummary]);
+    return {
+        orderSummary,
+        isLoading,
+        isRefetching,
+        error,
+        total: orderSummary?.totalAdjustedAmount ?? 0,
+        currency: orderSummary?.currency ?? 'EUR',
+        refetch,
+    };
+}
+/**
+ * Simplified hook that just returns the total and currency
+ * Reuses the data from useOrderSummary
+ */
+export function useOrderTotal(options = {}) {
+    const { total, currency, isLoading } = useOrderSummary(options);
+    return {
+        total,
+        currency,
+        isLoading,
+    };
+}

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

@@ -0,0 +1,48 @@
+import { PickupPoint } from '../types';
+export interface ShippingRate {
+    id: string;
+    shippingRateName: string;
+    amount: number;
+    currency: string;
+    isFree: boolean;
+    description?: string;
+    highlighted?: boolean;
+    icon?: string;
+    isPickupPoint?: boolean;
+    pickupPointCarriers?: string[];
+}
+export interface ShippingRatesResponse {
+    rates: ShippingRate[];
+    pickupPoint?: PickupPoint;
+    forceCheckoutSessionRefetch?: boolean;
+}
+export interface UseShippingRatesOptions {
+    onSuccess?: () => void;
+    disabled?: boolean;
+    checkoutSessionId?: string;
+}
+export interface UseShippingRatesResult {
+    shippingRates: ShippingRate[] | undefined;
+    forceCheckoutSessionRefetch: boolean | undefined;
+    handleSelectRate: (rateId: string) => void;
+    isPickupPointSelected: boolean;
+    selectedRateId: string | null;
+    setSelectedRateId: (rateId: string | null) => void;
+    setShippingRate: (data: {
+        shippingRateId: string;
+    }) => Promise<void>;
+    setShippingRateAsync: (data: {
+        shippingRateId: string;
+    }) => Promise<void>;
+    isPending: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    setPickupPoint: (data: {
+        checkoutSessionId: string;
+        data: PickupPoint;
+    }) => Promise<void>;
+    selectedRate: ShippingRate | undefined;
+}
+export declare const useShippingRates: ({ onSuccess, disabled, checkoutSessionId }?: UseShippingRatesOptions) => UseShippingRatesResult;

package/dist/react/hooks/useShippingRates.js

@@ -0,0 +1,204 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+// Debounce utility to prevent rapid successive calls
+function useDebounce(callback, delay) {
+    const timeoutRef = useRef(null);
+    const isMountedRef = useRef(true);
+    useEffect(() => {
+        isMountedRef.current = true;
+        return () => {
+            isMountedRef.current = false;
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    return useCallback(((...args) => {
+        if (!isMountedRef.current)
+            return;
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            if (isMountedRef.current) {
+                callback(...args);
+            }
+        }, delay);
+    }), [callback, delay]);
+}
+export const useShippingRates = ({ onSuccess, disabled, checkoutSessionId } = {}) => {
+    const { apiService } = useTagadaContext();
+    const [selectedRateId, setSelectedRateId] = useState(null);
+    const [shippingRates, setShippingRates] = useState();
+    const [forceCheckoutSessionRefetch, setForceCheckoutSessionRefetch] = useState();
+    const [isLoading, setIsLoading] = useState(false);
+    const [isFetching, setIsFetching] = useState(false);
+    const [isPending, setIsPending] = useState(false);
+    const [error, setError] = useState(null);
+    const isMountedRef = useRef(true);
+    const isUpdatingRef = useRef(false);
+    // Use checkoutSessionId from props or fall back to session
+    const sessionId = checkoutSessionId;
+    // Track mounted state
+    useEffect(() => {
+        isMountedRef.current = true;
+        return () => {
+            isMountedRef.current = false;
+        };
+    }, []);
+    // Fetch shipping rates
+    const fetchShippingRates = useCallback(async () => {
+        if (!sessionId || !apiService)
+            return;
+        try {
+            setIsFetching(true);
+            setError(null);
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${sessionId}/shipping-rates`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (isMountedRef.current) {
+                setShippingRates(response.rates);
+                setForceCheckoutSessionRefetch(response.forceCheckoutSessionRefetch);
+            }
+        }
+        catch (err) {
+            if (isMountedRef.current) {
+                setError(err instanceof Error ? err : new Error('Failed to fetch shipping rates'));
+            }
+        }
+        finally {
+            if (isMountedRef.current) {
+                setIsFetching(false);
+            }
+        }
+    }, [sessionId, apiService]);
+    // Initial fetch of shipping rates when sessionId is available
+    useEffect(() => {
+        if (sessionId && !disabled && isMountedRef.current) {
+            fetchShippingRates();
+        }
+    }, [sessionId, disabled, fetchShippingRates]);
+    // Debounced success handler to prevent query invalidation storms
+    const debouncedOnSuccess = useDebounce(useCallback(async () => {
+        if (!isMountedRef.current || isUpdatingRef.current)
+            return;
+        try {
+            isUpdatingRef.current = true;
+            // Refetch shipping rates after successful update
+            await fetchShippingRates();
+            if (isMountedRef.current && onSuccess) {
+                onSuccess();
+            }
+        }
+        catch (error) {
+            console.error('Error in shipping rate success handler:', error);
+        }
+        finally {
+            if (isMountedRef.current) {
+                isUpdatingRef.current = false;
+            }
+        }
+    }, [fetchShippingRates, onSuccess]), 300);
+    // Set shipping rate mutation
+    const setShippingRate = useCallback(async (data) => {
+        if (!sessionId || !apiService)
+            return;
+        try {
+            setIsPending(true);
+            setError(null);
+            await apiService.fetch(`/api/v1/checkout-sessions/${sessionId}/shipping-rate`, {
+                method: 'POST',
+                body: data,
+            });
+            if (isMountedRef.current) {
+                await debouncedOnSuccess();
+            }
+        }
+        catch (err) {
+            if (isMountedRef.current) {
+                setSelectedRateId(selectedRateId); // Revert to previous selection
+                setError(err instanceof Error ? err : new Error('Failed to update shipping rate'));
+            }
+        }
+        finally {
+            if (isMountedRef.current) {
+                setIsPending(false);
+            }
+        }
+    }, [sessionId, apiService, debouncedOnSuccess, selectedRateId]);
+    const setShippingRateAsync = setShippingRate; // Alias for consistency
+    // Debounced refetch for country/postal changes
+    const debouncedRefetchRates = useDebounce(fetchShippingRates, 500);
+    // Set pickup point mutation
+    const setPickupPoint = useCallback(async (data) => {
+        if (!apiService)
+            return;
+        try {
+            setIsPending(true);
+            setError(null);
+            await apiService.fetch(`/api/v1/checkout-sessions/${data.checkoutSessionId}/pickup-point`, {
+                method: 'POST',
+                body: { data: data.data },
+            });
+            if (isMountedRef.current) {
+                await debouncedOnSuccess();
+            }
+        }
+        catch (err) {
+            if (isMountedRef.current) {
+                setSelectedRateId(selectedRateId); // Revert to previous selection
+                setError(err instanceof Error ? err : new Error('Failed to update pickup point'));
+            }
+        }
+        finally {
+            if (isMountedRef.current) {
+                setIsPending(false);
+            }
+        }
+    }, [apiService, debouncedOnSuccess, selectedRateId]);
+    const handleSelectRate = useCallback((rateId) => {
+        if (isPending || disabled || !isMountedRef.current)
+            return;
+        const selectedRate = shippingRates?.find((rate) => rate.id === rateId);
+        if (isMountedRef.current) {
+            setSelectedRateId(rateId);
+            setShippingRate({ shippingRateId: rateId });
+        }
+    }, [setShippingRate, isPending, disabled, shippingRates]);
+    // Auto-select shipping rate when only one is available
+    useEffect(() => {
+        if (!shippingRates?.length || selectedRateId || !isMountedRef.current)
+            return;
+        const nonPickupRates = shippingRates.filter((rate) => !rate.isPickupPoint);
+        if (nonPickupRates.length === 1) {
+            handleSelectRate(nonPickupRates[0].id);
+        }
+        else if (nonPickupRates.length > 1) {
+            const cheapestRate = nonPickupRates.reduce((prev, current) => current.amount < prev.amount ? current : prev);
+            handleSelectRate(cheapestRate.id);
+        }
+    }, [shippingRates, selectedRateId, handleSelectRate]);
+    // Get the currently selected shipping rate
+    const selectedRate = shippingRates?.find((rate) => rate.id === selectedRateId);
+    const isPickupPointSelected = Boolean(selectedRate?.isPickupPoint);
+    return {
+        shippingRates,
+        forceCheckoutSessionRefetch,
+        handleSelectRate,
+        isPickupPointSelected,
+        selectedRateId,
+        setSelectedRateId,
+        setShippingRate,
+        setShippingRateAsync,
+        isPending,
+        isFetching,
+        isLoading,
+        error,
+        refetch: fetchShippingRates,
+        setPickupPoint,
+        selectedRate,
+    };
+};

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

@@ -0,0 +1,18 @@
+type Primitive = string | number | boolean | null | undefined;
+export interface TranslateOptions {
+    defaultValue?: string;
+}
+export interface UseTranslationsResult {
+    t: (key: string, vars?: Record<string, Primitive>, options?: TranslateOptions) => string;
+    messages: Record<string, string>;
+    locale: string;
+    language: string;
+    region: string;
+}
+/**
+ * useTranslations - Lightweight translator for SDK plugins
+ * - Reads `locale.messages` populated by TagadaProvider session init
+ * - Provides `t(key, vars, options)` with simple `{var}` interpolation
+ */
+export declare function useTranslations(targetLanguageCode?: string): UseTranslationsResult;
+export {};

package/dist/react/hooks/useTranslations.js

@@ -0,0 +1,77 @@
+'use client';
+import { useEffect, useMemo, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+function interpolate(template, vars) {
+    if (!vars)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (_, name) => {
+        const value = vars[name];
+        return value === null || value === undefined ? '' : String(value);
+    });
+}
+/**
+ * useTranslations - Lightweight translator for SDK plugins
+ * - Reads `locale.messages` populated by TagadaProvider session init
+ * - Provides `t(key, vars, options)` with simple `{var}` interpolation
+ */
+export function useTranslations(targetLanguageCode) {
+    const { locale, apiService, pluginConfig } = useTagadaContext();
+    const selectedLanguage = targetLanguageCode || locale.language;
+    // Prefer backend messages for the selected language; fall back to provider
+    const [fetchedMessages, setFetchedMessages] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        async function fetchMessages() {
+            const region = locale.region || 'US';
+            const desiredLanguage = selectedLanguage;
+            const targetLocale = `${desiredLanguage}-${region}`;
+            try {
+                const storeId = pluginConfig?.storeId;
+                if (!storeId) {
+                    setFetchedMessages(null);
+                    return;
+                }
+                const data = await apiService.fetch('/api/v1/translation-messages', {
+                    method: 'GET',
+                    params: { locale: targetLocale, storeId },
+                });
+                if (!cancelled) {
+                    setFetchedMessages(data || {});
+                }
+            }
+            catch (_err) {
+                if (!cancelled) {
+                    setFetchedMessages(null);
+                }
+            }
+        }
+        void fetchMessages();
+        return () => {
+            cancelled = true;
+        };
+    }, [selectedLanguage, locale.region, pluginConfig?.storeId, apiService]);
+    const messages = useMemo(() => {
+        if (fetchedMessages)
+            return fetchedMessages;
+        return locale.messages || {};
+    }, [fetchedMessages, locale.messages]);
+    const t = useMemo(() => {
+        return (key, vars, opts) => {
+            const raw = messages[key] ?? opts?.defaultValue ?? key;
+            return interpolate(raw, vars);
+        };
+    }, [messages]);
+    const computedLocale = useMemo(() => {
+        if (selectedLanguage === locale.language)
+            return locale.locale;
+        const region = locale.region || 'US';
+        return `${selectedLanguage}-${region}`;
+    }, [selectedLanguage, locale.locale, locale.language, locale.region]);
+    return {
+        t,
+        messages,
+        locale: computedLocale,
+        language: selectedLanguage,
+        region: computedLocale.split('-')[1] || 'US',
+    };
+}

package/dist/react/index.d.ts

@@ -16,6 +16,7 @@ export { useOrderBump } from './hooks/useOrderBump';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
+export { useTranslations } from './hooks/useTranslations';
 export { useTagadaContext } from './providers/TagadaProvider';
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
 export type { PluginConfig } from './hooks/usePluginConfig';
@@ -28,6 +29,7 @@ export { usePayment } from './hooks/usePayment';
 export { usePaymentPolling } from './hooks/usePaymentPolling';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useApplePay } from './hooks/useApplePay';
 export type { AuthState, Currency, Customer, Environment, EnvironmentConfig, Locale, Order, OrderAddress, OrderItem, OrderSummary, PickupPoint, Session, Store } from './types';
 export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, CheckoutSessionPreview, Promotion, UseCheckoutOptions, UseCheckoutResult } from './hooks/useCheckout';
 export type { Discount, DiscountCodeValidation, UseDiscountsOptions, UseDiscountsResult } from './hooks/useDiscounts';
@@ -36,4 +38,5 @@ export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferLineIte
 export type { Payment, PaymentPollingHook, PollingOptions } from './hooks/usePaymentPolling';
 export type { PaymentInstrument, ThreedsChallenge, ThreedsHook, ThreedsOptions, ThreedsProvider, ThreedsSession } from './hooks/useThreeds';
 export type { ApplePayToken, CardPaymentMethod, PaymentHook, PaymentInstrumentResponse, PaymentOptions, PaymentResponse } from './hooks/usePayment';
+export type { ApplePayConfig, ApplePayLineItem, ApplePayPaymentAuthorizedEvent, ApplePayPaymentRequest, ApplePayPaymentToken, ApplePayValidateMerchantEvent, BasisTheorySessionRequest, BasisTheoryTokenizeRequest, PayToken, UseApplePayOptions, UseApplePayResult } from './types/apple-pay';
 export { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits } from './utils/money';

package/dist/react/index.js

@@ -19,6 +19,7 @@ export { useOrderBump } from './hooks/useOrderBump';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
+export { useTranslations } from './hooks/useTranslations';
 export { useTagadaContext } from './providers/TagadaProvider';
 // Plugin configuration hooks
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
@@ -31,6 +32,8 @@ export { usePayment } from './hooks/usePayment';
 export { usePaymentPolling } from './hooks/usePaymentPolling';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+// Apple Pay hooks exports
+export { useApplePay } from './hooks/useApplePay';
 // Component exports (if any)
 // export { SomeComponent } from './components/SomeComponent';
 // Utility exports

package/dist/react/types/apple-pay.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Apple Pay types for the Tagada Pay Plugin SDK
+ */
+export interface ApplePayPaymentRequest {
+    countryCode: string;
+    currencyCode: string;
+    supportedNetworks: string[];
+    merchantCapabilities: string[];
+    total: ApplePayLineItem;
+    lineItems: ApplePayLineItem[];
+}
+export interface ApplePayLineItem {
+    label: string;
+    amount: string;
+    type: 'final' | 'pending';
+}
+export interface ApplePayPaymentAuthorizedEvent {
+    payment: {
+        token: ApplePayPaymentToken;
+    };
+}
+export interface ApplePayPaymentToken {
+    paymentData: any;
+    paymentMethod: {
+        displayName: string;
+        network: string;
+        type: string;
+    };
+    transactionIdentifier: string;
+}
+export interface ApplePayValidateMerchantEvent {
+    validationURL: string;
+}
+export interface BasisTheorySessionRequest {
+    display_name: string;
+    domain: string;
+}
+export interface BasisTheoryTokenizeRequest {
+    apple_payment_data: ApplePayPaymentToken;
+}
+export interface PayToken {
+    id: string;
+    type: string;
+    card: {
+        bin: string;
+        last4: string;
+        expiration_month: number;
+        expiration_year: number;
+        brand: string;
+    };
+}
+export interface ApplePayConfig {
+    countryCode?: string;
+    supportedNetworks?: string[];
+    merchantCapabilities?: string[];
+}
+export interface UseApplePayOptions {
+    onSuccess?: (payment: any) => void;
+    onError?: (error: string) => void;
+    onCancel?: () => void;
+    config?: ApplePayConfig;
+}
+export interface UseApplePayResult {
+    handleApplePayClick: (checkoutSessionId: string, lineItems: ApplePayLineItem[], total: ApplePayLineItem, config?: ApplePayConfig) => void;
+    processingPayment: boolean;
+    applePayError: string | null;
+    isApplePayAvailable: boolean;
+}
+declare global {
+    interface Window {
+        ApplePaySession: typeof ApplePaySession;
+    }
+}
+declare class ApplePaySession {
+    static STATUS_SUCCESS: number;
+    static STATUS_FAILURE: number;
+    static canMakePayments(): boolean;
+    static canMakePaymentsWithActiveCard(merchantIdentifier: string): Promise<boolean>;
+    constructor(version: number, request: ApplePayPaymentRequest);
+    begin(): void;
+    abort(): void;
+    onerror: ((event: any) => void) | null;
+    completeMerchantValidation(merchantSession: any): void;
+    completeShippingContactSelection(status: number, shippingMethods: any[], total: any, lineItems: any[]): void;
+    completeShippingMethodSelection(status: number, total: any, lineItems: any[]): void;
+    completePayment(status: number): void;
+    onvalidatemerchant: ((event: ApplePayValidateMerchantEvent) => void) | null;
+    onpaymentauthorized: ((event: ApplePayPaymentAuthorizedEvent) => void) | null;
+    oncancel: (() => void) | null;
+    onshippingmethodselected: ((event: any) => void) | null;
+    onshippingcontactselected: ((event: any) => void) | null;
+}
+export {};

package/dist/react/types/apple-pay.js

@@ -0,0 +1,4 @@
+/**
+ * Apple Pay types for the Tagada Pay Plugin SDK
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.3.5",
+  "version": "2.3.8",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",