@tagadapay/plugin-sdk 2.6.11 → 2.6.13

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

@@ -0,0 +1,71 @@
+import React, { ReactNode } from 'react';
+import { CheckoutData } from './useCheckout';
+export interface Address {
+    address1: string;
+    address2?: string;
+    lastName?: string;
+    firstName?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    postal?: string;
+    phone?: string;
+    email?: string;
+}
+type PaymentMethod = {
+    id: string;
+    type: string;
+    title: string;
+    iconUrl: string;
+    default: boolean;
+    metadata?: Record<string, unknown>;
+};
+type ExpressOrderLineItem = {
+    label: string;
+    amount: string;
+};
+type ExpressShippingMethod = {
+    label: string;
+    amount: string;
+    identifier: string;
+    detail: string;
+};
+export interface ExpressPaymentContextType {
+    applePayPaymentMethod?: PaymentMethod;
+    googlePayPaymentMethod?: PaymentMethod;
+    reComputeOrderSummary: () => Promise<{
+        lineItems: ExpressOrderLineItem[];
+        total: {
+            label: string;
+            amount: string;
+        };
+        shippingMethods: ExpressShippingMethod[];
+    } | undefined>;
+    loading?: boolean;
+    availableExpressPaymentMethodIds: string[];
+    setAvailableExpressPaymentMethodIds: (value: string[]) => void;
+    shippingMethods: ExpressShippingMethod[];
+    lineItems: ExpressOrderLineItem[];
+    handleAddExpressId: (id: string) => void;
+    updateCheckoutSessionValues: (input: {
+        data: {
+            shippingAddress: Address;
+            billingAddress?: Address | null;
+        };
+    }) => Promise<void>;
+    updateCustomerEmail: (input: {
+        data: {
+            email: string;
+        };
+    }) => Promise<void>;
+    error: string | null;
+    setError: (error: string | null) => void;
+}
+interface ExpressPaymentProviderProps {
+    children: ReactNode;
+    customerId?: string;
+    checkout?: CheckoutData;
+}
+export declare const ExpressPaymentProvider: React.FC<ExpressPaymentProviderProps>;
+export declare const useExpressPayment: () => ExpressPaymentContextType;
+export {};

package/dist/react/hooks/useExpressPayment.js

@@ -0,0 +1,158 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useCallback, useContext, useMemo, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { useOrderSummary } from './useOrderSummary';
+import { useShippingRates } from './useShippingRates';
+const ExpressPaymentContext = createContext(undefined);
+export const ExpressPaymentProvider = ({ children, customerId, checkout, }) => {
+    const { apiService } = useTagadaContext();
+    const [availableExpressPaymentMethodIds, setAvailableExpressPaymentMethodIds] = useState([]);
+    const [error, setError] = useState(null);
+    const [paymentMethods, setPaymentMethods] = useState(null);
+    const [isLoadingPaymentMethods, setIsLoadingPaymentMethods] = useState(false);
+    const checkoutSessionId = checkout?.checkoutSession.id;
+    // Fetch enabled payment methods for this checkout session
+    React.useEffect(() => {
+        let mounted = true;
+        const fetchPaymentMethods = async () => {
+            try {
+                if (!checkoutSessionId)
+                    return;
+                setIsLoadingPaymentMethods(true);
+                const response = await apiService.fetch(`/api/v1/payment-methods?checkoutSessionId=${encodeURIComponent(checkoutSessionId)}`);
+                if (mounted)
+                    setPaymentMethods(response);
+            }
+            catch (e) {
+                if (mounted)
+                    setPaymentMethods([]);
+            }
+            finally {
+                if (mounted)
+                    setIsLoadingPaymentMethods(false);
+            }
+        };
+        if (checkout)
+            void fetchPaymentMethods();
+        return () => {
+            mounted = false;
+        };
+    }, [apiService, checkoutSessionId]);
+    const handleAddExpressId = (id) => {
+        setAvailableExpressPaymentMethodIds((prev) => (prev.includes(id) ? prev : [...prev, id]));
+    };
+    // Base data hooks
+    const { orderSummary, isLoading: isLoadingOrderSummary, isRefetching: isRefetchingOrderSummary, refetch: refetchOrderSummary, } = useOrderSummary({ sessionId: checkoutSessionId });
+    const { shippingRates, refetch: refetchRates } = useShippingRates({ checkout });
+    const minorUnitsToCurrencyString = (amountMinor, currency) => {
+        if (!amountMinor || !currency)
+            return '0.00';
+        return (amountMinor / 100).toFixed(2);
+    };
+    const shippingMethods = useMemo(() => (shippingRates || []).map((rate) => ({
+        label: rate.shippingRateName,
+        amount: minorUnitsToCurrencyString(rate.amount, rate.currency),
+        identifier: rate.id,
+        detail: rate.description || '',
+    })), [shippingRates]);
+    const lineItems = useMemo(() => [
+        {
+            label: 'Subtotal',
+            amount: minorUnitsToCurrencyString(orderSummary?.subtotalAdjustedAmount, orderSummary?.currency),
+        },
+        {
+            label: 'Shipping',
+            amount: minorUnitsToCurrencyString(orderSummary?.shippingCost ?? 0, orderSummary?.currency),
+        },
+        {
+            label: 'Tax',
+            amount: minorUnitsToCurrencyString(orderSummary?.totalTaxAmount, orderSummary?.currency),
+        },
+    ], [
+        orderSummary?.subtotalAdjustedAmount,
+        orderSummary?.shippingCost,
+        orderSummary?.totalTaxAmount,
+        orderSummary?.currency,
+    ]);
+    const reComputeOrderSummary = useCallback(async () => {
+        try {
+            await refetchOrderSummary();
+            await refetchRates();
+            if (!orderSummary || !shippingRates)
+                return;
+            const recomputedLineItems = [
+                {
+                    label: 'Subtotal',
+                    amount: minorUnitsToCurrencyString(orderSummary.subtotalAdjustedAmount, orderSummary.currency),
+                },
+                {
+                    label: 'Shipping',
+                    amount: minorUnitsToCurrencyString(orderSummary.shippingCost ?? 0, orderSummary.currency),
+                },
+                {
+                    label: 'Tax',
+                    amount: minorUnitsToCurrencyString(orderSummary.totalTaxAmount, orderSummary.currency),
+                },
+            ];
+            const total = {
+                label: 'Order Total',
+                amount: minorUnitsToCurrencyString(orderSummary.totalAdjustedAmount, orderSummary.currency),
+            };
+            const recomputedShippingMethods = (shippingRates || []).map((rate) => ({
+                label: rate.shippingRateName,
+                amount: minorUnitsToCurrencyString(rate.amount, rate.currency),
+                identifier: rate.id,
+                detail: rate.description || '',
+            }));
+            return {
+                lineItems: recomputedLineItems,
+                total,
+                shippingMethods: recomputedShippingMethods,
+            };
+        }
+        catch (e) {
+            return undefined;
+        }
+    }, [orderSummary, shippingRates, refetchOrderSummary, refetchRates]);
+    const updateCheckoutSessionValues = useCallback(async (input) => {
+        await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/address`, {
+            method: 'POST',
+            body: input,
+        });
+    }, [apiService, checkoutSessionId]);
+    const updateCustomerEmail = useCallback(async (input) => {
+        if (!customerId)
+            return;
+        await apiService.fetch(`/api/v1/customers/${customerId}`, {
+            method: 'POST',
+            body: input,
+        });
+    }, [apiService, customerId]);
+    const enabledApplePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'apple_pay'), [paymentMethods]);
+    const enabledGooglePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'google_pay'), [paymentMethods]);
+    const loading = !paymentMethods || isLoadingPaymentMethods || isLoadingOrderSummary;
+    const contextValue = {
+        availableExpressPaymentMethodIds,
+        setAvailableExpressPaymentMethodIds,
+        applePayPaymentMethod: enabledApplePayPaymentMethod,
+        googlePayPaymentMethod: enabledGooglePayPaymentMethod,
+        shippingMethods,
+        lineItems,
+        reComputeOrderSummary,
+        loading,
+        handleAddExpressId,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        error,
+        setError,
+    };
+    const hasAnyEnabled = Boolean(enabledApplePayPaymentMethod || enabledGooglePayPaymentMethod);
+    return (_jsx(ExpressPaymentContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
+};
+export const useExpressPayment = () => {
+    const context = useContext(ExpressPaymentContext);
+    if (context === undefined) {
+        throw new Error('useExpressPayment must be used within an ExpressPaymentProvider');
+    }
+    return context;
+};

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/v2/core/resources/funnel.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Funnel Resource - API client for funnel navigation and session management
+ */
+import { ApiClient } from './apiClient';
+export interface FunnelEvent {
+    type: string;
+    data?: any;
+    timestamp?: string;
+}
+export interface FunnelNavigationAction {
+    type: 'redirect' | 'replace' | 'push' | 'external' | 'none';
+    url?: string;
+    data?: any;
+}
+export interface FunnelNavigationResult {
+    stepId: string;
+    action: FunnelNavigationAction;
+    context: SimpleFunnelContext;
+    tracking?: {
+        from: string;
+        to: string;
+        event: string;
+        timestamp: string;
+    };
+}
+export interface SimpleFunnelContext {
+    customerId: string;
+    storeId: string;
+    sessionId: string;
+    funnelId: string;
+    currentStepId: string;
+    previousStepId?: string;
+    startedAt: number;
+    lastActivityAt: number;
+    metadata?: Record<string, any>;
+}
+export interface FunnelInitializeRequest {
+    cmsSession: {
+        customerId: string;
+        storeId: string;
+        sessionId: string;
+        accountId: string;
+    };
+    funnelId?: string;
+    entryStepId?: string;
+    existingSessionId?: string;
+}
+export interface FunnelInitializeResponse {
+    success: boolean;
+    context?: SimpleFunnelContext;
+    error?: string;
+}
+export interface FunnelNavigateRequest {
+    sessionId: string;
+    event: FunnelEvent;
+    contextUpdates?: Partial<SimpleFunnelContext>;
+}
+export interface FunnelNavigateResponse {
+    success: boolean;
+    result?: {
+        stepId: string;
+        url?: string;
+        tracking?: {
+            from: string;
+            to: string;
+            event: string;
+            timestamp: string;
+        };
+    };
+    error?: string;
+}
+export interface FunnelContextUpdateRequest {
+    contextUpdates: Partial<SimpleFunnelContext>;
+}
+export interface FunnelContextUpdateResponse {
+    success: boolean;
+    error?: string;
+}
+export declare class FunnelResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Initialize a funnel session
+     */
+    initialize(request: FunnelInitializeRequest): Promise<FunnelInitializeResponse>;
+    /**
+     * Navigate to next step in funnel
+     */
+    navigate(request: FunnelNavigateRequest): Promise<FunnelNavigateResponse>;
+    /**
+     * Update funnel context
+     */
+    updateContext(sessionId: string, request: FunnelContextUpdateRequest): Promise<FunnelContextUpdateResponse>;
+    /**
+     * End funnel session
+     */
+    endSession(sessionId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get funnel session by ID
+     */
+    getSession(sessionId: string): Promise<{
+        success: boolean;
+        context?: SimpleFunnelContext;
+        error?: string;
+    }>;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Funnel Resource - API client for funnel navigation and session management
+ */
+export class FunnelResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Initialize a funnel session
+     */
+    async initialize(request) {
+        return this.apiClient.post('/api/v1/funnel/initialize', request);
+    }
+    /**
+     * Navigate to next step in funnel
+     */
+    async navigate(request) {
+        return this.apiClient.post('/api/v1/funnel/navigate', request);
+    }
+    /**
+     * Update funnel context
+     */
+    async updateContext(sessionId, request) {
+        return this.apiClient.patch(`/api/v1/funnel/context/${sessionId}`, request);
+    }
+    /**
+     * End funnel session
+     */
+    async endSession(sessionId) {
+        return this.apiClient.delete(`/api/v1/funnel/session/${sessionId}`);
+    }
+    /**
+     * Get funnel session by ID
+     */
+    async getSession(sessionId) {
+        return this.apiClient.get(`/api/v1/funnel/session/${sessionId}`);
+    }
+}

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

@@ -15,3 +15,4 @@ export * from './shippingRates';
 export * from './storeConfig';
 export * from './threeds';
 export * from './vipOffers';
+export * from './funnel';

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

@@ -15,3 +15,4 @@ export * from './shippingRates';
 export * from './storeConfig';
 export * from './threeds';
 export * from './vipOffers';
+export * from './funnel';

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

@@ -80,33 +80,66 @@ const loadLocalDevConfig = async (configVariant = 'default') => {
         return null;
     }
 };
+/**
+ * Helper to get content from meta tag
+ */
+const getMetaContent = (name) => {
+    const metaTag = document.querySelector(`meta[name="${name}"]`);
+    return metaTag?.getAttribute('content') || undefined;
+};
 /**
  * Load production config from headers and meta tags
  */
 const loadProductionConfig = async () => {
     try {
-        // Get headers
-        const response = await fetch(window.location.href, { method: 'HEAD' });
-        const storeId = response.headers.get('X-Plugin-Store-Id') || undefined;
-        const accountId = response.headers.get('X-Plugin-Account-Id') || undefined;
-        const basePath = response.headers.get('X-Plugin-Base-Path') || '/';
+        // Try to get headers first
+        let storeId;
+        let accountId;
+        let basePath;
+        try {
+            const response = await fetch(window.location.href, { method: 'HEAD' });
+            storeId = response.headers.get('X-Plugin-Store-Id') || undefined;
+            accountId = response.headers.get('X-Plugin-Account-Id') || undefined;
+            basePath = response.headers.get('X-Plugin-Base-Path') || undefined;
+        }
+        catch {
+            // Headers fetch failed, will fallback to meta tags
+        }
+        // Fallback to meta tags if headers are not available
+        if (!storeId) {
+            storeId = getMetaContent('x-plugin-store-id');
+        }
+        if (!accountId) {
+            accountId = getMetaContent('x-plugin-account-id');
+        }
+        if (!basePath) {
+            basePath = getMetaContent('x-plugin-base-path') || '/';
+        }
         // Get deployment config from meta tags
         let config = {};
         try {
-            const configMeta = document.querySelector('meta[name="x-plugin-config"]');
-            const encodedConfig = configMeta?.getAttribute('content');
+            const encodedConfig = getMetaContent('x-plugin-config');
             if (encodedConfig) {
                 const decodedConfig = decodeURIComponent(encodedConfig);
                 config = JSON.parse(decodedConfig);
             }
         }
-        catch {
-            // Deployment config is optional
+        catch (error) {
+            console.warn('Failed to parse plugin config from meta tag:', error);
+        }
+        // Final validation and warnings
+        if (!storeId) {
+            console.warn('⚠️ Plugin config: Store ID not found in headers or meta tags');
         }
-        console.log('🏭 Using production plugin config 2:', { storeId, accountId, basePath, config });
-        return { storeId, accountId, basePath, config };
+        if (!accountId) {
+            console.warn('⚠️ Plugin config: Account ID not found in headers or meta tags');
+        }
+        const result = { storeId, accountId, basePath: basePath || '/', config };
+        console.log('🏭 Using production plugin config:', result);
+        return result;
     }
-    catch {
+    catch (error) {
+        console.warn('Failed to load production config, using defaults:', error);
         return { basePath: '/', config: {} };
     }
 };

package/dist/v2/index.d.ts

@@ -20,4 +20,5 @@ export type { ShippingRate, ShippingRatesResponse } from './core/resources/shipp
 export type { ApplyDiscountResponse, Discount, DiscountCodeValidation, RemoveDiscountResponse } from './core/resources/discounts';
 export type { ToggleOrderBumpResponse, VipOffer, VipPreviewResponse } from './core/resources/vipOffers';
 export type { StoreConfig } from './core/resources/storeConfig';
-export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';
+export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext, FunnelInitializeRequest, FunnelInitializeResponse, FunnelNavigateRequest, FunnelNavigateResponse, FunnelContextUpdateRequest, FunnelContextUpdateResponse } from './core/resources/funnel';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers, useFunnel, useSimpleFunnel } from './react';

package/dist/v2/index.js

@@ -12,4 +12,4 @@ export * from './core/utils/currency';
 export * from './core/utils/pluginConfig';
 export * from './core/utils/products';
 // React exports (hooks and components only, types are exported above)
-export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useVipOffers, useFunnel, useSimpleFunnel } from './react';

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

@@ -0,0 +1,51 @@
+/**
+ * useFunnel Hook (v2) - TanStack Query-based funnel navigation
+ *
+ * Modern implementation using TanStack Query for state management
+ * and the v2 ApiClient for API calls.
+ */
+import { FunnelEvent, FunnelNavigationResult, SimpleFunnelContext } from '../../core/resources/funnel';
+export interface UseFunnelOptions {
+    funnelId?: string;
+    currentStepId?: string;
+    onNavigate?: (result: FunnelNavigationResult) => void | boolean;
+    onError?: (error: Error) => void;
+    autoInitialize?: boolean;
+    enabled?: boolean;
+}
+export interface UseFunnelResult {
+    next: (event: FunnelEvent) => Promise<any>;
+    goToStep: (stepId: string) => Promise<any>;
+    updateContext: (updates: Partial<SimpleFunnelContext>) => Promise<void>;
+    currentStep: {
+        id: string;
+    };
+    context: SimpleFunnelContext | null;
+    isLoading: boolean;
+    isInitialized: boolean;
+    initializeSession: (entryStepId?: string) => Promise<void>;
+    endSession: () => Promise<void>;
+    retryInitialization: () => Promise<void>;
+    initializationError: Error | null;
+    isSessionLoading: boolean;
+    sessionError: Error | null;
+    refetch: () => void;
+}
+/**
+ * React Hook for Funnel Navigation (Plugin SDK v2)
+ *
+ * Modern funnel navigation using TanStack Query for state management
+ * and the v2 ApiClient architecture.
+ */
+export declare function useFunnel(options: UseFunnelOptions): UseFunnelResult;
+/**
+ * Simplified funnel hook for basic step tracking (v2)
+ */
+export declare function useSimpleFunnel(funnelId: string, initialStepId?: string): {
+    currentStepId: string;
+    next: (event: FunnelEvent) => Promise<any>;
+    goToStep: (stepId: string) => Promise<any>;
+    isLoading: boolean;
+    context: SimpleFunnelContext | null;
+};
+export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from '../../core/resources/funnel';