@tagadapay/plugin-sdk 3.1.5 → 3.1.9

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

@@ -0,0 +1,26 @@
+/**
+ * Payment Retrieve Hook using TanStack Query (V2)
+ * Handles payment status retrieval after external redirects
+ * This is useful for processors that require server-side status checks (e.g., some 3DS flows)
+ */
+export interface RetrieveResult {
+    retrieveResult?: {
+        status?: string;
+        message?: string;
+        success?: boolean;
+    };
+    paymentId: string;
+    transactionCreated?: boolean;
+    status?: string;
+    transactionId?: string;
+    message?: string;
+    success?: boolean;
+    error?: any;
+}
+export interface PaymentRetrieveHook {
+    startRetrievePolling: (paymentId: string) => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+    isPolling: boolean;
+}
+export declare function usePaymentRetrieve(): PaymentRetrieveHook;

package/dist/v2/react/hooks/usePaymentRetrieve.js

@@ -0,0 +1,175 @@
+/**
+ * Payment Retrieve Hook using TanStack Query (V2)
+ * Handles payment status retrieval after external redirects
+ * This is useful for processors that require server-side status checks (e.g., some 3DS flows)
+ */
+import { useState, useCallback, useRef, useEffect, useMemo } from 'react';
+import { PaymentsResource } from '../../core/resources/payments';
+import { usePaymentPolling } from './usePaymentPolling';
+import { getGlobalApiClient } from './useApiQuery';
+export function usePaymentRetrieve() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    // Create payments resource client
+    const paymentsResource = useMemo(() => {
+        try {
+            return new PaymentsResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize payments resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    const { startPolling } = usePaymentPolling();
+    // Refs to prevent multiple simultaneous calls
+    const isPollingRef = useRef(false);
+    const pollIntervalRef = useRef(null);
+    const attemptsRef = useRef(0);
+    const isPageLoadedRef = useRef(false);
+    // Check if page is fully loaded
+    const checkPageLoaded = useCallback(() => {
+        return new Promise((resolve) => {
+            // If already loaded, resolve immediately
+            if (document.readyState === 'complete') {
+                isPageLoadedRef.current = true;
+                resolve();
+                return;
+            }
+            // Wait for load event
+            const handleLoad = () => {
+                isPageLoadedRef.current = true;
+                window.removeEventListener('load', handleLoad);
+                resolve();
+            };
+            window.addEventListener('load', handleLoad);
+            // Fallback: resolve after a short delay if load event doesn't fire
+            setTimeout(() => {
+                if (!isPageLoadedRef.current) {
+                    isPageLoadedRef.current = true;
+                    window.removeEventListener('load', handleLoad);
+                    resolve();
+                }
+            }, 1000);
+        });
+    }, []);
+    // Cleanup function
+    const cleanup = useCallback(() => {
+        if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+            pollIntervalRef.current = null;
+        }
+        isPollingRef.current = false;
+        attemptsRef.current = 0;
+        setIsLoading(false);
+        // Clean up query parameters
+        if (typeof window !== 'undefined') {
+            const newUrl = window.location.pathname;
+            window.history.replaceState({}, document.title, newUrl);
+        }
+    }, []);
+    // Start retrieve polling
+    const startRetrievePolling = useCallback(async (paymentId) => {
+        // Prevent multiple simultaneous calls
+        if (isPollingRef.current) {
+            return;
+        }
+        // Wait for page to be fully loaded
+        await checkPageLoaded();
+        // Double-check after page load
+        if (isPollingRef.current) {
+            return;
+        }
+        isPollingRef.current = true;
+        setIsLoading(true);
+        attemptsRef.current = 0;
+        const maxAttempts = 10;
+        const pollInterval = 3000; // 3 seconds
+        const checkRetrieve = async () => {
+            try {
+                attemptsRef.current++;
+                const result = await paymentsResource.retrievePayment(paymentId);
+                const status = result?.retrieveResult?.status || result?.status;
+                // Fetch payment to check for requireAction
+                const payment = await paymentsResource.getPaymentStatus(paymentId);
+                // Check if payment requires action
+                if (payment?.requireAction !== 'none' && payment?.requireActionData && !payment?.requireActionData?.processed) {
+                    cleanup();
+                    // Payment requires new action - would need to be handled by parent component
+                    return;
+                }
+                // Check if payment is succeeded
+                if (result?.retrieveResult?.success && status === 'succeeded') {
+                    cleanup();
+                    // Start regular polling to handle UI updates
+                    startPolling(paymentId, {
+                        onSuccess: () => {
+                            // Payment succeeded after retrieve
+                        },
+                        onFailure: (errorMsg) => {
+                            setError(errorMsg);
+                        },
+                    });
+                    return;
+                }
+                // Check if payment is declined or error
+                if (status === 'declined' || status === 'error') {
+                    cleanup();
+                    const errorMsg = result?.retrieveResult?.message || result?.message || 'Payment failed';
+                    setError(errorMsg);
+                    return;
+                }
+                // If still pending and haven't reached max attempts, continue polling
+                if (attemptsRef.current < maxAttempts && status === 'pending') {
+                    return;
+                }
+                // Max attempts reached or unknown status
+                if (attemptsRef.current >= maxAttempts) {
+                    cleanup();
+                    const errorMsg = 'Payment status check timed out. Please check your payment status manually.';
+                    setError(errorMsg);
+                }
+            }
+            catch (error) {
+                // On error, continue polling unless we've reached max attempts
+                if (attemptsRef.current >= maxAttempts) {
+                    cleanup();
+                    const errorMsg = error instanceof Error ? error.message : 'Failed to retrieve payment status';
+                    setError(errorMsg);
+                }
+            }
+        };
+        // Initial check
+        await checkRetrieve();
+        // Set up polling interval
+        pollIntervalRef.current = setInterval(async () => {
+            if (attemptsRef.current >= maxAttempts || !isPollingRef.current) {
+                cleanup();
+                return;
+            }
+            await checkRetrieve();
+        }, pollInterval);
+    }, [paymentsResource, startPolling, cleanup, checkPageLoaded]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            cleanup();
+        };
+    }, [cleanup]);
+    // Handle retrieve mode from URL query parameters
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        // Check for payment retrieve mode in URL
+        const urlParams = new URLSearchParams(window.location.search);
+        const paymentMode = urlParams.get('mode');
+        const paymentIdFromUrl = urlParams.get('paymentId');
+        if (paymentMode === 'retrieve' && paymentIdFromUrl) {
+            void startRetrievePolling(paymentIdFromUrl);
+        }
+    }, [startRetrievePolling]);
+    return {
+        startRetrievePolling,
+        isLoading,
+        error,
+        isPolling: isPollingRef.current,
+    };
+}

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

@@ -0,0 +1,56 @@
+/**
+ * usePixelTracking Hook & Provider
+ *
+ * SDK-level pixel tracking based on runtime stepConfig.pixels injected
+ * by the CRM. This mirrors the CMS pixel context pattern but uses the
+ * funnel step configuration as the source of truth instead of store
+ * integrations.
+ */
+import React from 'react';
+export type StandardPixelEvent = 'PageView' | 'ViewContent' | 'AddToCart' | 'InitiateCheckout' | 'AddPaymentInfo' | 'Purchase' | 'Lead' | 'CompleteRegistration' | 'Conversion';
+export interface PixelTrackingContextValue {
+    track: (eventName: StandardPixelEvent, parameters?: Record<string, any>) => void;
+    pixelsInitialized: boolean;
+}
+/**
+ * Provider that initializes pixels based on stepConfig.pixels
+ * and exposes a simple track(event, params) API.
+ */
+export declare function PixelTrackingProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access SDK pixel tracking.
+ * Must be used within TagadaProvider (which wraps PixelTrackingProvider).
+ */
+export declare function usePixelTracking(): PixelTrackingContextValue;
+declare global {
+    interface FacebookPixelFunction {
+        (...args: unknown[]): void;
+        callMethod?: (...args: unknown[]) => void;
+        queue?: unknown[];
+        loaded?: boolean;
+        version?: string;
+    }
+    interface TikTokPixelFunction {
+        (...args: unknown[]): void;
+        methods?: string[];
+        setAndDefer?: (target: TikTokPixelFunction, method: string) => void;
+        load?: (pixelId: string) => void;
+        page?: () => void;
+        track?: (eventName: string, params: Record<string, unknown>) => void;
+        queue?: unknown[];
+    }
+    interface SnapchatPixelFunction {
+        (...args: unknown[]): void;
+        handleRequest?: (...args: unknown[]) => void;
+        queue?: unknown[];
+    }
+    interface Window {
+        fbq?: FacebookPixelFunction;
+        _fbq?: FacebookPixelFunction;
+        ttq?: TikTokPixelFunction;
+        snaptr?: SnapchatPixelFunction;
+        dataLayer?: any[];
+    }
+}