@tagadapay/plugin-sdk 3.1.12 → 3.1.24

package/dist/v2/react/providers/ExpressPaymentMethodsProvider.d.ts

@@ -3,6 +3,7 @@
  * Manages express payment methods (Apple Pay, Google Pay, PayPal, Klarna)
  */
 import React, { ReactNode } from 'react';
+import { TagadaError } from '../../core/errors';
 import { CheckoutData } from '../../core/resources/checkout';
 import { Address, PaymentMethod } from '../../core/resources/expressPaymentMethods';
 type ExpressOrderLineItem = {
@@ -21,6 +22,7 @@ interface ExpressPaymentMethodsContextType {
     googlePayPaymentMethod?: PaymentMethod;
     paypalPaymentMethod?: PaymentMethod;
     klarnaPaymentMethod?: PaymentMethod;
+    stripeExpressPaymentMethod?: PaymentMethod;
     availableExpressPaymentMethodIds: string[];
     setAvailableExpressPaymentMethodIds: (value: string[]) => void;
     handleAddExpressId: (id: string) => void;
@@ -47,7 +49,7 @@ interface ExpressPaymentMethodsContextType {
         };
     }) => Promise<void>;
     loading?: boolean;
-    error: string | null;
+    error: TagadaError | null;
     setError: (error: string | null) => void;
 }
 interface ExpressPaymentMethodsProviderProps {

package/dist/v2/react/providers/ExpressPaymentMethodsProvider.js

@@ -5,6 +5,7 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
  */
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { createContext, useCallback, useMemo, useState } from 'react';
+import { TagadaError, TagadaErrorCode } from '../../core/errors';
 import { ExpressPaymentMethodsResource, } from '../../core/resources/expressPaymentMethods';
 import { getGlobalApiClient } from '../hooks/useApiQuery';
 import { useShippingRatesQuery } from '../hooks/useShippingRatesQuery';
@@ -169,7 +170,15 @@ export const ExpressPaymentMethodsProvider = ({ children, customerId, checkout,
     const googlePayPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'google_pay'), [paymentMethods]);
     const paypalPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'paypal'), [paymentMethods]);
     const klarnaPaymentMethod = useMemo(() => paymentMethods?.find((p) => p.type === 'klarna'), [paymentMethods]);
+    // Find a stripe_apm or tagadapay_apm integration with any express method enabled in any processor group.
+    // Backward compatible: existing configs with only apple_pay/google_pay continue to match.
+    const stripeExpressPaymentMethod = useMemo(() => {
+        const EXPRESS_METHOD_KEYS = ['apple_pay', 'google_pay', 'paypal', 'link', 'klarna_express'];
+        return paymentMethods?.find((p) => (p.type === 'stripe_apm' || p.type === 'tagadapay_apm') &&
+            p.settings?.processors?.some((g) => EXPRESS_METHOD_KEYS.some((key) => g?.methods?.[key]?.enabled === true)));
+    }, [paymentMethods]);
     const loading = !paymentMethods || isLoadingPaymentMethods;
+    const tagadaError = useMemo(() => error ? new TagadaError(error, { code: TagadaErrorCode.PAYMENT_FAILED }) : null, [error]);
     const contextValue = {
         paymentMethods,
         availableExpressPaymentMethodIds,
@@ -178,6 +187,7 @@ export const ExpressPaymentMethodsProvider = ({ children, customerId, checkout,
         googlePayPaymentMethod,
         paypalPaymentMethod,
         klarnaPaymentMethod,
+        stripeExpressPaymentMethod,
         shippingMethods,
         lineItems,
         reComputeOrderSummary,
@@ -185,9 +195,9 @@ export const ExpressPaymentMethodsProvider = ({ children, customerId, checkout,
         handleAddExpressId,
         updateCheckoutSessionValues,
         updateCustomerEmail,
-        error,
+        error: tagadaError,
         setError,
     };
-    const hasAnyEnabled = Boolean(applePayPaymentMethod || googlePayPaymentMethod || paypalPaymentMethod || klarnaPaymentMethod);
+    const hasAnyEnabled = Boolean(applePayPaymentMethod || googlePayPaymentMethod || paypalPaymentMethod || klarnaPaymentMethod || stripeExpressPaymentMethod);
     return (_jsx(ExpressPaymentMethodsContext.Provider, { value: contextValue, children: hasAnyEnabled ? _jsx(_Fragment, { children: children }) : _jsx(_Fragment, {}) }));
 };

package/dist/v2/react/providers/TagadaProvider.js

@@ -4,14 +4,14 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * TagadaProvider - Main provider component for the Tagada Pay React SDK
  */
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { Suspense, createContext, lazy, useCallback, useContext, useEffect, useMemo, useState } from 'react';
 import { ApiService } from '../../../react/services/apiService';
 import { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits, } from '../../../react/utils/money';
 import { TagadaClient } from '../../core/client';
-import { default as DebugDrawer } from '../components/DebugDrawer';
-import { FunnelScriptInjector } from '../components/FunnelScriptInjector';
 import { setGlobalApiClient } from '../hooks/useApiQuery';
 import { PixelTrackingProvider } from '../hooks/usePixelTracking';
+const FunnelScriptInjector = lazy(() => import('../components/FunnelScriptInjector').then(m => ({ default: m.FunnelScriptInjector })));
+const DebugDrawer = lazy(() => import('../components/DebugDrawer'));
 // Professional, subtle loading component for initialization
 const InitializationLoader = () => (_jsxs("div", { style: {
         position: 'fixed',
@@ -213,6 +213,75 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
         formatSimpleMoney,
     }), []);
     const [isDebugDrawerOpen, setIsDebugDrawerOpen] = useState(false);
+    // Track last injected script to prevent duplicate execution
+    /**
+     * Editor Element Click Bridge (Iframe → Parent)
+     *
+     * When running inside the CRM config editor iframe, elements can declare an `editor-id`
+     * attribute (e.g. <h1 editor-id="config.texts.checkoutTitle">Title</h1>).
+     *
+     * This effect sets up a delegated click listener on `document` that:
+     * - Finds the closest ancestor with an `editor-id`
+     * - Sends a `postMessage` to `window.parent` with the editorId and text content
+     *
+     * The parent (ConfigEditor) can then map this back to the corresponding config field.
+     */
+    useEffect(() => {
+        if (typeof window === 'undefined' || typeof document === 'undefined') {
+            return;
+        }
+        const handleClick = (event) => {
+            if (!(event.target instanceof Element))
+                return;
+            const targetWithEditorId = event.target.closest('[editor-id]');
+            if (!targetWithEditorId)
+                return;
+            const editorId = targetWithEditorId.getAttribute('editor-id');
+            if (!editorId)
+                return;
+            const textContent = targetWithEditorId.textContent ?? '';
+            // Only attempt cross-window messaging when inside an iframe
+            const isInIframe = window.parent && window.parent !== window;
+            if (!isInIframe) {
+                return;
+            }
+            const message = {
+                type: 'TAGADAPAY_EDITOR_ELEMENT_CLICK',
+                editorId,
+                textContent,
+            };
+            try {
+                // Derive parent origin from document.referrer when possible; fall back to '*'
+                // This avoids postMessage origin mismatch errors in dev (e.g. 3001 ↔ 5173)
+                let targetOrigin = '*';
+                try {
+                    if (typeof document !== 'undefined' && document.referrer) {
+                        const url = new URL(document.referrer);
+                        targetOrigin = url.origin;
+                    }
+                }
+                catch {
+                    // Fallback to '*'
+                    targetOrigin = '*';
+                }
+                window.parent.postMessage(message, targetOrigin);
+                if (state.debugMode) {
+                    // eslint-disable-next-line no-console
+                    console.log('[TagadaProvider] Sent editor element click to parent:', message);
+                }
+            }
+            catch (error) {
+                if (state.debugMode) {
+                    // eslint-disable-next-line no-console
+                    console.error('[TagadaProvider] Failed to post editor element click message:', error);
+                }
+            }
+        };
+        document.addEventListener('click', handleClick, true);
+        return () => {
+            document.removeEventListener('click', handleClick, true);
+        };
+    }, [state.debugMode]);
     // Funnel Methods
     const funnelMethods = useMemo(() => {
         if (!client.funnel) {
@@ -320,7 +389,7 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
     // Loading State Logic
     const shouldShowLoading = state.isLoading || state.pluginConfigLoading || (blockUntilSessionReady && !state.isSessionInitialized);
     const canRenderChildren = !state.pluginConfigLoading && (!blockUntilSessionReady || state.isSessionInitialized);
-    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(TagadaContext.Provider, { value: contextValue, children: _jsxs(PixelTrackingProvider, { children: [_jsx(FunnelScriptInjector, { ...funnelState }), shouldShowLoading && _jsx(InitializationLoader, {}), state.debugMode && canRenderChildren && (_jsxs(_Fragment, { children: [_jsx("button", { onClick: () => setIsDebugDrawerOpen(true), style: {
+    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(TagadaContext.Provider, { value: contextValue, children: _jsxs(PixelTrackingProvider, { children: [_jsx(Suspense, { fallback: null, children: _jsx(FunnelScriptInjector, { ...funnelState }) }), shouldShowLoading && _jsx(InitializationLoader, {}), state.debugMode && canRenderChildren && (_jsxs(_Fragment, { children: [_jsx("button", { onClick: () => setIsDebugDrawerOpen(true), style: {
                                     position: 'fixed',
                                     bottom: '16px',
                                     right: '16px',
@@ -335,7 +404,7 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
                                     boxShadow: '0 4px 12px rgba(0, 0, 0, 0.3)',
                                     zIndex: 999997,
                                     transition: 'all 0.2s ease',
-                                }, title: "Open TagadaPay SDK Debug Panel", children: "\uD83D\uDC1B" }), _jsx(DebugDrawer, { isOpen: isDebugDrawerOpen, onClose: () => setIsDebugDrawerOpen(false) })] })), canRenderChildren && children] }) }) }));
+                                }, title: "Open TagadaPay SDK Debug Panel", children: "\uD83D\uDC1B" }), _jsx(Suspense, { fallback: null, children: _jsx(DebugDrawer, { isOpen: isDebugDrawerOpen, onClose: () => setIsDebugDrawerOpen(false) }) })] })), canRenderChildren && children] }) }) }));
 }
 export function useTagadaContext() {
     const context = useContext(TagadaContext);

package/dist/v2/standalone/external-tracker.d.ts

@@ -1,59 +1,48 @@
 /**
  * TagadaPay External Page Tracker
  *
- * A lightweight standalone script for tracking users on external pages
- * that are part of a Tagadapay funnel but not hosted on the Tagadapay platform.
+ * Standalone script for tracking users on external pages that are part of a
+ * TagadaPay funnel but not hosted on the TagadaPay platform.
  *
- * ARCHITECTURE:
- * - Reuses core SDK infrastructure (TagadaClient) for authentication and API handling
- * - All tracking handled automatically by funnelOrchestrator via autoInitialize() and navigate()
- * - No separate tracking endpoints needed - unified tracking through orchestrator
+ * Use cases:
+ *   - WooCommerce / WordPress storefronts
+ *   - Custom landing pages
+ *   - Any external page that is a funnel step
  *
- * Usage (via CDN):
+ * @example CDN usage
+ * ```html
  * <script src="https://cdn.jsdelivr.net/npm/@tagadapay/plugin-sdk/dist/external-tracker.min.js"></script>
  * <script>
  *   TagadaTracker.init({
  *     storeId: 'store_xxx',
  *     accountId: 'acc_xxx',
- *     funnelId: 'funnel_xxx',  // Optional: detected from URL
  *     stepId: 'step_xxx',
- *     stepName: 'External Offer Page',
- *     stepType: 'external'
- *   });
- *
- *   // Navigate to next step (tracking automatic)
- *   TagadaTracker.navigate({
- *     eventType: 'form.submitted',
- *     eventData: { email: 'user@example.com' }
  *   });
  * </script>
+ * ```
  */
 import type { TagadaClient } from '../core/client';
+export declare const TRACKER_VERSION = "1.0.0";
 export interface TagadaTrackerConfig {
     /** Store ID (required) */
     storeId: string;
-    /** Account ID (required for session init) */
-    accountId?: string;
-    /** Funnel ID (optional - can be extracted from URL param) */
+    /** Account ID (required — session init will fail without it) */
+    accountId: string;
+    /** Funnel ID (optional — can be extracted from URL param) */
     funnelId?: string;
-    /**
-     * Step ID (REQUIRED for external pages)
-     *
-     * External URLs cannot be mapped to steps via URL matching (only works for Tagadapay-hosted pages).
-     * You must explicitly specify which step this external page represents.
-     */
+    /** Step ID (required for external pages — URL-to-step mapping only works for TagadaPay-hosted pages) */
     stepId: string;
-    /** Step name (optional - for analytics/debugging) */
+    /** Step name (optional — for analytics/debugging) */
     stepName?: string;
-    /** Step type (optional - e.g., 'landing', 'offer', 'external') */
+    /** Step type (optional — e.g., 'landing', 'offer', 'external') */
     stepType?: string;
-    /** API base URL (defaults to production) */
+    /** API base URL (defaults to https://app.tagadapay.com) */
     apiBaseUrl?: string;
     /** Enable debug logging */
     debug?: boolean;
     /** Callback when session is ready */
     onReady?: (session: ExternalTrackerSession) => void;
-    /** Callback on error */
+    /** Callback on error — when provided, init() will NOT throw */
     onError?: (error: Error) => void;
 }
 export interface ExternalTrackerSession {
@@ -71,49 +60,66 @@ export interface NavigateOptions {
     eventData?: Record<string, unknown>;
     /** Override return URL */
     returnUrl?: string;
-    /** Disable auto-redirect to control navigation manually (default: true) */
+    /** Whether to auto-redirect after navigation (default: true) */
     autoRedirect?: boolean;
 }
+export interface TrackEventOptions {
+    /** Event name (e.g., 'button_click', 'scroll_depth', 'video_play') */
+    name: string;
+    /** Arbitrary event data */
+    data?: Record<string, unknown>;
+}
 declare class TagadaExternalTracker {
     private config;
     private client;
     private initialized;
     private initializing;
+    private unsubscribe;
+    /** Tracker version */
+    readonly version = "1.0.0";
     /**
-     * Initialize the tracker using SDK infrastructure
+     * Initialize the tracker.
+     * When `onError` is provided, errors are passed to the callback and init()
+     * resolves to `null` instead of throwing.
      */
     init(config: TagadaTrackerConfig): Promise<ExternalTrackerSession | null>;
-    /**
-     * Get current session from SDK state
-     */
+    /** Get current session data. */
     getSession(): ExternalTrackerSession | null;
-    /**
-     * Check if tracker is ready
-     */
+    /** Whether the tracker is fully initialized and ready. */
     isReady(): boolean;
     /**
-     * Navigate to next step in funnel using SDK's funnel client
+     * Navigate to the next step in the funnel.
+     * By default, auto-redirects the browser window.
      */
     navigate(options: NavigateOptions): Promise<{
         url: string;
     } | null>;
     /**
-     * Get customer ID (for identifying the user)
+     * Track a custom event (e.g., button click, scroll depth, video play).
+     * Events are sent through the funnel orchestrator for unified analytics.
      */
+    trackEvent(options: TrackEventOptions): Promise<void>;
+    /** Get customer ID. */
     getCustomerId(): string | null;
-    /**
-     * Get funnel session ID
-     */
+    /** Get funnel session ID. */
     getFunnelSessionId(): string | null;
     /**
-     * Build a URL with funnel context parameters
-     * Useful for linking to other external pages while preserving session
+     * Build a URL that preserves funnel session context.
+     * Use this to link to other external pages within the same funnel.
      */
     buildUrl(baseUrl: string, additionalParams?: Record<string, string>): string;
+    /** Get the underlying SDK client (advanced usage). */
+    getClient(): TagadaClient | null;
     /**
-     * Get the underlying SDK client (for advanced usage)
+     * Reset the tracker to a new step without re-creating the session.
+     * Useful for SPAs that navigate between funnel steps client-side.
      */
-    getClient(): TagadaClient | null;
+    reset(newStepId: string): Promise<ExternalTrackerSession | null>;
+    /**
+     * Destroy the tracker, clean up event listeners and state.
+     * Call this when the tracker is no longer needed (e.g., SPA teardown).
+     */
+    destroy(): void;
     private waitForClientReady;
     private initializeFunnel;
 }