@tagadapay/plugin-sdk 2.6.10 → 2.6.12

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

@@ -0,0 +1,71 @@
+import React, { ReactNode } from 'react';
+import { CheckoutData } from './useCheckout';
+export interface Address {
+    address1: string;
+    address2?: string;
+    lastName?: string;
+    firstName?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    postal?: string;
+    phone?: string;
+    email?: string;
+}
+type PaymentMethod = {
+    id: string;
+    type: string;
+    title: string;
+    iconUrl: string;
+    default: boolean;
+    metadata?: Record<string, unknown>;
+};
+type ExpressOrderLineItem = {
+    label: string;
+    amount: string;
+};
+type ExpressShippingMethod = {
+    label: string;
+    amount: string;
+    identifier: string;
+    detail: string;
+};
+export interface ExpressPaymentContextType {
+    applePayPaymentMethod?: PaymentMethod;
+    googlePayPaymentMethod?: PaymentMethod;
+    reComputeOrderSummary: () => Promise<{
+        lineItems: ExpressOrderLineItem[];
+        total: {
+            label: string;
+            amount: string;
+        };
+        shippingMethods: ExpressShippingMethod[];
+    } | undefined>;
+    loading?: boolean;
+    availableExpressPaymentMethodIds: string[];
+    setAvailableExpressPaymentMethodIds: (value: string[]) => void;
+    shippingMethods: ExpressShippingMethod[];
+    lineItems: ExpressOrderLineItem[];
+    handleAddExpressId: (id: string) => void;
+    updateCheckoutSessionValues: (input: {
+        data: {
+            shippingAddress: Address;
+            billingAddress?: Address | null;
+        };
+    }) => Promise<void>;
+    updateCustomerEmail: (input: {
+        data: {
+            email: string;
+        };
+    }) => Promise<void>;
+    error: string | null;
+    setError: (error: string | null) => void;
+}
+interface ExpressPaymentProviderProps {
+    children: ReactNode;
+    customerId?: string;
+    checkout?: CheckoutData;
+}
+export declare const ExpressPaymentProvider: React.FC<ExpressPaymentProviderProps>;
+export declare const useExpressPayment: () => ExpressPaymentContextType;
+export {};

package/dist/react/hooks/useExpressPayment.js

@@ -0,0 +1,158 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useCallback, useContext, useMemo, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { useOrderSummary } from './useOrderSummary';
+import { useShippingRates } from './useShippingRates';
+const ExpressPaymentContext = createContext(undefined);
+export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
+    const { apiService } = useTagadaContext();
+    const [availableExpressPaymentMethodIds, setAvailableExpressPaymentMethodIds] = useState([]);
+    const [error, setError] = useState(null);
+    const [paymentMethods, setPaymentMethods] = useState(null);
+    const [isLoadingPaymentMethods, setIsLoadingPaymentMethods] = useState(false);
+    const checkoutSessionId = checkout?.checkoutSession.id;
+    // Fetch enabled payment methods for this checkout session
+    React.useEffect(() => {
+        let mounted = true;
+        const fetchPaymentMethods = async () => {
+            try {
+                if (!checkoutSessionId)
+                    return;
+                setIsLoadingPaymentMethods(true);
+                const response = await apiService.fetch(`/api/v1/payment-methods?checkoutSessionId=${encodeURIComponent(checkoutSessionId)}`);
+                if (mounted)
+                    setPaymentMethods(response);
+            }
+            catch (e) {
+                if (mounted)
+                    setPaymentMethods([]);
+            }
+            finally {
+                if (mounted)
+                    setIsLoadingPaymentMethods(false);
+            }
+        };
+        if (checkout)
+            void fetchPaymentMethods();
+        return () => {
+            mounted = false;
+        };
+    }, [apiService, checkoutSessionId]);
+    const handleAddExpressId = (id) => {
+        setAvailableExpressPaymentMethodIds((prev) => (prev.includes(id) ? prev : [...prev, id]));
+    };
+    // Base data hooks
+    const { orderSummary, isLoading: isLoadingOrderSummary, isRefetching: isRefetchingOrderSummary, refetch: refetchOrderSummary, } = useOrderSummary({ sessionId: checkoutSessionId });
+    const { shippingRates, refetch: refetchRates } = useShippingRates({ checkout });
+    const minorUnitsToCurrencyString = (amountMinor, currency) => {
+        if (!amountMinor || !currency)
+            return '0.00';
+        return (amountMinor / 100).toFixed(2);
+    };
+    const shippingMethods = useMemo(() => (shippingRates || []).map((rate) => ({
+        label: rate.shippingRateName,
+        amount: minorUnitsToCurrencyString(rate.amount, rate.currency),
+        identifier: rate.id,
+        detail: rate.description || '',
+    })), [shippingRates]);
+    const lineItems = useMemo(() => [
+        {
+            label: 'Subtotal',
+            amount: minorUnitsToCurrencyString(orderSummary?.subtotalAdjustedAmount, orderSummary?.currency),
+        },
+        {
+            label: 'Shipping',
+            amount: minorUnitsToCurrencyString(orderSummary?.shippingCost ?? 0, orderSummary?.currency),
+        },
+        {
+            label: 'Tax',
+            amount: minorUnitsToCurrencyString(orderSummary?.totalTaxAmount, orderSummary?.currency),
+        },
+    ], [
+        orderSummary?.subtotalAdjustedAmount,
+        orderSummary?.shippingCost,
+        orderSummary?.totalTaxAmount,
+        orderSummary?.currency,
+    ]);
+    const reComputeOrderSummary = useCallback(async () => {
+        try {
+            await refetchOrderSummary();
+            await refetchRates();
+            if (!orderSummary || !shippingRates)
+                return;
+            const recomputedLineItems = [
+                {
+                    label: 'Subtotal',
+                    amount: minorUnitsToCurrencyString(orderSummary.subtotalAdjustedAmount, orderSummary.currency),
+                },
+                {
+                    label: 'Shipping',
+                    amount: minorUnitsToCurrencyString(orderSummary.shippingCost ?? 0, orderSummary.currency),
+                },
+                {
+                    label: 'Tax',
+                    amount: minorUnitsToCurrencyString(orderSummary.totalTaxAmount, orderSummary.currency),
+                },
+            ];
+            const total = {
+                label: 'Order Total',
+                amount: minorUnitsToCurrencyString(orderSummary.totalAdjustedAmount, orderSummary.currency),
+            };
+            const recomputedShippingMethods = (shippingRates || []).map((rate) => ({
+                label: rate.shippingRateName,
+                amount: minorUnitsToCurrencyString(rate.amount, rate.currency),
+                identifier: rate.id,
+                detail: rate.description || '',
+            }));
+            return {
+                lineItems: recomputedLineItems,
+                total,
+                shippingMethods: recomputedShippingMethods,
+            };
+        }
+        catch (e) {
+            return undefined;
+        }
+    }, [orderSummary, shippingRates, refetchOrderSummary, refetchRates]);
+    const updateCheckoutSessionValues = useCallback(async (input) => {
+        await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/address`, {
+            method: 'POST',
+            body: input,
+        });
+    }, [apiService, checkoutSessionId]);
+    const updateCustomerEmail = useCallback(async (input) => {
+        if (!customerId)
+            return;
+        await apiService.fetch(`/api/v1/customers/${customerId}`, {
+            method: 'POST',
+            body: input,
+        });
+    }, [apiService, customerId]);
+    const enabledApplePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'apple_pay'), [paymentMethods]);
+    const enabledGooglePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'google_pay'), [paymentMethods]);
+    const loading = !paymentMethods || isLoadingPaymentMethods || isLoadingOrderSummary;
+    const contextValue = {
+        availableExpressPaymentMethodIds,
+        setAvailableExpressPaymentMethodIds,
+        applePayPaymentMethod: enabledApplePayPaymentMethod,
+        googlePayPaymentMethod: enabledGooglePayPaymentMethod,
+        shippingMethods,
+        lineItems,
+        reComputeOrderSummary,
+        loading,
+        handleAddExpressId,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        error,
+        setError,
+    };
+    const hasAnyEnabled = Boolean(enabledApplePayPaymentMethod || enabledGooglePayPaymentMethod);
+    return (_jsx(ExpressPaymentContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
+};
+export const useExpressPayment = () => {
+    const context = useContext(ExpressPaymentContext);
+    if (context === undefined) {
+        throw new Error('useExpressPayment must be used within an ExpressPaymentProvider');
+    }
+    return context;
+};

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

@@ -0,0 +1,109 @@
+/**
+ * Funnel Resource - API client for funnel navigation and session management
+ */
+import { ApiClient } from './apiClient';
+export interface FunnelEvent {
+    type: string;
+    data?: any;
+    timestamp?: string;
+}
+export interface FunnelNavigationAction {
+    type: 'redirect' | 'replace' | 'push' | 'external' | 'none';
+    url?: string;
+    data?: any;
+}
+export interface FunnelNavigationResult {
+    stepId: string;
+    action: FunnelNavigationAction;
+    context: SimpleFunnelContext;
+    tracking?: {
+        from: string;
+        to: string;
+        event: string;
+        timestamp: string;
+    };
+}
+export interface SimpleFunnelContext {
+    customerId: string;
+    storeId: string;
+    sessionId: string;
+    funnelId: string;
+    currentStepId: string;
+    previousStepId?: string;
+    startedAt: number;
+    lastActivityAt: number;
+    metadata?: Record<string, any>;
+}
+export interface FunnelInitializeRequest {
+    cmsSession: {
+        customerId: string;
+        storeId: string;
+        sessionId: string;
+        accountId: string;
+    };
+    funnelId?: string;
+    entryStepId?: string;
+    existingSessionId?: string;
+}
+export interface FunnelInitializeResponse {
+    success: boolean;
+    context?: SimpleFunnelContext;
+    error?: string;
+}
+export interface FunnelNavigateRequest {
+    sessionId: string;
+    event: FunnelEvent;
+    contextUpdates?: Partial<SimpleFunnelContext>;
+}
+export interface FunnelNavigateResponse {
+    success: boolean;
+    result?: {
+        stepId: string;
+        url?: string;
+        tracking?: {
+            from: string;
+            to: string;
+            event: string;
+            timestamp: string;
+        };
+    };
+    error?: string;
+}
+export interface FunnelContextUpdateRequest {
+    contextUpdates: Partial<SimpleFunnelContext>;
+}
+export interface FunnelContextUpdateResponse {
+    success: boolean;
+    error?: string;
+}
+export declare class FunnelResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Initialize a funnel session
+     */
+    initialize(request: FunnelInitializeRequest): Promise<FunnelInitializeResponse>;
+    /**
+     * Navigate to next step in funnel
+     */
+    navigate(request: FunnelNavigateRequest): Promise<FunnelNavigateResponse>;
+    /**
+     * Update funnel context
+     */
+    updateContext(sessionId: string, request: FunnelContextUpdateRequest): Promise<FunnelContextUpdateResponse>;
+    /**
+     * End funnel session
+     */
+    endSession(sessionId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get funnel session by ID
+     */
+    getSession(sessionId: string): Promise<{
+        success: boolean;
+        context?: SimpleFunnelContext;
+        error?: string;
+    }>;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Funnel Resource - API client for funnel navigation and session management
+ */
+export class FunnelResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Initialize a funnel session
+     */
+    async initialize(request) {
+        return this.apiClient.post('/api/v1/funnel/initialize', request);
+    }
+    /**
+     * Navigate to next step in funnel
+     */
+    async navigate(request) {
+        return this.apiClient.post('/api/v1/funnel/navigate', request);
+    }
+    /**
+     * Update funnel context
+     */
+    async updateContext(sessionId, request) {
+        return this.apiClient.patch(`/api/v1/funnel/context/${sessionId}`, request);
+    }
+    /**
+     * End funnel session
+     */
+    async endSession(sessionId) {
+        return this.apiClient.delete(`/api/v1/funnel/session/${sessionId}`);
+    }
+    /**
+     * Get funnel session by ID
+     */
+    async getSession(sessionId) {
+        return this.apiClient.get(`/api/v1/funnel/session/${sessionId}`);
+    }
+}

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

@@ -15,3 +15,4 @@ export * from './shippingRates';
 export * from './storeConfig';
 export * from './threeds';
 export * from './vipOffers';
+export * from './funnel';

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

@@ -15,3 +15,4 @@ export * from './shippingRates';
 export * from './storeConfig';
 export * from './threeds';
 export * from './vipOffers';
+export * from './funnel';

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

@@ -4,6 +4,8 @@
  */
 import { ApiClient } from './apiClient';
 export interface StoreConfig {
+    brandLogo?: string;
+    favicon?: string;
     badges?: {
         url: string;
         title: string;

package/dist/v2/index.d.ts

@@ -20,4 +20,6 @@ export type { ShippingRate, ShippingRatesResponse } from './core/resources/shipp
 export type { ApplyDiscountResponse, Discount, DiscountCodeValidation, RemoveDiscountResponse } from './core/resources/discounts';
 export type { ToggleOrderBumpResponse, VipOffer, VipPreviewResponse } from './core/resources/vipOffers';
 export type { StoreConfig } from './core/resources/storeConfig';
-export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';
+export type { FunnelContextUpdateRequest, FunnelContextUpdateResponse, FunnelEvent, FunnelInitializeRequest, FunnelInitializeResponse, FunnelNavigateRequest, FunnelNavigateResponse, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from './core/resources/funnel';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscountQuery, useDiscounts, useExpressPaymentMethods, useFunnel, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useSimpleFunnel, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';
+export type { StoreDiscount } from './react';

package/dist/v2/index.js

@@ -12,4 +12,4 @@ export * from './core/utils/currency';
 export * from './core/utils/pluginConfig';
 export * from './core/utils/products';
 // React exports (hooks and components only, types are exported above)
-export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscountQuery, useDiscounts, useExpressPaymentMethods, useFunnel, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useSimpleFunnel, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';

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

@@ -0,0 +1,79 @@
+/**
+ * Single Discount Hook using TanStack Query
+ * Fetches a specific discount for a given store
+ */
+import { UseQueryResult } from '@tanstack/react-query';
+export interface StoreDiscountRuleAmount {
+    rate: number;
+    amount: number;
+    lock: boolean;
+    date: string;
+}
+export interface StoreDiscountRule {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    promotionId: string;
+    type: string;
+    productId: string | null;
+    minimumQuantity: number | null;
+    minimumAmount: Record<string, StoreDiscountRuleAmount> | null;
+    variantIds: string[] | null;
+}
+export interface StoreDiscountAction {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    promotionId: string;
+    type: string;
+    adjustmentAmount: number | null;
+    adjustmentPercentage: number | null;
+    adjustmentType: string | null;
+    freeShipping: boolean | null;
+    priceIdToAdd: string | null;
+    productIdToAdd: string | null;
+    variantIdToAdd: string | null;
+    subscriptionFreeTrialDuration: number | null;
+    subscriptionFreeTrialDurationType: string | null;
+    targetProductId: string | null;
+    targetVariantIds: string[] | null;
+    maxQuantityDiscounted: number | null;
+    appliesOnEachItem: boolean | null;
+}
+export interface StoreDiscount {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    storeId: string;
+    accountId: string;
+    name: string;
+    code: string;
+    automatic: boolean;
+    usageLimit: number | null;
+    usageCount: number;
+    startDate: string;
+    endDate: string | null;
+    enabled: boolean;
+    archived: boolean;
+    ruleOperator: string;
+    externalId: string | null;
+    combinesWithOrderLevelDiscounts: boolean;
+    combinesWithLineItemDiscounts: boolean;
+    combinesWithShippingDiscounts: boolean;
+    forceCombine: boolean;
+    isTemporary: boolean;
+    rules: StoreDiscountRule[];
+    actions: StoreDiscountAction[];
+}
+export interface UseDiscountQueryOptions {
+    storeId?: string;
+    discountId?: string;
+    enabled?: boolean;
+}
+export interface UseDiscountQueryResult<TData = StoreDiscount> {
+    discount: TData | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: UseQueryResult<TData>['refetch'];
+}
+export declare function useDiscountQuery<TData = StoreDiscount>(options: UseDiscountQueryOptions): UseDiscountQueryResult<TData>;

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

@@ -0,0 +1,24 @@
+/**
+ * Single Discount Hook using TanStack Query
+ * Fetches a specific discount for a given store
+ */
+import { useMemo } from 'react';
+import { useApiQuery } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useDiscountQuery(options) {
+    const { storeId: storeIdFromConfig } = usePluginConfig();
+    const { storeId = storeIdFromConfig, discountId, enabled = true } = options;
+    const key = useMemo(() => ['discount', storeId, discountId], [storeId, discountId]);
+    const url = useMemo(() => {
+        if (!storeId || !discountId)
+            return null;
+        return `/api/v1/stores/${storeId}/discounts/${discountId}`;
+    }, [storeId, discountId]);
+    const query = useApiQuery(key, url, { enabled });
+    return {
+        discount: query.data,
+        isLoading: query.isLoading,
+        error: query.error || null,
+        refetch: query.refetch,
+    };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * useFunnel Hook (v2) - TanStack Query-based funnel navigation
+ *
+ * Modern implementation using TanStack Query for state management
+ * and the v2 ApiClient for API calls.
+ */
+import { FunnelEvent, FunnelNavigationResult, SimpleFunnelContext } from '../../core/resources/funnel';
+export interface UseFunnelOptions {
+    funnelId?: string;
+    currentStepId?: string;
+    onNavigate?: (result: FunnelNavigationResult) => void | boolean;
+    onError?: (error: Error) => void;
+    autoInitialize?: boolean;
+    enabled?: boolean;
+}
+export interface UseFunnelResult {
+    next: (event: FunnelEvent) => Promise<any>;
+    goToStep: (stepId: string) => Promise<any>;
+    updateContext: (updates: Partial<SimpleFunnelContext>) => Promise<void>;
+    currentStep: {
+        id: string;
+    };
+    context: SimpleFunnelContext | null;
+    isLoading: boolean;
+    isInitialized: boolean;
+    initializeSession: (entryStepId?: string) => Promise<void>;
+    endSession: () => Promise<void>;
+    retryInitialization: () => Promise<void>;
+    initializationError: Error | null;
+    isSessionLoading: boolean;
+    sessionError: Error | null;
+    refetch: () => void;
+}
+/**
+ * React Hook for Funnel Navigation (Plugin SDK v2)
+ *
+ * Modern funnel navigation using TanStack Query for state management
+ * and the v2 ApiClient architecture.
+ */
+export declare function useFunnel(options: UseFunnelOptions): UseFunnelResult;
+/**
+ * Simplified funnel hook for basic step tracking (v2)
+ */
+export declare function useSimpleFunnel(funnelId: string, initialStepId?: string): {
+    currentStepId: string;
+    next: (event: FunnelEvent) => Promise<any>;
+    goToStep: (stepId: string) => Promise<any>;
+    isLoading: boolean;
+    context: SimpleFunnelContext | null;
+};
+export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from '../../core/resources/funnel';

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

@@ -0,0 +1,432 @@
+/**
+ * useFunnel Hook (v2) - TanStack Query-based funnel navigation
+ *
+ * Modern implementation using TanStack Query for state management
+ * and the v2 ApiClient for API calls.
+ */
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { FunnelResource } from '../../core/resources/funnel';
+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)
+ *
+ * Modern funnel navigation using TanStack Query for state management
+ * and the v2 ApiClient architecture.
+ */
+export function useFunnel(options) {
+    const { auth, store } = 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);
+    const currentStepId = options.currentStepId || context?.currentStepId;
+    // Check for URL parameter overrides
+    const urlParams = typeof window !== 'undefined' ? new URLSearchParams(window.location.search) : new URLSearchParams();
+    const urlFunnelId = urlParams.get('funnelId') || undefined;
+    const effectiveFunnelId = urlFunnelId || options.funnelId;
+    // 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');
+            }
+            // Check for existing session ID in URL parameters
+            let existingSessionId = urlParams.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 session in cookie: ${existingSessionId}`);
+                }
+            }
+            if (!existingSessionId) {
+                console.log(`🍪 Funnel: No existing session found in URL params or cookie`);
+            }
+            // Send minimal CMS session data
+            const cmsSessionData = {
+                customerId: auth.session.customerId,
+                storeId: store.id,
+                sessionId: auth.session.sessionId,
+                accountId: auth.session.accountId
+            };
+            // 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
+            };
+            // Only include funnelId if it's provided (for backend fallback)
+            if (effectiveFunnelId) {
+                requestBody.funnelId = effectiveFunnelId;
+            }
+            const response = await funnelResource.initialize(requestBody);
+            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: Initialized session for funnel ${effectiveFunnelId || 'default'}`, newContext);
+            // 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');
+            }
+            console.log(`🍪 Funnel: Navigating with session ID: ${context.sessionId}`);
+            const requestBody = {
+                sessionId: context.sessionId,
+                event: {
+                    type: event.type,
+                    data: event.data,
+                    timestamp: event.timestamp || new Date().toISOString()
+                },
+                contextUpdates: {
+                    lastActivityAt: Date.now()
+                }
+            };
+            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;
+            // Update local context
+            const newContext = {
+                ...context,
+                currentStepId: result.stepId,
+                previousStepId: context.currentStepId,
+                lastActivityAt: Date.now(),
+                metadata: {
+                    ...context.metadata,
+                    lastEvent: 'navigation',
+                    lastTransition: new Date().toISOString()
+                }
+            };
+            setContext(newContext);
+            // 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}`);
+            // 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);
+            // 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: '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-initialize if requested and not already initialized
+    useEffect(() => {
+        if (options.autoInitialize &&
+            !context &&
+            !initializationAttempted &&
+            !initializationError &&
+            auth.session?.customerId &&
+            store?.id &&
+            !initializeMutation.isPending) {
+            console.log('🍪 Funnel: Auto-initializing session...');
+            initializeSession().catch(error => {
+                console.error('Auto-initialization failed - will not retry:', error);
+            });
+        }
+    }, [
+        options.autoInitialize,
+        context,
+        initializationAttempted,
+        initializationError,
+        auth.session?.customerId,
+        store?.id,
+        initializeMutation.isPending,
+        initializeSession
+    ]);
+    // 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)
+ */
+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
+    };
+}

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

@@ -2,8 +2,8 @@
  * Order Hook using TanStack Query
  * Handles order creation and management with automatic caching
  */
+import { useMutation, useQuery } from '@tanstack/react-query';
 import { useMemo } from 'react';
-import { useQuery, useMutation } from '@tanstack/react-query';
 import { OrdersResource } from '../../core/resources/orders';
 import { getGlobalApiClient } from './useApiQuery';
 export function useOrderQuery(options = {}) {

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

@@ -2,7 +2,7 @@
  * Post Purchases Hook using TanStack Query
  * Handles post-purchase offers with automatic caching
  */
-import { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary, CheckoutSessionState, OrderSummary, CurrencyOptions } from '../../core/resources/postPurchases';
+import { CheckoutSessionState, CurrencyOptions, OrderSummary, PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary } from '../../core/resources/postPurchases';
 export interface UsePostPurchasesQueryOptions {
     orderId: string;
     enabled?: boolean;

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

@@ -2,8 +2,8 @@
  * Post Purchases Hook using TanStack Query
  * Handles post-purchase offers with automatic caching
  */
-import { useMemo, useEffect, useState, useCallback } from 'react';
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { PostPurchasesResource } from '../../core/resources/postPurchases';
 import { useTagadaContext } from '../providers/TagadaProvider';
 import { getGlobalApiClient } from './useApiQuery';

package/dist/v2/react/index.d.ts

@@ -15,6 +15,7 @@ export { usePluginConfig } from './hooks/usePluginConfig';
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
 export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
 export { useCurrency } from './hooks/useCurrency';
+export { useDiscountQuery } from './hooks/useDiscountQuery';
 export { useDiscountsQuery as useDiscounts } from './hooks/useDiscountsQuery';
 export { useOffersQuery as useOffers } from './hooks/useOffersQuery';
 export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
@@ -28,6 +29,7 @@ export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQue
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
+export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';
 export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
 export type { ExpressPaymentMethodsContextType, ExpressPaymentMethodsProviderProps } from './hooks/useExpressPaymentMethods';
 export type { ApplePayButtonProps } from './components/ApplePayButton';
@@ -37,7 +39,9 @@ export type { ExtractedAddress, GooglePlaceDetails, GooglePrediction, UseGoogleA
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
 export type { UsePluginConfigOptions, UsePluginConfigResult } from './hooks/usePluginConfig';
 export type { UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
+export type { StoreDiscount, UseDiscountQueryOptions as UseDiscountOptions, UseDiscountQueryResult as UseDiscountResult } from './hooks/useDiscountQuery';
 export type { UseDiscountsQueryOptions as UseDiscountsOptions, UseDiscountsQueryResult as UseDiscountsResult } from './hooks/useDiscountsQuery';
+export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext, UseFunnelOptions, UseFunnelResult } from './hooks/useFunnel';
 export type { UseOffersQueryOptions as UseOffersOptions, UseOffersQueryResult as UseOffersResult } from './hooks/useOffersQuery';
 export type { UseOrderBumpQueryOptions as UseOrderBumpOptions, UseOrderBumpQueryResult as UseOrderBumpResult } from './hooks/useOrderBumpQuery';
 export type { UseOrderQueryOptions as UseOrderOptions, UseOrderQueryResult as UseOrderResult } from './hooks/useOrderQuery';

package/dist/v2/react/index.js

@@ -19,6 +19,7 @@ export { usePluginConfig } from './hooks/usePluginConfig';
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
 export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
 export { useCurrency } from './hooks/useCurrency';
+export { useDiscountQuery } from './hooks/useDiscountQuery';
 export { useDiscountsQuery as useDiscounts } from './hooks/useDiscountsQuery';
 export { useOffersQuery as useOffers } from './hooks/useOffersQuery';
 export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
@@ -32,5 +33,7 @@ export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQue
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
+// Funnel hooks
+export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';
 // Re-export utilities from main react
 export { formatMoney } from '../../react/utils/money';

package/package.json

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