@tagadapay/plugin-sdk 2.6.0 → 2.6.4

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/{useExpressPayment.d.ts → useExpressPaymentMethods.d.ts}

@@ -30,9 +30,17 @@ type ExpressShippingMethod = {
     identifier: string;
     detail: string;
 };
-export interface ExpressPaymentContextType {
+export interface ExpressPaymentMethodsContextType {
+    paymentMethods: PaymentMethod[] | undefined;
     applePayPaymentMethod?: PaymentMethod;
     googlePayPaymentMethod?: PaymentMethod;
+    paypalPaymentMethod?: PaymentMethod;
+    klarnaPaymentMethod?: PaymentMethod;
+    availableExpressPaymentMethodIds: string[];
+    setAvailableExpressPaymentMethodIds: (value: string[]) => void;
+    handleAddExpressId: (id: string) => void;
+    shippingMethods: ExpressShippingMethod[];
+    lineItems: ExpressOrderLineItem[];
     reComputeOrderSummary: () => Promise<{
         lineItems: ExpressOrderLineItem[];
         total: {
@@ -41,12 +49,6 @@ export interface ExpressPaymentContextType {
         };
         shippingMethods: ExpressShippingMethod[];
     } | undefined>;
-    loading?: boolean;
-    availableExpressPaymentMethodIds: string[];
-    setAvailableExpressPaymentMethodIds: (value: string[]) => void;
-    shippingMethods: ExpressShippingMethod[];
-    lineItems: ExpressOrderLineItem[];
-    handleAddExpressId: (id: string) => void;
     updateCheckoutSessionValues: (input: {
         data: {
             shippingAddress: Address;
@@ -58,14 +60,15 @@ export interface ExpressPaymentContextType {
             email: string;
         };
     }) => Promise<void>;
+    loading?: boolean;
     error: string | null;
     setError: (error: string | null) => void;
 }
-interface ExpressPaymentProviderProps {
+interface ExpressPaymentMethodsProviderProps {
     children: ReactNode;
     customerId?: string;
     checkout?: CheckoutData;
 }
-export declare const ExpressPaymentProvider: React.FC<ExpressPaymentProviderProps>;
-export declare const useExpressPayment: () => ExpressPaymentContextType;
+export declare const ExpressPaymentMethodsProvider: React.FC<ExpressPaymentMethodsProviderProps>;
+export declare const useExpressPaymentMethods: () => ExpressPaymentMethodsContextType;
 export {};

package/dist/react/hooks/{useExpressPayment.js → useExpressPaymentMethods.js}

@@ -3,8 +3,8 @@ import React, { createContext, useCallback, useContext, useMemo, useState } from
 import { useTagadaContext } from '../providers/TagadaProvider';
 import { useOrderSummary } from './useOrderSummary';
 import { useShippingRates } from './useShippingRates';
-const ExpressPaymentContext = createContext(undefined);
-export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
+const ExpressPaymentMethodsContext = createContext(undefined);
+export const ExpressPaymentMethodsProvider = ({ children, customerId, checkout, }) => {
     const { apiService } = useTagadaContext();
     const [availableExpressPaymentMethodIds, setAvailableExpressPaymentMethodIds] = useState([]);
     const [error, setError] = useState(null);
@@ -37,7 +37,7 @@ export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
         return () => {
             mounted = false;
         };
-    }, [apiService, checkoutSessionId]);
+    }, [apiService, checkoutSessionId, checkout]);
     const handleAddExpressId = (id) => {
         setAvailableExpressPaymentMethodIds((prev) => (prev.includes(id) ? prev : [...prev, id]));
     };
@@ -128,14 +128,20 @@ export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
             body: input,
         });
     }, [apiService, customerId]);
+    // Identify specific payment method types
     const enabledApplePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'apple_pay'), [paymentMethods]);
     const enabledGooglePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'google_pay'), [paymentMethods]);
+    const enabledPaypalPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'paypal'), [paymentMethods]);
+    const enabledKlarnaPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'klarna'), [paymentMethods]);
     const loading = !paymentMethods || isLoadingPaymentMethods || isLoadingOrderSummary;
     const contextValue = {
+        paymentMethods: paymentMethods || undefined,
         availableExpressPaymentMethodIds,
         setAvailableExpressPaymentMethodIds,
         applePayPaymentMethod: enabledApplePayPaymentMethod,
         googlePayPaymentMethod: enabledGooglePayPaymentMethod,
+        paypalPaymentMethod: enabledPaypalPaymentMethod,
+        klarnaPaymentMethod: enabledKlarnaPaymentMethod,
         shippingMethods,
         lineItems,
         reComputeOrderSummary,
@@ -146,13 +152,16 @@ export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
         error,
         setError,
     };
-    const hasAnyEnabled = Boolean(enabledApplePayPaymentMethod || enabledGooglePayPaymentMethod);
-    return (_jsx(ExpressPaymentContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
+    const hasAnyEnabled = Boolean(enabledApplePayPaymentMethod ||
+        enabledGooglePayPaymentMethod ||
+        enabledPaypalPaymentMethod ||
+        enabledKlarnaPaymentMethod);
+    return (_jsx(ExpressPaymentMethodsContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
 };
-export const useExpressPayment = () => {
-    const context = useContext(ExpressPaymentContext);
+export const useExpressPaymentMethods = () => {
+    const context = useContext(ExpressPaymentMethodsContext);
     if (context === undefined) {
-        throw new Error('useExpressPayment must be used within an ExpressPaymentProvider');
+        throw new Error('useExpressPaymentMethods must be used within an ExpressPaymentMethodsProvider');
     }
     return context;
 };

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

@@ -4,9 +4,14 @@
 export { TagadaProvider } from './providers/TagadaProvider';
 export { useAuth } from './hooks/useAuth';
 export { useCheckout } from './hooks/useCheckout';
+export { useCheckoutSession } from './hooks/useCheckoutSession';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
 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';
@@ -17,8 +22,6 @@ export { useOffers } from './hooks/useOffers';
 export { useOrderBump } from './hooks/useOrderBump';
 export { useOrderBumpV2 } from './hooks/useOrderBumpV2';
 export { useOrderBumpV3 } from './hooks/useOrderBumpV3';
-export { useCheckoutToken } from './hooks/useCheckoutToken';
-export { useCheckoutSession } from './hooks/useCheckoutSession';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
@@ -29,7 +32,7 @@ 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';
-export { getAvailableLanguages, useCountryOptions, useISOData, useRegionOptions, useLanguageImport } from './hooks/useISOData';
+export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
 export type { GeoLocationData, UseGeoLocationOptions, UseGeoLocationReturn } from './hooks/useGeoLocation';
 export type { ExtractedAddress, GoogleAddressComponent, GooglePlaceDetails, GooglePrediction, UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult } from './hooks/useGoogleAutocomplete';
@@ -40,15 +43,16 @@ export { usePaymentPolling } from './hooks/usePaymentPolling';
 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 { ExpressPaymentMethodsProvider, useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
+export type { ExpressPaymentMethodsContextType } from './hooks/useExpressPaymentMethods';
+export type { AuthState, Currency, Customer, CustomerInfos, Environment, EnvironmentConfig, Locale, Order, OrderAddress, OrderItem, OrderSummary, PickupPoint, Session, Store } from './types';
 export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, CheckoutSessionPreview, Promotion, UseCheckoutOptions, UseCheckoutResult } from './hooks/useCheckout';
 export type { Discount, DiscountCodeValidation, UseDiscountsOptions, UseDiscountsResult } from './hooks/useDiscounts';
+export type { UseCheckoutSessionOptions, UseCheckoutSessionResult } from './hooks/useCheckoutSession';
+export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
 export type { OrderBumpPreview, UseOrderBumpOptions, UseOrderBumpResult } from './hooks/useOrderBump';
 export type { UseOrderBumpV2Options, UseOrderBumpV2Result } from './hooks/useOrderBumpV2';
 export type { UseOrderBumpV3Options, UseOrderBumpV3Result } from './hooks/useOrderBumpV3';
-export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
-export type { UseCheckoutSessionOptions, UseCheckoutSessionResult } from './hooks/useCheckoutSession';
 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';

package/dist/react/index.js

@@ -7,9 +7,14 @@ export { TagadaProvider } from './providers/TagadaProvider';
 // Hook exports
 export { useAuth } from './hooks/useAuth';
 export { useCheckout } from './hooks/useCheckout';
+export { useCheckoutSession } from './hooks/useCheckoutSession';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
 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';
@@ -20,8 +25,6 @@ export { useOffers } from './hooks/useOffers';
 export { useOrderBump } from './hooks/useOrderBump';
 export { useOrderBumpV2 } from './hooks/useOrderBumpV2';
 export { useOrderBumpV3 } from './hooks/useOrderBumpV3';
-export { useCheckoutToken } from './hooks/useCheckoutToken';
-export { useCheckoutSession } from './hooks/useCheckoutSession';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
@@ -32,7 +35,7 @@ export { useTagadaContext } from './providers/TagadaProvider';
 // Plugin configuration hooks
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
 // ISO Data hooks
-export { getAvailableLanguages, useCountryOptions, useISOData, useRegionOptions, useLanguageImport } from './hooks/useISOData';
+export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
 // Order hook exports
 export { useOrder } from './hooks/useOrder';
 // Payment hooks exports
@@ -43,7 +46,8 @@ export { useThreedsModal } from './hooks/useThreedsModal';
 // Apple Pay hooks exports
 export { useApplePay } from './hooks/useApplePay';
 // Express Payment context exports
-export { ExpressPaymentProvider, useExpressPayment } from './hooks/useExpressPayment';
+// Express Payment Methods (extended functionality)
+export { ExpressPaymentMethodsProvider, useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 // Component exports
 export { ApplePayButton, Button } from './components';
 // Utility exports

package/dist/react/providers/TagadaProvider.js

@@ -38,11 +38,11 @@ const InitializationLoader = () => (_jsxs("div", { style: {
                 borderTop: '1.5px solid #9ca3af',
                 borderRadius: '50%',
                 animation: 'tagada-spin 1s linear infinite',
-            } }), _jsx("span", { children: "Loading..." }), _jsx("style", { children: `
-        @keyframes tagada-spin {
-          0% { transform: rotate(0deg); }
-          100% { transform: rotate(360deg); }
-        }
+            } }), _jsx("span", { children: "Loading..." }), _jsx("style", { children: `
+        @keyframes tagada-spin {
+          0% { transform: rotate(0deg); }
+          100% { transform: rotate(360deg); }
+        }
       ` })] }));
 const TagadaContext = createContext(null);
 export function TagadaProvider({ children, environment, customApiConfig, debugMode, // Remove default, will be set based on environment
@@ -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({