@tagadapay/plugin-sdk 2.8.8 → 2.8.9

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

@@ -4,16 +4,10 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * TagadaProvider - Main provider component for the Tagada Pay React SDK
  */
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
-import { detectEnvironment, getEnvironmentConfig } from '../../../react/config/environment';
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, useRef, } from 'react';
+import { TagadaClient } from '../../core/client';
 import { ApiService } from '../../../react/services/apiService';
-import { collectDeviceInfo, getBrowserLocale, getUrlParams } from '../../../react/utils/deviceInfo';
-import { decodeJWTClient, isTokenExpired } from '../../../react/utils/jwtDecoder';
-import { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits, } from '../../../react/utils/money';
-import { clearClientToken, getClientToken, setClientToken } from '../../../react/utils/tokenStorage';
-import { ApiClient } from '../../core/resources/apiClient';
-import { resolveEnvValue } from '../../core/utils/env';
-import { loadPluginConfig } from '../../core/utils/pluginConfig';
+import { formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits, convertCurrency, } from '../../../react/utils/money';
 import { default as DebugDrawer } from '../components/DebugDrawer';
 import { setGlobalApiClient } from '../hooks/useApiQuery';
 // Professional, subtle loading component for initialization
@@ -48,248 +42,47 @@ const InitializationLoader = () => (_jsxs("div", { style: {
           100% { transform: rotate(360deg); }
         }
       ` })] }));
-const isEnvironment = (value) => value === 'production' || value === 'development' || value === 'local';
-const resolveEnvironmentFromVariables = () => {
-    const envValue = resolveEnvValue('TAGADA_ENV') ?? resolveEnvValue('TAGADA_ENVIRONMENT');
-    if (!envValue) {
-        return undefined;
-    }
-    const normalized = envValue.trim().toLowerCase();
-    return isEnvironment(normalized) ? normalized : undefined;
-};
 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' ||
-            window.location.hostname.includes('.localhost') ||
-            window.location.hostname.includes('127.0.0.1'));
-    const configVariant = isLocalDev ? localConfig || 'default' : 'default';
-    // Debug logging (only log once during initial render)
-    const hasLoggedRef = useRef(false);
-    if (!hasLoggedRef.current) {
-        console.log(`🔍 [TagadaProvider] Instance ${instanceId} Config Debug:`, {
-            hostname: typeof window !== 'undefined' ? window.location.hostname : 'SSR',
-            isLocalDev,
+export function TagadaProvider({ children, environment, customApiConfig, // Ignored for now in TagadaClient, or need to add support
+debugMode, localConfig, blockUntilSessionReady = false, rawPluginConfig, }) {
+    // Initialize client
+    const client = useMemo(() => {
+        const config = {
+            environment,
+            debugMode,
             localConfig,
-            configVariant,
-        });
-        hasLoggedRef.current = true;
-    }
-    // Load plugin configuration directly (not using hook to avoid circular dependency)
-    // Initialize with raw config if available to avoid empty config during loading
-    const [pluginConfig, setPluginConfig] = useState(() => {
-        if (rawPluginConfig) {
-            return {
-                storeId: rawPluginConfig.storeId,
-                accountId: rawPluginConfig.accountId,
-                basePath: rawPluginConfig.basePath ?? '/',
-                config: rawPluginConfig.config ?? {},
-            };
-        }
-        return { basePath: '/', config: {} };
-    });
-    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
-                const config = await loadPluginConfig(configVariant, rawPluginConfig);
-                // Ensure we have required store ID before proceeding
-                if (!config.storeId) {
-                    console.warn('⚠️ No store ID found in plugin config. This may cause hooks to fail.');
-                }
-                setPluginConfig(config);
-                console.log('✅ Phase 1 & 2 Complete - Plugin config loaded:', {
-                    storeId: config.storeId,
-                    accountId: config.accountId,
-                    basePath: config.basePath,
-                    hasConfig: !!config.config,
-                    source: rawPluginConfig ? 'raw' : 'file',
-                });
-                if (blockUntilSessionReady) {
-                    console.log('⏳ Blocking mode: Children will render after Phase 3 (session init) completes');
-                }
-                else {
-                    console.log('🚀 Non-blocking mode: Children can now render - Phase 3 (session init) will continue in background');
-                }
-            }
-            catch (error) {
-                console.error('❌ Failed to load plugin config in TagadaProvider:', error);
-                setPluginConfig({ basePath: '/', config: {} });
-            }
-            finally {
-                setConfigLoading(false);
-            }
+            rawPluginConfig,
+            blockUntilSessionReady,
         };
-        void loadConfig();
-    }, [configVariant, rawPluginConfig]);
-    // Extract store/account IDs from plugin config (only source now)
-    const storeId = pluginConfig.storeId;
-    const [isLoading, setIsLoading] = useState(true);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const [token, setToken] = useState(null);
-    const [hasAttemptedAnonymousToken, setHasAttemptedAnonymousToken] = useState(false);
-    const [isDebugDrawerOpen, setIsDebugDrawerOpen] = useState(false);
-    const isInitializing = useRef(false);
-    // Initialize environment configuration
-    const [environmentConfig, _setEnvironmentConfig] = useState(() => {
-        const envFromVariables = resolveEnvironmentFromVariables();
-        const detectedEnv = environment || envFromVariables || detectEnvironment();
-        const config = getEnvironmentConfig(detectedEnv);
-        console.log('envFromVariables', envFromVariables);
-        console.log('detectedEnv', detectedEnv);
-        // Log environment detection for debugging
-        if (environment) {
-            console.log(`[TagadaSDK] Using explicit environment: ${environment}`);
-        }
-        else if (envFromVariables) {
-            console.log(`[TagadaSDK] Using environment from env variables: ${envFromVariables}`);
-        }
-        else {
-            console.log(`[TagadaSDK] Auto-detected environment: ${detectedEnv} (${typeof window !== 'undefined' ? window.location.hostname : 'SSR'})`);
-        }
-        // Apply custom API config if provided
-        if (customApiConfig) {
-            return {
-                ...config,
-                ...customApiConfig,
-                apiConfig: {
-                    ...config.apiConfig,
-                    ...customApiConfig.apiConfig,
-                },
-            };
-        }
-        return config;
-    });
-    // Auto-set debugMode based on environment (unless explicitly provided)
-    const finalDebugMode = debugMode ?? environmentConfig.environment !== 'production';
-    // Initialize API service
-    const [apiService] = useState(() => {
-        const service = new ApiService({
-            environmentConfig,
-            token,
-            onTokenUpdate: (newToken) => {
-                setToken(newToken);
-                setClientToken(newToken);
-            },
-            onTokenClear: () => {
-                setToken(null);
-                clearClientToken();
-            },
-        });
-        // Store ID is managed by plugin configuration system
-        if (storeId) {
-            console.log(`[SDK] Using store ID from config: ${storeId}`);
-        }
-        return service;
-    });
-    // Initialize TanStack Query API client synchronously during provider initialization
-    // This ensures the global client is available immediately for hooks that use it in useMemo
-    const [apiClient] = useState(() => {
-        const client = new ApiClient({
-            baseURL: environmentConfig.apiConfig.baseUrl,
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        });
-        // Set the global client for TanStack Query hooks
-        setGlobalApiClient(client);
-        // Check for existing token and set it immediately
-        const existingToken = getClientToken();
-        if (existingToken && !isTokenExpired(existingToken)) {
-            client.updateToken(existingToken);
-            console.log('[SDK] ApiClient initialized with existing token:', existingToken.substring(0, 8) + '...');
-        }
-        else {
-            console.log('[SDK] ApiClient initialized with baseURL:', environmentConfig.apiConfig.baseUrl);
-        }
-        return client;
-    });
-    // Update API client when environment config changes
+        return new TagadaClient(config);
+    }, []); // Singleton behavior
+    // State Sync
+    const [state, setState] = useState(client.getState());
     useEffect(() => {
-        apiClient.updateConfig({
-            baseURL: environmentConfig.apiConfig.baseUrl,
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        });
-        console.log('[SDK] ApiClient config updated with baseURL:', environmentConfig.apiConfig.baseUrl);
-    }, [environmentConfig, apiClient]);
-    // Sync token updates between ApiService and ApiClient
+        return client.subscribe(setState);
+    }, [client]);
+    // Cleanup client on unmount
     useEffect(() => {
-        // Always use the token from ApiService as the source of truth
-        const currentToken = apiService.getCurrentToken();
-        if (currentToken && typeof currentToken === 'string') {
-            apiClient.updateToken(currentToken);
-            console.log('[SDK] Token synced to ApiClient:', currentToken.substring(0, 8) + '...');
-        }
-        else {
-            apiClient.updateToken(null);
-            console.log('[SDK] Token cleared from ApiClient');
-        }
-    }, [token, apiService, apiClient]);
-    // Update API service when config or token changes
+        return () => {
+            client.destroy();
+        };
+    }, [client]);
+    // Sync global API client for hooks
     useEffect(() => {
-        apiService.updateConfig(environmentConfig);
-        apiService.updateToken(token);
-    }, [apiService, environmentConfig, token]);
-    // Initialize state
-    const [customer, setCustomer] = useState(null);
-    const [session, setSession] = useState(null);
-    const [store, setStore] = useState(null);
-    const [isSessionInitialized, setIsSessionInitialized] = useState(false);
-    // Initialize locale and currency with defaults
-    const [locale, setLocale] = useState({
-        locale: 'en-US',
-        language: 'en',
-        region: 'US',
-        messages: {},
-    });
-    const [currency, setCurrency] = useState({
-        code: 'USD',
-        symbol: '$',
-        name: 'US Dollar',
-    });
-    // Initialize debug checkout state
+        setGlobalApiClient(client.apiClient);
+    }, [client]);
+    // Initialize ApiService for backward compatibility
+    // We use state.environment to keep it updated
+    const [apiService] = useState(() => new ApiService({
+        environmentConfig: state.environment,
+        token: client.apiClient.getCurrentToken(),
+    }));
+    // Sync token and config to ApiService
+    useEffect(() => {
+        apiService.updateToken(state.token);
+        apiService.updateConfig(state.environment);
+    }, [state.token, state.environment, apiService]);
+    // Debug State (React specific)
     const [debugCheckout, setDebugCheckout] = useState({
         isActive: false,
         data: null,
@@ -304,367 +97,60 @@ rawPluginConfig, }) {
         isLoading: false,
         lastUpdated: null,
     });
-    // Initialize auth state
-    const [auth, setAuth] = useState({
-        isAuthenticated: false,
-        isLoading: false,
-        customer: null,
-        session: null,
-    });
-    // 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(`[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(`[TagadaProvider] Instance ${instanceId} [DEBUG] Initializing session with store config...`, sessionData);
-        }
-        setIsLoading(true);
-        try {
-            const deviceInfo = collectDeviceInfo();
-            const urlParams = getUrlParams();
-            const browserLocale = getBrowserLocale();
-            const sessionInitData = {
-                storeId: sessionData.storeId,
-                accountId: sessionData.accountId,
-                customerId: sessionData.customerId,
-                role: sessionData.role,
-                browserLocale,
-                queryLocale: urlParams.locale,
-                queryCurrency: urlParams.currency,
-                utmSource: urlParams.utmSource,
-                utmMedium: urlParams.utmMedium,
-                utmCampaign: urlParams.utmCampaign,
-                browser: deviceInfo.userAgent.browser.name,
-                browserVersion: deviceInfo.userAgent.browser.version,
-                os: deviceInfo.userAgent.os.name,
-                osVersion: deviceInfo.userAgent.os.version,
-                deviceType: deviceInfo.userAgent.device?.type,
-                deviceModel: deviceInfo.userAgent.device?.model,
-                screenWidth: deviceInfo.screenResolution.width,
-                screenHeight: deviceInfo.screenResolution.height,
-                timeZone: deviceInfo.timeZone,
-            };
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Session init data:', sessionInitData);
-            }
-            const response = await apiService.initializeSession(sessionInitData);
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Session init response:', response);
-            }
-            // Update store data
-            if (response.store) {
-                const storeData = response.store;
-                const storeConfig = {
-                    ...response.store,
-                    presentmentCurrencies: storeData.presentmentCurrencies || [response.store.currency || 'USD'],
-                    chargeCurrencies: storeData.chargeCurrencies || [response.store.currency || 'USD'],
-                };
-                setStore(storeConfig);
-                if (finalDebugMode) {
-                    console.debug('[SDK][DEBUG] Store config loaded:', storeConfig);
-                }
-            }
-            // Update locale
-            const localeConfig = {
-                locale: response.locale,
-                language: response.locale.split('-')[0],
-                region: response.locale.split('-')[1] ?? 'US',
-                messages: response.messages ?? {},
-            };
-            setLocale(localeConfig);
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Locale config:', localeConfig);
-            }
-            // Update currency based on store
-            if (response.store) {
-                const currencyConfig = {
-                    code: response.store.currency,
-                    symbol: getCurrencySymbol(response.store.currency),
-                    name: getCurrencyName(response.store.currency),
-                };
-                setCurrency(currencyConfig);
-                if (finalDebugMode) {
-                    console.debug('[SDK][DEBUG] Currency config:', currencyConfig);
-                }
-            }
-            // Update customer data if available
-            if (response.customer) {
-                setCustomer(response.customer);
-                if (finalDebugMode) {
-                    console.debug('[SDK][DEBUG] Customer data:', response.customer);
-                }
-            }
-            // Update auth state
-            const authState = {
-                isAuthenticated: response.customer?.isAuthenticated ?? false,
-                isLoading: false,
-                customer: response.customer ?? null,
-                session: sessionData,
-            };
-            setAuth(authState);
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Auth state:', authState);
-            }
-            console.debug('[SDK] Session initialized successfully');
-            setIsInitialized(true);
-            setIsSessionInitialized(true); // Mark CMS session as ready
-            setIsLoading(false);
-        }
-        catch (error) {
-            console.error('[SDK] Error initializing session:', error);
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Full error details:', error);
-            }
-            setIsInitialized(true);
-            setIsLoading(false);
-        }
-    }, [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(`[TagadaProvider] Instance ${instanceId} 🚀 Starting Phase 3 - Session initialization...`);
-        if (finalDebugMode) {
-            console.debug(`[TagadaProvider] Instance ${instanceId} [DEBUG] Creating anonymous token for store:`, targetStoreId);
-        }
-        setHasAttemptedAnonymousToken(true);
-        try {
-            const response = await apiService.createAnonymousToken(targetStoreId);
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Anonymous token response:', response);
-            }
-            // Set the token in state and storage
-            setToken(response.token);
-            setClientToken(response.token);
-            // Update the API service with the new token
-            apiService.updateToken(response.token);
-            // IMPORTANT: Immediately sync token to API client before marking session as ready
-            // This ensures any queries that become enabled after isSessionInitialized=true have the token
-            apiClient.updateToken(response.token);
-            console.log('[SDK] Token immediately synced to ApiClient:', response.token.substring(0, 8) + '...');
-            // Decode the token to get session data
-            const decodedSession = decodeJWTClient(response.token);
-            if (decodedSession) {
-                if (finalDebugMode) {
-                    console.debug('[SDK][DEBUG] Decoded session from token:', decodedSession);
-                }
-                setSession(decodedSession);
-                // Initialize session with API call
-                await initializeSession(decodedSession);
-            }
-            else {
-                console.error('[SDK] Failed to decode anonymous token');
-                setIsInitialized(true);
-                setIsLoading(false);
-            }
-            console.log('[SDK] ✅ Phase 3 Complete - Session initialization completed successfully');
-            setIsSessionInitialized(true); // Mark CMS session as ready
-        }
-        catch (error) {
-            console.error('[SDK] ❌ Initialization failed:', error);
-            if (finalDebugMode) {
-                console.debug('[SDK][DEBUG] Anonymous token creation failed:', error);
-            }
-            setIsInitialized(true);
-            setIsLoading(false);
-        }
-    }, [apiService, hasAttemptedAnonymousToken, initializeSession, finalDebugMode, isActiveInstance, instanceId]);
-    // Initialize token from storage or create anonymous token (extracted to stable callback)
-    const initializeToken = useCallback(async () => {
-        if (!isActiveInstance) {
-            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping token initialization`);
-            return;
-        }
-        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);
-                // IMPORTANT: Immediately sync token to API client
-                apiClient.updateToken(tokenToUse);
-                console.log('[SDK] Token immediately synced to ApiClient:', tokenToUse.substring(0, 8) + '...');
-                // 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, apiClient, storeId, createAnonymousToken, initializeSession, 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;
-        void initializeToken();
-    }, [storeId, initializeToken, configLoading, isActiveInstance, instanceId]);
-    // Listen for storage changes (e.g., token updated in another tab)
-    useEffect(() => {
-        if (!isActiveInstance) {
-            return;
-        }
-        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, isActiveInstance]);
-    // Update auth state when customer/session changes
-    useEffect(() => {
-        setAuth({
-            isAuthenticated: customer?.isAuthenticated ?? false,
-            isLoading: false,
-            customer,
-            session,
+    // Debug Data Updaters
+    const updateCheckoutDebugData = useCallback((data, error, isLoading) => {
+        setDebugCheckout({
+            isActive: true,
+            data,
+            error: error ?? null,
+            isLoading: isLoading ?? false,
+            lastUpdated: new Date(),
         });
-    }, [customer, session]);
-    // Refresh coordinator for bidirectional hook communication
+    }, []);
+    const updateFunnelDebugData = useCallback((data, error, isLoading) => {
+        setDebugFunnel({
+            isActive: true,
+            data,
+            error: error ?? null,
+            isLoading: isLoading ?? false,
+            lastUpdated: new Date(),
+        });
+    }, []);
+    // Refresh Coordinator
     const checkoutRefreshRefs = useRef(new Set());
     const orderBumpRefreshRefs = useRef(new Set());
     const refreshCoordinator = useMemo(() => ({
         registerCheckoutRefresh: (refreshFn, name) => {
-            const hookName = name || 'unknown';
-            console.log(`🔄 [RefreshCoordinator] Registering checkout refresh function from ${hookName}:`, refreshFn.toString().substring(0, 100) + '...');
             checkoutRefreshRefs.current.add(refreshFn);
-            console.log(`✅ [RefreshCoordinator] Checkout refresh function registered from ${hookName} (total: ${checkoutRefreshRefs.current.size})`);
         },
         registerOrderBumpRefresh: (refreshFn) => {
             orderBumpRefreshRefs.current.add(refreshFn);
-            console.log('🔄 [RefreshCoordinator] Order bump refresh function registered');
         },
         notifyCheckoutChanged: async () => {
             if (orderBumpRefreshRefs.current.size > 0) {
-                console.log('🔄 [RefreshCoordinator] Checkout changed, refreshing order bump data...');
-                const refreshPromises = Array.from(orderBumpRefreshRefs.current).map(async (refreshFn) => {
-                    try {
-                        await refreshFn();
-                    }
-                    catch (error) {
-                        console.warn('⚠️ [RefreshCoordinator] Order bump refresh failed:', error);
-                    }
-                });
-                await Promise.all(refreshPromises);
-                console.log('✅ [RefreshCoordinator] Order bump refresh completed');
+                await Promise.all(Array.from(orderBumpRefreshRefs.current).map((fn) => fn().catch(console.warn)));
             }
         },
         notifyOrderBumpChanged: async () => {
-            console.log(`🔄 [RefreshCoordinator] Order bump changed, refreshing checkout data... (${checkoutRefreshRefs.current.size} functions registered)`);
             if (checkoutRefreshRefs.current.size > 0) {
-                const refreshPromises = Array.from(checkoutRefreshRefs.current).map(async (refreshFn, index) => {
-                    try {
-                        console.log(`🔄 [RefreshCoordinator] Calling checkout refresh function ${index + 1}/${checkoutRefreshRefs.current.size}`);
-                        await refreshFn();
-                        console.log(`✅ [RefreshCoordinator] Checkout refresh function ${index + 1} completed`);
-                    }
-                    catch (error) {
-                        console.warn(`⚠️ [RefreshCoordinator] Checkout refresh function ${index + 1} failed:`, error);
-                    }
-                });
-                await Promise.all(refreshPromises);
-                console.log('✅ [RefreshCoordinator] All checkout refreshes completed');
-            }
-            else {
-                console.warn('⚠️ [RefreshCoordinator] No checkout refresh functions registered!');
+                await Promise.all(Array.from(checkoutRefreshRefs.current).map((fn) => fn().catch(console.warn)));
             }
         },
         unregisterCheckoutRefresh: (refreshFn) => {
-            if (refreshFn) {
+            if (refreshFn)
                 checkoutRefreshRefs.current.delete(refreshFn);
-                console.log(`🧹 [RefreshCoordinator] Checkout refresh function unregistered (remaining: ${checkoutRefreshRefs.current.size})`);
-            }
-            else {
+            else
                 checkoutRefreshRefs.current.clear();
-                console.log('🧹 [RefreshCoordinator] All checkout refresh functions unregistered');
-            }
         },
         unregisterOrderBumpRefresh: (refreshFn) => {
-            if (refreshFn) {
+            if (refreshFn)
                 orderBumpRefreshRefs.current.delete(refreshFn);
-            }
-            else {
+            else
                 orderBumpRefreshRefs.current.clear();
-            }
-            console.log('🧹 [RefreshCoordinator] Order bump refresh function unregistered');
         },
     }), []);
-    // Memoize stable values that don't change frequently
-    const memoizedMoneyUtils = useMemo(() => ({
+    // Money Utils
+    const moneyUtils = useMemo(() => ({
         formatMoney,
         getCurrencyInfo,
         moneyStringOrNumberToMinorUnits,
@@ -673,77 +159,23 @@ rawPluginConfig, }) {
         convertCurrency,
         formatSimpleMoney,
     }), []);
-    const memoizedUpdateDebugData = useCallback((data, error, isLoading) => {
-        setDebugCheckout({
-            isActive: true,
-            data,
-            error: error ?? null,
-            isLoading: isLoading ?? false,
-            lastUpdated: new Date(),
-        });
-    }, []);
-    // Memoize the context value to prevent unnecessary re-renders
-    const contextValue = useMemo(() => ({
-        auth,
-        session,
-        customer,
-        locale,
-        currency,
-        store,
-        environment: environmentConfig,
-        apiService,
-        isLoading,
-        isInitialized,
-        isSessionInitialized,
-        debugMode: finalDebugMode,
-        pluginConfig,
-        pluginConfigLoading: configLoading,
-        debugCheckout,
-        updateCheckoutDebugData: memoizedUpdateDebugData,
-        debugFunnel,
-        updateFunnelDebugData: (data, error, isLoading) => {
-            setDebugFunnel({
-                isActive: true,
-                data,
-                error: error ?? null,
-                isLoading: isLoading ?? false,
-                lastUpdated: new Date(),
-            });
-        },
-        refreshCoordinator,
-        money: memoizedMoneyUtils,
-    }), [
-        auth,
-        session,
-        customer,
-        locale,
-        currency,
-        store,
-        environmentConfig,
+    const [isDebugDrawerOpen, setIsDebugDrawerOpen] = useState(false);
+    const contextValue = {
+        ...state,
         apiService,
-        isLoading,
-        isInitialized,
-        isSessionInitialized,
         debugCheckout,
+        updateCheckoutDebugData,
         debugFunnel,
-        finalDebugMode,
-        pluginConfig,
-        configLoading,
+        updateFunnelDebugData,
         refreshCoordinator,
-        memoizedUpdateDebugData,
-        memoizedMoneyUtils,
-        // debugCheckout removed from deps to prevent unnecessary re-renders
-    ]);
-    // Determine if we should show loading
-    // Always block until config is loaded (even if empty)
-    const shouldShowLoading = configLoading;
-    const canRenderChildren = !configLoading;
-    // Initialize TanStack Query client
+        money: moneyUtils,
+    };
+    // Query Client
     const [queryClient] = useState(() => new QueryClient({
         defaultOptions: {
             queries: {
-                staleTime: 30000, // 30 seconds
-                gcTime: 5 * 60 * 1000, // 5 minutes
+                staleTime: 30000,
+                gcTime: 5 * 60 * 1000,
                 refetchOnWindowFocus: false,
                 retry: 1,
             },
@@ -752,7 +184,10 @@ rawPluginConfig, }) {
             },
         },
     }));
-    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsxs(TagadaContext.Provider, { value: contextValue, children: [shouldShowLoading && _jsx(InitializationLoader, {}), finalDebugMode && canRenderChildren && (_jsxs(_Fragment, { children: [_jsx("button", { onClick: () => setIsDebugDrawerOpen(true), style: {
+    // Loading State Logic
+    const shouldShowLoading = state.isLoading || state.pluginConfigLoading || (blockUntilSessionReady && !state.isSessionInitialized);
+    const canRenderChildren = !state.pluginConfigLoading && (!blockUntilSessionReady || state.isSessionInitialized);
+    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsxs(TagadaContext.Provider, { value: contextValue, children: [shouldShowLoading && _jsx(InitializationLoader, {}), state.debugMode && canRenderChildren && (_jsxs(_Fragment, { children: [_jsx("button", { onClick: () => setIsDebugDrawerOpen(true), style: {
                                 position: 'fixed',
                                 bottom: '16px',
                                 right: '16px',
@@ -767,12 +202,6 @@ rawPluginConfig, }) {
                                 boxShadow: '0 4px 12px rgba(0, 0, 0, 0.3)',
                                 zIndex: 999997,
                                 transition: 'all 0.2s ease',
-                            }, onMouseEnter: (e) => {
-                                e.currentTarget.style.backgroundColor = '#ea580c';
-                                e.currentTarget.style.transform = 'scale(1.1)';
-                            }, onMouseLeave: (e) => {
-                                e.currentTarget.style.backgroundColor = '#f97316';
-                                e.currentTarget.style.transform = 'scale(1)';
                             }, title: "Open TagadaPay SDK Debug Panel", children: "\uD83D\uDC1B" }), _jsx(DebugDrawer, { isOpen: isDebugDrawerOpen, onClose: () => setIsDebugDrawerOpen(false) })] })), canRenderChildren && children] }) }));
 }
 export function useTagadaContext() {
@@ -782,26 +211,3 @@ export function useTagadaContext() {
     }
     return context;
 }
-// Helper functions
-function getCurrencySymbol(code) {
-    const symbols = {
-        USD: '$',
-        EUR: '€',
-        GBP: '£',
-        JPY: '¥',
-        CAD: 'C$',
-        AUD: 'A$',
-    };
-    return symbols[code] || code;
-}
-function getCurrencyName(code) {
-    const names = {
-        USD: 'US Dollar',
-        EUR: 'Euro',
-        GBP: 'British Pound',
-        JPY: 'Japanese Yen',
-        CAD: 'Canadian Dollar',
-        AUD: 'Australian Dollar',
-    };
-    return names[code] || code;
-}