@tagadapay/plugin-sdk 2.3.8 → 2.3.10

package/dist/react/hooks/useApplePay.js

@@ -1,51 +1,139 @@
-import { useCallback, useState } from 'react';
+import { useCallback, useEffect, 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 [isApplePayAvailable, setIsApplePayAvailable] = useState(false);
     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;
+    // Check Apple Pay availability on mount
+    useEffect(() => {
+        const checkApplePayAvailability = () => {
+            if (typeof window === 'undefined') {
+                setIsApplePayAvailable(false);
+                return;
             }
-            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) {
+                    setIsApplePayAvailable(true);
+                    return;
+                }
+                setIsApplePayAvailable(false);
+                return;
+            }
+            try {
+                // Check basic Apple Pay support
+                const canMakePayments = window.ApplePaySession.canMakePayments();
+                setIsApplePayAvailable(canMakePayments);
+            }
+            catch (error) {
+                console.warn('Apple Pay availability check failed:', error);
+                setIsApplePayAvailable(false);
+            }
+        };
+        checkApplePayAvailability();
+        // Debug logging
+    }, []);
+    // Utility function to convert Apple Pay contact to address
+    const appleContactToAddress = useCallback((contact) => {
+        return {
+            address1: contact?.addressLines?.[0] || '',
+            address2: contact?.addressLines?.[1] || '',
+            lastName: contact?.familyName || '',
+            firstName: contact?.givenName || '',
+            city: contact?.locality || '',
+            state: contact?.administrativeArea || '',
+            country: contact?.countryCode || '',
+            postal: contact?.postalCode || '',
+            phone: contact?.phoneNumber || '',
+            email: contact?.emailAddress || '',
+        };
+    }, []);
+    // Update checkout session with addresses and customer info
+    const updateCheckoutSessionValues = useCallback(async (data) => {
+        try {
+            await apiService.fetch(`/api/v1/checkout-sessions/${options.checkoutSessionId}/address`, {
+                method: 'POST',
+                body: {
+                    data: {
+                        shippingAddress: data.shippingAddress,
+                        billingAddress: data.billingAddress,
+                    },
+                },
+            });
+        }
+        catch (error) {
+            console.error('Failed to update checkout session addresses:', error);
+            throw error;
+        }
+    }, [apiService, options.checkoutSessionId]);
+    // Update customer email
+    const updateCustomerEmail = useCallback(async (email) => {
+        try {
+            await apiService.fetch(`/api/v1/customers/${options.customerId}`, {
+                method: 'POST',
+                body: {
+                    data: {
+                        email,
+                    },
+                },
+            });
+        }
+        catch (error) {
+            console.error('Failed to update customer email:', error);
+            throw error;
+        }
+    }, [apiService, options.customerId]);
+    // Recompute order summary after address/shipping changes
+    const reComputeOrderSummary = useCallback(async () => {
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${options.checkoutSessionId}/order-summary`, {
+                method: 'POST',
+            });
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to recompute order summary:', error);
+            throw error;
         }
+    }, [apiService, options.checkoutSessionId]);
+    // Get shipping rates for the checkout session
+    const getShippingRates = useCallback(async () => {
         try {
-            // Check basic Apple Pay support
-            return window.ApplePaySession.canMakePayments();
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${options.checkoutSessionId}/shipping-rates`);
+            return response;
         }
         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 () => {
+            console.error('Failed to get shipping rates:', error);
+            throw error;
+        }
+    }, [apiService, options.checkoutSessionId]);
+    // Set shipping rate
+    const setShippingRate = useCallback(async (shippingRateId) => {
+        try {
+            await apiService.fetch(`/api/v1/checkout-sessions/${options.checkoutSessionId}/shipping-rate`, {
+                method: 'POST',
+                body: {
+                    shippingRateId,
+                },
+            });
+        }
+        catch (error) {
+            console.error('Failed to set shipping rate:', error);
+            throw error;
+        }
+    }, [apiService, options.checkoutSessionId]);
+    const validateMerchant = useCallback(async (storeName) => {
         try {
             const response = await fetch('https://api.basistheory.com/apple-pay/session', {
                 method: 'POST',
@@ -54,7 +142,7 @@ export function useApplePay(options = {}) {
                     'BT-API-KEY': apiKey,
                 },
                 body: JSON.stringify({
-                    display_name: 'Tagada Pay Store',
+                    display_name: storeName || 'Tagada Pay Store',
                     domain: typeof window !== 'undefined' ? window.location.host : 'localhost',
                 }),
             });
@@ -92,7 +180,7 @@ export function useApplePay(options = {}) {
             throw error;
         }
     }, [apiKey]);
-    const handleApplePayClick = useCallback((checkoutSessionId, lineItems, total, config = {}) => {
+    const handleApplePayClick = useCallback((checkoutSessionId, lineItems, total, config = {}, storeName, currencyCode, shippingMethods) => {
         if (!isApplePayAvailable) {
             const errorMsg = 'Apple Pay is not available on this device';
             setError(errorMsg);
@@ -101,19 +189,21 @@ export function useApplePay(options = {}) {
         }
         const request = {
             countryCode: config.countryCode || 'US',
-            currencyCode: 'USD', // This should be passed as a parameter
+            currencyCode: currencyCode || 'USD',
             supportedNetworks: config.supportedNetworks || ['visa', 'masterCard', 'amex', 'discover'],
             merchantCapabilities: config.merchantCapabilities || ['supports3DS'],
             total,
             lineItems,
+            shippingMethods: shippingMethods || [],
+            requiredShippingContactFields: ['name', 'phone', 'email', 'postalAddress'],
+            requiredBillingContactFields: ['postalAddress'],
         };
         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();
+                        const merchantSession = await validateMerchant(storeName);
                         session.completeMerchantValidation(merchantSession);
                     }
                     catch (error) {
@@ -130,6 +220,22 @@ export function useApplePay(options = {}) {
                     try {
                         setProcessingPayment(true);
                         setError(null);
+                        // Extract address information
+                        const shippingContact = event.payment.shippingContact;
+                        const billingContact = event.payment.billingContact;
+                        const shippingAddress = shippingContact ? appleContactToAddress(shippingContact) : null;
+                        const billingAddress = billingContact ? appleContactToAddress(billingContact) : null;
+                        // Update checkout session with addresses
+                        if (shippingAddress || billingAddress) {
+                            await updateCheckoutSessionValues({
+                                shippingAddress: shippingAddress || undefined,
+                                billingAddress: billingAddress || undefined,
+                            });
+                        }
+                        // Update customer email if available
+                        if (shippingContact?.emailAddress) {
+                            await updateCustomerEmail(shippingContact.emailAddress);
+                        }
                         // Tokenize the Apple Pay payment
                         const applePayToken = await tokenizeApplePay(event);
                         // Complete the Apple Pay session
@@ -157,6 +263,48 @@ export function useApplePay(options = {}) {
                     }
                 })();
             };
+            // Handle shipping method selection
+            session.onshippingmethodselected = (event) => {
+                void (async () => {
+                    try {
+                        await setShippingRate(event.shippingMethod.identifier);
+                        const newOrderSummary = await reComputeOrderSummary();
+                        if (!newOrderSummary) {
+                            session.abort();
+                            return;
+                        }
+                        const { lineItems: newLineItems, total: newTotal } = newOrderSummary;
+                        session.completeShippingMethodSelection(window.ApplePaySession.STATUS_SUCCESS, newTotal, newLineItems);
+                    }
+                    catch (error) {
+                        console.error('Shipping method selection failed:', error);
+                        session.abort();
+                    }
+                })();
+            };
+            // Handle shipping contact selection
+            session.onshippingcontactselected = (event) => {
+                void (async () => {
+                    try {
+                        const shippingContact = event.shippingContact;
+                        await updateCheckoutSessionValues({
+                            shippingAddress: appleContactToAddress(shippingContact),
+                        });
+                        const newOrderSummary = await reComputeOrderSummary();
+                        if (!newOrderSummary) {
+                            session.abort();
+                            setError('Payment Failed');
+                            return;
+                        }
+                        const { lineItems: newLineItems, total: newTotal, shippingMethods: newShippingMethods, } = newOrderSummary;
+                        session.completeShippingContactSelection(window.ApplePaySession.STATUS_SUCCESS, newShippingMethods, newTotal, newLineItems);
+                    }
+                    catch (error) {
+                        console.error('Shipping contact selection failed:', error);
+                        session.abort();
+                    }
+                })();
+            };
             session.onerror = (event) => {
                 console.error('Apple Pay Session Error:', event);
                 const errorMsg = 'Apple Pay session error';
@@ -168,6 +316,7 @@ export function useApplePay(options = {}) {
                 setProcessingPayment(false);
                 options.onCancel?.();
             };
+            // Begin the Apple Pay session - this opens the modal
             session.begin();
         }
         catch (error) {
@@ -181,6 +330,10 @@ export function useApplePay(options = {}) {
         validateMerchant,
         tokenizeApplePay,
         processApplePayPayment,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        setShippingRate,
+        reComputeOrderSummary,
         options,
     ]);
     return {
@@ -188,5 +341,8 @@ export function useApplePay(options = {}) {
         processingPayment,
         applePayError: error,
         isApplePayAvailable,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        setShippingRate,
     };
 }

package/dist/react/hooks/useCheckout.js

@@ -179,19 +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');
         }
-        console.log('🔄 [useCheckout] Refreshing checkout data...', {
-            checkoutToken: currentCheckoutTokenRef.current.substring(0, 8) + '...',
-            timestamp: new Date().toISOString(),
-        });
         await getCheckout(currentCheckoutTokenRef.current);
-        console.log('✅ [useCheckout] Refresh completed, debug data will be updated automatically');
     }, [getCheckout]);
     // Register refresh function with coordinator and cleanup on unmount
     useEffect(() => {

package/dist/react/hooks/usePluginConfig.js

@@ -19,6 +19,7 @@ const loadLocalDevConfig = async (configVariant = 'default') => {
         // Use hostname-based detection for better Vite compatibility
         const isLocalDev = typeof window !== 'undefined' &&
             (window.location.hostname === 'localhost' ||
+                window.location.hostname.includes('ngrok-free.app') ||
                 window.location.hostname.includes('.localhost') ||
                 window.location.hostname.includes('127.0.0.1'));
         if (!isLocalDev) {
@@ -184,6 +185,7 @@ export const debugPluginConfig = async (configVariant = 'default') => {
     // Use hostname-based detection for better Vite compatibility
     const isLocalDev = typeof window !== 'undefined' &&
         (window.location.hostname === 'localhost' ||
+            window.location.hostname.includes('ngrok-free.app') ||
             window.location.hostname.includes('.localhost') ||
             window.location.hostname.includes('127.0.0.1'));
     if (!isLocalDev) {

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

@@ -0,0 +1,69 @@
+export interface VipOffer {
+    id: string;
+    productId: string;
+    variantId: string;
+}
+export interface VipPreviewResponse {
+    savings: number;
+    currency: string;
+    selectedOffers: {
+        productId: string;
+        variantId: string;
+        isSelected: boolean;
+    }[];
+    savingsPct: number;
+}
+export interface UseVipOffersOptions {
+    /**
+     * Checkout session ID for VIP offers
+     */
+    checkoutSessionId: string;
+    /**
+     * Array of VIP offer IDs to manage
+     */
+    vipOfferIds: string[];
+    /**
+     * Whether to automatically fetch VIP preview on mount
+     * @default true
+     */
+    autoPreview?: boolean;
+}
+export interface UseVipOffersResult {
+    /**
+     * Array of VIP offers
+     */
+    vipOffers: VipOffer[];
+    /**
+     * VIP preview data including savings and selected offers
+     */
+    vipPreview: VipPreviewResponse | null;
+    /**
+     * Loading state for VIP preview
+     */
+    isLoadingVipPreview: boolean;
+    /**
+     * Whether any VIP offers are currently selected
+     */
+    hasVip: boolean;
+    /**
+     * Check if a specific VIP offer is selected
+     */
+    isOfferSelected: (offer: VipOffer) => boolean;
+    /**
+     * Select all VIP offers
+     */
+    selectVipOffers: () => Promise<void>;
+    /**
+     * Cancel/deselect all VIP offers
+     */
+    cancelVipOffers: () => Promise<void>;
+    /**
+     * Refresh VIP preview data
+     */
+    refreshVipPreview: () => Promise<void>;
+    /**
+     * Error state
+     */
+    error: Error | null;
+}
+export declare function useVipOffers(options: UseVipOffersOptions): UseVipOffersResult;

package/dist/react/hooks/useVipOffers.js

@@ -0,0 +1,144 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useVipOffers(options) {
+    const { apiService, refreshCoordinator } = useTagadaContext();
+    const { checkoutSessionId, vipOfferIds, autoPreview = true } = options;
+    const [vipOffers, setVipOffers] = useState([]);
+    const [vipPreview, setVipPreview] = useState(null);
+    const [isLoadingVipPreview, setIsLoadingVipPreview] = useState(false);
+    const [hasVip, setHasVip] = useState(false);
+    const [error, setError] = useState(null);
+    // Convert offer IDs to VipOffer objects
+    useEffect(() => {
+        const offers = vipOfferIds.map((id) => ({
+            id,
+            productId: '', // These will be populated from the checkout session data
+            variantId: '', // These will be populated from the checkout session data
+        }));
+        setVipOffers(offers);
+    }, [vipOfferIds]);
+    // Fetch VIP preview
+    const refreshVipPreview = useCallback(async () => {
+        if (!checkoutSessionId || vipOfferIds.length === 0)
+            return;
+        setIsLoadingVipPreview(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/vip-preview`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferIds: vipOfferIds,
+                    orderBumpType: 'vip',
+                },
+            });
+            setVipPreview(response);
+            // Update hasVip based on selected offers
+            const hasSelectedVipOffers = response.selectedOffers?.some((offer) => offer.isSelected) ?? false;
+            setHasVip(hasSelectedVipOffers);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch VIP preview');
+            setError(error);
+            console.error('VIP preview failed:', error);
+        }
+        finally {
+            setIsLoadingVipPreview(false);
+        }
+    }, [checkoutSessionId, vipOfferIds]);
+    // Check if a specific VIP offer is selected
+    const isOfferSelected = useCallback((offer) => {
+        if (!vipPreview?.selectedOffers)
+            return false;
+        return vipPreview.selectedOffers.some((selected) => selected.productId === offer.productId &&
+            selected.variantId === offer.variantId &&
+            selected.isSelected);
+    }, [vipPreview?.selectedOffers]);
+    // Keep hasVip in sync with actual selected offers
+    useEffect(() => {
+        const hasSelectedVipOffers = vipOffers.some(isOfferSelected);
+        if (hasSelectedVipOffers !== hasVip) {
+            setHasVip(hasSelectedVipOffers);
+        }
+    }, [vipOffers, isOfferSelected, hasVip, vipPreview?.selectedOffers]);
+    // Toggle VIP offers mutation
+    const toggleOrderBump = useCallback(async (orderBumpOfferId, selected) => {
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/toggle-order-bump`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferId,
+                    selected,
+                },
+            });
+            if (response.success) {
+                // Notify other hooks that checkout data changed
+                await refreshCoordinator.notifyCheckoutChanged();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
+            throw error;
+        }
+    }, [checkoutSessionId]);
+    // Handle selecting VIP offers
+    const selectVipOffers = useCallback(async () => {
+        try {
+            await Promise.all(vipOffers.map((offer) => {
+                if (!isOfferSelected(offer)) {
+                    return toggleOrderBump(offer.id, true);
+                }
+                return Promise.resolve({ success: true });
+            }));
+            setHasVip(true);
+            await refreshVipPreview();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to select VIP offers');
+            setError(error);
+            console.error('Failed to select VIP offers:', error);
+            throw error;
+        }
+    }, [vipOffers, isOfferSelected, toggleOrderBump, refreshVipPreview]);
+    // Handle canceling VIP offers
+    const cancelVipOffers = useCallback(async () => {
+        try {
+            setHasVip(false);
+            await Promise.all(vipOffers.map((offer) => toggleOrderBump(offer.id, false)));
+            await refreshVipPreview();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to cancel VIP offers');
+            setError(error);
+            console.error('Failed to cancel VIP offers:', error);
+            setHasVip(true); // Revert optimistic update
+            throw error;
+        }
+    }, [vipOffers, toggleOrderBump, refreshVipPreview]);
+    // Auto-fetch preview on mount and when dependencies change
+    useEffect(() => {
+        if (autoPreview && checkoutSessionId && vipOfferIds.length > 0) {
+            refreshVipPreview().catch((error) => {
+                console.error('Auto-preview failed:', error);
+            });
+        }
+    }, [autoPreview, refreshVipPreview]);
+    // Register refresh function with coordinator and cleanup on unmount
+    useEffect(() => {
+        refreshCoordinator.registerOrderBumpRefresh(refreshVipPreview);
+        return () => {
+            refreshCoordinator.unregisterOrderBumpRefresh();
+        };
+    }, [refreshVipPreview]);
+    return {
+        vipOffers,
+        vipPreview,
+        isLoadingVipPreview,
+        hasVip,
+        isOfferSelected,
+        selectVipOffers,
+        cancelVipOffers,
+        refreshVipPreview,
+        error,
+    };
+}

package/dist/react/index.d.ts

@@ -17,6 +17,7 @@ export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
 export { useTranslations } from './hooks/useTranslations';
+export { useVipOffers } from './hooks/useVipOffers';
 export { useTagadaContext } from './providers/TagadaProvider';
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
 export type { PluginConfig } from './hooks/usePluginConfig';
@@ -34,9 +35,10 @@ export type { AuthState, Currency, Customer, Environment, EnvironmentConfig, Loc
 export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, CheckoutSessionPreview, Promotion, UseCheckoutOptions, UseCheckoutResult } from './hooks/useCheckout';
 export type { Discount, DiscountCodeValidation, UseDiscountsOptions, UseDiscountsResult } from './hooks/useDiscounts';
 export type { OrderBumpPreview, UseOrderBumpOptions, UseOrderBumpResult } from './hooks/useOrderBump';
+export type { UseVipOffersOptions, UseVipOffersResult, VipOffer, VipPreviewResponse } from './hooks/useVipOffers';
 export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferLineItem, PostPurchaseOfferSummary, UsePostPurchasesOptions, UsePostPurchasesResult } from './hooks/usePostPurchases';
 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 type { ApplePayAddress, 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

@@ -20,6 +20,7 @@ export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
 export { useTranslations } from './hooks/useTranslations';
+export { useVipOffers } from './hooks/useVipOffers';
 export { useTagadaContext } from './providers/TagadaProvider';
 // Plugin configuration hooks
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
@@ -34,7 +35,7 @@ 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';
+// Component exports
+// Apple Pay components removed - use useApplePay hook directly
 // Utility exports
 export { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits } from './utils/money';

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

@@ -8,6 +8,9 @@ export interface ApplePayPaymentRequest {
     merchantCapabilities: string[];
     total: ApplePayLineItem;
     lineItems: ApplePayLineItem[];
+    requiredShippingContactFields?: string[];
+    requiredBillingContactFields?: string[];
+    shippingMethods?: any[];
 }
 export interface ApplePayLineItem {
     label: string;
@@ -17,6 +20,8 @@ export interface ApplePayLineItem {
 export interface ApplePayPaymentAuthorizedEvent {
     payment: {
         token: ApplePayPaymentToken;
+        shippingContact?: any;
+        billingContact?: any;
     };
 }
 export interface ApplePayPaymentToken {
@@ -59,12 +64,32 @@ export interface UseApplePayOptions {
     onError?: (error: string) => void;
     onCancel?: () => void;
     config?: ApplePayConfig;
+    checkoutSessionId?: string;
+    customerId?: string;
+}
+export interface ApplePayAddress {
+    address1: string;
+    address2?: string;
+    lastName: string;
+    firstName: string;
+    city: string;
+    state: string;
+    country: string;
+    postal: string;
+    phone?: string;
+    email?: string;
 }
 export interface UseApplePayResult {
-    handleApplePayClick: (checkoutSessionId: string, lineItems: ApplePayLineItem[], total: ApplePayLineItem, config?: ApplePayConfig) => void;
+    handleApplePayClick: (checkoutSessionId: string, lineItems: ApplePayLineItem[], total: ApplePayLineItem, config?: ApplePayConfig, storeName?: string, currencyCode?: string, shippingMethods?: any[]) => void;
     processingPayment: boolean;
     applePayError: string | null;
     isApplePayAvailable: boolean;
+    updateCheckoutSessionValues: (data: {
+        shippingAddress?: ApplePayAddress;
+        billingAddress?: ApplePayAddress;
+    }) => Promise<void>;
+    updateCustomerEmail: (email: string) => Promise<void>;
+    setShippingRate: (shippingRateId: string) => Promise<void>;
 }
 declare global {
     interface Window {

package/package.json

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