@tagadapay/plugin-sdk 2.5.2 → 2.6.2

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

@@ -0,0 +1,15 @@
+import type { CustomerInfos } from '../types';
+export interface UseCustomerInfosOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerInfosResult {
+    data: CustomerInfos | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * useCustomerInfos - Fetches customer infos from `/api/v1/customers/{customerId}` with `storeId` param
+ */
+export declare function useCustomerInfos(options: UseCustomerInfosOptions): UseCustomerInfosResult;

package/dist/react/hooks/useCustomerInfos.js

@@ -0,0 +1,54 @@
+'use client';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { usePluginConfig } from './usePluginConfig';
+/**
+ * useCustomerInfos - Fetches customer infos from `/api/v1/customers/{customerId}` with `storeId` param
+ */
+export function useCustomerInfos(options) {
+    const { apiService } = useTagadaContext();
+    const { storeId } = usePluginConfig();
+    const stableOptions = useMemo(() => {
+        return {
+            customerId: options.customerId ?? null,
+            enabled: options.enabled ?? true,
+        };
+    }, [options.customerId, options.enabled]);
+    const isEnabled = useMemo(() => {
+        return Boolean(stableOptions.enabled && stableOptions.customerId && storeId);
+    }, [stableOptions.enabled, stableOptions.customerId, storeId]);
+    const [data, setData] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const fetchCustomerInfos = useCallback(async () => {
+        if (!isEnabled)
+            return;
+        if (!stableOptions.customerId || !storeId)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/customers/${stableOptions.customerId}`, {
+                method: 'GET',
+                params: { storeId },
+            });
+            setData(response ?? null);
+        }
+        catch (err) {
+            const safeError = err instanceof Error ? err : new Error('Failed to fetch customer infos');
+            setError(safeError);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, isEnabled, stableOptions.customerId, storeId]);
+    useEffect(() => {
+        void fetchCustomerInfos();
+    }, [fetchCustomerInfos]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: fetchCustomerInfos,
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { OrderWithRelations } from '../types';
+export interface UseCustomerOrdersOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerOrdersResult {
+    data: {
+        orders: OrderWithRelations[];
+    } | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare function useCustomerOrders(options: UseCustomerOrdersOptions): UseCustomerOrdersResult;

package/dist/react/hooks/useCustomerOrders.js

@@ -0,0 +1,51 @@
+'use client';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerOrders(options) {
+    const { apiService } = useTagadaContext();
+    const { storeId } = usePluginConfig();
+    const stableOptions = useMemo(() => {
+        return {
+            customerId: options.customerId ?? null,
+            enabled: options.enabled ?? true,
+        };
+    }, [options.customerId, options.enabled]);
+    const isEnabled = useMemo(() => {
+        return Boolean(stableOptions.enabled && stableOptions.customerId && storeId);
+    }, [stableOptions.enabled, stableOptions.customerId, storeId]);
+    const [data, setData] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const fetchOrders = useCallback(async () => {
+        if (!isEnabled)
+            return;
+        if (!stableOptions.customerId || !storeId)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/orders/customer/${stableOptions.customerId}`, {
+                method: 'GET',
+                params: { storeId },
+            });
+            setData(response ?? null);
+        }
+        catch (err) {
+            const safeError = err instanceof Error ? err : new Error('Failed to fetch customer orders');
+            setError(safeError);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, isEnabled, stableOptions.customerId, storeId]);
+    useEffect(() => {
+        void fetchOrders();
+    }, [fetchOrders]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: fetchOrders,
+    };
+}

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

@@ -0,0 +1,56 @@
+export interface Subscription {
+    id: string;
+    status: string;
+    createdAt: string;
+    currency: string;
+    cancelAtPeriodEnd: boolean;
+    currentPeriodEnd: string | null;
+    currentPeriodStart: string | null;
+    quantity: number;
+    trialEnd: string | null;
+    customerId: string;
+    customerEmail: string;
+    customerName: string;
+    priceCurrencyOptions: Record<string, {
+        rate: number;
+        amount: number;
+        lock: boolean;
+        date: string;
+    }>;
+    priceInterval: string;
+    priceIntervalCount: number;
+    priceRecurring: boolean;
+    productId: string;
+    priceId: string;
+    productTitle: string;
+}
+export interface SubscriptionsResponse {
+    items: Subscription[];
+    pagination: {
+        page: number;
+        pageSize: number;
+        hasNext: boolean;
+        nextPage: number | null;
+        previousPage: number | null;
+        totalItems: number;
+    };
+}
+export interface UseCustomerSubscriptionsOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerSubscriptionsResult {
+    data: SubscriptionsResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    resumeSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    cancelSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function useCustomerSubscriptions(options: UseCustomerSubscriptionsOptions): UseCustomerSubscriptionsResult;

package/dist/react/hooks/useCustomerSubscriptions.js

@@ -0,0 +1,77 @@
+'use client';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useCustomerSubscriptions(options) {
+    const { apiService } = useTagadaContext();
+    const stableOptions = useMemo(() => {
+        return {
+            customerId: options.customerId ?? null,
+            enabled: options.enabled ?? true,
+        };
+    }, [options.customerId, options.enabled]);
+    const isEnabled = useMemo(() => {
+        return Boolean(stableOptions.enabled && stableOptions.customerId);
+    }, [stableOptions.enabled, stableOptions.customerId]);
+    const [data, setData] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const fetchSubscriptions = useCallback(async () => {
+        if (!isEnabled)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Token-authenticated request; backend infers customer from token
+            const response = await apiService.fetch(`/api/v1/subscriptions`, {
+                method: 'GET',
+            });
+            setData(response ?? null);
+        }
+        catch (err) {
+            const safeError = err instanceof Error ? err : new Error('Failed to fetch subscriptions');
+            setError(safeError);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, isEnabled]);
+    useEffect(() => {
+        void fetchSubscriptions();
+    }, [fetchSubscriptions]);
+    const resumeSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await apiService.fetch(`/api/v1/subscriptions/resume`, {
+                method: 'POST',
+                body: { subscriptionId },
+            });
+            await fetchSubscriptions();
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to resume subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [apiService, fetchSubscriptions]);
+    const cancelSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await apiService.fetch(`/api/v1/subscriptions/cancel`, {
+                method: 'POST',
+                body: { subscriptionId },
+            });
+            await fetchSubscriptions();
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to cancel subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [apiService, fetchSubscriptions]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: fetchSubscriptions,
+        resumeSubscription,
+        cancelSubscription,
+    };
+}

package/dist/react/hooks/useLogin.js

@@ -1,7 +1,7 @@
 import { useCallback, useState } from 'react';
 import { useTagadaContext } from '../providers/TagadaProvider';
-import { usePluginConfig } from './usePluginConfig';
 import { setClientToken } from '../utils/tokenStorage';
+import { usePluginConfig } from './usePluginConfig';
 export function useLogin() {
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);

package/dist/react/index.d.ts

@@ -7,6 +7,9 @@ export { useCheckout } from './hooks/useCheckout';
 export { useClubOffers } from './hooks/useClubOffers';
 export { useCurrency } from './hooks/useCurrency';
 export { useCustomer } from './hooks/useCustomer';
+export { useCustomerInfos } from './hooks/useCustomerInfos';
+export { useCustomerOrders } from './hooks/useCustomerOrders';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useDiscounts } from './hooks/useDiscounts';
 export { useEnvironment } from './hooks/useEnvironment';
 export { useGeoLocation } from './hooks/useGeoLocation';
@@ -41,7 +44,7 @@ export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export { useApplePay } from './hooks/useApplePay';
 export { ExpressPaymentProvider, useExpressPayment } from './hooks/useExpressPayment';
-export type { AuthState, Currency, Customer, Environment, EnvironmentConfig, Locale, Order, OrderAddress, OrderItem, OrderSummary, PickupPoint, Session, Store } from './types';
+export type { AuthState, Currency, Customer, CustomerInfos, 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';
 export type { OrderBumpPreview, UseOrderBumpOptions, UseOrderBumpResult } from './hooks/useOrderBump';

package/dist/react/index.js

@@ -10,6 +10,9 @@ export { useCheckout } from './hooks/useCheckout';
 export { useClubOffers } from './hooks/useClubOffers';
 export { useCurrency } from './hooks/useCurrency';
 export { useCustomer } from './hooks/useCustomer';
+export { useCustomerInfos } from './hooks/useCustomerInfos';
+export { useCustomerOrders } from './hooks/useCustomerOrders';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useDiscounts } from './hooks/useDiscounts';
 export { useEnvironment } from './hooks/useEnvironment';
 export { useGeoLocation } from './hooks/useGeoLocation';

package/dist/react/providers/TagadaProvider.js

@@ -362,6 +362,58 @@ rawPluginConfig, }) {
             setIsLoading(false);
         }
     }, [apiService, hasAttemptedAnonymousToken, initializeSession, finalDebugMode]);
+    // Initialize token from storage or create anonymous token (extracted to stable callback)
+    const initializeToken = useCallback(async () => {
+        try {
+            console.debug('[SDK] Initializing token...');
+            setIsLoading(true);
+            // Check for existing token
+            const existingToken = getClientToken();
+            let tokenToUse = null;
+            // Check URL params for token
+            const urlParams = new URLSearchParams(window.location.search);
+            const queryToken = urlParams.get('token');
+            if (queryToken) {
+                console.debug('[SDK] Found token in URL params');
+                tokenToUse = queryToken;
+                setClientToken(queryToken);
+            }
+            else if (existingToken && !isTokenExpired(existingToken)) {
+                console.debug('[SDK] Using existing token from storage');
+                tokenToUse = existingToken;
+            }
+            else {
+                console.debug('[SDK] No valid token found');
+                // Determine storeId for anonymous token
+                const targetStoreId = storeId || 'default-store';
+                await createAnonymousToken(targetStoreId);
+                return;
+            }
+            if (tokenToUse) {
+                setToken(tokenToUse);
+                // Update the API service with the token
+                apiService.updateToken(tokenToUse);
+                // Decode token to get session data
+                const decodedSession = decodeJWTClient(tokenToUse);
+                if (decodedSession) {
+                    setSession(decodedSession);
+                    // Initialize session with API call
+                    await initializeSession(decodedSession);
+                }
+                else {
+                    console.error('[SDK] Failed to decode token');
+                    setIsInitialized(true);
+                    setIsSessionInitialized(false); // Session failed to initialize
+                    setIsLoading(false);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[SDK] Error initializing token:', error);
+            setIsInitialized(true);
+            setIsLoading(false);
+        }
+    }, [apiService, storeId, createAnonymousToken, initializeSession]);
     // Initialize token from storage or create anonymous token
     // This runs in the background after phases 1 & 2 complete, but doesn't block rendering
     useEffect(() => {
@@ -373,59 +425,19 @@ rawPluginConfig, }) {
             return;
         }
         isInitializing.current = true;
-        const initializeToken = async () => {
-            try {
-                console.debug('[SDK] Initializing token...');
-                setIsLoading(true);
-                // Check for existing token
-                const existingToken = getClientToken();
-                let tokenToUse = null;
-                // Check URL params for token
-                const urlParams = new URLSearchParams(window.location.search);
-                const queryToken = urlParams.get('token');
-                if (queryToken) {
-                    console.debug('[SDK] Found token in URL params');
-                    tokenToUse = queryToken;
-                    setClientToken(queryToken);
-                }
-                else if (existingToken && !isTokenExpired(existingToken)) {
-                    console.debug('[SDK] Using existing token from storage');
-                    tokenToUse = existingToken;
-                }
-                else {
-                    console.debug('[SDK] No valid token found');
-                    // Determine storeId for anonymous token
-                    const targetStoreId = storeId || 'default-store';
-                    await createAnonymousToken(targetStoreId);
-                    return;
-                }
-                if (tokenToUse) {
-                    setToken(tokenToUse);
-                    // Update the API service with the token
-                    apiService.updateToken(tokenToUse);
-                    // Decode token to get session data
-                    const decodedSession = decodeJWTClient(tokenToUse);
-                    if (decodedSession) {
-                        setSession(decodedSession);
-                        // Initialize session with API call
-                        await initializeSession(decodedSession);
-                    }
-                    else {
-                        console.error('[SDK] Failed to decode token');
-                        setIsInitialized(true);
-                        setIsSessionInitialized(false); // Session failed to initialize
-                        setIsLoading(false);
-                    }
-                }
-            }
-            catch (error) {
-                console.error('[SDK] Error initializing token:', error);
-                setIsInitialized(true);
-                setIsLoading(false);
-            }
-        };
         void initializeToken();
-    }, [storeId, createAnonymousToken, initializeSession, configLoading]);
+    }, [storeId, configLoading, initializeToken]);
+    useEffect(() => {
+        function onStorage() {
+            // Re-run initialization when token may have changed in another tab
+            isInitializing.current = false;
+            void initializeToken();
+        }
+        window.addEventListener('storage', onStorage);
+        return () => {
+            window.removeEventListener('storage', onStorage);
+        };
+    }, [initializeToken]);
     // Update auth state when customer/session changes
     useEffect(() => {
         setAuth({

package/dist/react/types.d.ts

@@ -150,3 +150,112 @@ export interface Order {
     };
     relatedOrders?: Order[];
 }
+export interface PaymentSummary {
+    id: string;
+    status: string;
+    amount: number;
+    currency: string;
+    createdAt: string;
+    updatedAt?: string;
+    provider?: string;
+    metadata?: Record<string, any>;
+}
+export interface PromotionSummary {
+    id: string;
+    code?: string | null;
+    type?: string;
+    amount?: number;
+    description?: string | null;
+}
+export interface OrderAdjustmentSummary {
+    type: string;
+    amount: number;
+    description: string;
+}
+export interface OrderWithRelations extends Order {
+    customer?: Customer;
+    store?: Store;
+    account?: {
+        id: string;
+        name?: string;
+    } | undefined;
+    items: OrderItem[];
+    payments?: PaymentSummary[];
+    summaries: OrderSummary[];
+    checkoutSession?: {
+        id?: string;
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    promotions?: PromotionSummary[];
+    subscriptions?: any[];
+    adjustments: OrderAdjustmentSummary[];
+}
+export interface CustomerAddress {
+    company?: string;
+    firstName: string;
+    lastName: string;
+    address1: string;
+    city: string;
+    country: string;
+    state: string;
+    postal: string;
+    phone?: string;
+    email?: string;
+}
+export interface CustomerOrderSummary {
+    id: string;
+    storeId: string;
+    accountId: string;
+    createdAt: string;
+    updatedAt: string;
+    status: string;
+    cancelledAt: string | null;
+    cancelledReason: string | null;
+    paidAt: string | null;
+    paidAmount: number | null;
+    openAt: string | null;
+    abandonedAt: string | null;
+    currency: string;
+    externalCustomerType: string | null;
+    externalCustomerId: string | null;
+    externalOrderId: string | null;
+    billingAddress: CustomerAddress;
+    shippingAddress: Omit<CustomerAddress, 'email'>;
+    pickupAddress: any | null;
+    taxesIncluded: boolean;
+    draft: boolean;
+    checkoutSessionId: string | null;
+    sessionHash: string | null;
+    customerId: string;
+    createdFrom: string | null;
+    paymentInstrumentId: string | null;
+    refundedAt: string | null;
+    refundedAmount: number | null;
+    metadata?: Record<string, any>;
+}
+export interface CustomerInfos {
+    customer: {
+        id: string;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        externalCustomerId: string | null;
+        lastOrderId: string | null;
+        accountId: string;
+        storeId: string;
+        billingAddress: CustomerAddress | null;
+        shippingAddress: Omit<CustomerAddress, 'email'> | null;
+        currency: string | null;
+        locale: string | null;
+        draft: boolean;
+        acceptsMarketing: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, any>;
+        device: any | null;
+        orders: CustomerOrderSummary[];
+        subscriptions: any[];
+    };
+    promotionCodes: any[];
+}

package/dist/react/utils/tokenStorage.js

@@ -10,6 +10,7 @@ export function setClientToken(token) {
     if (typeof window !== 'undefined') {
         try {
             localStorage.setItem(TOKEN_KEY, token);
+            window.dispatchEvent(new Event('storage'));
         }
         catch (error) {
             console.error('Failed to save token to localStorage:', error);

package/dist/v2/core/resources/checkout.d.ts

@@ -20,6 +20,7 @@ export interface CheckoutInitParams {
     customerMetadata?: Record<string, unknown>;
     metadata?: Record<string, unknown>;
     storeId?: string;
+    customerId?: string;
     customer?: {
         currency?: string;
         locale?: string;

package/dist/v2/core/resources/checkout.js

@@ -10,6 +10,7 @@ export class CheckoutResource {
      * Initialize a new checkout session
      */
     async initCheckout(params) {
+        // Pass all params including customerId to prevent duplicate customer creation
         return this.apiClient.post('/api/v1/checkout/session/init', params);
     }
     /**

package/dist/v2/react/hooks/useCheckoutQuery.d.ts

@@ -19,6 +19,7 @@ export interface UseCheckoutQueryResult {
     }>;
     refresh: () => Promise<void>;
     updateLineItems: (lineItems: CheckoutLineItem[]) => Promise<any>;
+    updateLineItemsOptimistic: (lineItems: CheckoutLineItem[]) => void;
     setItemQuantity: (variantId: string, quantity: number, priceId?: string) => Promise<any>;
     updateCustomer: (data: {
         email: string;

package/dist/v2/react/hooks/useCheckoutQuery.js

@@ -2,7 +2,7 @@
  * Checkout Hook using TanStack Query
  * Replaces the coordinator pattern with automatic cache invalidation
  */
-import { useCallback, useState, useEffect, useMemo } from 'react';
+import { useCallback, useState, useEffect, useMemo, useRef } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { CheckoutResource } from '../../core/resources/checkout';
 import { useTagadaContext } from '../providers/TagadaProvider';
@@ -14,7 +14,46 @@ export function useCheckoutQuery(options = {}) {
     const { storeId } = usePluginConfig();
     const currency = useCurrency();
     const queryClient = useQueryClient();
-    const { isSessionInitialized } = useTagadaContext();
+    const { isSessionInitialized, session } = useTagadaContext();
+    // Track pending session promises to avoid creating multiple promises
+    const pendingSessionPromise = useRef(null);
+    const sessionResolvers = useRef(new Set());
+    // Resolve all pending promises when session becomes ready
+    useEffect(() => {
+        if (isSessionInitialized && sessionResolvers.current.size > 0) {
+            console.log('✅ [useCheckout] CMS session ready, resolving pending promises');
+            sessionResolvers.current.forEach(resolve => resolve());
+            sessionResolvers.current.clear();
+            pendingSessionPromise.current = null;
+        }
+    }, [isSessionInitialized]);
+    // Clean, event-driven session waiting - no polling needed
+    const waitForSession = useCallback(async () => {
+        if (isSessionInitialized) {
+            return Promise.resolve();
+        }
+        // Reuse existing promise if one is pending
+        if (pendingSessionPromise.current) {
+            return pendingSessionPromise.current;
+        }
+        console.log('⏳ [useCheckout] Waiting for CMS session to be initialized...');
+        // Create new promise that will be resolved by useEffect above
+        pendingSessionPromise.current = new Promise((resolve, reject) => {
+            // Add resolver to set for useEffect to call
+            sessionResolvers.current.add(resolve);
+            // Safety timeout
+            setTimeout(() => {
+                if (sessionResolvers.current.has(resolve)) {
+                    sessionResolvers.current.delete(resolve);
+                    if (sessionResolvers.current.size === 0) {
+                        pendingSessionPromise.current = null;
+                    }
+                    reject(new Error('Session initialization timeout. Please refresh the page and try again.'));
+                }
+            }, 10000);
+        });
+        return pendingSessionPromise.current;
+    }, [isSessionInitialized]);
     // Create checkout resource client
     const checkoutResource = useMemo(() => {
         try {
@@ -55,6 +94,8 @@ export function useCheckoutQuery(options = {}) {
                 ...params,
                 storeId: params.storeId || storeId,
                 returnUrl: params.returnUrl || window.location.origin,
+                // Include customerId from session to prevent duplicate customer creation
+                customerId: params.customerId || session?.customerId,
                 customer: {
                     ...params.customer,
                     currency: params.customer?.currency ?? currency.code,
@@ -75,7 +116,7 @@ export function useCheckoutQuery(options = {}) {
         },
     });
     // Order bump functionality removed - use useOrderBumpQuery instead
-    // Line items mutation
+    // Line items mutation with optimistic updates
     const lineItemsMutation = useMutation({
         mutationFn: ({ lineItems }) => {
             if (!checkout?.checkoutSession?.id) {
@@ -83,7 +124,38 @@ export function useCheckoutQuery(options = {}) {
             }
             return checkoutResource.updateLineItems(checkout.checkoutSession.id, lineItems);
         },
-        onSuccess: () => {
+        onMutate: async ({ lineItems }) => {
+            // Cancel any outgoing refetches (so they don't overwrite our optimistic update)
+            await queryClient.cancelQueries({ queryKey: ['checkout', checkoutToken] });
+            // Snapshot the previous value
+            const previousCheckout = queryClient.getQueryData(['checkout', checkoutToken]);
+            // Optimistically update the checkout data
+            if (previousCheckout && checkout?.checkoutSession?.id) {
+                const optimisticCheckout = {
+                    ...previousCheckout,
+                    checkoutSession: {
+                        ...previousCheckout.checkoutSession,
+                        sessionLineItems: lineItems.map(item => ({
+                            variantId: item.variantId,
+                            quantity: item.quantity,
+                            priceId: item.priceId,
+                            isOrderBump: false, // Default for line items
+                        })),
+                    },
+                };
+                queryClient.setQueryData(['checkout', checkoutToken], optimisticCheckout);
+            }
+            // Return a context object with the snapshotted value
+            return { previousCheckout };
+        },
+        onError: (err, _variables, context) => {
+            // If the mutation fails, use the context returned from onMutate to roll back
+            if (context && typeof context === 'object' && 'previousCheckout' in context) {
+                queryClient.setQueryData(['checkout', checkoutToken], context.previousCheckout);
+            }
+        },
+        onSettled: () => {
+            // Always refetch after error or success to ensure we have the latest data
             if (checkoutToken) {
                 void queryClient.invalidateQueries({ queryKey: ['checkout', checkoutToken] });
             }
@@ -173,6 +245,8 @@ export function useCheckoutQuery(options = {}) {
         isSuccess,
         // Actions
         init: async (params) => {
+            // Wait for session to be initialized to ensure we have customerId
+            await waitForSession();
             const result = await initMutation.mutateAsync(params);
             // Update internal token state so the query can fetch the checkout data
             setInternalToken(result.checkoutToken);
@@ -185,6 +259,7 @@ export function useCheckoutQuery(options = {}) {
         refresh,
         // Checkout operations
         updateLineItems: (lineItems) => lineItemsMutation.mutateAsync({ lineItems }),
+        updateLineItemsOptimistic: (lineItems) => lineItemsMutation.mutate({ lineItems }),
         setItemQuantity: (variantId, quantity, priceId) => quantityMutation.mutateAsync({ variantId, quantity, priceId }),
         updateCustomer: (data) => customerMutation.mutateAsync(data),
         updateCustomerAndSessionInfo: (data) => customerAndSessionMutation.mutateAsync(data),

package/dist/v2/react/hooks/useOrderBumpQuery.d.ts

@@ -5,7 +5,6 @@
 export interface UseOrderBumpQueryOptions {
     checkoutToken: string | null;
     offerId: string;
-    productId?: string;
     checkout?: any;
 }
 export interface UseOrderBumpQueryResult {

package/dist/v2/react/hooks/useOrderBumpQuery.js

@@ -6,7 +6,7 @@ import { useState, useCallback, useEffect } from 'react';
 import { useApiMutation, useInvalidateQuery, getGlobalApiClient } from './useApiQuery';
 import { useCheckoutQuery } from './useCheckoutQuery';
 export function useOrderBumpQuery(options) {
-    const { checkoutToken, offerId, productId, checkout: providedCheckout } = options;
+    const { checkoutToken, offerId, checkout: providedCheckout } = options;
     const { invalidateCheckout, invalidatePromotions } = useInvalidateQuery();
     const client = getGlobalApiClient();
     // Use checkout query only if no checkout is provided
@@ -23,11 +23,12 @@ export function useOrderBumpQuery(options) {
         if (!checkout?.checkoutSession?.sessionLineItems) {
             return false;
         }
-        const targetProductId = productId || offerId;
+        // Check if any order bump items exist in sessionLineItems
+        // The offerId is the upsell offer ID, but we check for isOrderBump === true
         return checkout.checkoutSession.sessionLineItems.some((item) => {
-            return item.isOrderBump === true && item.productId === targetProductId;
+            return item.isOrderBump === true;
         });
-    }, [checkout?.checkoutSession?.sessionLineItems, offerId, productId]);
+    }, [checkout?.checkoutSession?.sessionLineItems]);
     // State management
     const [isSelected, setIsSelected] = useState(() => checkOrderBumpSelection());
     const [error, setError] = useState(null);
@@ -82,7 +83,7 @@ export function useOrderBumpQuery(options) {
             const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
             return { success: false, error: error.message };
         }
-    }, [checkout?.checkoutSession?.id, isSelected, toggleMutation, offerId, productId, checkoutToken, actualCheckoutToken]);
+    }, [checkout?.checkoutSession?.id, isSelected, toggleMutation, offerId, checkoutToken, actualCheckoutToken]);
     return {
         isSelected,
         isToggling: toggleMutation.isPending,

package/dist/v2/react/hooks/usePluginConfig.d.ts

@@ -11,6 +11,8 @@ export interface UsePluginConfigResult<TConfig = Record<string, any>> {
     storeId?: string;
     accountId?: string;
     basePath?: string;
+    loading: boolean;
+    error?: Error;
     isValid: boolean;
 }
 export declare function usePluginConfig<TConfig = Record<string, any>>(options?: UsePluginConfigOptions): UsePluginConfigResult<TConfig>;

package/dist/v2/react/hooks/usePluginConfig.js

@@ -6,7 +6,7 @@ import { useMemo } from 'react';
 import { useTagadaContext } from '../providers/TagadaProvider';
 import { PluginConfigUtils } from '../../core/utils/pluginConfig';
 export function usePluginConfig(options = {}) {
-    const { pluginConfig } = useTagadaContext();
+    const { pluginConfig, pluginConfigLoading } = useTagadaContext();
     const config = useMemo(() => {
         const baseConfig = PluginConfigUtils.getPluginConfig(options.rawConfig, {
             storeId: pluginConfig.storeId,
@@ -30,6 +30,8 @@ export function usePluginConfig(options = {}) {
         storeId: config.storeId,
         accountId: config.accountId,
         basePath: config.basePath,
+        loading: pluginConfigLoading,
+        error: undefined, // TODO: Add error handling if needed
         isValid,
     };
 }

package/dist/v2/react/providers/TagadaProvider.js

@@ -48,9 +48,39 @@ const InitializationLoader = () => (_jsxs("div", { style: {
         }
       ` })] }));
 const TagadaContext = createContext(null);
+// Global instance tracking for TagadaProvider
+let globalTagadaInstance = null;
+let globalTagadaInitialized = false;
 export function TagadaProvider({ children, environment, customApiConfig, debugMode, // Remove default, will be set based on environment
 localConfig, blockUntilSessionReady = false, // Default to new non-blocking behavior
 rawPluginConfig, }) {
+    // Instance tracking
+    const [instanceId] = useState(() => {
+        if (!globalTagadaInstance) {
+            globalTagadaInstance = Math.random().toString(36).substr(2, 9);
+        }
+        return globalTagadaInstance;
+    });
+    const isActiveInstance = useMemo(() => {
+        if (!globalTagadaInitialized) {
+            globalTagadaInitialized = true;
+            console.log(`✅ [TagadaProvider] Instance ${instanceId} is now the active instance`);
+            return true;
+        }
+        else {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is duplicate - blocking execution`);
+            return false;
+        }
+    }, [instanceId]);
+    useEffect(() => {
+        return () => {
+            if (globalTagadaInstance === instanceId) {
+                globalTagadaInitialized = false;
+                globalTagadaInstance = null;
+                console.log(`🧹 [TagadaProvider] Instance ${instanceId} cleanup - allowing new instances`);
+            }
+        };
+    }, [instanceId]);
     // LOCAL DEV ONLY: Use localConfig override if in local development, otherwise use default
     const isLocalDev = typeof window !== 'undefined' &&
         (window.location.hostname === 'localhost' ||
@@ -60,7 +90,7 @@ rawPluginConfig, }) {
     // Debug logging (only log once during initial render)
     const hasLoggedRef = useRef(false);
     if (!hasLoggedRef.current) {
-        console.log('🔍 TagadaProvider Config Debug:', {
+        console.log(`🔍 [TagadaProvider] Instance ${instanceId} Config Debug:`, {
             hostname: typeof window !== 'undefined' ? window.location.hostname : 'SSR',
             isLocalDev,
             localConfig,
@@ -84,6 +114,11 @@ rawPluginConfig, }) {
     const [configLoading, setConfigLoading] = useState(!rawPluginConfig);
     // Load plugin config on mount with the specified variant
     useEffect(() => {
+        // Prevent multiple config loads
+        if (configLoading === false && pluginConfig.storeId) {
+            console.log('🔒 [TagadaProvider] Config already loaded, skipping reload');
+            return;
+        }
         const loadConfig = async () => {
             try {
                 // Use the v2 core loadPluginConfig function
@@ -239,12 +274,21 @@ rawPluginConfig, }) {
     });
     // Initialize session
     const initializeSession = useCallback(async (sessionData) => {
+        if (!isActiveInstance) {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping session initialization`);
+            return;
+        }
         if (!sessionData.storeId || !sessionData.accountId) {
-            console.error('[SDK] Missing required session data');
+            console.error(`[TagadaProvider] Instance ${instanceId} missing required session data`);
+            return;
+        }
+        // Prevent multiple session initializations
+        if (isSessionInitialized) {
+            console.log(`🔒 [TagadaProvider] Instance ${instanceId} session already initialized, skipping`);
             return;
         }
         if (finalDebugMode) {
-            console.debug('[SDK][DEBUG] Initializing session with store config...', sessionData);
+            console.debug(`[TagadaProvider] Instance ${instanceId} [DEBUG] Initializing session with store config...`, sessionData);
         }
         setIsLoading(true);
         try {
@@ -352,15 +396,23 @@ rawPluginConfig, }) {
             setIsInitialized(true);
             setIsLoading(false);
         }
-    }, [apiService, finalDebugMode]);
+    }, [apiService, finalDebugMode, isActiveInstance, instanceId]);
     // Create anonymous token if needed
     const createAnonymousToken = useCallback(async (targetStoreId) => {
+        if (!isActiveInstance) {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping anonymous token creation`);
+            return;
+        }
         if (hasAttemptedAnonymousToken || !targetStoreId) {
+            console.log(`🔒 [TagadaProvider] Instance ${instanceId} anonymous token already attempted or no storeId:`, {
+                hasAttemptedAnonymousToken,
+                targetStoreId,
+            });
             return;
         }
-        console.log('[SDK] 🚀 Starting Phase 3 - Session initialization...');
+        console.log(`[TagadaProvider] Instance ${instanceId} 🚀 Starting Phase 3 - Session initialization...`);
         if (finalDebugMode) {
-            console.debug('[SDK][DEBUG] Creating anonymous token for store:', targetStoreId);
+            console.debug(`[TagadaProvider] Instance ${instanceId} [DEBUG] Creating anonymous token for store:`, targetStoreId);
         }
         setHasAttemptedAnonymousToken(true);
         try {
@@ -405,15 +457,24 @@ rawPluginConfig, }) {
             setIsInitialized(true);
             setIsLoading(false);
         }
-    }, [apiService, hasAttemptedAnonymousToken, initializeSession, finalDebugMode]);
+    }, [apiService, hasAttemptedAnonymousToken, initializeSession, finalDebugMode, isActiveInstance, instanceId]);
     // Initialize token from storage or create anonymous token
     // This runs in the background after phases 1 & 2 complete, but doesn't block rendering
     useEffect(() => {
+        if (!isActiveInstance) {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping token initialization`);
+            return;
+        }
         if (isInitializing.current) {
+            console.log(`🔒 [TagadaProvider] Instance ${instanceId} already initializing, skipping`);
             return;
         }
         // Wait for plugin config to load AND ensure we have a store ID before initializing
         if (configLoading || !storeId) {
+            console.log(`⏳ [TagadaProvider] Instance ${instanceId} waiting for config or storeId:`, {
+                configLoading,
+                storeId,
+            });
             return;
         }
         isInitializing.current = true;
@@ -469,7 +530,7 @@ rawPluginConfig, }) {
             }
         };
         void initializeToken();
-    }, [storeId, createAnonymousToken, initializeSession, configLoading]);
+    }, [storeId, createAnonymousToken, initializeSession, configLoading, isActiveInstance, instanceId]);
     // Update auth state when customer/session changes
     useEffect(() => {
         setAuth({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.5.2",
+  "version": "2.6.2",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -42,7 +42,7 @@
     "version:sync": "node version-sync.js sync",
     "version:list": "node version-sync.js list",
     "version:next": "node version-sync.js next",
-    "postversion": "echo \"✅ Version updated to $(node -p 'require(\"./package.json\").version')\" && git push && git push --tags"
+    "postversion": "echo \"✅ Version updated to $(node -p 'require(\"./package.json\").version')\" && (git push && git push --tags || echo \"⚠️ Git push failed - you may need to pull and push manually\")"
   },
   "keywords": [
     "tagadapay",