@tagadapay/plugin-sdk 3.1.2 → 3.1.8

package/dist/react/hooks/useApplePay.js

@@ -282,9 +282,7 @@ export function useApplePay(options = {}) {
                         // Tokenize the Apple Pay payment
                         const applePayToken = await tokenizeApplePay(event);
                         // Complete the Apple Pay session
-                        session.completePayment({
-                            status: window.ApplePaySession.STATUS_SUCCESS,
-                        });
+                        session.completePayment(window.ApplePaySession.STATUS_SUCCESS);
                         // Process the payment using the SDK's payment methods
                         await processApplePayPayment(checkoutSessionId, applePayToken, {
                             onSuccess: (payment) => {
@@ -300,9 +298,7 @@ export function useApplePay(options = {}) {
                     }
                     catch (error) {
                         console.error('Payment processing failed:', error);
-                        session.completePayment({
-                            status: window.ApplePaySession.STATUS_FAILURE,
-                        });
+                        session.completePayment(window.ApplePaySession.STATUS_FAILURE);
                         setProcessingPayment(false);
                         const errorMsg = error instanceof Error ? error.message : 'Payment processing failed';
                         setError(errorMsg);
@@ -321,18 +317,15 @@ export function useApplePay(options = {}) {
                             return;
                         }
                         const { lineItems: newLineItems, total: newTotal } = newOrderSummary;
-                        session.completeShippingMethodSelection({
-                            newTotal: {
-                                label: newTotal.label,
-                                amount: newTotal.amount,
-                                type: 'final',
-                            },
-                            newLineItems: newLineItems.map(item => ({
-                                label: item.label,
-                                amount: item.amount,
-                                type: 'final',
-                            })),
-                        });
+                        session.completeShippingMethodSelection(window.ApplePaySession.STATUS_SUCCESS, {
+                            label: newTotal.label,
+                            amount: newTotal.amount,
+                            type: 'final',
+                        }, newLineItems.map(item => ({
+                            label: item.label,
+                            amount: item.amount,
+                            type: 'final',
+                        })));
                     }
                     catch (error) {
                         console.error('Shipping method selection failed:', error);
@@ -358,24 +351,20 @@ export function useApplePay(options = {}) {
                         console.log('======= APPLE PAY ON SHIPPING CONTACT SELECTED ======');
                         console.log('newOrderSummary', newOrderSummary);
                         console.log(newLineItems, newTotal, newShippingMethods);
-                        session.completeShippingContactSelection({
-                            newShippingMethods: newShippingMethods.map(method => ({
-                                label: method.label,
-                                amount: method.amount,
-                                detail: method.detail,
-                                identifier: method.identifier,
-                            })),
-                            newTotal: {
-                                label: newTotal.label,
-                                amount: newTotal.amount,
-                                type: 'final',
-                            },
-                            newLineItems: newLineItems.map(item => ({
-                                label: item.label,
-                                amount: item.amount,
-                                type: 'final',
-                            })),
-                        });
+                        session.completeShippingContactSelection(window.ApplePaySession.STATUS_SUCCESS, newShippingMethods.map(method => ({
+                            label: method.label,
+                            amount: method.amount,
+                            detail: method.detail,
+                            identifier: method.identifier,
+                        })), {
+                            label: newTotal.label,
+                            amount: newTotal.amount,
+                            type: 'final',
+                        }, newLineItems.map(item => ({
+                            label: item.label,
+                            amount: item.amount,
+                            type: 'final',
+                        })));
                     }
                     catch (error) {
                         console.error('Shipping contact selection failed:', error);

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

@@ -2,14 +2,14 @@ export interface Payment {
     id: string;
     status: string;
     subStatus: string;
-    requireAction: 'none' | 'redirect' | 'error';
+    requireAction: 'none' | 'redirect' | 'error' | 'radar';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error';
+        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect';
+            type: 'redirect' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;
@@ -20,6 +20,12 @@ export interface Payment {
                 acsTransID: string;
                 messageVersion: string;
             };
+            radar?: {
+                merchantId: string;
+                environment: 'sandbox' | 'live';
+                orderId?: string;
+                publishableKey?: string;
+            };
         };
         redirectUrl?: string;
         resumeToken?: string;

package/dist/react/providers/TagadaProvider.js

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

package/dist/react/utils/money.d.ts

@@ -2251,12 +2251,11 @@ export declare function getCurrencyInfo(currencyCode: string): {
  * Convert a money string or number to minor units
  */
 export declare function moneyStringOrNumberToMinorUnits(moneyStringOrNumber: string | number, currencyCode: string): number;
-/**
- * Convert minor units to major units (decimal value)
- */
 export declare function minorUnitsToMajorUnits(amountMinorUnits: number, currencyCode: string): number;
 /**
  * Format money without currency symbol, just the numeric value
+ * Note: The backend stores all amounts with 2 decimal places (multiplied by 100),
+ * even for currencies with 0 decimal places like JPY.
  */
 export declare const formatMoneyWithoutSymbol: ({ amount, currencyCode, fromCents, }: {
     amount: number;
@@ -2269,5 +2268,7 @@ export declare const formatMoneyWithoutSymbol: ({ amount, currencyCode, fromCent
 export declare const convertCurrency: (amount: number, fromCurrency: string, toCurrency: string, rate: number) => number;
 /**
  * Simple money formatter for quick use (similar to the existing useCurrency format function)
+ * Note: The backend stores all amounts with 2 decimal places (multiplied by 100),
+ * even for currencies with 0 decimal places like JPY.
  */
 export declare function formatSimpleMoney(amount: number, currencyCode: string): string;

package/dist/react/utils/money.js

@@ -42,7 +42,22 @@ export function formatMoney(amountMinorUnits, currencyCode = 'USD', locale) {
         throw new Error(`Currency ${currencyCode} not found in currency data.`);
     }
     // Convert minor units to major units
-    const value = amountMinorUnits / Math.pow(10, currencyInfo.ISOdigits);
+    // Note: The backend stores all amounts with 2 decimal places (multiplied by 100),
+    // regardless of the currency's ISOdigits. This means:
+    // - For ISOdigits: 0 (JPY, KRW, etc.) → divide by 100 (not 10^0 = 1)
+    // - For ISOdigits: 2 (USD, EUR, etc.) → divide by 100 (matches 10^2)
+    // - For ISOdigits: 3 (KWD, BHD, etc.) → divide by 100 (not 10^3 = 1000)
+    //   Note: This means currencies with 3 decimal places lose precision (3rd decimal is lost)
+    let value;
+    if (currencyInfo.ISOdigits === 0 || currencyInfo.ISOdigits === 3) {
+        // Backend stores amounts with 2 decimal places for all currencies
+        // For currencies with 0 or 3 decimal places, divide by 100 to convert from backend format
+        value = amountMinorUnits / 100;
+    }
+    else {
+        // For currencies with 2 decimal places (most common), use the standard conversion
+        value = amountMinorUnits / Math.pow(10, currencyInfo.ISOdigits);
+    }
     return formatCurrency(value, safeLocale, currencyCode);
 }
 /**
@@ -63,23 +78,36 @@ export function moneyStringOrNumberToMinorUnits(moneyStringOrNumber, currencyCod
     const value = typeof moneyStringOrNumber === 'string' ? parseFloat(moneyStringOrNumber) : moneyStringOrNumber;
     return Math.round(value * Math.pow(10, currencyInfo.ISOdigits));
 }
-/**
- * Convert minor units to major units (decimal value)
- */
 export function minorUnitsToMajorUnits(amountMinorUnits, currencyCode) {
     const currencyInfo = currencyData[currencyCode];
     if (!currencyInfo) {
         throw new Error(`Currency ${currencyCode} not found in currency data.`);
     }
+    // Backend stores amounts with 2 decimal places for all currencies
+    // For currencies with 0 or 3 decimal places, divide by 100 to convert from backend format
+    if (currencyInfo.ISOdigits === 0 || currencyInfo.ISOdigits === 3) {
+        return amountMinorUnits / 100;
+    }
     return amountMinorUnits / Math.pow(10, currencyInfo.ISOdigits);
 }
 /**
  * Format money without currency symbol, just the numeric value
+ * Note: The backend stores all amounts with 2 decimal places (multiplied by 100),
+ * even for currencies with 0 decimal places like JPY.
  */
 export const formatMoneyWithoutSymbol = ({ amount, currencyCode, fromCents = true, }) => {
     const currencyInfo = currencyData[currencyCode];
     const digits = currencyInfo?.ISOdigits || 2;
-    const value = fromCents ? amount / Math.pow(10, digits) : amount;
+    let value;
+    if (fromCents) {
+        // Backend stores amounts with 2 decimal places for all currencies
+        // For currencies with 0 or 3 decimal places, divide by 100 to convert from backend format
+        const divisor = digits === 0 || digits === 3 ? 100 : Math.pow(10, digits);
+        value = amount / divisor;
+    }
+    else {
+        value = amount;
+    }
     return new Intl.NumberFormat('en-US', {
         minimumFractionDigits: digits,
         maximumFractionDigits: digits,
@@ -95,10 +123,15 @@ export const convertCurrency = (amount, fromCurrency, toCurrency, rate) => {
 };
 /**
  * Simple money formatter for quick use (similar to the existing useCurrency format function)
+ * Note: The backend stores all amounts with 2 decimal places (multiplied by 100),
+ * even for currencies with 0 decimal places like JPY.
  */
 export function formatSimpleMoney(amount, currencyCode) {
     const currencyInfo = currencyData[currencyCode];
     const symbol = currencyInfo?.symbol || currencyCode;
     const digits = currencyInfo?.ISOdigits || 2;
-    return `${symbol}${(amount / Math.pow(10, digits)).toFixed(digits)}`;
+    // Backend stores amounts with 2 decimal places for all currencies
+    // For currencies with 0 or 3 decimal places, divide by 100 to convert from backend format
+    const divisor = digits === 0 || digits === 3 ? 100 : Math.pow(10, digits);
+    return `${symbol}${(amount / divisor).toFixed(digits)}`;
 }

package/dist/react/utils/trackingUtils.js

@@ -70,6 +70,7 @@ export const trackingCookiePatterns = [
     /^utm_/,
     /^_clck/,
     /^_clsk/,
+    /^_wtp/
 ];
 /**
  * Function to get cookies with retry logic

package/dist/v2/core/client.js

@@ -334,10 +334,22 @@ export class TagadaClient {
      * Normal token initialization flow (no cross-domain handoff)
      */
     async fallbackToNormalFlow() {
-        // Check for existing token in URL or storage
-        const existingToken = getClientToken();
+        // 🔒 CRITICAL: Read URL token FIRST before any async operations
+        // This prevents race conditions where anonymous token creation overwrites URL token
         const urlParams = new URLSearchParams(typeof window !== 'undefined' ? window.location.search : '');
         const queryToken = urlParams.get('token');
+        // If URL has token, set it IMMEDIATELY to prevent any race condition
+        if (queryToken) {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] 🔒 URL token detected, setting immediately to prevent race condition`);
+            }
+            // Set token on API client immediately
+            this.apiClient.updateToken(queryToken);
+            // Also persist to localStorage
+            setClientToken(queryToken);
+        }
+        // Now check storage (which should have the URL token if we just set it)
+        const existingToken = getClientToken();
         console.log(`[TagadaClient ${this.instanceId}] Initializing token (normal flow)...`, {
             hasExistingToken: !!existingToken,
             hasQueryToken: !!queryToken,
@@ -425,6 +437,26 @@ export class TagadaClient {
      * Create anonymous token
      */
     async createAnonymousToken(storeId) {
+        // 🔒 CRITICAL: Never create anonymous token if URL has a token
+        // This prevents race conditions during forceReset
+        if (typeof window !== 'undefined') {
+            const urlParams = new URLSearchParams(window.location.search);
+            const urlToken = urlParams.get('token');
+            if (urlToken) {
+                if (this.state.debugMode) {
+                    console.log(`[TagadaClient ${this.instanceId}] 🔒 URL has token, skipping anonymous token creation`);
+                }
+                // Use the URL token instead
+                this.setToken(urlToken);
+                setClientToken(urlToken);
+                const decodedSession = decodeJWTClient(urlToken);
+                if (decodedSession) {
+                    this.updateState({ session: decodedSession });
+                    await this.initializeSession(decodedSession);
+                }
+                return;
+            }
+        }
         // Prevent concurrent anonymous token creation
         if (this.isInitializingSession) {
             if (this.state.debugMode) {

package/dist/v2/core/config/environment.js

@@ -160,6 +160,7 @@ export function getEndpointUrl(config, category, endpoint) {
  * 4. Default fallback - Production (safest)
  */
 export function detectEnvironment() {
+    console.log('[SDK] detectEnvironment() called');
     // Check if we're in browser
     if (typeof window === 'undefined') {
         return 'local'; // SSR fallback
@@ -185,15 +186,21 @@ export function detectEnvironment() {
     }
     const hostname = window.location.hostname;
     const href = window.location.href;
+    console.log(`[SDK] detectEnvironment() - hostname: "${hostname}"`);
     // 1. Check for LOCAL environment first (highest priority for dev)
-    // Local: localhost, local IPs, or local domains
+    // Local: localhost, local IPs, local domains, or ngrok tunnels (used for local dev)
     if (hostname === 'localhost' ||
         hostname.startsWith('127.') ||
         hostname.startsWith('192.168.') ||
         hostname.startsWith('10.') ||
         hostname.includes('.local') ||
         hostname === '' ||
-        hostname === '0.0.0.0') {
+        hostname === '0.0.0.0' ||
+        hostname.includes('ngrok-free.dev') ||
+        hostname.includes('ngrok-free.app') ||
+        hostname.includes('ngrok.io') ||
+        hostname.includes('ngrok.app')) {
+        console.log('[SDK] detectEnvironment() - returning LOCAL');
         // For local development, allow override via window.__TAGADA_ENV__ (injected by dev server)
         if (typeof window !== 'undefined' && window?.__TAGADA_ENV__?.TAGADA_ENVIRONMENT) {
             const override = window.__TAGADA_ENV__.TAGADA_ENVIRONMENT.toLowerCase();

package/dist/v2/core/funnelClient.d.ts

@@ -1,6 +1,90 @@
 import { ApiClient } from './resources/apiClient';
 import { SimpleFunnelContext, FunnelAction, FunnelNavigationResult } from './resources/funnel';
 import { PluginConfig } from './utils/pluginConfig';
+/**
+ * Runtime step configuration injected from the CRM
+ * Contains payment flows, static resources, scripts, and pixel tracking configs
+ */
+export interface RuntimeStepConfig {
+    payment?: {
+        paymentFlowId?: string;
+    };
+    staticResources?: Record<string, string>;
+    scripts?: Array<{
+        name: string;
+        enabled: boolean;
+        content: string;
+        position?: 'head-start' | 'head-end' | 'body-start' | 'body-end';
+    }>;
+    pixels?: Record<string, string>;
+}
+/**
+ * Local funnel configuration for development
+ * Loaded from /config/funnel.local.json
+ */
+export interface LocalFunnelConfig {
+    /** Funnel ID to use in local dev */
+    funnelId?: string;
+    /** Step ID to simulate */
+    stepId?: string;
+    /** Static resources (offer ID, product ID, etc.) */
+    staticResources?: Record<string, string>;
+    /** Payment flow ID override */
+    paymentFlowId?: string;
+    /** Custom scripts for local testing */
+    scripts?: RuntimeStepConfig['scripts'];
+    /** Pixel tracking config */
+    pixels?: Record<string, string>;
+}
+/**
+ * Load local funnel config from /config/funnel.local.json (for local dev only)
+ * This replaces the old resources.static.json with a more complete structure
+ *
+ * Example funnel.local.json:
+ * {
+ *   "funnelId": "funnelv2_xxx",
+ *   "stepId": "step_checkout",
+ *   "staticResources": {
+ *     "offer": "offer_xxx",
+ *     "product": "product_xxx"
+ *   },
+ *   "paymentFlowId": "flow_xxx"
+ * }
+ */
+export declare function loadLocalFunnelConfig(): Promise<LocalFunnelConfig | null>;
+/**
+ * Get the cached local funnel config (sync access after loadLocalFunnelConfig)
+ */
+export declare function getLocalFunnelConfig(): LocalFunnelConfig | null;
+/**
+ * Get the runtime step configuration
+ * Contains payment flow, static resources, scripts, and pixel tracking
+ *
+ * Priority:
+ * 1. Local funnel config (local dev only - /config/funnel.local.json) - HIGHEST in local dev
+ * 2. Window variable (production - HTML injection)
+ * 3. Meta tag (production - HTML injection fallback)
+ *
+ * This allows local developers to override injected config for testing.
+ *
+ * Returns undefined if not available
+ */
+export declare function getAssignedStepConfig(): RuntimeStepConfig | undefined;
+/**
+ * Get the assigned payment flow ID from step config or legacy injection
+ * Returns undefined if not available
+ */
+export declare function getAssignedPaymentFlowId(): string | undefined;
+/**
+ * Get the assigned static resources from step config
+ * Returns undefined if not available
+ */
+export declare function getAssignedStaticResources(): Record<string, string> | undefined;
+/**
+ * Get the assigned scripts from step config
+ * Returns only enabled scripts, filtered by position if specified
+ */
+export declare function getAssignedScripts(position?: 'head-start' | 'head-end' | 'body-start' | 'body-end'): RuntimeStepConfig['scripts'];
 export interface FunnelClientConfig {
     apiClient: ApiClient;
     debugMode?: boolean;
@@ -86,16 +170,23 @@ export declare class FunnelClient {
      * @param options.fireAndForget - If true, queues navigation to QStash and returns immediately without waiting for result
      * @param options.customerTags - Customer tags to set (merged with existing customer tags)
      * @param options.deviceId - Device ID for geo/device tag enrichment (optional, rarely needed)
+     * @param options.autoRedirect - Override global autoRedirect setting for this specific call (default: use config)
      */
     navigate(event: FunnelAction, options?: {
         fireAndForget?: boolean;
         customerTags?: string[];
         deviceId?: string;
+        autoRedirect?: boolean;
+        waitForSession?: boolean;
     }): Promise<FunnelNavigationResult>;
     /**
      * Go to a specific step (direct navigation)
+     * @param stepId - Target step ID
+     * @param options - Navigation options (autoRedirect, etc.)
      */
-    goToStep(stepId: string): Promise<FunnelNavigationResult>;
+    goToStep(stepId: string, options?: {
+        autoRedirect?: boolean;
+    }): Promise<FunnelNavigationResult>;
     /**
      * Refresh session data
      */