@tagadapay/plugin-sdk 3.1.8 → 3.1.10

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

@@ -1,9 +1,79 @@
 import { ApiClient } from './resources/apiClient';
-import { SimpleFunnelContext, FunnelAction, FunnelNavigationResult } from './resources/funnel';
+import { FunnelAction, FunnelNavigationResult, SimpleFunnelContext } from './resources/funnel';
 import { PluginConfig } from './utils/pluginConfig';
+/**
+ * Tracking providers supported by the SDK.
+ * Mirrors `TrackingType` in `apps/crm-app/.../types/tracking.ts`.
+ */
+export declare enum TrackingProvider {
+    FACEBOOK = "facebook",
+    TIKTOK = "tiktok",
+    SNAPCHAT = "snapchat",
+    META_CONVERSION = "meta_conversion",
+    GTM = "gtm"
+}
+/**
+ * Base tracking config (all providers)
+ */
+export interface BaseTrackingConfig {
+    enabled: boolean;
+}
+/**
+ * Pixel-based providers (Facebook, TikTok)
+ */
+export interface PixelTrackingConfig extends BaseTrackingConfig {
+    pixelId: string;
+    events: {
+        PageView: boolean;
+        InitiateCheckout: boolean;
+        Purchase: boolean;
+    };
+}
+/**
+ * Snapchat pixel config (extends base pixel events)
+ */
+export interface SnapchatTrackingConfig extends BaseTrackingConfig {
+    pixelId: string;
+    events: {
+        PageView: boolean;
+        InitiateCheckout: boolean;
+        Purchase: boolean;
+        AddToCart: boolean;
+        ViewContent: boolean;
+        Search: boolean;
+        AddToWishlist: boolean;
+        CompleteRegistration: boolean;
+    };
+}
+/**
+ * Meta Conversion API config
+ */
+export interface MetaConversionTrackingConfig extends BaseTrackingConfig {
+    accessToken: string;
+    pixelId: string;
+    publishPurchaseIfNewCustomerOnly: boolean;
+}
+/**
+ * Google Tag Manager config
+ */
+export interface GTMTrackingConfig extends BaseTrackingConfig {
+    containerId: string;
+    events: {
+        PageView: boolean;
+        InitiateCheckout: boolean;
+        Purchase: boolean;
+        AddToCart: boolean;
+        ViewContent: boolean;
+    };
+}
+/**
+ * Union of all tracking configs.
+ * This mirrors `TrackingFormValues` from the CRM.
+ */
+export type PixelConfig = PixelTrackingConfig | SnapchatTrackingConfig | MetaConversionTrackingConfig | GTMTrackingConfig;
 /**
  * Runtime step configuration injected from the CRM
- * Contains payment flows, static resources, scripts, and pixel tracking configs
+ * Contains payment flows, static resources, scripts, and tracking configs
  */
 export interface RuntimeStepConfig {
     payment?: {
@@ -16,7 +86,13 @@ export interface RuntimeStepConfig {
         content: string;
         position?: 'head-start' | 'head-end' | 'body-start' | 'body-end';
     }>;
-    pixels?: Record<string, string>;
+    pixels?: {
+        [TrackingProvider.FACEBOOK]?: PixelTrackingConfig[];
+        [TrackingProvider.TIKTOK]?: PixelTrackingConfig[];
+        [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
+        [TrackingProvider.META_CONVERSION]?: MetaConversionTrackingConfig[];
+        [TrackingProvider.GTM]?: GTMTrackingConfig[];
+    };
 }
 /**
  * Local funnel configuration for development
@@ -34,7 +110,7 @@ export interface LocalFunnelConfig {
     /** Custom scripts for local testing */
     scripts?: RuntimeStepConfig['scripts'];
     /** Pixel tracking config */
-    pixels?: Record<string, string>;
+    pixels?: RuntimeStepConfig['pixels'];
 }
 /**
  * Load local funnel config from /config/funnel.local.json (for local dev only)
@@ -85,6 +161,17 @@ export declare function getAssignedStaticResources(): Record<string, string> | u
  * Returns only enabled scripts, filtered by position if specified
  */
 export declare function getAssignedScripts(position?: 'head-start' | 'head-end' | 'body-start' | 'body-end'): RuntimeStepConfig['scripts'];
+/**
+ * Get assigned pixel tracking configuration (normalized to arrays)
+ * Always returns arrays of PixelConfig for consistent consumption.
+ */
+export declare function getAssignedPixels(): {
+    [TrackingProvider.FACEBOOK]?: PixelTrackingConfig[];
+    [TrackingProvider.TIKTOK]?: PixelTrackingConfig[];
+    [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
+    [TrackingProvider.META_CONVERSION]?: MetaConversionTrackingConfig[];
+    [TrackingProvider.GTM]?: GTMTrackingConfig[];
+} | undefined;
 export interface FunnelClientConfig {
     apiClient: ApiClient;
     debugMode?: boolean;

package/dist/v2/core/funnelClient.js

@@ -1,9 +1,21 @@
-import { FunnelResource, FunnelActionType } from './resources/funnel';
-import { EventDispatcher } from './utils/eventDispatcher';
-import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
 import { detectEnvironment } from './config/environment';
+import { FunnelActionType, FunnelResource } from './resources/funnel';
+import { EventDispatcher } from './utils/eventDispatcher';
 import { getSDKParams } from './utils/previewMode';
 import { injectPreviewModeIndicator } from './utils/previewModeIndicator';
+import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
+/**
+ * Tracking providers supported by the SDK.
+ * Mirrors `TrackingType` in `apps/crm-app/.../types/tracking.ts`.
+ */
+export var TrackingProvider;
+(function (TrackingProvider) {
+    TrackingProvider["FACEBOOK"] = "facebook";
+    TrackingProvider["TIKTOK"] = "tiktok";
+    TrackingProvider["SNAPCHAT"] = "snapchat";
+    TrackingProvider["META_CONVERSION"] = "meta_conversion";
+    TrackingProvider["GTM"] = "gtm";
+})(TrackingProvider || (TrackingProvider = {}));
 /**
  * Get the funnel ID from the injected HTML
  * Returns undefined if not available
@@ -268,6 +280,31 @@ export function getAssignedScripts(position) {
     }
     return scripts.length > 0 ? scripts : undefined;
 }
+/**
+ * Get assigned pixel tracking configuration (normalized to arrays)
+ * Always returns arrays of PixelConfig for consistent consumption.
+ */
+export function getAssignedPixels() {
+    const stepConfig = getAssignedStepConfig();
+    const rawPixels = stepConfig?.pixels;
+    if (!rawPixels || typeof rawPixels !== 'object')
+        return undefined;
+    const normalized = {};
+    for (const [key, value] of Object.entries(rawPixels)) {
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            // Already an array
+            normalized[key] = value;
+        }
+        else if (typeof value === 'object') {
+            // Single object - wrap in array
+            normalized[key] = [value];
+        }
+        // Skip invalid entries
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 export class FunnelClient {
     constructor(config) {
         this.eventDispatcher = new EventDispatcher();
@@ -401,6 +438,8 @@ export class FunnelClient {
                 funnelEnv: funnelEnv || undefined, // 🎯 Pass funnel environment (staging/production)
                 tagadaClientEnv: sdkParams.tagadaClientEnv, // 🎯 Pass client environment override
                 tagadaClientBaseUrl: sdkParams.tagadaClientBaseUrl, // 🎯 Pass custom API base URL
+                currency: sdkParams.currency, // 🌍 Pass display currency override
+                locale: sdkParams.locale, // 🌍 Pass display locale override
             });
             if (response.success && response.context) {
                 const enriched = this.enrichContext(response.context);

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

@@ -485,6 +485,16 @@ export interface FunnelInitializeRequest {
      * Forces custom API base URL (e.g., for local development with ngrok)
      */
     tagadaClientBaseUrl?: string;
+    /**
+     * 🌍 Display currency override (e.g., 'USD', 'EUR')
+     * Forces specific currency for display purposes
+     */
+    currency?: string;
+    /**
+     * 🌍 Display locale override (e.g., 'en', 'fr')
+     * Forces specific locale for display purposes
+     */
+    locale?: string;
 }
 export interface FunnelInitializeResponse {
     success: boolean;

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

@@ -9,7 +9,7 @@ export interface Payment {
     subStatus: string;
     requireAction: 'none' | 'redirect' | 'error' | 'radar';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar';
+        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar';
         url?: string;
         processed: boolean;
         processorId?: string;
@@ -31,12 +31,18 @@ export interface Payment {
                 orderId?: string;
                 publishableKey?: string;
             };
+            provider?: string;
+            isTest?: boolean;
         };
         redirectUrl?: string;
         resumeToken?: string;
         message?: string;
         errorCode?: string;
     };
+    order?: {
+        id: string;
+        checkoutSessionId: string;
+    };
 }
 export interface PaymentResponse {
     paymentId: string;
@@ -149,6 +155,11 @@ export declare class PaymentsResource {
      */
     createApplePayPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
     applePayToken: ApplePayToken): Promise<PaymentInstrumentResponse>;
+    /**
+     * Create Google Pay payment instrument
+     */
+    createGooglePayPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
+    googlePayToken: any): Promise<PaymentInstrumentResponse>;
     /**
      * Helper function to format expiry date
      */
@@ -198,6 +209,7 @@ export declare class PaymentsResource {
         finixRadarSessionData?: Record<string, unknown>;
         stripeRadarSessionId?: string;
         stripeRadarSessionData?: Record<string, unknown>;
+        airwallexRadarSessionId?: string;
     }): Promise<{
         success: boolean;
         radarSessionId: string;
@@ -207,4 +219,12 @@ export declare class PaymentsResource {
      * This resumes the payment flow that was paused for additional authentication/verification
      */
     completePaymentAfterAction(paymentId: string): Promise<Payment>;
+    /**
+     * Update 3DS session status (used for Airwallex 3DS return handling)
+     */
+    updateThreedsStatus(data: {
+        paymentId: string;
+        status: 'succeeded' | 'failed' | 'pending';
+        paymentIntentId: string;
+    }): Promise<any>;
 }

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

@@ -78,6 +78,34 @@ export class PaymentsResource {
         const response = await this.apiClient.post('/api/v1/payment/create-payment-instrument', { paymentInstrumentData });
         return response;
     }
+    /**
+     * Create Google Pay payment instrument
+     */
+    async createGooglePayPaymentInstrument(basisTheory, // BasisTheory instance from @basis-theory/basis-theory-react
+    googlePayToken // Token from Basis Theory Google Pay tokenization
+    ) {
+        if (!basisTheory) {
+            throw new Error('Payment processor not initialized');
+        }
+        if (!googlePayToken.id) {
+            throw new Error('Google Pay token is missing');
+        }
+        const paymentInstrumentData = {
+            type: 'google_pay',
+            token: googlePayToken.id,
+            dpanType: googlePayToken.type,
+            card: {
+                bin: googlePayToken.card.bin,
+                last4: googlePayToken.card.last4,
+                expirationMonth: googlePayToken.card.expiration_month,
+                expirationYear: googlePayToken.card.expiration_year,
+                brand: googlePayToken.card.brand,
+            },
+            authMethod: googlePayToken?.details?.auth_method,
+        };
+        const response = await this.apiClient.post('/api/v1/payment/create-payment-instrument', { paymentInstrumentData });
+        return response;
+    }
     /**
      * Helper function to format expiry date
      */
@@ -154,4 +182,10 @@ export class PaymentsResource {
             paymentId,
         });
     }
+    /**
+     * Update 3DS session status (used for Airwallex 3DS return handling)
+     */
+    async updateThreedsStatus(data) {
+        return this.apiClient.post('/api/v1/threeds/status', data);
+    }
 }

package/dist/v2/core/utils/currency.d.ts

@@ -8,6 +8,20 @@ export interface Currency {
     name: string;
     decimalPlaces: number;
 }
+/**
+ * Format money amount from minor units (cents) to a formatted string
+ *
+ * @param amountMinorUnits - Amount in minor units (e.g., 12345 for $123.45)
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR")
+ * @param locale - Locale for formatting (default: "en-US")
+ * @returns Formatted money string (e.g., "$123.45")
+ *
+ * @example
+ * formatMoney(12345, 'USD') // "$123.45"
+ * formatMoney(10000, 'EUR', 'de-DE') // "100,00 €"
+ * formatMoney(1000, 'JPY') // "¥1,000"
+ */
+export declare function formatMoney(amountMinorUnits: number, currencyCode?: string, locale?: string): string;
 export declare class CurrencyUtils {
     /**
      * Get currency from context or fallback to default

package/dist/v2/core/utils/currency.js

@@ -2,6 +2,46 @@
  * Currency Utility Functions
  * Pure functions for currency management
  */
+/**
+ * Format money amount from minor units (cents) to a formatted string
+ *
+ * @param amountMinorUnits - Amount in minor units (e.g., 12345 for $123.45)
+ * @param currencyCode - ISO 4217 currency code (e.g., "USD", "EUR")
+ * @param locale - Locale for formatting (default: "en-US")
+ * @returns Formatted money string (e.g., "$123.45")
+ *
+ * @example
+ * formatMoney(12345, 'USD') // "$123.45"
+ * formatMoney(10000, 'EUR', 'de-DE') // "100,00 €"
+ * formatMoney(1000, 'JPY') // "¥1,000"
+ */
+export function formatMoney(amountMinorUnits, currencyCode = 'USD', locale = 'en-US') {
+    const decimalPlaces = CurrencyUtils.getDecimalPlaces(currencyCode);
+    // Convert minor units to major units
+    // Backend stores amounts with 2 decimal places for all currencies
+    // For currencies with 0 decimal places (JPY, KRW, etc.), divide by 100
+    let value;
+    if (decimalPlaces === 0) {
+        // For zero-decimal currencies, backend still stores with 2 decimals
+        value = amountMinorUnits / 100;
+    }
+    else {
+        value = amountMinorUnits / Math.pow(10, decimalPlaces);
+    }
+    try {
+        return new Intl.NumberFormat(locale, {
+            style: 'currency',
+            currency: currencyCode,
+            minimumFractionDigits: decimalPlaces,
+            maximumFractionDigits: decimalPlaces,
+        }).format(value);
+    }
+    catch {
+        // Fallback if Intl.NumberFormat fails
+        const symbol = CurrencyUtils.getCurrencySymbol(currencyCode);
+        return `${symbol}${value.toFixed(decimalPlaces)}`;
+    }
+}
 export class CurrencyUtils {
     /**
      * Get currency from context or fallback to default

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

@@ -12,3 +12,4 @@ export * from './postPurchases';
 export * from './orderBump';
 export * from './sessionStorage';
 export * from './funnelQueryKeys';
+export * from './configHotReload';

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

@@ -12,3 +12,5 @@ export * from './postPurchases';
 export * from './orderBump';
 export * from './sessionStorage';
 export * from './funnelQueryKeys';
+// Config hot reload for live preview editing
+export * from './configHotReload';

package/dist/v2/core/utils/pluginConfig.d.ts

@@ -22,6 +22,14 @@ export type RawPluginConfig<TConfig = Record<string, any>> = {
     basePath?: string;
     config?: any;
 } & TConfig;
+/**
+ * Synchronously get plugin config from meta tags
+ * This is a lightweight sync alternative to loadPluginConfig
+ * Use this when you need immediate config access (e.g., in CDN bundles)
+ *
+ * @returns Plugin config from meta tags or defaults
+ */
+export declare function getPluginConfig(): PluginConfig;
 /**
  * Core plugin config loading function
  *

package/dist/v2/core/utils/pluginConfig.js

@@ -154,9 +154,37 @@ const loadStaticResources = async () => {
  * Helper to get content from meta tag
  */
 const getMetaContent = (name) => {
+    if (typeof document === 'undefined')
+        return undefined;
     const metaTag = document.querySelector(`meta[name="${name}"]`);
     return metaTag?.getAttribute('content') || undefined;
 };
+/**
+ * Synchronously get plugin config from meta tags
+ * This is a lightweight sync alternative to loadPluginConfig
+ * Use this when you need immediate config access (e.g., in CDN bundles)
+ *
+ * @returns Plugin config from meta tags or defaults
+ */
+export function getPluginConfig() {
+    if (typeof document === 'undefined') {
+        return { basePath: '/', config: {} };
+    }
+    const storeId = getMetaContent('x-plugin-store-id');
+    const accountId = getMetaContent('x-plugin-account-id');
+    const basePath = getMetaContent('x-plugin-base-path') || '/';
+    let config = {};
+    try {
+        const encodedConfig = getMetaContent('x-plugin-config');
+        if (encodedConfig) {
+            config = JSON.parse(decodeURIComponent(encodedConfig));
+        }
+    }
+    catch (error) {
+        console.warn('[TagadaSDK] Failed to parse plugin config from meta tag:', error);
+    }
+    return { storeId, accountId, basePath, config };
+}
 /**
  * Load production config from meta tags (HIGHEST PRIORITY)
  * Meta tags are injected by the plugin middleware during HTML serving

package/dist/v2/core/utils/previewMode.d.ts

@@ -48,6 +48,10 @@ export interface SDKOverrideParams {
     tagadaClientEnv?: 'production' | 'development' | 'local';
     /** Force custom API base URL - overrides environment-based URL */
     tagadaClientBaseUrl?: string;
+    /** Display currency override (e.g., 'USD', 'EUR') */
+    currency?: string;
+    /** Display locale override (e.g., 'en', 'fr') */
+    locale?: string;
 }
 /**
  * Check if force reset is active (simulates hard refresh)

package/dist/v2/core/utils/previewMode.js

@@ -34,6 +34,8 @@ const STORAGE_KEYS = {
     FORCE_RESET: 'tgd_force_reset',
     CLIENT_ENV: 'tgd_client_env',
     CLIENT_BASE_URL: 'tgd_client_base_url',
+    CURRENCY: 'tgd_currency',
+    LOCALE: 'tgd_locale',
 };
 /**
  * Check if force reset is active (simulates hard refresh)
@@ -173,6 +175,30 @@ export function getSDKParams() {
             tagadaClientBaseUrl = storageBaseUrl;
         }
     }
+    // Get display currency (URL > localStorage > cookie)
+    let currency;
+    const urlCurrency = urlParams.get('currency');
+    if (urlCurrency) {
+        currency = urlCurrency;
+    }
+    else {
+        const storageCurrency = getFromStorage(STORAGE_KEYS.CURRENCY) || getFromCookie(STORAGE_KEYS.CURRENCY);
+        if (storageCurrency) {
+            currency = storageCurrency;
+        }
+    }
+    // Get display locale (URL > localStorage > cookie)
+    let locale;
+    const urlLocale = urlParams.get('locale');
+    if (urlLocale) {
+        locale = urlLocale;
+    }
+    else {
+        const storageLocale = getFromStorage(STORAGE_KEYS.LOCALE) || getFromCookie(STORAGE_KEYS.LOCALE);
+        if (storageLocale) {
+            locale = storageLocale;
+        }
+    }
     return {
         forceReset,
         token,
@@ -183,6 +209,8 @@ export function getSDKParams() {
         funnelEnv,
         tagadaClientEnv,
         tagadaClientBaseUrl,
+        currency,
+        locale,
     };
 }
 /**