@tagadapay/plugin-sdk 3.1.12 → 3.1.24

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

@@ -150,6 +150,24 @@ export function usePostPurchasesQuery(options) {
                 });
                 // Fetch order summary with variant options
                 await fetchOrderSummary(offerId, sessionId);
+                // Detect Whop payment method for this checkout session
+                try {
+                    const paymentMethods = await postPurchasesResource.getPaymentMethods(sessionId);
+                    const isWhop = paymentMethods.some((m) => m.type === 'whop');
+                    if (isWhop) {
+                        setCheckoutSessions(prev => ({
+                            ...prev,
+                            [offerId]: {
+                                ...prev[offerId],
+                                isWhop: true,
+                            }
+                        }));
+                    }
+                }
+                catch (err) {
+                    // Non-critical: if payment methods fetch fails, fall back to standard flow
+                    console.warn(`[SDK] Failed to detect payment methods for offer ${offerId}:`, err);
+                }
             }
             finally {
                 // Remove from initializing set
@@ -421,8 +439,22 @@ export function usePostPurchasesQuery(options) {
             if (!sessionState?.checkoutSessionId) {
                 throw new Error('Checkout session not initialized for this offer');
             }
-            // Use the enhanced payWithCheckoutSession with proper metadata
-            await postPurchasesResource.payWithCheckoutSession(sessionState.checkoutSessionId, orderId);
+            if (sessionState.isWhop) {
+                // Whop post-purchase: charge using the stored payment method from the original order
+                const storeId = session?.storeId;
+                if (!storeId) {
+                    throw new Error('Store ID not available for Whop payment');
+                }
+                await postPurchasesResource.chargeWhopPostPurchase({
+                    checkoutSessionId: sessionState.checkoutSessionId,
+                    orderId,
+                    storeId,
+                });
+            }
+            else {
+                // Standard post-purchase: use the generic pay endpoint
+                await postPurchasesResource.payWithCheckoutSession(sessionState.checkoutSessionId, orderId);
+            }
         },
     };
 }

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

@@ -1,9 +1,6 @@
 /**
- * Hook to extract URL parameters that works with both remapped and non-remapped paths
- *
- * This hook automatically detects if the current path is remapped and extracts
- * parameters correctly in both cases, so your components don't need to know
- * about path remapping at all.
+ * Hook to extract URL parameters that works with both remapped and non-remapped paths.
+ * Router-agnostic: uses window.location + path-to-regexp directly (no react-router-dom needed).
  *
  * @param internalPath - The internal path pattern (e.g., "/hello-with-param/:myparam")
  * @returns Parameters object with extracted values
@@ -13,7 +10,6 @@
  * function HelloWithParamPage() {
  *   // Works for both /hello-with-param/test AND /myremap/test
  *   const { myparam } = useRemappableParams<{ myparam: string }>('/hello-with-param/:myparam');
- *
  *   return <div>Parameter: {myparam}</div>;
  * }
  * ```

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

@@ -1,12 +1,22 @@
-import { useParams } from 'react-router-dom';
 import { getPathInfo } from '../../core/pathRemapping';
 import { match } from 'path-to-regexp';
 /**
- * Hook to extract URL parameters that works with both remapped and non-remapped paths
- *
- * This hook automatically detects if the current path is remapped and extracts
- * parameters correctly in both cases, so your components don't need to know
- * about path remapping at all.
+ * Extract params from a URL path using a pattern via path-to-regexp
+ */
+function extractMatchParams(pattern, path) {
+    try {
+        const matchFn = match(pattern, { decode: decodeURIComponent });
+        const result = matchFn(path);
+        if (result && typeof result !== 'boolean') {
+            return result.params;
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+/**
+ * Hook to extract URL parameters that works with both remapped and non-remapped paths.
+ * Router-agnostic: uses window.location + path-to-regexp directly (no react-router-dom needed).
  *
  * @param internalPath - The internal path pattern (e.g., "/hello-with-param/:myparam")
  * @returns Parameters object with extracted values
@@ -16,21 +26,19 @@ import { match } from 'path-to-regexp';
  * function HelloWithParamPage() {
  *   // Works for both /hello-with-param/test AND /myremap/test
  *   const { myparam } = useRemappableParams<{ myparam: string }>('/hello-with-param/:myparam');
- *
  *   return <div>Parameter: {myparam}</div>;
  * }
  * ```
  */
 export function useRemappableParams(internalPath) {
-    const routerParams = useParams();
     const pathInfo = getPathInfo();
-    // If not remapped, just return router params
+    const currentPath = typeof window !== 'undefined' ? window.location.pathname : '/';
+    // If not remapped, extract params from URL using the internal pattern directly
     if (!pathInfo.isRemapped) {
-        return routerParams;
+        return extractMatchParams(internalPath, currentPath) ?? {};
     }
     // If remapped, extract params from the external URL
     try {
-        // Get the external pattern from localStorage (for testing) or from meta tag
         let externalPattern = null;
         // Check localStorage for explicit remapping (development/testing)
         if (typeof localStorage !== 'undefined') {
@@ -54,17 +62,13 @@ export function useRemappableParams(internalPath) {
                 externalPattern = metaTag.getAttribute('content');
             }
         }
-        // If we have an external pattern, extract params from it
+        // If we have an external pattern, extract params and map to internal names
         if (externalPattern) {
             const matchFn = match(externalPattern, { decode: decodeURIComponent });
             const result = matchFn(pathInfo.externalPath);
             if (result && typeof result !== 'boolean') {
-                // We have extracted params from external URL
-                // Now we need to map them to internal param names
-                // Extract param names from both patterns
                 const externalParamNames = extractParamNames(externalPattern);
                 const internalParamNames = extractParamNames(internalPath);
-                // Map external params to internal params (by position)
                 const mappedParams = {};
                 externalParamNames.forEach((externalName, index) => {
                     const internalName = internalParamNames[index];
@@ -76,17 +80,13 @@ export function useRemappableParams(internalPath) {
             }
         }
         // Fallback: try to extract from internal path directly
-        const matchFn = match(internalPath, { decode: decodeURIComponent });
-        const result = matchFn(pathInfo.externalPath);
-        if (result && typeof result !== 'boolean') {
-            return result.params;
-        }
+        return extractMatchParams(internalPath, pathInfo.externalPath) ?? {};
     }
     catch (error) {
         console.error('[useRemappableParams] Failed to extract params:', error);
     }
-    // Fallback to router params
-    return routerParams;
+    // Final fallback: try matching current URL against internal pattern
+    return extractMatchParams(internalPath, currentPath) ?? {};
 }
 /**
  * Extract parameter names from a path pattern

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

@@ -0,0 +1,16 @@
+/**
+ * Hook for setting the payment method on a checkout session
+ */
+import { CheckoutData } from '../../core/resources/checkout';
+import type { PaymentMethodName } from '../../core/resources/checkout';
+export interface UseSetPaymentMethodOptions {
+    sessionId?: string;
+    checkout?: CheckoutData;
+    onSuccess?: (paymentMethodName: PaymentMethodName) => void;
+}
+export interface UseSetPaymentMethodResult {
+    setPaymentMethod: (paymentMethodName: PaymentMethodName) => Promise<void>;
+    isPending: boolean;
+    error: Error | null;
+}
+export declare function useSetPaymentMethod(options?: UseSetPaymentMethodOptions): UseSetPaymentMethodResult;

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

@@ -0,0 +1,33 @@
+/**
+ * Hook for setting the payment method on a checkout session
+ */
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CheckoutResource } from '../../core/resources/checkout';
+import { getGlobalApiClient } from './useApiQuery';
+export function useSetPaymentMethod(options = {}) {
+    const { sessionId, checkout, onSuccess } = options;
+    const queryClient = useQueryClient();
+    const checkoutResource = useMemo(() => new CheckoutResource(getGlobalApiClient()), []);
+    const effectiveSessionId = sessionId ?? checkout?.checkoutSession?.id;
+    const mutation = useMutation({
+        mutationFn: (paymentMethodName) => {
+            if (!effectiveSessionId) {
+                throw new Error('No session ID available');
+            }
+            return checkoutResource.setPaymentMethod(effectiveSessionId, paymentMethodName);
+        },
+        onSuccess: async (_, paymentMethodName) => {
+            await queryClient.invalidateQueries({ queryKey: ['checkout'] });
+            onSuccess?.(paymentMethodName);
+        },
+    });
+    const setPaymentMethod = async (paymentMethodName) => {
+        await mutation.mutateAsync(paymentMethodName);
+    };
+    return {
+        setPaymentMethod,
+        isPending: mutation.isPending,
+        error: mutation.error,
+    };
+}

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

@@ -29,7 +29,11 @@ export function useShippingRatesQuery(options = {}) {
     // Main shipping rates query
     const { data: shippingRatesData, isLoading: isFetching, error: fetchError, refetch: refetchRates, } = useQuery({
         queryKey: ['shipping-rates', effectiveSessionId],
-        queryFn: () => shippingRatesResource.getShippingRates(effectiveSessionId),
+        queryFn: () => {
+            if (!enabled)
+                return Promise.resolve({ rates: [] });
+            return shippingRatesResource.getShippingRates(effectiveSessionId);
+        },
         enabled: enabled && !!effectiveSessionId,
         staleTime: 30000, // 30 seconds
         refetchOnWindowFocus: false,
@@ -76,8 +80,10 @@ export function useShippingRatesQuery(options = {}) {
     });
     // Select rate function
     const selectRate = useCallback(async (rateId) => {
+        if (!enabled)
+            return;
         await setShippingRateMutation.mutateAsync({ rateId });
-    }, [setShippingRateMutation]);
+    }, [enabled, setShippingRateMutation]);
     // Auto-select cheapest rate when:
     // 1. Rates are loaded
     // 2. No rate is currently selected in checkout
@@ -117,8 +123,10 @@ export function useShippingRatesQuery(options = {}) {
     }, [shippingRates, checkoutSelectedRateId]);
     // Refetch function
     const refetch = useCallback(async () => {
+        if (!enabled)
+            return;
         await refetchRates();
-    }, [refetchRates]);
+    }, [enabled, refetchRates]);
     // Clear error function
     const clearError = useCallback(() => {
         // TanStack Query doesn't provide a direct way to clear errors
@@ -127,7 +135,7 @@ export function useShippingRatesQuery(options = {}) {
     }, [refetch]);
     // Preview shipping rates for a country without updating session
     const previewRates = useCallback(async (countryCode, stateCode) => {
-        if (!effectiveSessionId)
+        if (!enabled || !effectiveSessionId)
             return [];
         try {
             setIsPreviewLoading(true);
@@ -153,7 +161,7 @@ export function useShippingRatesQuery(options = {}) {
         finally {
             setIsPreviewLoading(false);
         }
-    }, [effectiveSessionId, shippingRatesResource]);
+    }, [enabled, effectiveSessionId, shippingRatesResource]);
     return {
         shippingRates,
         selectedRate,

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

@@ -10,18 +10,18 @@
  *
  * Usage:
  * ```tsx
- * const { stepConfig, paymentFlowId, staticResources } = useStepConfig();
+ * const { stepConfig, paymentFlowId, resources } = useStepConfig();
  *
  * // Access payment flow override
  * if (paymentFlowId) {
  *   console.log('Using custom payment flow:', paymentFlowId);
  * }
  *
- * // Access static resources (e.g., offer ID for current A/B variant)
- * const offerId = staticResources?.offer;
+ * // Access resource bindings (e.g., offer ID for current A/B variant)
+ * const offerId = resources?.offer;
  * ```
  */
-import { PixelsConfig, RuntimeStepConfig } from '../../core/funnelClient';
+import { type PaymentSetupConfig, type PixelsConfig, type RuntimeStepConfig } from '../../core/funnelClient';
 export interface UseStepConfigResult {
     /**
      * Full step configuration object
@@ -34,10 +34,11 @@ export interface UseStepConfigResult {
      */
     paymentFlowId: string | undefined;
     /**
-     * Static resources assigned to this step/variant
-     * For A/B tests, this contains the resources for the specific variant the user landed on
+     * Resource bindings for this step/variant.
      * e.g., { offer: 'offer_xxx', product: 'product_xxx' }
      */
+    resources: Record<string, string> | undefined;
+    /** @deprecated Use `resources` instead */
     staticResources: Record<string, string> | undefined;
     /**
      * Get scripts for a specific injection position
@@ -46,6 +47,22 @@ export interface UseStepConfigResult {
      */
     getScripts: (position?: 'head-start' | 'head-end' | 'body-start' | 'body-end') => RuntimeStepConfig['scripts'];
     pixels: PixelsConfig | undefined;
+    /**
+     * Payment setup configuration for this step.
+     * Keys: "{method}" or "{method}:{provider}" (e.g. "card", "apple_pay:stripe")
+     * Use helpers: getEnabledMethods(), getExpressMethods(), findMethod()
+     */
+    paymentSetupConfig: PaymentSetupConfig | undefined;
+    /**
+     * Enabled order bump offer IDs for this step.
+     * undefined = inherit all store bumps, string[] = only these IDs.
+     */
+    orderBumpOfferIds: string[] | undefined;
+    /**
+     * Enabled upsell offer IDs for this step.
+     * undefined = inherit all store upsells, string[] = only these IDs.
+     */
+    upsellOfferIds: string[] | undefined;
 }
 /**
  * Hook to access runtime step configuration injected via HTML

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

@@ -10,19 +10,19 @@
  *
  * Usage:
  * ```tsx
- * const { stepConfig, paymentFlowId, staticResources } = useStepConfig();
+ * const { stepConfig, paymentFlowId, resources } = useStepConfig();
  *
  * // Access payment flow override
  * if (paymentFlowId) {
  *   console.log('Using custom payment flow:', paymentFlowId);
  * }
  *
- * // Access static resources (e.g., offer ID for current A/B variant)
- * const offerId = staticResources?.offer;
+ * // Access resource bindings (e.g., offer ID for current A/B variant)
+ * const offerId = resources?.offer;
  * ```
  */
 import { useMemo } from 'react';
-import { getAssignedPaymentFlowId, getAssignedPixels, getAssignedScripts, getAssignedStaticResources, getAssignedStepConfig, } from '../../core/funnelClient';
+import { getAssignedOrderBumpOfferIds, getAssignedPaymentFlowId, getAssignedPixels, getAssignedResources, getAssignedScripts, getAssignedStepConfig, getAssignedUpsellOfferIds, } from '../../core/funnelClient';
 /**
  * Hook to access runtime step configuration injected via HTML
  *
@@ -35,7 +35,7 @@ export function useStepConfig() {
     // Read once on mount - these values don't change during the page lifecycle
     const stepConfig = useMemo(() => getAssignedStepConfig(), []);
     const paymentFlowId = useMemo(() => getAssignedPaymentFlowId(), []);
-    const staticResources = useMemo(() => getAssignedStaticResources(), []);
+    const resources = useMemo(() => getAssignedResources(), []);
     const pixels = useMemo(() => getAssignedPixels(), []);
     // Create a stable reference for getScripts
     const getScripts = useMemo(() => {
@@ -43,11 +43,18 @@ export function useStepConfig() {
             return getAssignedScripts(position);
         };
     }, []);
+    const paymentSetupConfig = useMemo(() => stepConfig?.paymentSetupConfig, [stepConfig]);
+    const orderBumpOfferIds = useMemo(() => getAssignedOrderBumpOfferIds(), []);
+    const upsellOfferIds = useMemo(() => getAssignedUpsellOfferIds(), []);
     return {
         stepConfig,
         paymentFlowId,
-        staticResources,
+        resources,
+        staticResources: resources,
         getScripts,
-        pixels
+        pixels,
+        paymentSetupConfig,
+        orderBumpOfferIds,
+        upsellOfferIds,
     };
 }

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

@@ -85,9 +85,24 @@ export const useTranslation = (options = {}) => {
                 // Even without params, we need to unescape any escaped characters
                 return str.replace(/\\([{}<>])/g, '$1');
             }
+            // Replace escaped characters with sentinels so they are not matched
+            // by tag/placeholder regexes (avoids lookbehind which breaks older Safari)
+            const ESC_LT = '\x00ELT\x00';
+            const ESC_GT = '\x00EGT\x00';
+            const ESC_LB = '\x00ELB\x00';
+            const ESC_RB = '\x00ERB\x00';
+            const restoreSentinels = (s) => s.replace(/\x00ELT\x00/g, '<')
+                .replace(/\x00EGT\x00/g, '>')
+                .replace(/\x00ELB\x00/g, '{')
+                .replace(/\x00ERB\x00/g, '}');
+            str = str
+                .replace(/\\</g, ESC_LT)
+                .replace(/\\>/g, ESC_GT)
+                .replace(/\\{/g, ESC_LB)
+                .replace(/\\}/g, ESC_RB);
             // First, process tag-based interpolation for functions
-            // Match tags like <i>content</i> but not \<i>content</i>
-            const tagRegex = /(?<!\\)<(\w+)>(.*?)(?<!\\)<\/\1>/g;
+            // Match tags like <i>content</i> (escaped tags are already replaced with sentinels)
+            const tagRegex = /<(\w+)>(.*?)<\/\1>/g;
             const hasTags = tagRegex.test(str);
             if (hasTags) {
                 // Reset regex lastIndex for reuse
@@ -125,13 +140,13 @@ export const useTranslation = (options = {}) => {
                             // Process {key} placeholders in string parts
                             let processed = Object.entries(params).reduce((acc, [key, value]) => {
                                 if (typeof value !== 'function') {
-                                    const regex = new RegExp(`(?<!\\\\)\\{${key}\\}`, 'g');
+                                    const regex = new RegExp(`\\{${key}\\}`, 'g');
                                     return acc.replace(regex, String(value));
                                 }
                                 return acc;
                             }, part);
-                            // Unescape escaped characters
-                            processed = processed.replace(/\\([{}<>])/g, '$1');
+                            // Restore sentinels to literal characters
+                            processed = restoreSentinels(processed);
                             return processed;
                         }
                         return part;
@@ -149,13 +164,13 @@ export const useTranslation = (options = {}) => {
             // Process {key} placeholders for string/number values
             let result = Object.entries(params).reduce((acc, [key, value]) => {
                 if (typeof value !== 'function') {
-                    const regex = new RegExp(`(?<!\\\\)\\{${key}\\}`, 'g');
+                    const regex = new RegExp(`\\{${key}\\}`, 'g');
                     return acc.replace(regex, String(value));
                 }
                 return acc;
             }, str);
-            // Remove escape characters from escaped characters (\{ -> {, \} -> }, \< -> <, \> -> >)
-            result = result.replace(/\\([{}<>])/g, '$1');
+            // Restore sentinels to literal characters (\{ -> {, \} -> }, \< -> <, \> -> >)
+            result = restoreSentinels(result);
             return result;
         };
         if (!text)

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

@@ -0,0 +1,30 @@
+export interface WhopPayment {
+    id: string;
+    status: 'succeeded' | 'declined' | 'pending';
+    requireAction: 'none' | 'redirect' | 'error';
+    orderId: string;
+    amount: number;
+    currency: string;
+    order?: {
+        id: string;
+        amount: number;
+        currency: string;
+    };
+}
+export interface UseWhopPaymentPollingOptions {
+    apiService: {
+        fetch: <T>(url: string, options: any) => Promise<T>;
+    };
+    checkoutSessionId: string;
+    maxAttempts?: number;
+    intervalMs?: number;
+    onSuccess?: (payment: WhopPayment) => void;
+    onMaxAttemptsReached?: () => void;
+    onError?: (error: Error) => void;
+}
+export interface UseWhopPaymentPollingReturn {
+    startPolling: (receiptId: string, orderId: string) => void;
+    stopPolling: () => void;
+    isPolling: boolean;
+}
+export declare const useWhopPaymentPolling: ({ apiService, checkoutSessionId, maxAttempts, intervalMs, onSuccess, onMaxAttemptsReached, onError, }: UseWhopPaymentPollingOptions) => UseWhopPaymentPollingReturn;

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

@@ -0,0 +1,61 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+export const useWhopPaymentPolling = ({ apiService, checkoutSessionId, maxAttempts = 60, intervalMs = 2000, onSuccess, onMaxAttemptsReached, onError, }) => {
+    const pollIntervalRef = useRef(null);
+    const attemptsRef = useRef(0);
+    const currentParamsRef = useRef(null);
+    const [isPolling, setIsPolling] = useState(false);
+    const stopPolling = useCallback(() => {
+        if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+            pollIntervalRef.current = null;
+        }
+        setIsPolling(false);
+        attemptsRef.current = 0;
+        currentParamsRef.current = null;
+    }, []);
+    const startPolling = useCallback((receiptId, orderId) => {
+        stopPolling();
+        attemptsRef.current = 0;
+        currentParamsRef.current = { receiptId, orderId };
+        setIsPolling(true);
+        pollIntervalRef.current = setInterval(async () => {
+            if (!currentParamsRef.current)
+                return;
+            try {
+                attemptsRef.current++;
+                console.log(`Whop payment polling attempt ${attemptsRef.current}/${maxAttempts}...`);
+                const data = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/whop-payment-status`, {
+                    method: 'POST',
+                    body: JSON.stringify(currentParamsRef.current),
+                    headers: { 'Content-Type': 'application/json' },
+                });
+                if (data && (data.status === 'succeeded' || data.status === 'declined')) {
+                    stopPolling();
+                    onSuccess?.(data);
+                }
+                else if (attemptsRef.current >= maxAttempts) {
+                    stopPolling();
+                    onMaxAttemptsReached?.();
+                }
+            }
+            catch (error) {
+                console.warn(`Whop polling attempt ${attemptsRef.current} failed:`, error);
+                if (attemptsRef.current >= maxAttempts) {
+                    stopPolling();
+                    onError?.(error instanceof Error ? error : new Error(String(error)));
+                }
+                // Otherwise keep polling through transient errors
+            }
+        }, intervalMs);
+    }, [apiService, checkoutSessionId, maxAttempts, intervalMs, onSuccess, onMaxAttemptsReached, onError, stopPolling]);
+    useEffect(() => {
+        return () => {
+            stopPolling();
+        };
+    }, [stopPolling]);
+    return {
+        startPolling,
+        stopPolling,
+        isPolling,
+    };
+};

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

@@ -6,8 +6,10 @@ export { ExpressPaymentMethodsProvider } from './providers/ExpressPaymentMethods
 export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export type { DebugScript } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
+export { StripeExpressButton } from './components/StripeExpressButton';
 export { GooglePayButton } from './components/GooglePayButton';
 export { PreviewModeIndicator } from './components/PreviewModeIndicator';
+export { WhopCheckout } from './components/WhopCheckout';
 export { useApplePayCheckout } from './hooks/useApplePayCheckout';
 export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
@@ -40,12 +42,14 @@ export { usePostPurchasesQuery as usePostPurchases } from './hooks/usePostPurcha
 export { usePreviewOffer } from './hooks/usePreviewOffer';
 export { useProductsQuery as useProducts } from './hooks/useProductsQuery';
 export { usePromotionsQuery as usePromotions } from './hooks/usePromotionsQuery';
+export { useSetPaymentMethod } from './hooks/useSetPaymentMethod';
 export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRatesQuery';
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
+export { useWhopPaymentPolling } from './hooks/useWhopPaymentPolling';
 export { useFunnel } from './hooks/useFunnel';
 export { useStepConfig } from './hooks/useStepConfig';
 export { useFunnel as useFunnelLegacy, useSimpleFunnel } from './hooks/useFunnelLegacy';
@@ -61,19 +65,24 @@ export type { ExpressPaymentMethodsContextType, ExpressPaymentMethodsProviderPro
 export type { UseGooglePayCheckoutOptions } from './hooks/useGooglePayCheckout';
 export type { UseLoginOptions, UseLoginResult } from './hooks/useLogin';
 export type { ApplePayButtonProps } from './components/ApplePayButton';
+export type { StripeExpressButtonProps } from './components/StripeExpressButton';
 export type { GooglePayButtonProps } from './components/GooglePayButton';
 export type { PreviewModeIndicatorProps } from './components/PreviewModeIndicator';
+export type { WhopCheckoutHandle, WhopCheckoutProps } from './components/WhopCheckout';
+export type { WhopPayment, UseWhopPaymentPollingOptions, UseWhopPaymentPollingReturn } from './hooks/useWhopPaymentPolling';
 export type { GeoLocationData, UseGeoLocationOptions, UseGeoLocationReturn } from './hooks/useGeoLocation';
 export type { ExtractedAddress, GooglePlaceDetails, GooglePrediction, UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult } from './hooks/useGoogleAutocomplete';
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
 export type { UsePluginConfigOptions, UsePluginConfigResult } from './hooks/usePluginConfig';
 export type { TranslateFunction, UseTranslationOptions, UseTranslationResult } from './hooks/useTranslation';
 export { FunnelActionType } from '../core/resources/funnel';
-export type { UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
+export type { CheckoutMessages, UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
 export type { UseDiscountsQueryOptions as UseDiscountsOptions, UseDiscountsQueryResult as UseDiscountsResult } from './hooks/useDiscountsQuery';
 export type { FunnelAction, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from '../core/resources/funnel';
 export type { FunnelContextValue, StepConfigValue } from './hooks/useFunnel';
 export type { UseStepConfigResult } from './hooks/useStepConfig';
+export type { RuntimeStepConfig, PaymentMethodConfig, PaymentSetupConfig, PaymentSetupMethod } from '../core/funnelClient';
+export { getEnabledMethods, getExpressMethods, getExpressMethodsByProcessor, findMethod, isMethodEnabled } from '../core/funnelClient';
 export type { UseFunnelOptions as UseFunnelLegacyOptions, UseFunnelResult as UseFunnelLegacyResult } from './hooks/useFunnelLegacy';
 export type { AvailableVariant, LineItemSelection, OfferLineItem, OfferPreviewSummary, UseOfferQueryOptions as UseOfferOptions, UseOfferQueryResult as UseOfferResult } from './hooks/useOfferQuery';
 export type { UseOrderBumpQueryOptions as UseOrderBumpOptions, UseOrderBumpQueryResult as UseOrderBumpResult } from './hooks/useOrderBumpQuery';
@@ -84,9 +93,14 @@ export type { UsePostPurchasesQueryOptions as UsePostPurchasesOptions, UsePostPu
 export type { PreviewOfferSummary, UsePreviewOfferOptions, UsePreviewOfferResult } from './hooks/usePreviewOffer';
 export type { UseProductsQueryOptions as UseProductsOptions, UseProductsQueryResult as UseProductsResult } from './hooks/useProductsQuery';
 export type { UsePromotionsQueryOptions as UsePromotionsOptions, UsePromotionsQueryResult as UsePromotionsResult } from './hooks/usePromotionsQuery';
+export type { UseSetPaymentMethodOptions, UseSetPaymentMethodResult } from './hooks/useSetPaymentMethod';
 export type { UseShippingRatesQueryOptions as UseShippingRatesOptions, UseShippingRatesQueryResult as UseShippingRatesResult } from './hooks/useShippingRatesQuery';
 export type { UseStoreConfigQueryOptions as UseStoreConfigOptions, UseStoreConfigQueryResult as UseStoreConfigResult } from './hooks/useStoreConfigQuery';
 export type { PaymentInstrument, ThreedsChallenge, ThreedsHook, ThreedsOptions, ThreedsProvider, ThreedsSession } from './hooks/useThreeds';
 export type { UseVipOffersQueryOptions as UseVipOffersOptions, UseVipOffersQueryResult as UseVipOffersResult } from './hooks/useVipOffersQuery';
 export { formatMoney } from '../../react/utils/money';
+export { TagadaError, TagadaApiError, TagadaNetworkError, TagadaAuthError, TagadaValidationError, TagadaCircuitBreakerError, TagadaErrorCode, } from '../core/errors';
+export type { TagadaErrorOptions, TagadaErrorCodeValue } from '../core/errors';
+export type { PaymentMethodName } from '../core/resources/checkout';
+export type { Order, OrderItem as CoreOrderItem, OrderAddress, OrderSummary, OrderWithRelations, PaymentSummary, PromotionSummary, Subscription, DeviceInfo, PromotionCode, Customer, Store, PickupPoint, } from '../core/types';
 export type OrderItem = import('../core/utils/order').OrderLineItem;

package/dist/v2/react/index.js

@@ -7,8 +7,10 @@ export { ExpressPaymentMethodsProvider } from './providers/ExpressPaymentMethods
 export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 // Components
 export { ApplePayButton } from './components/ApplePayButton';
+export { StripeExpressButton } from './components/StripeExpressButton';
 export { GooglePayButton } from './components/GooglePayButton';
 export { PreviewModeIndicator } from './components/PreviewModeIndicator';
+export { WhopCheckout } from './components/WhopCheckout';
 // Hooks
 export { useApplePayCheckout } from './hooks/useApplePayCheckout';
 export { useAuth } from './hooks/useAuth';
@@ -42,12 +44,14 @@ export { usePostPurchasesQuery as usePostPurchases } from './hooks/usePostPurcha
 export { usePreviewOffer } from './hooks/usePreviewOffer';
 export { useProductsQuery as useProducts } from './hooks/useProductsQuery';
 export { usePromotionsQuery as usePromotions } from './hooks/usePromotionsQuery';
+export { useSetPaymentMethod } from './hooks/useSetPaymentMethod';
 export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRatesQuery';
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
 export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
+export { useWhopPaymentPolling } from './hooks/useWhopPaymentPolling';
 // Funnel hooks
 export { useFunnel } from './hooks/useFunnel';
 // Step config hook (access runtime configuration from HTML injection)
@@ -56,5 +60,8 @@ export { useStepConfig } from './hooks/useStepConfig';
 export { useFunnel as useFunnelLegacy, useSimpleFunnel } from './hooks/useFunnelLegacy';
 // TanStack Query types
 export { FunnelActionType } from '../core/resources/funnel';
+export { getEnabledMethods, getExpressMethods, getExpressMethodsByProcessor, findMethod, isMethodEnabled } from '../core/funnelClient';
 // Re-export utilities from main react
 export { formatMoney } from '../../react/utils/money';
+// Error types
+export { TagadaError, TagadaApiError, TagadaNetworkError, TagadaAuthError, TagadaValidationError, TagadaCircuitBreakerError, TagadaErrorCode, } from '../core/errors';