@tagadapay/plugin-sdk 3.1.10 → 3.1.12

package/dist/v2/react/components/ApplePayButton.js

@@ -41,11 +41,20 @@ export const ApplePayButton = ({ checkout, onSuccess, onError, onCancel }) => {
     // Check Apple Pay availability (matches CMS pattern - useApplePayAvailable hook)
     useEffect(() => {
         const addExpress = () => handleAddExpressId('apple_pay');
-        if (window?.ApplePaySession && ApplePaySession.canMakePayments()) {
-            setIsApplePayAvailable(true);
-            addExpress();
+        try {
+            // Apple Pay requires a secure context (HTTPS). On HTTP (like localhost),
+            // calling canMakePayments() throws InvalidAccessError
+            if (window?.ApplePaySession && ApplePaySession.canMakePayments()) {
+                setIsApplePayAvailable(true);
+                addExpress();
+            }
+            else {
+                setIsApplePayAvailable(false);
+            }
         }
-        else {
+        catch (error) {
+            // Likely "Trying to start an Apple Pay session from an insecure document"
+            console.warn('[ApplePay] Apple Pay not available:', error);
             setIsApplePayAvailable(false);
         }
     }, [handleAddExpressId]);

package/dist/v2/react/components/FunnelScriptInjector.js

@@ -199,27 +199,27 @@ export function FunnelScriptInjector({ context, isInitialized }) {
             existingScript.remove();
         }
         // Wrap script content with error handling and context checks
-        const wrappedScript = `
-      (function() {
-        try {
-          // Check if we have basic DOM access
-          if (typeof document === 'undefined') {
-            console.error('[TagadaPay] Document not available');
-            return;
-          }
-          
-          // Check if we have Tagada
-          if (!window.Tagada) {
-            console.error('[TagadaPay] Tagada not available');
-            return;
-          }
-          
-          // Execute the original script
-          ${scriptBody}
-        } catch (error) {
-          console.error('[TagadaPay] Script execution error:', error);
-        }
-      })();
+        const wrappedScript = `
+      (function() {
+        try {
+          // Check if we have basic DOM access
+          if (typeof document === 'undefined') {
+            console.error('[TagadaPay] Document not available');
+            return;
+          }
+          
+          // Check if we have Tagada
+          if (!window.Tagada) {
+            console.error('[TagadaPay] Tagada not available');
+            return;
+          }
+          
+          // Execute the original script
+          ${scriptBody}
+        } catch (error) {
+          console.error('[TagadaPay] Script execution error:', error);
+        }
+      })();
     `;
         // Create and inject new script element
         const scriptElement = document.createElement('script');
@@ -273,15 +273,15 @@ export function FunnelScriptInjector({ context, isInitialized }) {
             if (!scriptBody)
                 return;
             // Wrap script content with error handling
-            const wrappedScript = `
-        (function() {
-          try {
-            // Script: ${script.name}
-            ${scriptBody}
-          } catch (error) {
-            console.error('[TagadaPay] StepConfig script "${script.name}" error:', error);
-          }
-        })();
+            const wrappedScript = `
+        (function() {
+          try {
+            // Script: ${script.name}
+            ${scriptBody}
+          } catch (error) {
+            console.error('[TagadaPay] StepConfig script "${script.name}" error:', error);
+          }
+        })();
       `;
             // Create script element
             const scriptElement = document.createElement('script');

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

@@ -19,7 +19,7 @@
  * const paymentFlowId = stepConfig.paymentFlowId;
  * ```
  */
-import { FunnelState, GTMTrackingConfig, MetaConversionTrackingConfig, PixelTrackingConfig, RuntimeStepConfig, SnapchatTrackingConfig, TrackingProvider } from '../../core/funnelClient';
+import { FunnelState, GTMTrackingConfig, PixelTrackingConfig, RuntimeStepConfig, SnapchatTrackingConfig, TrackingProvider } from '../../core/funnelClient';
 import { FunnelAction, FunnelNavigationResult, SimpleFunnelContext } from '../../core/resources/funnel';
 /**
  * Step configuration from HTML injection (for current step/variant)
@@ -52,7 +52,6 @@ export interface StepConfigValue {
         [TrackingProvider.FACEBOOK]?: PixelTrackingConfig[];
         [TrackingProvider.TIKTOK]?: PixelTrackingConfig[];
         [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
-        [TrackingProvider.META_CONVERSION]?: MetaConversionTrackingConfig[];
         [TrackingProvider.GTM]?: GTMTrackingConfig[];
     };
 }

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

@@ -165,6 +165,15 @@ export function useGoogleAutocomplete(options) {
             postalCode: '',
             fullStreetAddress: '',
         };
+        // Temporary variables for comprehensive address component extraction
+        let premise = '';
+        let neighborhood = '';
+        let sublocality5 = '';
+        let sublocality4 = '';
+        let sublocality3 = '';
+        let sublocality2 = '';
+        let sublocality1 = '';
+        let postalTown = '';
         place.address_components?.forEach((component) => {
             const types = component.types;
             if (types.includes('subpremise')) {
@@ -174,19 +183,47 @@ export function useGoogleAutocomplete(options) {
             if (types.includes('street_number')) {
                 extracted.streetNumber = component.long_name;
             }
+            if (types.includes('premise')) {
+                // Building number (used in Asian addresses instead of street_number)
+                premise = component.long_name;
+            }
             if (types.includes('route')) {
                 extracted.route = component.long_name;
             }
+            if (types.includes('neighborhood')) {
+                // Neighborhood (alternative to sublocality in some regions)
+                neighborhood = component.long_name;
+            }
+            if (types.includes('sublocality_level_5')) {
+                // Fifth-level sublocality (most granular)
+                sublocality5 = component.long_name;
+            }
+            if (types.includes('sublocality_level_4')) {
+                // Street name in Asian addresses (e.g., Korean: "Yulgok-ro 27-gil", Japanese block)
+                sublocality4 = component.long_name;
+            }
+            if (types.includes('sublocality_level_3')) {
+                // Neighborhood (e.g., Japanese chōme: "3-chōme")
+                sublocality3 = component.long_name;
+            }
+            if (types.includes('sublocality_level_2')) {
+                // Second-level sublocality (e.g., Japanese area: "Hirano")
+                sublocality2 = component.long_name;
+            }
+            if (types.includes('sublocality_level_1')) {
+                // District (fallback for city in some Asian countries)
+                sublocality1 = component.long_name;
+            }
             if (types.includes('locality')) {
                 extracted.locality = component.long_name;
             }
+            if (types.includes('postal_town')) {
+                // Postal town (used in UK, Ireland instead of locality)
+                postalTown = component.long_name;
+            }
             if (types.includes('administrative_area_level_2')) {
                 extracted.administrativeAreaLevel2 = component.short_name;
                 extracted.administrativeAreaLevel2Long = component.long_name;
-                // Use level_2 as fallback for locality if locality is not set
-                if (!extracted.locality) {
-                    extracted.locality = component.long_name;
-                }
             }
             if (types.includes('administrative_area_level_1')) {
                 extracted.administrativeAreaLevel1 = component.short_name;
@@ -199,45 +236,57 @@ export function useGoogleAutocomplete(options) {
                 extracted.postalCode = component.long_name;
             }
         });
+        // === APPLY COMPREHENSIVE FALLBACK LOGIC ===
+        // 1. Building/House Number with fallbacks
+        // Priority: street_number (Western) > premise (Asian)
+        const buildingNumber = extracted.streetNumber || premise;
+        // 2. Street Name with comprehensive fallbacks
+        // Priority: route (Western) > sublocality_level_5 > sublocality_level_4 (Asian streets)
+        //          > sublocality_level_3 (Neighborhood) > neighborhood
+        const streetName = extracted.route || sublocality5 || sublocality4 || sublocality3 || neighborhood;
+        // 3. Update locality with fallbacks if not set
+        // Priority: locality > postal_town > sublocality_level_2 > sublocality_level_1
+        if (!extracted.locality) {
+            extracted.locality = postalTown || sublocality2 || sublocality1 || '';
+        }
+        // 4. State fallback for French addresses
         // For countries like France where administrative_area_level_1 (région) may be missing,
         // use administrative_area_level_2 (département) as the primary state/province value
-        // We prefer the long_name (e.g., "Bouches-du-Rhône") over short_name (e.g., "13")
-        // because it's more likely to match our state database entries
         if (!extracted.administrativeAreaLevel1 && extracted.administrativeAreaLevel2) {
-            // Use long name as the primary value (e.g., "Bouches-du-Rhône" instead of "13")
             extracted.administrativeAreaLevel1 = extracted.administrativeAreaLevel2Long || extracted.administrativeAreaLevel2;
             extracted.administrativeAreaLevel1Long = extracted.administrativeAreaLevel2Long;
         }
-        // Construct full street address
-        // Handle different formats:
-        // - "711/3 Network Place" (Australian unit format)
-        // - "3 Network Place" (house number only)
-        // - "Unit 711, 3 Network Place" (alternative format)
-        const streetParts = [];
-        if (extracted.subpremise) {
-            // Check if subpremise already contains formatting (e.g., "Unit 711")
-            const normalizedSubpremise = extracted.subpremise.trim();
-            streetParts.push(normalizedSubpremise);
-        }
-        if (extracted.streetNumber) {
-            streetParts.push(extracted.streetNumber);
+        // === CONSTRUCT FULL STREET ADDRESS ===
+        let addressValue = '';
+        if (extracted.subpremise && buildingNumber && streetName) {
+            // Unit + Building + Street (e.g., "711/3 Network Place", "5/3 Yulgok-ro 27-gil")
+            addressValue = `${extracted.subpremise}/${buildingNumber} ${streetName}`;
         }
-        if (extracted.route) {
-            streetParts.push(extracted.route);
+        else if (buildingNumber && streetName) {
+            // Building + Street (e.g., "3 Network Place", "3-8 Hirano" for Japanese)
+            // For Japanese addresses, check if we have multiple sublocality levels to combine
+            if (premise && sublocality4 && sublocality3) {
+                // Japanese format: "3-chōme-8-3" (chome-block-building)
+                addressValue = `${sublocality3}-${sublocality4}-${premise}`;
+                // Add area name if available (e.g., "3-chōme-8-3 Hirano")
+                if (sublocality2) {
+                    addressValue = `${addressValue} ${sublocality2}`;
+                }
+            }
+            else {
+                // Standard format
+                addressValue = `${buildingNumber} ${streetName}`;
+            }
         }
-        // For Australian format, if we have both subpremise and streetNumber,
-        // format as "subpremise/streetNumber route" (e.g., "711/3 Network Place")
-        if (extracted.subpremise && extracted.streetNumber && extracted.route) {
-            // Remove "Unit", "Apt", etc. prefixes for cleaner format
-            const cleanSubpremise = extracted.subpremise
-                .replace(/^(Unit|Apt|Apartment|Suite|#)\s*/i, '')
-                .trim();
-            extracted.fullStreetAddress = `${cleanSubpremise}/${extracted.streetNumber} ${extracted.route}`;
+        else if (streetName) {
+            // Only street name available (e.g., "Pyeongtaek 3-ro 56beon-gil")
+            addressValue = streetName;
         }
-        else {
-            // Standard format: join all parts with spaces
-            extracted.fullStreetAddress = streetParts.join(' ');
+        else if (buildingNumber) {
+            // Edge case: Only building number (rare)
+            addressValue = buildingNumber;
         }
+        extracted.fullStreetAddress = addressValue.trim();
         return extracted;
     }, []);
     // Extract address in the format expected by shipping/billing address forms

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

@@ -46,11 +46,16 @@ declare global {
         handleRequest?: (...args: unknown[]) => void;
         queue?: unknown[];
     }
+    interface PinterestPixelFunction {
+        (...args: unknown[]): void;
+        queue?: unknown[];
+    }
     interface Window {
         fbq?: FacebookPixelFunction;
         _fbq?: FacebookPixelFunction;
         ttq?: TikTokPixelFunction;
         snaptr?: SnapchatPixelFunction;
+        pintrk?: PinterestPixelFunction;
         dataLayer?: any[];
     }
 }

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

@@ -87,6 +87,17 @@ export function PixelTrackingProvider({ children }) {
                     });
                 }
             }
+            // Pinterest - support multiple pixels
+            const pinterestPixels = pixels.pinterest;
+            if (pinterestPixels) {
+                if (Array.isArray(pinterestPixels)) {
+                    pinterestPixels.forEach((pixel) => {
+                        if (pixel.enabled && pixel.pixelId) {
+                            initPinterestPixel(pixel.pixelId);
+                        }
+                    });
+                }
+            }
             // GTM - support multiple containers
             const gtmPixels = pixels.gtm;
             if (gtmPixels) {
@@ -163,6 +174,21 @@ export function PixelTrackingProvider({ children }) {
                     });
                 }
             }
+            // Pinterest - track to all enabled pixels
+            const pinterestPixels = pixels.pinterest;
+            if (pinterestPixels) {
+                const pixelArray = Array.isArray(pinterestPixels)
+                    ? pinterestPixels
+                    : [pinterestPixels];
+                const enabledPixels = pixelArray.filter((p) => p.enabled);
+                if (enabledPixels.length > 0) {
+                    const { name, params } = mapPinterestEvent(eventName, parameters);
+                    // Track to all enabled Pinterest pixels
+                    enabledPixels.forEach(() => {
+                        trackPinterestEvent(name, params);
+                    });
+                }
+            }
             // GTM - track to all enabled containers
             const gtmPixels = pixels.gtm;
             if (gtmPixels) {
@@ -355,6 +381,35 @@ function trackSnapchatEvent(name, params) {
     const snaptr = window.snaptr;
     snaptr?.('track', name, params);
 }
+function initPinterestPixel(pixelId) {
+    if (typeof window === 'undefined')
+        return;
+    if (window.pintrk)
+        return;
+    (function (w, d, tagName) {
+        if (w.pintrk)
+            return;
+        const a = (function (...args) {
+            a.queue.push(args);
+        });
+        a.queue = [];
+        w.pintrk = a;
+        const s = d.createElement(tagName);
+        s.async = true;
+        s.src = 'https://s.pinimg.com/ct/core.js';
+        const u = d.getElementsByTagName(tagName)[0];
+        u.parentNode?.insertBefore(s, u);
+    })(window, document, 'script');
+    const pintrk = window.pintrk;
+    pintrk?.('load', pixelId);
+    pintrk?.('page');
+}
+function trackPinterestEvent(name, params) {
+    if (typeof window === 'undefined' || !window.pintrk)
+        return;
+    const pintrk = window.pintrk;
+    pintrk?.('track', name, params);
+}
 function initGTM(containerId) {
     if (typeof window === 'undefined' || typeof document === 'undefined')
         return;
@@ -444,6 +499,59 @@ function mapTikTokEvent(eventName, parameters) {
 function mapSnapchatEvent(eventName, parameters) {
     return { name: eventName, params: parameters };
 }
+function mapPinterestEvent(eventName, parameters) {
+    // Pinterest uses lowercase event names
+    const pinterestEventMap = {
+        PageView: 'pagevisit',
+        ViewContent: 'viewcontent',
+        AddToCart: 'addtocart',
+        InitiateCheckout: 'initiatecheckout',
+        AddPaymentInfo: 'addpaymentinfo',
+        Purchase: 'checkout',
+        Lead: 'lead',
+        CompleteRegistration: 'signup',
+    };
+    const pinterestEventName = pinterestEventMap[eventName] ?? eventName.toLowerCase();
+    // Transform parameters for Pinterest
+    const pinterestParams = transformPinterestParameters(eventName, parameters);
+    return { name: pinterestEventName, params: pinterestParams };
+}
+function transformPinterestParameters(eventName, parameters) {
+    const pinParams = { ...parameters };
+    // Pinterest uses 'value' and 'order_quantity' as primary event data
+    // Ensure currency is uppercase
+    if (pinParams.currency) {
+        pinParams.currency = String(pinParams.currency).toUpperCase();
+    }
+    // Convert to major units if currency is present
+    if (pinParams.currency && pinParams.value) {
+        try {
+            pinParams.value = minorUnitsToMajorUnits(Number(pinParams.value), String(pinParams.currency));
+        }
+        catch {
+            // Fallback to simple division by 100
+            pinParams.value = Number(pinParams.value) / 100;
+        }
+    }
+    // Ensure numeric values
+    if (pinParams.value !== undefined) {
+        pinParams.value = Number(pinParams.value);
+    }
+    if (pinParams.order_quantity !== undefined) {
+        pinParams.order_quantity = Number(pinParams.order_quantity);
+    }
+    // Transform contents to Pinterest format (product_id array)
+    if (pinParams.contents && Array.isArray(pinParams.contents)) {
+        pinParams.line_items = pinParams.contents.map((item) => ({
+            product_id: item.content_id,
+            product_name: item.content_name,
+            product_category: item.content_category,
+            product_price: item.price ? Number(item.price) : undefined,
+            product_quantity: item.quantity ? Number(item.quantity) : undefined,
+        }));
+    }
+    return pinParams;
+}
 function mapGTMEvent(eventName, parameters) {
     // Map standard event names to GTM event names
     const gtmEventMap = {

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

@@ -18,5 +18,11 @@ export interface UseShippingRatesQueryResult {
     error: Error | null;
     clearError: () => void;
     refetch: () => Promise<void>;
+    /** Preview shipping rates for a country without updating session */
+    previewRates: (countryCode: string, stateCode?: string) => Promise<ShippingRate[]>;
+    /** Rates from the last previewRates call */
+    previewedRates: ShippingRate[] | undefined;
+    /** Loading state for previewRates */
+    isPreviewLoading: boolean;
 }
 export declare function useShippingRatesQuery(options?: UseShippingRatesQueryOptions): UseShippingRatesQueryResult;

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

@@ -3,7 +3,7 @@
  * Simplified shipping rates management with automatic cache invalidation
  */
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { ShippingRatesResource } from '../../core/resources/shippingRates';
 import { getGlobalApiClient } from './useApiQuery';
 export function useShippingRatesQuery(options = {}) {
@@ -23,6 +23,9 @@ export function useShippingRatesQuery(options = {}) {
     const effectiveSessionId = sessionId || checkout?.checkoutSession?.id;
     // Track if we've synced the initial selection from checkout
     const hasSyncedInitialSelectionRef = useRef(false);
+    // Preview rates state
+    const [previewedRates, setPreviewedRates] = useState();
+    const [isPreviewLoading, setIsPreviewLoading] = useState(false);
     // Main shipping rates query
     const { data: shippingRatesData, isLoading: isFetching, error: fetchError, refetch: refetchRates, } = useQuery({
         queryKey: ['shipping-rates', effectiveSessionId],
@@ -122,6 +125,35 @@ export function useShippingRatesQuery(options = {}) {
         // We can trigger a refetch which will clear the error
         void refetch();
     }, [refetch]);
+    // Preview shipping rates for a country without updating session
+    const previewRates = useCallback(async (countryCode, stateCode) => {
+        if (!effectiveSessionId)
+            return [];
+        try {
+            setIsPreviewLoading(true);
+            const response = await shippingRatesResource.previewShippingRates(effectiveSessionId, {
+                countryCode,
+                stateCode,
+            });
+            // Sort rates: free first, then by ascending amount
+            const sortedRates = [...response.rates].sort((a, b) => {
+                if (a.isFree && !b.isFree)
+                    return -1;
+                if (!a.isFree && b.isFree)
+                    return 1;
+                return (a.amount ?? 0) - (b.amount ?? 0);
+            });
+            setPreviewedRates(sortedRates);
+            return sortedRates;
+        }
+        catch (error) {
+            console.error('[useShippingRatesQuery] Error previewing shipping rates:', error);
+            return [];
+        }
+        finally {
+            setIsPreviewLoading(false);
+        }
+    }, [effectiveSessionId, shippingRatesResource]);
     return {
         shippingRates,
         selectedRate,
@@ -130,5 +162,8 @@ export function useShippingRatesQuery(options = {}) {
         error: (fetchError || setShippingRateMutation.error),
         clearError,
         refetch,
+        previewRates,
+        previewedRates,
+        isPreviewLoading,
     };
 }

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

@@ -21,7 +21,7 @@
  * const offerId = staticResources?.offer;
  * ```
  */
-import { GTMTrackingConfig, MetaConversionTrackingConfig, PixelTrackingConfig, RuntimeStepConfig, SnapchatTrackingConfig, TrackingProvider } from '../../core/funnelClient';
+import { PixelsConfig, RuntimeStepConfig } from '../../core/funnelClient';
 export interface UseStepConfigResult {
     /**
      * Full step configuration object
@@ -45,13 +45,7 @@ export interface UseStepConfigResult {
      * @param position - Where the scripts should be injected
      */
     getScripts: (position?: 'head-start' | 'head-end' | 'body-start' | 'body-end') => RuntimeStepConfig['scripts'];
-    pixels: {
-        [TrackingProvider.FACEBOOK]?: PixelTrackingConfig[];
-        [TrackingProvider.TIKTOK]?: PixelTrackingConfig[];
-        [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
-        [TrackingProvider.META_CONVERSION]?: MetaConversionTrackingConfig[];
-        [TrackingProvider.GTM]?: GTMTrackingConfig[];
-    } | undefined;
+    pixels: PixelsConfig | undefined;
 }
 /**
  * Hook to access runtime step configuration injected via HTML

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

@@ -22,7 +22,7 @@
  * ```
  */
 import { useMemo } from 'react';
-import { getAssignedPaymentFlowId, getAssignedPixels, getAssignedScripts, getAssignedStaticResources, getAssignedStepConfig, TrackingProvider } from '../../core/funnelClient';
+import { getAssignedPaymentFlowId, getAssignedPixels, getAssignedScripts, getAssignedStaticResources, getAssignedStepConfig, } from '../../core/funnelClient';
 /**
  * Hook to access runtime step configuration injected via HTML
  *

package/dist/v2/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, localConfig, blockUntilSessionReady = false, rawPluginConfig, features, funnelId, autoInitializeFunnel = true, onNavigate, onFunnelError, debugScripts = [], }) {

package/dist/v2/standalone/index.js

@@ -19,7 +19,7 @@ export function createTagadaClient(config = {}) {
 // Re-export Core Classes
 export { TagadaClient, ApiClient, CheckoutResource };
 export { FunnelActionType } from '../core/resources/funnel';
-// Re-export Utilities (includes formatMoney from core/utils/currency)
+// Re-export Utilities
 export * from '../core/utils';
 // ============================================================================
 // EXTERNAL PAGE TRACKER