@tagadapay/plugin-sdk 2.8.9 → 3.0.1

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

@@ -1,668 +1,30 @@
 /**
- * useFunnel Hook (v2) - TanStack Query-based funnel navigation
+ * useFunnel Hook - Access funnel state and navigation methods
  *
- * Modern implementation using TanStack Query for state management
- * and the v2 ApiClient for API calls.
+ * This hook consumes the funnel state from TagadaProvider. All complex
+ * initialization and session management is handled at the provider level.
+ *
+ * Usage:
+ * ```tsx
+ * // In your root component or layout:
+ * <TagadaProvider funnelId="funnelv2_xxx" autoInitializeFunnel={true}>
+ *   <YourApp />
+ * </TagadaProvider>
+ *
+ * // In any child component:
+ * const { context, next, isLoading } = useFunnel();
+ * ```
  */
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { FunnelActionType, FunnelResource } from '../../core/resources/funnel';
 import { useTagadaContext } from '../providers/TagadaProvider';
-import { getGlobalApiClient } from './useApiQuery';
-// Query keys for funnel operations
-const funnelQueryKeys = {
-    session: (sessionId) => ['funnel', 'session', sessionId],
-    context: (sessionId) => ['funnel', 'context', sessionId],
-};
 /**
- * React Hook for Funnel Navigation (Plugin SDK v2)
+ * Hook to access funnel state and methods
  *
- * Modern funnel navigation using TanStack Query for state management
- * and the v2 ApiClient architecture.
- */
-export function useFunnel(options = {}) {
-    const { auth, store, debugMode, updateFunnelDebugData } = useTagadaContext();
-    const queryClient = useQueryClient();
-    const apiClient = getGlobalApiClient();
-    const funnelResource = useMemo(() => new FunnelResource(apiClient), [apiClient]);
-    // Local state
-    const [context, setContext] = useState(null);
-    const [initializationAttempted, setInitializationAttempted] = useState(false);
-    const [initializationError, setInitializationError] = useState(null);
-    // Track the last processed URL funnelId to avoid re-processing on context changes
-    const lastProcessedUrlFunnelIdRef = useRef(undefined);
-    // Check if we have an existing session in cookies (to avoid unnecessary re-initialization)
-    const hasExistingSessionCookie = useMemo(() => {
-        if (typeof document === 'undefined')
-            return false;
-        const funnelSessionCookie = document.cookie
-            .split('; ')
-            .find(row => row.startsWith('tgd-funnel-session-id='));
-        return !!funnelSessionCookie;
-    }, []); // Only check once on mount
-    const currentStepId = options.currentStepId || context?.currentStepId;
-    // Check for URL parameter overrides - recalculate on every render to detect URL changes
-    // This is cheap and ensures we always have the latest URL params
-    const [currentUrl, setCurrentUrl] = useState(() => typeof window !== 'undefined' ? window.location.href : '');
-    // Listen for URL changes (navigation)
-    useEffect(() => {
-        if (typeof window === 'undefined')
-            return;
-        const updateUrl = () => {
-            setCurrentUrl(window.location.href);
-        };
-        // Listen for popstate (back/forward buttons) and pushState/replaceState
-        window.addEventListener('popstate', updateUrl);
-        // Also update on any navigation
-        const originalPushState = window.history.pushState;
-        const originalReplaceState = window.history.replaceState;
-        window.history.pushState = function (...args) {
-            originalPushState.apply(window.history, args);
-            updateUrl();
-        };
-        window.history.replaceState = function (...args) {
-            originalReplaceState.apply(window.history, args);
-            updateUrl();
-        };
-        return () => {
-            window.removeEventListener('popstate', updateUrl);
-            window.history.pushState = originalPushState;
-            window.history.replaceState = originalReplaceState;
-        };
-    }, []);
-    const urlFunnelId = useMemo(() => {
-        if (typeof window === 'undefined')
-            return undefined;
-        const params = new URLSearchParams(window.location.search);
-        return params.get('funnelId') || undefined;
-    }, [currentUrl]); // Re-compute when URL changes
-    const effectiveFunnelId = urlFunnelId || options.funnelId;
-    /**
-     * Fetch debug data for the funnel debugger
-     */
-    const fetchFunnelDebugData = useCallback(async (sessionId) => {
-        if (!debugMode) {
-            console.log('🐛 [useFunnel V2] Debug mode is OFF, skipping debug data fetch');
-            return;
-        }
-        console.log('🐛 [useFunnel V2] Fetching debug data for session:', sessionId);
-        try {
-            const response = await funnelResource.getSession(sessionId, undefined, true);
-            console.log('🐛 [useFunnel V2] Debug data response:', response);
-            if (response.success && response.debugData) {
-                updateFunnelDebugData(response.debugData, null, false);
-                console.log('🐛 [useFunnel V2] Debug data updated successfully:', response.debugData);
-            }
-            else {
-                console.warn('🐛 [useFunnel V2] No debug data in response');
-            }
-        }
-        catch (error) {
-            console.error('🐛 [useFunnel V2] Failed to fetch funnel debug data:', error);
-        }
-    }, [funnelResource, debugMode, updateFunnelDebugData]);
-    // Session query - only enabled when we have a session ID
-    const { data: sessionData, isLoading: isSessionLoading, error: sessionError, refetch: refetchSession } = useQuery({
-        queryKey: funnelQueryKeys.session(context?.sessionId || ''),
-        queryFn: async () => {
-            if (!context?.sessionId) {
-                console.warn('🍪 Funnel: No session ID available for query');
-                return null;
-            }
-            console.log(`🍪 Funnel: Fetching session data for ID: ${context.sessionId}`);
-            const response = await funnelResource.getSession(context.sessionId);
-            console.log(`🍪 Funnel: Session fetch response:`, response);
-            if (response.success && response.context) {
-                return response.context;
-            }
-            throw new Error(response.error || 'Failed to fetch session');
-        },
-        enabled: !!context?.sessionId && (options.enabled !== false),
-        staleTime: 30000, // 30 seconds
-        gcTime: 5 * 60 * 1000, // 5 minutes
-        refetchOnWindowFocus: false,
-    });
-    // Initialize session mutation
-    const initializeMutation = useMutation({
-        mutationFn: async (entryStepId) => {
-            if (!auth.session?.customerId || !store?.id) {
-                throw new Error('Authentication required for funnel session');
-            }
-            // Get CURRENT URL params (not cached) to ensure we have latest values
-            const currentUrlParams = typeof window !== 'undefined'
-                ? new URLSearchParams(window.location.search)
-                : new URLSearchParams();
-            const currentUrlFunnelId = currentUrlParams.get('funnelId') || undefined;
-            const currentEffectiveFunnelId = currentUrlFunnelId || options.funnelId;
-            // Check for existing session ID in URL parameters
-            let existingSessionId = currentUrlParams.get('funnelSessionId') || undefined;
-            if (existingSessionId) {
-                console.log(`🍪 Funnel: Found session ID in URL params: ${existingSessionId}`);
-            }
-            else {
-                // Fallback to cookie for same-domain scenarios
-                const funnelSessionCookie = document.cookie
-                    .split('; ')
-                    .find(row => row.startsWith('tgd-funnel-session-id='));
-                existingSessionId = funnelSessionCookie ? funnelSessionCookie.split('=')[1] : undefined;
-                if (existingSessionId) {
-                    console.log(`🍪 Funnel: Found existing session in cookie: ${existingSessionId}`);
-                }
-            }
-            // Log initialization strategy
-            console.log(`🍪 Funnel: Initialize request:`);
-            console.log(`   - Existing session ID: ${existingSessionId || 'none'}`);
-            console.log(`   - URL funnelId: ${currentUrlFunnelId || 'none'}`);
-            console.log(`   - Hook funnelId: ${options.funnelId || 'none'}`);
-            console.log(`   - Effective funnelId to send: ${currentEffectiveFunnelId || 'none (will use existing or backend default)'}`);
-            if (existingSessionId && !currentEffectiveFunnelId) {
-                console.log(`   → Strategy: REUSE existing session from cookie`);
-            }
-            else if (existingSessionId && currentEffectiveFunnelId) {
-                console.log(`   → Strategy: VALIDATE existing session matches funnelId, or create new`);
-            }
-            else {
-                console.log(`   → Strategy: CREATE new session`);
-            }
-            // Send minimal CMS session data
-            const cmsSessionData = {
-                customerId: auth.session.customerId,
-                storeId: store.id,
-                sessionId: auth.session.sessionId,
-                accountId: auth.session.accountId
-            };
-            // Get current URL for session synchronization
-            const currentUrl = typeof window !== 'undefined' ? window.location.href : undefined;
-            // Call API to initialize session - backend will restore existing or create new
-            const requestBody = {
-                cmsSession: cmsSessionData,
-                entryStepId, // Optional override
-                existingSessionId, // Pass existing session ID from URL or cookie
-                currentUrl // Include current URL for step tracking
-            };
-            // Only include funnelId if it's provided (for backend fallback)
-            if (currentEffectiveFunnelId) {
-                requestBody.funnelId = currentEffectiveFunnelId;
-            }
-            console.log(`📤 Funnel: Sending initialize request to backend:`);
-            console.log(`   Request body:`, JSON.stringify({
-                ...requestBody,
-                cmsSession: { ...cmsSessionData, sessionId: `${cmsSessionData.sessionId.substring(0, 20)}...` }
-            }, null, 2));
-            const response = await funnelResource.initialize(requestBody);
-            console.log(`📥 Funnel: Received response from backend:`);
-            console.log(`   Success: ${response.success}`);
-            if (response.context) {
-                console.log(`   Returned session ID: ${response.context.sessionId}`);
-                console.log(`   Returned funnel ID: ${response.context.funnelId}`);
-                console.log(`   Is same session? ${response.context.sessionId === existingSessionId ? '✅ YES (reused)' : '❌ NO (new session created)'}`);
-            }
-            if (response.error) {
-                console.log(`   Error: ${response.error}`);
-            }
-            if (response.success && response.context) {
-                return response.context;
-            }
-            else {
-                throw new Error(response.error || 'Failed to initialize funnel session');
-            }
-        },
-        onSuccess: (newContext) => {
-            setContext(newContext);
-            setInitializationError(null);
-            // Set session cookie for persistence across page reloads
-            setSessionCookie(newContext.sessionId);
-            console.log(`✅ Funnel: Session initialized/loaded successfully`);
-            console.log(`   - Session ID: ${newContext.sessionId}`);
-            console.log(`   - Funnel ID: ${newContext.funnelId}`);
-            console.log(`   - Current Step: ${newContext.currentStepId}`);
-            // Fetch debug data if in debug mode
-            if (debugMode) {
-                void fetchFunnelDebugData(newContext.sessionId);
-            }
-            // Invalidate session query to refetch with new session ID
-            void queryClient.invalidateQueries({
-                queryKey: funnelQueryKeys.session(newContext.sessionId)
-            });
-        },
-        onError: (error) => {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            setInitializationError(errorObj);
-            console.error('Error initializing funnel session:', error);
-            if (options.onError) {
-                options.onError(errorObj);
-            }
-        }
-    });
-    // Navigate mutation
-    const navigateMutation = useMutation({
-        mutationFn: async (event) => {
-            if (!context) {
-                throw new Error('Funnel session not initialized');
-            }
-            if (!context.sessionId) {
-                throw new Error('Funnel session ID missing - session may be corrupted');
-            }
-            // ✅ Automatically include currentUrl for URL-to-Step mapping
-            // User can override by providing event.currentUrl explicitly
-            const currentUrl = event.currentUrl || (typeof window !== 'undefined' ? window.location.href : undefined);
-            console.log(`🍪 Funnel: Navigating with session ID: ${context.sessionId}`);
-            if (currentUrl) {
-                console.log(`🍪 Funnel: Current URL for sync: ${currentUrl}`);
-            }
-            const requestBody = {
-                sessionId: context.sessionId,
-                event: {
-                    type: event.type,
-                    data: event.data,
-                    timestamp: event.timestamp || new Date().toISOString(),
-                    currentUrl: event.currentUrl // Preserve user override if provided
-                },
-                contextUpdates: {
-                    lastActivityAt: Date.now()
-                },
-                currentUrl, // ✅ Send to backend for URL→Step mapping
-                funnelId: effectiveFunnelId || options.funnelId // ✅ Send for session recovery
-            };
-            const response = await funnelResource.navigate(requestBody);
-            if (response.success && response.result) {
-                return response.result;
-            }
-            else {
-                throw new Error(response.error || 'Navigation failed');
-            }
-        },
-        onSuccess: (result) => {
-            if (!context)
-                return;
-            // 🔄 Handle session recovery (if backend created a new session)
-            let recoveredSessionId;
-            if (result.sessionId && result.sessionId !== context.sessionId) {
-                console.warn(`🔄 Funnel: Session recovered! Old: ${context.sessionId}, New: ${result.sessionId}`);
-                recoveredSessionId = result.sessionId;
-            }
-            // Update local context
-            const newContext = {
-                ...context,
-                sessionId: recoveredSessionId || context.sessionId, // ✅ Use recovered session ID if provided
-                currentStepId: result.stepId,
-                previousStepId: context.currentStepId,
-                lastActivityAt: Date.now(),
-                metadata: {
-                    ...context.metadata,
-                    lastEvent: 'navigation',
-                    lastTransition: new Date().toISOString(),
-                    ...(recoveredSessionId ? { recovered: true, oldSessionId: context.sessionId } : {})
-                }
-            };
-            setContext(newContext);
-            // Update cookie with new session ID if recovered
-            if (recoveredSessionId) {
-                document.cookie = `funnelSessionId=${recoveredSessionId}; path=/; max-age=86400; SameSite=Lax`;
-                console.log(`🍪 Funnel: Updated cookie with recovered session ID: ${recoveredSessionId}`);
-            }
-            // Create typed navigation result
-            const navigationResult = {
-                stepId: result.stepId,
-                action: {
-                    type: 'redirect', // Default action type
-                    url: result.url
-                },
-                context: newContext,
-                tracking: result.tracking
-            };
-            // Handle navigation callback with override capability
-            let shouldPerformDefaultNavigation = true;
-            if (options.onNavigate) {
-                const callbackResult = options.onNavigate(navigationResult);
-                if (callbackResult === false) {
-                    shouldPerformDefaultNavigation = false;
-                }
-            }
-            // Perform default navigation if not overridden
-            if (shouldPerformDefaultNavigation && navigationResult.action.url) {
-                // Add URL parameters for cross-domain session continuity
-                const urlWithParams = addSessionParams(navigationResult.action.url, newContext.sessionId, effectiveFunnelId || options.funnelId);
-                const updatedAction = { ...navigationResult.action, url: urlWithParams };
-                performNavigation(updatedAction);
-            }
-            console.log(`🍪 Funnel: Navigated from ${context.currentStepId} to ${result.stepId}`);
-            // Fetch debug data if in debug mode
-            if (debugMode) {
-                void fetchFunnelDebugData(newContext.sessionId);
-            }
-            // Invalidate and refetch session data
-            void queryClient.invalidateQueries({
-                queryKey: funnelQueryKeys.session(newContext.sessionId)
-            });
-        },
-        onError: (error) => {
-            console.error('Funnel navigation error:', error);
-            if (options.onError) {
-                options.onError(error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-    });
-    // Update context mutation
-    const updateContextMutation = useMutation({
-        mutationFn: async (updates) => {
-            if (!context) {
-                throw new Error('Funnel session not initialized');
-            }
-            const requestBody = {
-                contextUpdates: updates
-            };
-            const response = await funnelResource.updateContext(context.sessionId, requestBody);
-            if (response.success) {
-                return updates;
-            }
-            else {
-                throw new Error(response.error || 'Context update failed');
-            }
-        },
-        onSuccess: (updates) => {
-            if (!context)
-                return;
-            const updatedContext = {
-                ...context,
-                ...updates,
-                lastActivityAt: Date.now()
-            };
-            setContext(updatedContext);
-            console.log(`🍪 Funnel: Updated context for step ${context.currentStepId}`);
-            // Invalidate session query
-            void queryClient.invalidateQueries({
-                queryKey: funnelQueryKeys.session(context.sessionId)
-            });
-        },
-        onError: (error) => {
-            console.error('Error updating funnel context:', error);
-            if (options.onError) {
-                options.onError(error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-    });
-    // End session mutation
-    const endSessionMutation = useMutation({
-        mutationFn: async () => {
-            if (!context)
-                return;
-            await funnelResource.endSession(context.sessionId);
-        },
-        onSuccess: () => {
-            if (!context)
-                return;
-            console.log(`🍪 Funnel: Ended session ${context.sessionId}`);
-            setContext(null);
-            // Reset the processed URL funnelId ref to allow re-initialization
-            lastProcessedUrlFunnelIdRef.current = undefined;
-            // Clear queries
-            queryClient.removeQueries({
-                queryKey: funnelQueryKeys.session(context.sessionId)
-            });
-        },
-        onError: (error) => {
-            console.error('Error ending funnel session:', error);
-            // Don't throw here - session ending is best effort
-        }
-    });
-    /**
-     * Set funnel session cookie
-     */
-    const setSessionCookie = useCallback((sessionId) => {
-        const maxAge = 24 * 60 * 60; // 24 hours
-        const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
-        // Set cookie for same-domain scenarios
-        document.cookie = `tgd-funnel-session-id=${sessionId}; path=/; expires=${expires}; SameSite=Lax`;
-        console.log(`🍪 Funnel: Set session cookie: ${sessionId}`);
-    }, []);
-    /**
-     * Add session parameters to URL for cross-domain continuity
-     */
-    const addSessionParams = useCallback((url, sessionId, funnelId) => {
-        try {
-            const urlObj = new URL(url);
-            urlObj.searchParams.set('funnelSessionId', sessionId);
-            if (funnelId) {
-                urlObj.searchParams.set('funnelId', funnelId);
-            }
-            const urlWithParams = urlObj.toString();
-            console.log(`🍪 Funnel: Added session params to URL: ${url} → ${urlWithParams}`);
-            return urlWithParams;
-        }
-        catch (error) {
-            console.warn('Failed to add session params to URL:', error);
-            return url; // Return original URL if parsing fails
-        }
-    }, []);
-    /**
-     * Perform navigation based on action type
-     */
-    const performNavigation = useCallback((action) => {
-        if (!action.url)
-            return;
-        // Handle relative URLs by making them absolute
-        let targetUrl = action.url;
-        if (targetUrl.startsWith('/') && !targetUrl.startsWith('//')) {
-            // Relative URL - use current origin
-            targetUrl = window.location.origin + targetUrl;
-        }
-        switch (action.type) {
-            case 'redirect':
-                console.log(`🍪 Funnel: Redirecting to ${targetUrl}`);
-                window.location.href = targetUrl;
-                break;
-            case 'replace':
-                console.log(`🍪 Funnel: Replacing current page with ${targetUrl}`);
-                window.location.replace(targetUrl);
-                break;
-            case 'push':
-                console.log(`🍪 Funnel: Pushing to history: ${targetUrl}`);
-                window.history.pushState({}, '', targetUrl);
-                // Trigger a popstate event to update React Router
-                window.dispatchEvent(new PopStateEvent('popstate'));
-                break;
-            case 'external':
-                console.log(`🍪 Funnel: Opening external URL: ${targetUrl}`);
-                window.open(targetUrl, '_blank');
-                break;
-            case 'none':
-                console.log(`🍪 Funnel: No navigation action required`);
-                break;
-            default:
-                console.warn(`🍪 Funnel: Unknown navigation action type: ${action.type}`);
-                break;
-        }
-    }, []);
-    // Public API methods
-    const initializeSession = useCallback(async (entryStepId) => {
-        setInitializationAttempted(true);
-        await initializeMutation.mutateAsync(entryStepId);
-    }, [initializeMutation]);
-    const next = useCallback(async (event) => {
-        return navigateMutation.mutateAsync(event);
-    }, [navigateMutation]);
-    const goToStep = useCallback(async (stepId) => {
-        return next({
-            type: FunnelActionType.DIRECT_NAVIGATION,
-            data: { targetStepId: stepId },
-            timestamp: new Date().toISOString()
-        });
-    }, [next]);
-    const updateContext = useCallback(async (updates) => {
-        await updateContextMutation.mutateAsync(updates);
-    }, [updateContextMutation]);
-    const endSession = useCallback(async () => {
-        await endSessionMutation.mutateAsync();
-    }, [endSessionMutation]);
-    const retryInitialization = useCallback(async () => {
-        setInitializationAttempted(false);
-        setInitializationError(null);
-        await initializeSession();
-    }, [initializeSession]);
-    /**
-     * Auto-initialization effect
-     *
-     * Handles funnel session initialization with the following logic:
-     * 1. If no session exists => Initialize with URL funnelId or hook funnelId or backend default
-     * 2. If session exists + explicit funnelId provided that differs => Reset and create new
-     * 3. If session exists + no funnelId provided => Keep existing session
-     *
-     * IMPORTANT: Only resets session if an EXPLICIT funnelId is provided that differs
-     * from the current session. If no funnelId is provided, keeps the existing session.
-     *
-     * Priority: URL funnelId > Hook funnelId > Existing session funnelId > Backend default
-     */
-    useEffect(() => {
-        console.log('🔍 Funnel: Auto-init effect triggered');
-        console.log(`   - autoInitialize: ${options.autoInitialize ?? true}`);
-        console.log(`   - hasAuth: ${!!auth.session?.customerId}`);
-        console.log(`   - hasStore: ${!!store?.id}`);
-        console.log(`   - isPending: ${initializeMutation.isPending}`);
-        console.log(`   - hasContext: ${!!context}`);
-        console.log(`   - context.sessionId: ${context?.sessionId || 'none'}`);
-        console.log(`   - context.funnelId: ${context?.funnelId || 'none'}`);
-        console.log(`   - urlFunnelId: ${urlFunnelId || 'none'}`);
-        console.log(`   - options.funnelId: ${options.funnelId || 'none'}`);
-        console.log(`   - initializationAttempted: ${initializationAttempted}`);
-        console.log(`   - hasExistingSessionCookie: ${hasExistingSessionCookie}`);
-        // Skip if auto-initialize is disabled
-        const autoInit = options.autoInitialize ?? true; // Default to true
-        if (!autoInit) {
-            console.log('⏭️  Funnel: Skipping - auto-initialize disabled');
-            return;
-        }
-        // Skip if required dependencies are not available
-        if (!auth.session?.customerId || !store?.id) {
-            console.log('⏭️  Funnel: Skipping - missing auth or store');
-            return;
-        }
-        // Skip if already initializing
-        if (initializeMutation.isPending) {
-            console.log('⏭️  Funnel: Skipping - already initializing');
-            return;
-        }
-        // Determine if we have an explicit funnelId request (URL has priority)
-        const explicitFunnelId = urlFunnelId || options.funnelId;
-        console.log(`   - explicitFunnelId: ${explicitFunnelId || 'none'}`);
-        // Case 1: No session exists yet - need to initialize
-        if (!context) {
-            console.log('📍 Funnel: Case 1 - No context exists');
-            // Check if we've already attempted initialization
-            if (!initializationAttempted) {
-                if (hasExistingSessionCookie) {
-                    console.log('🍪 Funnel: Loading existing session from cookie...');
-                }
-                else {
-                    console.log('🍪 Funnel: No session found - creating new session...');
-                }
-                if (explicitFunnelId) {
-                    console.log(`   with funnelId: ${explicitFunnelId}`);
-                }
-                setInitializationAttempted(true);
-                initializeSession().catch(error => {
-                    console.error('❌ Funnel: Auto-initialization failed:', error);
-                });
-            }
-            else {
-                console.log('⏭️  Funnel: Skipping - already attempted initialization');
-            }
-            return;
-        }
-        console.log('📍 Funnel: Case 2 - Context exists, checking for reset needs');
-        // Case 2: Session exists - check if we need to reset it
-        // ONLY reset if an explicit funnelId is provided AND it differs from current session
-        if (explicitFunnelId && context.funnelId && explicitFunnelId !== context.funnelId) {
-            console.log(`🔍 Funnel: Mismatch check - explicitFunnelId: ${explicitFunnelId}, context.funnelId: ${context.funnelId}`);
-            // Check if we've already processed this funnelId to prevent loops
-            if (lastProcessedUrlFunnelIdRef.current === explicitFunnelId) {
-                console.log('⏭️  Funnel: Skipping - already processed this funnelId');
-                return;
-            }
-            console.log(`🔄 Funnel: Explicit funnelId mismatch detected!`);
-            console.log(`   Current session funnelId: ${context.funnelId}`);
-            console.log(`   Requested funnelId: ${explicitFunnelId}`);
-            console.log(`   Resetting session...`);
-            // Mark this funnelId as processed
-            lastProcessedUrlFunnelIdRef.current = explicitFunnelId;
-            // Clear existing session
-            setContext(null);
-            setInitializationAttempted(false);
-            setInitializationError(null);
-            // Clear session cookie
-            document.cookie = 'tgd-funnel-session-id=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax';
-            // Clear queries for old session
-            queryClient.removeQueries({
-                queryKey: funnelQueryKeys.session(context.sessionId)
-            });
-            // Initialize new session with correct funnelId
-            console.log(`🍪 Funnel: Creating new session with funnelId: ${explicitFunnelId}`);
-            initializeSession().catch(error => {
-                console.error('❌ Funnel: Failed to reset session:', error);
-            });
-        }
-        else {
-            // Case 3: Session exists and no conflicting funnelId - keep using it
-            console.log('✅ Funnel: Case 3 - Keeping existing session (no reset needed)');
-            console.log(`   - explicitFunnelId: ${explicitFunnelId || 'none (will keep existing)'}`);
-            console.log(`   - context.funnelId: ${context.funnelId}`);
-            console.log(`   - Match or no explicit request: keeping session ${context.sessionId}`);
-        }
-    }, [
-        options.autoInitialize,
-        options.funnelId,
-        urlFunnelId,
-        context?.funnelId,
-        context?.sessionId,
-        initializationAttempted,
-        auth.session?.customerId,
-        store?.id,
-        initializeMutation.isPending,
-        initializeSession,
-        hasExistingSessionCookie,
-        queryClient
-    ]);
-    // Sync session data from query to local state
-    useEffect(() => {
-        if (sessionData && sessionData !== context) {
-            setContext(sessionData);
-        }
-    }, [sessionData, context]);
-    const isLoading = initializeMutation.isPending || navigateMutation.isPending || updateContextMutation.isPending;
-    const isInitialized = !!context;
-    return {
-        next,
-        goToStep,
-        updateContext,
-        currentStep: {
-            id: currentStepId || 'unknown'
-        },
-        context,
-        isLoading,
-        isInitialized,
-        initializeSession,
-        endSession,
-        retryInitialization,
-        initializationError,
-        isSessionLoading,
-        sessionError,
-        refetch: () => void refetchSession()
-    };
-}
-/**
- * Simplified funnel hook for basic step tracking (v2)
+ * This hook simply returns the funnel state from TagadaProvider.
+ * All complex logic is handled at the provider level.
+ *
+ * @returns FunnelContextValue with state and methods
  */
-export function useSimpleFunnel(funnelId, initialStepId) {
-    const funnel = useFunnel({
-        funnelId,
-        currentStepId: initialStepId,
-        autoInitialize: true
-    });
-    return {
-        currentStepId: funnel.currentStep.id,
-        next: funnel.next,
-        goToStep: funnel.goToStep,
-        isLoading: funnel.isLoading,
-        context: funnel.context
-    };
+export function useFunnel() {
+    const { funnel } = useTagadaContext();
+    return funnel;
 }