@tagadapay/plugin-sdk 3.1.5 → 3.1.9

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

@@ -26,11 +26,79 @@ export interface CheckoutInitParams {
         locale?: string;
     };
 }
+export interface UpsellTrigger {
+    id: string;
+    type: string;
+    productId: string | null;
+}
+export interface OrderBumpOfferVariant {
+    id: string;
+    name: string;
+    sku: string;
+    imageUrl: string;
+    active: boolean;
+    default: boolean;
+    createdAt: string;
+    updatedAt: string;
+    externalVariantId: string | null;
+    description: string;
+    currency: string | null;
+}
+export interface OrderBumpOfferProduct {
+    id: string;
+    name: string;
+}
+export interface PriceCurrencyOption {
+    rate: number;
+    amount: number;
+    lock: boolean;
+    date: string;
+}
+export interface OrderBumpOfferPrice {
+    id: string;
+    currencyOptions: Record<string, PriceCurrencyOption>;
+}
+export interface CheckoutOrderBumpOffer {
+    id: string;
+    type: string;
+    productId: string;
+    variantId: string;
+    priceId: string;
+    titleTrans: Record<string, string>;
+    descriptionTrans: Record<string, string>;
+    overrideImageUrl: string | null;
+    precheck: boolean;
+    displayPrice: boolean;
+    displayCompareAtPrice: boolean;
+    compareAtPriceDiscount: number;
+    quantity: number;
+    variant: OrderBumpOfferVariant;
+    product: OrderBumpOfferProduct;
+    price: OrderBumpOfferPrice;
+}
+export interface Upsell {
+    id: string;
+    type: string;
+    enabled: boolean;
+    triggers: UpsellTrigger[];
+    orderBumpOffers: CheckoutOrderBumpOffer[];
+}
+export interface Store {
+    id: string;
+    accountId: string;
+    name: string;
+    presentmentCurrencies: string[];
+    chargeCurrencies: string[];
+    upsells: Upsell[];
+    emailDomains: string[];
+    integrations: any[];
+}
 export interface CheckoutSession {
     id: string;
     checkoutToken: string;
     status: string;
     storeId: string;
+    store: Store;
     accountId: string;
     customerId: string;
     draft: boolean;

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

@@ -470,6 +470,31 @@ export interface FunnelInitializeRequest {
      * When false, disables all funnel tracking events (useful for iframed previews in config editor)
      */
     funnelTracking?: boolean;
+    /**
+     * 🎯 Funnel environment override ('staging' | 'production')
+     * Determines which funnel config to use
+     */
+    funnelEnv?: 'staging' | 'production';
+    /**
+     * 🎯 Tagada client environment override ('production' | 'development' | 'local')
+     * Forces specific API environment
+     */
+    tagadaClientEnv?: 'production' | 'development' | 'local';
+    /**
+     * 🎯 Tagada client base URL override
+     * 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

@@ -7,14 +7,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' | 'radar';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect';
+            type: 'redirect' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;
@@ -25,12 +25,24 @@ export interface Payment {
                 acsTransID: string;
                 messageVersion: string;
             };
+            radar?: {
+                merchantId?: string;
+                environment?: 'sandbox' | 'live';
+                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;
@@ -76,6 +88,12 @@ export interface PaymentOptions {
     threedsProvider?: 'basis_theory';
     initiatedBy?: 'customer' | 'merchant';
     source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+    /**
+     * Override the store's default payment flow
+     * If not provided, the SDK will auto-read from stepConfig.paymentFlowId (if available)
+     * If neither is set, the store's selectedPaymentFlowId will be used
+     */
+    paymentFlowId?: string;
     /** @deprecated Use onPaymentSuccess instead - this will be removed in v3 */
     onSuccess?: (response: PaymentResponse) => void;
     /** @deprecated Use onPaymentFailed instead - this will be removed in v3 */
@@ -137,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
      */
@@ -147,6 +170,7 @@ export declare class PaymentsResource {
     processPaymentDirect(checkoutSessionId: string, paymentInstrumentId: string, threedsSessionId?: string, options?: {
         initiatedBy?: 'customer' | 'merchant';
         source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+        paymentFlowId?: string;
     }): Promise<PaymentResponse>;
     /**
      * Get card payment instruments for customer
@@ -160,4 +184,47 @@ export declare class PaymentsResource {
      * Get payment status
      */
     getPaymentStatus(paymentId: string): Promise<Payment>;
+    /**
+     * Retrieve payment status from processor
+     * Used for external payment flows that require server-side status checks
+     */
+    retrievePayment(paymentId: string): Promise<{
+        retrieveResult?: {
+            status?: string;
+            message?: string;
+            success?: boolean;
+        };
+        paymentId: string;
+        transactionCreated?: boolean;
+        status?: string;
+        transactionId?: string;
+        message?: string;
+        success?: boolean;
+        error?: any;
+    }>;
+    saveRadarSession(data: {
+        orderId?: string;
+        checkoutSessionId?: string;
+        finixRadarSessionId?: string;
+        finixRadarSessionData?: Record<string, unknown>;
+        stripeRadarSessionId?: string;
+        stripeRadarSessionData?: Record<string, unknown>;
+        airwallexRadarSessionId?: string;
+    }): Promise<{
+        success: boolean;
+        radarSessionId: string;
+    }>;
+    /**
+     * Complete payment after an action (3DS, radar, etc.)
+     * 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
      */
@@ -95,13 +123,23 @@ export class PaymentsResource {
      * Process payment directly with checkout session
      */
     async processPaymentDirect(checkoutSessionId, paymentInstrumentId, threedsSessionId, options = {}) {
-        return this.apiClient.post('/api/public/v1/checkout/pay-v2', {
-            checkoutSessionId,
-            paymentInstrumentId,
-            ...(threedsSessionId && { threedsSessionId }),
-            ...(options.initiatedBy && { initiatedBy: options.initiatedBy }),
-            ...(options.source && { source: options.source }),
-        });
+        console.log('[PaymentsResource] processPaymentDirect START', options.paymentFlowId ? `(flow: ${options.paymentFlowId})` : '');
+        try {
+            const response = await this.apiClient.post('/api/public/v1/checkout/pay-v2', {
+                checkoutSessionId,
+                paymentInstrumentId,
+                ...(threedsSessionId && { threedsSessionId }),
+                ...(options.initiatedBy && { initiatedBy: options.initiatedBy }),
+                ...(options.source && { source: options.source }),
+                ...(options.paymentFlowId && { paymentFlowId: options.paymentFlowId }),
+            });
+            console.log('[PaymentsResource] processPaymentDirect SUCCESS:', response);
+            return response;
+        }
+        catch (error) {
+            console.error('[PaymentsResource] processPaymentDirect ERROR:', error);
+            throw error;
+        }
     }
     /**
      * Get card payment instruments for customer
@@ -123,4 +161,31 @@ export class PaymentsResource {
     async getPaymentStatus(paymentId) {
         return this.apiClient.get(`/api/v1/payments/${paymentId}`);
     }
+    /**
+     * Retrieve payment status from processor
+     * Used for external payment flows that require server-side status checks
+     */
+    async retrievePayment(paymentId) {
+        return this.apiClient.post('/api/v1/payments/retrieve', {
+            paymentId,
+        });
+    }
+    async saveRadarSession(data) {
+        return this.apiClient.post('/api/v1/radar-sessions', data);
+    }
+    /**
+     * Complete payment after an action (3DS, radar, etc.)
+     * This resumes the payment flow that was paused for additional authentication/verification
+     */
+    async completePaymentAfterAction(paymentId) {
+        return this.apiClient.post('/api/v1/payments/complete-after-3ds', {
+            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/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

@@ -85,7 +85,10 @@ const loadLocalDevConfig = async (configVariant = 'default') => {
 };
 /**
  * Load static resources for local development
- * Loads /config/resources.static.json
+ *
+ * Priority:
+ * 1. /config/funnel.local.json (NEW - recommended)
+ * 2. /config/resources.static.json (OLD - deprecated, for backward compatibility)
  */
 const loadStaticResources = async () => {
     try {
@@ -99,15 +102,47 @@ const loadStaticResources = async () => {
         if (!isLocalEnvironment(true)) {
             return null;
         }
-        // Load static resources file
-        console.log('🛠️ [V2] Attempting to load /config/resources.static.json...');
+        // ============================================================
+        // PRIORITY 1: NEW format - funnel.local.json
+        // Also populates the stepConfig cache for getAssignedStepConfig()
+        // ============================================================
+        try {
+            console.log('🛠️ [V2] Attempting to load /config/funnel.local.json...');
+            const funnelResponse = await fetch('/config/funnel.local.json');
+            if (funnelResponse.ok) {
+                const funnelConfig = await funnelResponse.json();
+                console.log('🛠️ [V2] ✅ Loaded local funnel config (NEW format):', funnelConfig);
+                // Also trigger loadLocalFunnelConfig to populate the cache
+                // Import dynamically to avoid circular dependency
+                const { loadLocalFunnelConfig } = await import('../funnelClient');
+                await loadLocalFunnelConfig();
+                // Return staticResources in the old format for backward compatibility
+                // The new stepConfig system reads from funnel.local.json via getAssignedStepConfig()
+                if (funnelConfig.staticResources) {
+                    // Transform flat format to old nested format for legacy compatibility
+                    const transformed = {};
+                    for (const [key, value] of Object.entries(funnelConfig.staticResources)) {
+                        transformed[key] = { id: value };
+                    }
+                    return transformed;
+                }
+                return null;
+            }
+        }
+        catch (e) {
+            console.log('🛠️ [V2] funnel.local.json not found, trying legacy format...');
+        }
+        // ============================================================
+        // PRIORITY 2: OLD format - resources.static.json (deprecated)
+        // ============================================================
+        console.log('🛠️ [V2] Attempting to load /config/resources.static.json (legacy)...');
         const response = await fetch('/config/resources.static.json');
         if (!response.ok) {
-            console.log('🛠️ [V2] resources.static.json not found or failed to load');
+            console.log('🛠️ [V2] No local static resources found');
             return null;
         }
         const staticResources = await response.json();
-        console.log('🛠️ [V2] ✅ Loaded local static resources:', staticResources);
+        console.log('🛠️ [V2] ✅ Loaded legacy static resources:', staticResources);
         return staticResources;
     }
     catch (error) {
@@ -119,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

@@ -42,10 +42,16 @@ export interface SDKOverrideParams {
     draft?: boolean;
     /** Enable/disable funnel tracking events (false in config editor iframe, true in funnel previews) */
     funnelTracking?: boolean;
+    /** Funnel environment (staging/production) - determines which funnel config to use */
+    funnelEnv?: 'staging' | 'production';
     /** Force specific environment (production/development/local) - overrides auto-detection */
     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)
@@ -68,6 +74,7 @@ export declare function getPreviewParams(): SDKOverrideParams;
 export declare function isDraftMode(): boolean;
 /**
  * Set draft mode in storage for persistence
+ * ⚠️ ONLY writes to localStorage (not cookies) to avoid resurrection issues
  */
 export declare function setDraftMode(draft: boolean): void;
 /**