@tagadapay/plugin-sdk 2.8.8 → 2.8.9

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

@@ -6,6 +6,7 @@ import axios from 'axios';
 export class ApiClient {
     constructor(config) {
         this.currentToken = null;
+        this.tokenProvider = null;
         this.axios = axios.create({
             baseURL: config.baseURL,
             timeout: config.timeout || 30000,
@@ -15,12 +16,28 @@ export class ApiClient {
             },
         });
         // Request interceptor for logging and auth
-        this.axios.interceptors.request.use((config) => {
-            console.log(`[SDK] Making ${config.method?.toUpperCase()} request to: ${config.baseURL}${config.url}`);
-            console.log('[SDK] Request headers:', config.headers);
-            if (config.data) {
-                console.log('[SDK] Request body:', config.data);
+        this.axios.interceptors.request.use(async (config) => {
+            // Check if we need to wait for token
+            if (!config.skipAuth && !this.currentToken && this.tokenProvider) {
+                try {
+                    console.log('[SDK] Waiting for token...');
+                    const token = await this.tokenProvider();
+                    if (token) {
+                        this.updateToken(token);
+                        // Ensure header is set on this specific request config
+                        config.headers['x-cms-token'] = token;
+                    }
+                }
+                catch (error) {
+                    console.error('[SDK] Failed to get token from provider:', error);
+                }
             }
+            // Ensure token is in headers if we have it (and not skipped)
+            if (!config.skipAuth && this.currentToken) {
+                config.headers['x-cms-token'] = this.currentToken;
+            }
+            console.log(`[SDK] Making ${config.method?.toUpperCase()} request to: ${config.baseURL || ''}${config.url}`);
+            // console.log('[SDK] Request headers:', config.headers);
             return config;
         }, (error) => {
             console.error('[SDK] Request error:', error);
@@ -28,14 +45,18 @@ export class ApiClient {
         });
         // Response interceptor for logging
         this.axios.interceptors.response.use((response) => {
-            console.log('[SDK] Response status:', response.status);
-            console.log('[SDK] Response data:', response.data);
+            // console.log('[SDK] Response status:', response.status);
             return response;
         }, (error) => {
-            console.error('[SDK] Response error:', error);
+            console.error('[SDK] Response error:', error.message);
             return Promise.reject(error instanceof Error ? error : new Error(String(error)));
         });
     }
+    // Set a provider that returns a promise resolving to the token
+    // This allows requests to wait until the token is ready
+    setTokenProvider(provider) {
+        this.tokenProvider = provider;
+    }
     // Convenience methods
     async get(url, config) {
         const response = await this.axios.get(url, config);
@@ -69,7 +90,7 @@ export class ApiClient {
         this.currentToken = token;
         if (token) {
             this.setHeader('x-cms-token', token);
-            console.log('[SDK] Token updated in ApiClient:', token.substring(0, 8) + '...');
+            // console.log('[SDK] Token updated in ApiClient:', token.substring(0, 8) + '...');
         }
         else {
             this.removeHeader('x-cms-token');

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

@@ -391,6 +391,14 @@ export interface SimpleFunnelContext<TCustom = {}> {
      * Only moves forward, never backward - used for analytics
      */
     furthestStepId?: string;
+    /**
+     * ✅ Environment context (staging or production)
+     * - Determined at session initialization based on entry URL
+     * - Ensures all navigation stays in the same environment
+     * - 'staging': Uses funnel.config (alias domains like funnel--store.cdn.tagadapay.com)
+     * - 'production': Uses funnel.productionConfig (custom domains)
+     */
+    environment?: 'staging' | 'production';
     startedAt: number;
     lastActivityAt: number;
     /**
@@ -416,6 +424,12 @@ export interface FunnelInitializeRequest {
     funnelId?: string;
     entryStepId?: string;
     existingSessionId?: string;
+    /**
+     * Current URL for session synchronization (browser back/forward handling)
+     * If not provided, SDK will automatically use window.location.href
+     * @example '/checkout', 'https://store.com/payment'
+     */
+    currentUrl?: string;
 }
 export interface FunnelInitializeResponse {
     success: boolean;

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

@@ -76,9 +76,32 @@ export interface PaymentOptions {
     threedsProvider?: 'basis_theory';
     initiatedBy?: 'customer' | 'merchant';
     source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+    /** @deprecated Use onPaymentSuccess instead - this will be removed in v3 */
     onSuccess?: (response: PaymentResponse) => void;
+    /** @deprecated Use onPaymentFailed instead - this will be removed in v3 */
     onFailure?: (error: string) => void;
     onRequireAction?: (payment: Payment) => void;
+    /**
+     * Called when payment succeeds (matches FunnelActionType.PAYMENT_SUCCESS)
+     * Use this with useFunnel's next() to navigate to the next step
+     * This replaces automatic redirects to /post or /thankyou
+     */
+    onPaymentSuccess?: (response: PaymentResponse) => void;
+    /**
+     * Called when payment fails (matches FunnelActionType.PAYMENT_FAILED)
+     * Use this to handle retry logic, show errors, or trigger funnel failure flows
+     */
+    onPaymentFailed?: (error: {
+        code: string;
+        message: string;
+        payment?: Payment;
+    }) => void;
+    /**
+     * Disable automatic redirects to /post or /thankyou (default: true)
+     * Set to false only for legacy implementations without funnel orchestrator
+     * The funnel orchestrator handles navigation automatically with useFunnel
+     */
+    disableAutoRedirect?: boolean;
 }
 export interface CardPaymentMethod {
     cardNumber: string;

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

@@ -0,0 +1,271 @@
+/**
+ * Types for the Tagada Pay SDK Core
+ */
+export type Environment = 'production' | 'development' | 'local';
+export interface ApiConfig {
+    baseUrl: string;
+    endpoints: {
+        checkout: {
+            sessionInit: string;
+            sessionStatus: string;
+        };
+        customer: {
+            profile: string;
+            session: string;
+        };
+        store: {
+            config: string;
+        };
+    };
+}
+export interface EnvironmentConfig {
+    environment: Environment;
+    apiConfig: ApiConfig;
+}
+export interface Customer {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    isAuthenticated: boolean;
+    role: 'authenticated' | 'anonymous';
+}
+export type SessionRole = 'authenticated' | 'anonymous';
+export interface Session {
+    sessionId: string;
+    storeId: string;
+    accountId: string;
+    customerId: string;
+    role: SessionRole;
+    isValid: boolean;
+    isLoading: boolean;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    customer: Customer | null;
+    session: Session | null;
+}
+export interface Locale {
+    locale: string;
+    language: string;
+    region: string;
+    messages?: Record<string, string>;
+}
+export interface Currency {
+    code: string;
+    symbol: string;
+    name: string;
+}
+export interface Store {
+    id: string;
+    name: string;
+    domain: string;
+    currency: string;
+    locale: string;
+    presentmentCurrencies: string[];
+    chargeCurrencies: string[];
+}
+export interface PickupPoint {
+    id: string;
+    name: string;
+    country: string;
+    postal_code: string;
+    city: string;
+    address: string;
+    address2?: string;
+    house_number?: string;
+    phone?: string;
+    email?: string;
+    latitude?: number;
+    longitude?: number;
+    opening_hours?: string;
+    extra_info?: string;
+}
+export interface OrderItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    adjustedAmount: number;
+    currency: string;
+    recurring?: boolean;
+    interval?: 'day' | 'week' | 'month' | 'year' | null;
+    intervalCount?: number | null;
+    orderLineItemProduct?: {
+        name: string;
+    };
+    orderLineItemVariant?: {
+        name: string;
+        imageUrl: string | null;
+    };
+    subscriptionSettings?: {
+        trial?: boolean;
+    };
+}
+export interface OrderSummary {
+    currency: string;
+    totalPromotionAmount: number;
+    totalTaxAmount: number;
+    shippingCost: number;
+    shippingCostIsFree: boolean;
+    subtotalAmount: number;
+    subtotalAdjustedAmount: number;
+    totalAdjustedAmount: number;
+    adjustments?: {
+        type: string;
+        amount: number;
+        description: string;
+    }[];
+}
+export interface OrderAddress {
+    firstName: string;
+    lastName: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    state: string;
+    postal: string;
+    country: string;
+    phone?: string;
+}
+export interface Order {
+    id: string;
+    currency: string;
+    paidAmount: number;
+    status: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+    items: OrderItem[];
+    summaries?: OrderSummary[];
+    shippingAddress?: OrderAddress;
+    billingAddress?: OrderAddress;
+    pickupAddress?: PickupPoint;
+    checkoutSession?: {
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    relatedOrders?: Order[];
+}
+export interface PaymentSummary {
+    id: string;
+    status: string;
+    amount: number;
+    currency: string;
+    createdAt: string;
+    updatedAt?: string;
+    provider?: string;
+    metadata?: Record<string, any>;
+}
+export interface PromotionSummary {
+    id: string;
+    code?: string | null;
+    type?: string;
+    amount?: number;
+    description?: string | null;
+}
+export interface OrderAdjustmentSummary {
+    type: string;
+    amount: number;
+    description: string;
+}
+export interface OrderWithRelations extends Order {
+    customer?: Customer;
+    store?: Store;
+    account?: {
+        id: string;
+        name?: string;
+    } | undefined;
+    items: OrderItem[];
+    payments?: PaymentSummary[];
+    summaries: OrderSummary[];
+    checkoutSession?: {
+        id?: string;
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    promotions?: PromotionSummary[];
+    subscriptions?: any[];
+    adjustments: OrderAdjustmentSummary[];
+}
+export interface CustomerAddress {
+    company?: string;
+    firstName: string;
+    lastName: string;
+    address1: string;
+    city: string;
+    country: string;
+    state: string;
+    postal: string;
+    phone?: string;
+    email?: string;
+}
+export interface CustomerOrderSummary {
+    id: string;
+    storeId: string;
+    accountId: string;
+    createdAt: string;
+    updatedAt: string;
+    status: string;
+    cancelledAt: string | null;
+    cancelledReason: string | null;
+    paidAt: string | null;
+    paidAmount: number | null;
+    openAt: string | null;
+    abandonedAt: string | null;
+    currency: string;
+    externalCustomerType: string | null;
+    externalCustomerId: string | null;
+    externalOrderId: string | null;
+    billingAddress: CustomerAddress;
+    shippingAddress: Omit<CustomerAddress, 'email'>;
+    pickupAddress: any | null;
+    taxesIncluded: boolean;
+    draft: boolean;
+    checkoutSessionId: string | null;
+    sessionHash: string | null;
+    customerId: string;
+    createdFrom: string | null;
+    paymentInstrumentId: string | null;
+    refundedAt: string | null;
+    refundedAmount: number | null;
+    metadata?: Record<string, any>;
+}
+export interface CustomerInfos {
+    customer: {
+        id: string;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        externalCustomerId: string | null;
+        lastOrderId: string | null;
+        accountId: string;
+        storeId: string;
+        billingAddress: CustomerAddress | null;
+        shippingAddress: Omit<CustomerAddress, 'email'> | null;
+        currency: string | null;
+        locale: string | null;
+        draft: boolean;
+        acceptsMarketing: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, any>;
+        device: any | null;
+        orders: CustomerOrderSummary[];
+        subscriptions: any[];
+    };
+    promotionCodes: any[];
+}
+export interface SessionInitResponse {
+    store: Store;
+    locale: string;
+    messages?: Record<string, string>;
+    customer?: Customer;
+    session?: Session;
+}
+export interface AnonymousTokenResponse {
+    token: string;
+}

package/dist/v2/core/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the Tagada Pay SDK Core
+ */
+export {};

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

@@ -0,0 +1,39 @@
+export interface DeviceInfo {
+    userAgent: {
+        browser: {
+            name: string;
+            version: string;
+        };
+        os: {
+            name: string;
+            version: string;
+        };
+        device?: {
+            type: string;
+            model: string;
+        };
+    };
+    screenResolution: {
+        width: number;
+        height: number;
+    };
+    timeZone: string;
+}
+/**
+ * Get browser locale
+ */
+export declare function getBrowserLocale(): string;
+/**
+ * Collect all device information
+ */
+export declare function collectDeviceInfo(): DeviceInfo;
+/**
+ * Get URL parameters for session initialization
+ */
+export declare function getUrlParams(): {
+    locale?: string;
+    currency?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+};

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

@@ -0,0 +1,162 @@
+/**
+ * Get basic browser information from user agent
+ */
+function getBrowserInfo() {
+    const userAgent = navigator.userAgent;
+    // Chrome
+    if (userAgent.includes('Chrome')) {
+        const match = /Chrome\/(\d+)/.exec(userAgent);
+        return { name: 'Chrome', version: match ? match[1] : 'unknown' };
+    }
+    // Firefox
+    if (userAgent.includes('Firefox')) {
+        const match = /Firefox\/(\d+)/.exec(userAgent);
+        return { name: 'Firefox', version: match ? match[1] : 'unknown' };
+    }
+    // Safari
+    if (userAgent.includes('Safari') && !userAgent.includes('Chrome')) {
+        const match = /Version\/(\d+)/.exec(userAgent);
+        return { name: 'Safari', version: match ? match[1] : 'unknown' };
+    }
+    // Edge
+    if (userAgent.includes('Edge')) {
+        const match = /Edge\/(\d+)/.exec(userAgent);
+        return { name: 'Edge', version: match ? match[1] : 'unknown' };
+    }
+    return { name: 'unknown', version: 'unknown' };
+}
+/**
+ * Get basic OS information from user agent
+ */
+function getOSInfo() {
+    const userAgent = navigator.userAgent;
+    // Windows
+    if (userAgent.includes('Windows')) {
+        if (userAgent.includes('Windows NT 10.0'))
+            return { name: 'Windows', version: '10' };
+        if (userAgent.includes('Windows NT 6.3'))
+            return { name: 'Windows', version: '8.1' };
+        if (userAgent.includes('Windows NT 6.2'))
+            return { name: 'Windows', version: '8' };
+        if (userAgent.includes('Windows NT 6.1'))
+            return { name: 'Windows', version: '7' };
+        return { name: 'Windows', version: 'unknown' };
+    }
+    // macOS
+    if (userAgent.includes('Mac OS X')) {
+        const match = /Mac OS X (\d+[._]\d+)/.exec(userAgent);
+        return { name: 'macOS', version: match ? match[1].replace('_', '.') : 'unknown' };
+    }
+    // iOS
+    if (userAgent.includes('iPhone') || userAgent.includes('iPad')) {
+        const match = /OS (\d+[._]\d+)/.exec(userAgent);
+        return { name: 'iOS', version: match ? match[1].replace('_', '.') : 'unknown' };
+    }
+    // Android
+    if (userAgent.includes('Android')) {
+        const match = /Android (\d+[.\d]*)/.exec(userAgent);
+        return { name: 'Android', version: match ? match[1] : 'unknown' };
+    }
+    // Linux
+    if (userAgent.includes('Linux')) {
+        return { name: 'Linux', version: 'unknown' };
+    }
+    return { name: 'unknown', version: 'unknown' };
+}
+/**
+ * Get device information
+ */
+function getDeviceInfo() {
+    const userAgent = navigator.userAgent;
+    // Mobile devices
+    if (userAgent.includes('iPhone')) {
+        return { type: 'mobile', model: 'iPhone' };
+    }
+    if (userAgent.includes('iPad')) {
+        return { type: 'tablet', model: 'iPad' };
+    }
+    if (userAgent.includes('Android')) {
+        if (userAgent.includes('Mobile')) {
+            return { type: 'mobile', model: 'Android' };
+        }
+        else {
+            return { type: 'tablet', model: 'Android' };
+        }
+    }
+    // Desktop (no specific device info)
+    return undefined;
+}
+/**
+ * Get screen resolution
+ */
+function getScreenResolution() {
+    return {
+        width: window.screen.width,
+        height: window.screen.height,
+    };
+}
+/**
+ * Get timezone
+ */
+function getTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    catch (error) {
+        console.error('Failed to get timezone:', error);
+        return 'UTC';
+    }
+}
+/**
+ * Get browser locale
+ */
+export function getBrowserLocale() {
+    try {
+        return navigator.language || 'en-US';
+    }
+    catch (error) {
+        console.error('Failed to get browser locale:', error);
+        return 'en-US';
+    }
+}
+/**
+ * Collect all device information
+ */
+export function collectDeviceInfo() {
+    if (typeof window === 'undefined') {
+        // Server-side fallback
+        return {
+            userAgent: {
+                browser: { name: 'unknown', version: 'unknown' },
+                os: { name: 'unknown', version: 'unknown' },
+            },
+            screenResolution: { width: 0, height: 0 },
+            timeZone: 'UTC',
+        };
+    }
+    return {
+        userAgent: {
+            browser: getBrowserInfo(),
+            os: getOSInfo(),
+            device: getDeviceInfo(),
+        },
+        screenResolution: getScreenResolution(),
+        timeZone: getTimeZone(),
+    };
+}
+/**
+ * Get URL parameters for session initialization
+ */
+export function getUrlParams() {
+    if (typeof window === 'undefined') {
+        return {};
+    }
+    const params = new URLSearchParams(window.location.search);
+    return {
+        locale: params.get('locale') || undefined,
+        currency: params.get('currency') || undefined,
+        utmSource: params.get('utm_source') || undefined,
+        utmMedium: params.get('utm_medium') || undefined,
+        utmCampaign: params.get('utm_campaign') || undefined,
+    };
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Simple event dispatcher for handling state changes in the SDK
+ */
+export type Listener<T> = (data: T) => void;
+export declare class EventDispatcher<T> {
+    private listeners;
+    subscribe(listener: Listener<T>): () => void;
+    notify(data: T): void;
+    clear(): void;
+}

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

@@ -0,0 +1,24 @@
+export class EventDispatcher {
+    constructor() {
+        this.listeners = new Set();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    notify(data) {
+        this.listeners.forEach((listener) => {
+            try {
+                listener(data);
+            }
+            catch (error) {
+                console.error('Error in event listener:', error);
+            }
+        });
+    }
+    clear() {
+        this.listeners.clear();
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Session } from '../types';
+/**
+ * Decode a JWT token to extract session information
+ * This is a simple client-side decoder - do not use for security validation
+ */
+export declare function decodeJWTClient(token: string): Session | null;
+/**
+ * Check if a JWT token is expired
+ */
+export declare function isTokenExpired(token: string): boolean;
+/**
+ * Get token expiration time
+ */
+export declare function getTokenExpiration(token: string): Date | null;