@tagadapay/plugin-sdk 3.1.11 → 3.1.22

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/useGeoLocation.d.ts

@@ -1,3 +1,4 @@
+import { TagadaError } from '../../core/errors';
 export interface GeoLocationData {
     ip_address?: string | null;
     city?: string | null;
@@ -82,7 +83,7 @@ export interface UseGeoLocationReturn {
     /**
      * Any error that occurred during the request
      */
-    error: string | null;
+    error: TagadaError | null;
     /**
      * Function to manually fetch geolocation data
      */

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

@@ -1,6 +1,7 @@
 'use client';
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useTagadaContext } from '../providers/TagadaProvider';
+import { TagadaError, TagadaErrorCode } from '../../core/errors';
 /**
  * Hook to fetch and manage geolocation data - V2 Implementation
  * Compatible with V1 interface while using V2 provider architecture
@@ -111,10 +112,11 @@ export function useGeoLocation(options = {}) {
             void fetchGeoData();
         }
     }, [refetchOnMount, apiService, fetchGeoData]);
+    const tagadaError = useMemo(() => error ? new TagadaError(error, { code: TagadaErrorCode.NETWORK_ERROR }) : null, [error]);
     return {
         data,
         isLoading,
-        error,
+        error: tagadaError,
         fetchGeoData,
         clearData,
         isLocalhost: isLocalhost(data?.ip_address),

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/useISOData.js

@@ -106,7 +106,7 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
  */
 export function getAvailableLanguages() {
     // Return all available languages (not just registered ones)
-    return ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+    return ['en', 'ru', 'de', 'da', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
 }
 /**
  * Hook to manually import and register a language

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

@@ -2,14 +2,14 @@ export interface Payment {
     id: string;
     status: string;
     subStatus: string;
-    requireAction: 'none' | 'redirect' | 'error' | 'radar';
+    requireAction: 'none' | 'redirect' | 'redirect_to_payment' | 'error' | 'radar';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar';
+        type: 'redirect' | 'redirect_to_payment' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar' | 'kesspay_auth' | 'trustflow_auth' | 'mastercard_auth';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect' | 'stripe_radar' | 'finix_radar';
+            type: 'redirect' | 'redirect_to_payment' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;

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

@@ -2,7 +2,8 @@
  * Payment Hook using TanStack Query (V2)
  * Matches the old usePayment.ts implementation exactly for easy migration
  */
-import type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../core/resources/payments';
+import type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, GooglePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../core/resources/payments';
+import { TagadaError } from '../../core/errors';
 export type { Payment as PaymentType, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse, PaymentInstrumentCustomer } from '../../core/resources/payments';
 /**
  * Metadata provided with payment callbacks
@@ -11,7 +12,12 @@ export interface PaymentCompletionMetadata {
     /** True if payment completed after external redirect (3DS, PayPal, etc.) */
     isRedirectReturn: boolean;
     /** Order associated with the payment (if available) */
-    order?: any;
+    order?: {
+        id: string;
+        amount?: number;
+        currency?: string;
+        [key: string]: unknown;
+    };
     /** Checkout session ID (if available) */
     checkoutSessionId?: string;
 }
@@ -37,14 +43,21 @@ export interface UsePaymentOptions {
 export interface PaymentHook {
     processCardPayment: (checkoutSessionId: string, cardData: CardPaymentMethod, options?: PaymentOptions) => Promise<PaymentResponse>;
     processApplePayPayment: (checkoutSessionId: string, applePayToken: ApplePayToken, options?: PaymentOptions) => Promise<PaymentResponse>;
-    processGooglePayPayment: (checkoutSessionId: string, googlePayToken: any, options?: PaymentOptions) => Promise<PaymentResponse>;
+    processGooglePayPayment: (checkoutSessionId: string, googlePayToken: GooglePayToken, options?: PaymentOptions) => Promise<PaymentResponse>;
     processPaymentWithInstrument: (checkoutSessionId: string, paymentInstrumentId: string, options?: PaymentOptions) => Promise<PaymentResponse>;
+    processApmPayment: (checkoutSessionId: string, options: {
+        processorId: string;
+        paymentMethod: string;
+        initiatedBy?: 'customer' | 'merchant';
+        source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+        paymentFlowId?: string;
+    } & Pick<PaymentOptions, 'onFailure' | 'onPaymentFailed' | 'onSuccess' | 'onPaymentSuccess'>) => Promise<PaymentResponse>;
     createCardPaymentInstrument: (cardData: CardPaymentMethod) => Promise<PaymentInstrumentResponse>;
     createApplePayPaymentInstrument: (applePayToken: ApplePayToken) => Promise<PaymentInstrumentResponse>;
-    createGooglePayPaymentInstrument: (googlePayToken: any) => Promise<PaymentInstrumentResponse>;
+    createGooglePayPaymentInstrument: (googlePayToken: GooglePayToken) => Promise<PaymentInstrumentResponse>;
     getCardPaymentInstruments: () => Promise<PaymentInstrumentCustomerResponse>;
     isLoading: boolean;
-    error: string | null;
+    error: TagadaError | null;
     clearError: () => void;
     currentPaymentId: string | null;
 }