@tagadapay/plugin-sdk 1.0.10 → 1.0.12

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

@@ -273,6 +273,12 @@ export interface UseCheckoutResult {
         shippingCountryChanged?: boolean;
         billingCountryChanged?: boolean;
     }>;
+    previewOrderSummary: (orderBumpOfferIds: string[], orderBumpType?: 'primary' | 'secondary' | 'vip') => Promise<{
+        savings: number;
+        savingsPct: number;
+        currency: string;
+        error?: any;
+    }>;
     clear: () => void;
 }
 export declare function useCheckout(options?: UseCheckoutOptions): UseCheckoutResult;

package/dist/react/hooks/useCheckout.js

@@ -3,7 +3,7 @@ import { useTagadaContext } from '../providers/TagadaProvider';
 import { getCheckoutToken } from '../utils/urlUtils';
 import { useCurrency } from '../hooks/useCurrency';
 export function useCheckout(options = {}) {
-    const { apiService } = useTagadaContext();
+    const { apiService, updateCheckoutDebugData, refreshCoordinator } = useTagadaContext();
     const { code: currentCurrency } = useCurrency();
     const [checkout, setCheckout] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
@@ -21,6 +21,38 @@ export function useCheckout(options = {}) {
             }
         };
     }, []);
+    // Update debug data whenever checkout state changes with comprehensive information
+    useEffect(() => {
+        const debugData = checkout
+            ? {
+                checkout,
+                sessionId: checkout.checkoutSession?.id,
+                checkoutToken: currentCheckoutTokenRef.current,
+                currency: checkout.summary?.currency,
+                totalAmount: checkout.summary?.totalAmount,
+                totalAdjustedAmount: checkout.summary?.totalAdjustedAmount,
+                promotionAmount: checkout.summary?.totalPromotionAmount,
+                itemsCount: checkout.summary?.items?.length || 0,
+                orderBumps: checkout.checkoutSession?.sessionLineItems?.filter((item) => item.isOrderBump) || [],
+                adjustments: checkout.summary?.adjustments || [],
+                isInitialized,
+                lastUpdated: new Date().toISOString(),
+            }
+            : null;
+        updateCheckoutDebugData(debugData, error, isLoading);
+        if (debugData) {
+            console.log('🐛 [useCheckout] Debug data updated for debug drawer', {
+                sessionId: debugData.sessionId,
+                totalAmount: debugData.totalAmount,
+                totalAdjustedAmount: debugData.totalAdjustedAmount,
+                promotionAmount: debugData.promotionAmount,
+                itemsCount: debugData.itemsCount,
+                orderBumpsCount: debugData.orderBumps?.length || 0,
+                adjustmentsCount: debugData.adjustments?.length || 0,
+                lastUpdated: debugData.lastUpdated,
+            });
+        }
+    }, [checkout, error, isLoading, isInitialized]); // Removed updateCheckoutDebugData from deps to prevent infinite loop
     const init = useCallback(async (params) => {
         // Don't allow init if we already have a checkout token
         if (providedToken) {
@@ -85,6 +117,14 @@ export function useCheckout(options = {}) {
             setCheckout(response);
             currentCheckoutTokenRef.current = checkoutToken;
             setIsInitialized(true);
+            console.log('📊 [useCheckout] Checkout data updated', {
+                sessionId: response.checkoutSession?.id,
+                totalAmount: response.summary?.totalAmount,
+                promotionAmount: response.summary?.totalPromotionAmount,
+                itemsCount: response.summary?.items?.length || 0,
+                orderBumpsCount: response.checkoutSession?.sessionLineItems?.filter((item) => item.isOrderBump)?.length || 0,
+                timestamp: new Date().toISOString(),
+            });
             return response;
         }
         catch (err) {
@@ -100,8 +140,20 @@ export function useCheckout(options = {}) {
         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(() => {
+        refreshCoordinator.registerCheckoutRefresh(refresh);
+        return () => {
+            refreshCoordinator.unregisterCheckoutRefresh();
+        };
+    }, [refresh, refreshCoordinator]);
     const updateAddress = useCallback(async (data) => {
         if (!checkout?.checkoutSession.id) {
             throw new Error('No checkout session available');
@@ -205,6 +257,8 @@ export function useCheckout(options = {}) {
             });
             if (response.success) {
                 await refresh();
+                // Notify other hooks that checkout data changed
+                await refreshCoordinator.notifyCheckoutChanged();
             }
             return response;
         }
@@ -212,7 +266,7 @@ export function useCheckout(options = {}) {
             const error = err instanceof Error ? err : new Error('Failed to update line items');
             throw error;
         }
-    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    }, [apiService, checkout?.checkoutSession.id, refresh, refreshCoordinator]);
     const addLineItems = useCallback(async (lineItems) => {
         if (!checkout?.checkoutSession.id) {
             throw new Error('No checkout session available');
@@ -280,7 +334,13 @@ export function useCheckout(options = {}) {
                 body: { orderBumpOfferId, selected },
             });
             if (response.success) {
+                console.log('🎯 [useCheckout] Order bump toggled successfully, refreshing checkout data...', {
+                    orderBumpOfferId,
+                    selected,
+                    timestamp: new Date().toISOString(),
+                });
                 await refresh();
+                console.log('✅ [useCheckout] Order bump refresh completed, debug drawer should now show updated data');
             }
             return response;
         }
@@ -325,6 +385,30 @@ export function useCheckout(options = {}) {
             throw error;
         }
     }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const previewOrderSummary = useCallback(async (orderBumpOfferIds, orderBumpType = 'vip') => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/vip-preview`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferIds,
+                    orderBumpType,
+                },
+            });
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to preview order summary');
+            return {
+                savings: 0,
+                savingsPct: 0,
+                currency: checkout?.summary?.currency ?? 'EUR',
+                error: error.message,
+            };
+        }
+    }, [apiService, checkout?.checkoutSession.id, checkout?.summary?.currency]);
     const clear = useCallback(() => {
         setCheckout(null);
         setError(null);
@@ -380,6 +464,7 @@ export function useCheckout(options = {}) {
         toggleOrderBump,
         updateCustomer,
         updateCustomerAndSessionInfo,
+        previewOrderSummary,
         clear,
     };
 }

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

@@ -0,0 +1,30 @@
+export interface OrderBumpPreview {
+    savings: number;
+    savingsPct: number;
+    currency: string;
+    selectedOffers: {
+        productId: string | null;
+        variantId: string | null;
+        isSelected: boolean;
+    }[];
+}
+export interface UseOrderBumpOptions {
+    checkoutSessionId?: string;
+    offerId: string;
+    orderBumpType?: 'primary' | 'secondary' | 'vip';
+    autoPreview?: boolean;
+}
+export interface UseOrderBumpResult {
+    isSelected: boolean;
+    preview: OrderBumpPreview | null;
+    savings: number | null;
+    isLoading: boolean;
+    isToggling: boolean;
+    error: Error | null;
+    toggle: (selected?: boolean) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    refreshPreview: () => Promise<void>;
+}
+export declare function useOrderBump(options: UseOrderBumpOptions): UseOrderBumpResult;

package/dist/react/hooks/useOrderBump.js

@@ -0,0 +1,106 @@
+import { useState, useCallback, useEffect } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useOrderBump(options) {
+    const { apiService, refreshCoordinator } = useTagadaContext();
+    const { checkoutSessionId, offerId, orderBumpType = 'vip', autoPreview = true } = options;
+    const [isSelected, setIsSelected] = useState(false);
+    const [preview, setPreview] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isToggling, setIsToggling] = useState(false);
+    const [error, setError] = useState(null);
+    const refreshPreview = useCallback(async () => {
+        if (!checkoutSessionId)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/vip-preview`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferIds: [offerId],
+                    orderBumpType,
+                },
+            });
+            setPreview(response);
+            // Update isSelected based on preview data
+            const offerSelected = response.selectedOffers?.some((offer) => offer.isSelected);
+            setIsSelected(offerSelected ?? false);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch preview');
+            setError(error);
+            console.error('Order bump preview failed:', error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [checkoutSessionId, offerId, orderBumpType, apiService]);
+    const toggle = useCallback(async (selected) => {
+        if (!checkoutSessionId) {
+            throw new Error('No checkout session available');
+        }
+        const targetState = selected ?? !isSelected;
+        // Optimistic update
+        setIsSelected(targetState);
+        setIsToggling(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/toggle-order-bump`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferId: offerId,
+                    selected: targetState,
+                },
+            });
+            if (response.success) {
+                // Refresh preview to get updated savings
+                await refreshPreview();
+                // Notify checkout hook that order bump data changed
+                await refreshCoordinator.notifyOrderBumpChanged();
+                return { success: true };
+            }
+            else {
+                // Revert optimistic update
+                setIsSelected(!targetState);
+                return { success: false, error: response.error };
+            }
+        }
+        catch (err) {
+            // Revert optimistic update
+            setIsSelected(!targetState);
+            const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
+            setError(error);
+            return { success: false, error: error.message };
+        }
+        finally {
+            setIsToggling(false);
+        }
+    }, [checkoutSessionId, offerId, isSelected, apiService, refreshPreview, refreshCoordinator]);
+    // Auto-fetch preview on mount and when dependencies change
+    useEffect(() => {
+        if (autoPreview && checkoutSessionId) {
+            refreshPreview().catch((error) => {
+                console.error('Auto-preview failed:', error);
+            });
+        }
+    }, [autoPreview, refreshPreview]);
+    // Register refresh function with coordinator and cleanup on unmount
+    useEffect(() => {
+        refreshCoordinator.registerOrderBumpRefresh(refreshPreview);
+        return () => {
+            refreshCoordinator.unregisterOrderBumpRefresh();
+        };
+    }, [refreshPreview, refreshCoordinator]);
+    // Calculate current savings
+    const savings = isSelected && preview?.savings ? preview.savings : preview?.savings || null;
+    return {
+        isSelected,
+        preview,
+        savings,
+        isLoading,
+        isToggling,
+        error,
+        toggle,
+        refreshPreview,
+    };
+}

package/dist/react/index.d.ts

@@ -5,6 +5,7 @@ export { TagadaProvider } from './providers/TagadaProvider';
 export { useCheckout } from './hooks/useCheckout';
 export { useProducts } from './hooks/useProducts';
 export { useOffers } from './hooks/useOffers';
+export { useOrderBump } from './hooks/useOrderBump';
 export { useSession } from './hooks/useSession';
 export { useCurrency } from './hooks/useCurrency';
 export { useCustomer } from './hooks/useCustomer';
@@ -19,6 +20,7 @@ export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export type { Customer, Session, AuthState, Locale, Currency, Store, Environment, EnvironmentConfig, Order, OrderItem, OrderSummary, OrderAddress, PickupPoint, } from './types';
 export type { UseCheckoutOptions, UseCheckoutResult, CheckoutInitParams, CheckoutLineItem, CheckoutSession, CheckoutData, Promotion, } from './hooks/useCheckout';
+export type { UseOrderBumpOptions, UseOrderBumpResult, OrderBumpPreview } from './hooks/useOrderBump';
 export type { Payment, PollingOptions, PaymentPollingHook } from './hooks/usePaymentPolling';
 export type { PaymentInstrument, ThreedsSession, ThreedsChallenge, ThreedsOptions, ThreedsHook, ThreedsProvider, } from './hooks/useThreeds';
 export type { ApplePayToken, CardPaymentMethod, PaymentResponse, PaymentOptions, PaymentInstrumentResponse, PaymentHook, } from './hooks/usePayment';

package/dist/react/index.js

@@ -8,6 +8,7 @@ export { TagadaProvider } from './providers/TagadaProvider';
 export { useCheckout } from './hooks/useCheckout';
 export { useProducts } from './hooks/useProducts';
 export { useOffers } from './hooks/useOffers';
+export { useOrderBump } from './hooks/useOrderBump';
 export { useSession } from './hooks/useSession';
 export { useCurrency } from './hooks/useCurrency';
 export { useCustomer } from './hooks/useCustomer';

package/dist/react/providers/TagadaProvider.d.ts

@@ -25,6 +25,14 @@ interface TagadaContextValue {
         lastUpdated: Date | null;
     };
     updateCheckoutDebugData: (data: any, error?: Error | null, isLoading?: boolean) => void;
+    refreshCoordinator: {
+        registerCheckoutRefresh: (refreshFn: () => Promise<void>) => void;
+        registerOrderBumpRefresh: (refreshFn: () => Promise<void>) => void;
+        notifyCheckoutChanged: () => Promise<void>;
+        notifyOrderBumpChanged: () => Promise<void>;
+        unregisterCheckoutRefresh: () => void;
+        unregisterOrderBumpRefresh: () => void;
+    };
     money: {
         formatMoney: typeof formatMoney;
         getCurrencyInfo: typeof getCurrencyInfo;
@@ -39,17 +47,11 @@ interface TagadaProviderProps {
     children: ReactNode;
     environment?: Environment;
     customApiConfig?: Partial<EnvironmentConfig>;
-    developmentMode?: boolean;
     debugMode?: boolean;
     storeId?: string;
     accountId?: string;
-    mockData?: {
-        customer?: Partial<Customer>;
-        session?: Partial<Session>;
-        store?: Partial<Store>;
-    };
 }
-export declare function TagadaProvider({ children, environment, customApiConfig, developmentMode, debugMode, // Remove default, will be set based on environment
-storeId, accountId, mockData, }: TagadaProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function TagadaProvider({ children, environment, customApiConfig, debugMode, // Remove default, will be set based on environment
+storeId, accountId, }: TagadaProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useTagadaContext(): TagadaContextValue;
 export {};

package/dist/react/providers/TagadaProvider.js

@@ -29,8 +29,8 @@ const InitializationLoader = () => (_jsx("div", { style: {
         }
       ` }) }));
 const TagadaContext = createContext(null);
-export function TagadaProvider({ children, environment, customApiConfig, developmentMode = false, debugMode, // Remove default, will be set based on environment
-storeId, accountId, mockData, }) {
+export function TagadaProvider({ children, environment, customApiConfig, debugMode, // Remove default, will be set based on environment
+storeId, accountId, }) {
     const [isLoading, setIsLoading] = useState(true);
     const [isInitialized, setIsInitialized] = useState(false);
     const [token, setToken] = useState(null);
@@ -284,49 +284,6 @@ storeId, accountId, mockData, }) {
             try {
                 console.debug('[SDK] Initializing token...');
                 setIsLoading(true);
-                if (developmentMode) {
-                    console.debug('[SDK] Development mode: Using mock data');
-                    // Use mock data in development mode
-                    if (mockData?.customer) {
-                        setCustomer({
-                            id: 'dev-customer-123',
-                            email: 'dev@example.com',
-                            firstName: 'John',
-                            lastName: 'Doe',
-                            phone: '+1234567890',
-                            isAuthenticated: true,
-                            role: 'authenticated',
-                            ...mockData.customer,
-                        });
-                    }
-                    if (mockData?.session) {
-                        setSession({
-                            sessionId: 'dev-session-123',
-                            storeId: 'dev-store-123',
-                            accountId: 'dev-account-123',
-                            customerId: 'dev-customer-123',
-                            role: 'authenticated',
-                            isValid: true,
-                            isLoading: false,
-                            ...mockData.session,
-                        });
-                    }
-                    if (mockData?.store) {
-                        setStore({
-                            id: 'dev-store-123',
-                            name: 'Development Store',
-                            domain: 'dev.localhost',
-                            currency: 'USD',
-                            locale: 'en-US',
-                            presentmentCurrencies: ['USD'],
-                            chargeCurrencies: ['USD'],
-                            ...mockData.store,
-                        });
-                    }
-                    setIsInitialized(true);
-                    setIsLoading(false);
-                    return;
-                }
                 // Check for existing token
                 const existingToken = getClientToken();
                 let tokenToUse = null;
@@ -374,7 +331,7 @@ storeId, accountId, mockData, }) {
             }
         };
         void initializeToken();
-    }, [developmentMode, mockData, storeId, createAnonymousToken, initializeSession]);
+    }, [storeId, createAnonymousToken, initializeSession]);
     // Update auth state when customer/session changes
     useEffect(() => {
         setAuth({
@@ -384,6 +341,51 @@ storeId, accountId, mockData, }) {
             session,
         });
     }, [customer, session]);
+    // Refresh coordinator for bidirectional hook communication
+    const checkoutRefreshRef = useRef(null);
+    const orderBumpRefreshRef = useRef(null);
+    const refreshCoordinator = {
+        registerCheckoutRefresh: (refreshFn) => {
+            checkoutRefreshRef.current = refreshFn;
+            console.log('🔄 [RefreshCoordinator] Checkout refresh function registered');
+        },
+        registerOrderBumpRefresh: (refreshFn) => {
+            orderBumpRefreshRef.current = refreshFn;
+            console.log('🔄 [RefreshCoordinator] Order bump refresh function registered');
+        },
+        notifyCheckoutChanged: async () => {
+            if (orderBumpRefreshRef.current) {
+                console.log('🔄 [RefreshCoordinator] Checkout changed, refreshing order bump data...');
+                try {
+                    await orderBumpRefreshRef.current();
+                    console.log('✅ [RefreshCoordinator] Order bump refresh completed');
+                }
+                catch (error) {
+                    console.warn('⚠️ [RefreshCoordinator] Order bump refresh failed:', error);
+                }
+            }
+        },
+        notifyOrderBumpChanged: async () => {
+            if (checkoutRefreshRef.current) {
+                console.log('🔄 [RefreshCoordinator] Order bump changed, refreshing checkout data...');
+                try {
+                    await checkoutRefreshRef.current();
+                    console.log('✅ [RefreshCoordinator] Checkout refresh completed');
+                }
+                catch (error) {
+                    console.warn('⚠️ [RefreshCoordinator] Checkout refresh failed:', error);
+                }
+            }
+        },
+        unregisterCheckoutRefresh: () => {
+            checkoutRefreshRef.current = null;
+            console.log('🧹 [RefreshCoordinator] Checkout refresh function unregistered');
+        },
+        unregisterOrderBumpRefresh: () => {
+            orderBumpRefreshRef.current = null;
+            console.log('🧹 [RefreshCoordinator] Order bump refresh function unregistered');
+        },
+    };
     const contextValue = {
         auth,
         session,
@@ -406,6 +408,7 @@ storeId, accountId, mockData, }) {
                 lastUpdated: new Date(),
             });
         },
+        refreshCoordinator,
         money: {
             formatMoney,
             getCurrencyInfo,

package/package.json

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