@tagadapay/plugin-sdk 2.4.39 → 2.5.0

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

@@ -0,0 +1,207 @@
+/**
+ * Google Autocomplete Hook - V2 Implementation
+ * Compatible with V1 interface while using V2 core architecture
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * React hook for Google Places Autocomplete with automatic script injection
+ * Automatically loads the Google Maps JavaScript API with Places library
+ */
+export function useGoogleAutocomplete(options) {
+    const { apiKey, libraries = ['places'], version = 'weekly', language, region } = options;
+    const [predictions, setPredictions] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isScriptLoaded, setIsScriptLoaded] = useState(false);
+    const autocompleteServiceRef = useRef(null);
+    const placesServiceRef = useRef(null);
+    const scriptLoadedRef = useRef(false);
+    // Inject Google Maps script
+    useEffect(() => {
+        if (!apiKey) {
+            console.error('Google Maps API key is required');
+            return;
+        }
+        if (scriptLoadedRef.current || window.google?.maps) {
+            setIsScriptLoaded(true);
+            return;
+        }
+        // Check if script is already being loaded
+        const existingScript = document.querySelector('script[src*="maps.googleapis.com"]');
+        if (existingScript) {
+            // Wait for existing script to load
+            const checkLoaded = () => {
+                if (window.google?.maps?.places?.AutocompleteService) {
+                    setIsScriptLoaded(true);
+                    scriptLoadedRef.current = true;
+                }
+                else {
+                    setTimeout(checkLoaded, 100);
+                }
+            };
+            checkLoaded();
+            return;
+        }
+        // Create and inject the script
+        const script = document.createElement('script');
+        const params = new URLSearchParams({
+            key: apiKey,
+            libraries: libraries.join(','),
+            v: version,
+        });
+        if (language)
+            params.append('language', language);
+        if (region)
+            params.append('region', region);
+        script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+        script.async = true;
+        script.defer = true;
+        script.onload = () => {
+            console.log('🗺️ Google Maps API loaded successfully');
+            setIsScriptLoaded(true);
+            scriptLoadedRef.current = true;
+        };
+        script.onerror = () => {
+            console.error('Failed to load Google Maps API');
+        };
+        document.head.appendChild(script);
+        // Cleanup function
+        return () => {
+            // Note: We don't remove the script as it might be used by other components
+            // The script will remain in the DOM for the session
+        };
+    }, [apiKey, libraries, version, language, region]);
+    // Initialize Google Places services
+    const initializeServices = useCallback(() => {
+        if (typeof window === 'undefined')
+            return false;
+        if (!window.google?.maps?.places?.AutocompleteService) {
+            return false;
+        }
+        if (!autocompleteServiceRef.current) {
+            autocompleteServiceRef.current = new window.google.maps.places.AutocompleteService();
+        }
+        if (!placesServiceRef.current) {
+            // Create a dummy map for PlacesService (required by Google API)
+            const map = new window.google.maps.Map(document.createElement('div'));
+            placesServiceRef.current = new window.google.maps.places.PlacesService(map);
+        }
+        return true;
+    }, []);
+    // Search for place predictions
+    const searchPlaces = useCallback((input, countryRestriction) => {
+        if (!isScriptLoaded) {
+            console.warn('Google Maps API not yet loaded');
+            return;
+        }
+        if (!initializeServices()) {
+            console.error('Google Places services not available');
+            return;
+        }
+        if (input.length < 3) {
+            setPredictions([]);
+            return;
+        }
+        setIsLoading(true);
+        const request = {
+            input,
+            ...(countryRestriction && {
+                componentRestrictions: { country: countryRestriction.toLowerCase() },
+            }),
+        };
+        autocompleteServiceRef.current.getPlacePredictions(request, (results, status) => {
+            setIsLoading(false);
+            if (status === window.google.maps.places.PlacesServiceStatus.OK && results) {
+                setPredictions(results);
+                console.log(`🔍 Found ${results.length} predictions for "${input}"`);
+            }
+            else {
+                setPredictions([]);
+                if (status !== window.google.maps.places.PlacesServiceStatus.ZERO_RESULTS) {
+                    console.warn('Google Places prediction failed:', status);
+                }
+            }
+        });
+    }, [initializeServices, isScriptLoaded]);
+    // Get detailed place information
+    const getPlaceDetails = useCallback((placeId) => {
+        return new Promise((resolve) => {
+            if (!isScriptLoaded) {
+                console.warn('Google Maps API not yet loaded');
+                resolve(null);
+                return;
+            }
+            if (!initializeServices()) {
+                console.error('Google Places services not available');
+                resolve(null);
+                return;
+            }
+            const request = {
+                placeId,
+                fields: ['place_id', 'formatted_address', 'address_components', 'geometry'],
+            };
+            placesServiceRef.current.getDetails(request, (place, status) => {
+                if (status === window.google.maps.places.PlacesServiceStatus.OK && place) {
+                    console.log('📍 Got place details:', place);
+                    resolve(place);
+                }
+                else {
+                    console.error('Failed to get place details:', status);
+                    resolve(null);
+                }
+            });
+        });
+    }, [initializeServices, isScriptLoaded]);
+    // Extract structured address components from Google place
+    const extractAddressComponents = useCallback((place) => {
+        const extracted = {
+            streetNumber: '',
+            route: '',
+            locality: '',
+            administrativeAreaLevel1: '',
+            administrativeAreaLevel1Long: '',
+            country: '',
+            postalCode: '',
+        };
+        console.log('🏗️ Extracted address components:', place.address_components);
+        place.address_components?.forEach((component) => {
+            const types = component.types;
+            if (types.includes('street_number')) {
+                extracted.streetNumber = component.long_name;
+            }
+            if (types.includes('route')) {
+                extracted.route = component.long_name;
+            }
+            if (types.includes('locality')) {
+                extracted.locality = component.long_name;
+            }
+            if (types.includes('administrative_area_level_2') && !extracted.locality) {
+                extracted.locality = component.long_name;
+            }
+            if (types.includes('administrative_area_level_1')) {
+                extracted.administrativeAreaLevel1 = component.short_name;
+                extracted.administrativeAreaLevel1Long = component.long_name;
+            }
+            if (types.includes('country')) {
+                extracted.country = component.short_name;
+            }
+            if (types.includes('postal_code')) {
+                extracted.postalCode = component.long_name;
+            }
+        });
+        console.log('🏗️ Extracted address components:', extracted);
+        return extracted;
+    }, []);
+    // Clear predictions
+    const clearPredictions = useCallback(() => {
+        setPredictions([]);
+    }, []);
+    return {
+        predictions,
+        isLoading,
+        isScriptLoaded,
+        searchPlaces,
+        getPlaceDetails,
+        extractAddressComponents,
+        clearPredictions,
+    };
+}

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

@@ -0,0 +1,61 @@
+import { type SupportedLanguage } from '../../../data/iso3166';
+export interface ISOCountry {
+    iso: string;
+    iso3: string;
+    numeric: number;
+    name: string;
+}
+export interface ISORegion {
+    iso: string;
+    name: string;
+}
+export interface UseISODataResult {
+    countries: Record<string, ISOCountry>;
+    getRegions: (countryCode: string) => ISORegion[];
+    findRegion: (countryCode: string, regionCode: string) => ISORegion | null;
+    mapGoogleToISO: (googleState: string, googleStateLong: string, countryCode: string) => ISORegion | null;
+    isLanguageLoaded: boolean;
+    registeredLanguages: SupportedLanguage[];
+}
+/**
+ * React hook for accessing ISO3166 countries and regions data with dynamic language loading
+ * @param language - Language code (supports: en, ru, de, fr, es, zh, hi, pt, ja, ar, it, he)
+ * @param autoImport - Whether to automatically import the language if not registered (default: true)
+ * @param disputeSetting - Territorial dispute perspective (currently only UN is supported)
+ * @returns Object with countries data and helper functions
+ */
+export declare function useISOData(language?: SupportedLanguage, autoImport?: boolean, disputeSetting?: string): UseISODataResult;
+/**
+ * Get available languages for ISO data
+ */
+export declare function getAvailableLanguages(): SupportedLanguage[];
+/**
+ * Hook to manually import and register a language
+ * @param language - Language code to import
+ * @returns Object with loading state and error handling
+ */
+export declare function useLanguageImport(language: SupportedLanguage): {
+    importLanguage: () => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+    isRegistered: boolean;
+};
+/**
+ * Get list of countries as options for select components
+ * @param language - Language code (defaults to 'en')
+ * @param autoImport - Whether to automatically import the language if not registered (default: true)
+ */
+export declare function useCountryOptions(language?: SupportedLanguage, autoImport?: boolean): {
+    value: string;
+    label: string;
+}[];
+/**
+ * Get list of regions/states for a country as options for select components
+ * @param countryCode - ISO country code
+ * @param language - Language code (defaults to 'en')
+ * @param autoImport - Whether to automatically import the language if not registered (default: true)
+ */
+export declare function useRegionOptions(countryCode: string, language?: SupportedLanguage, autoImport?: boolean): {
+    value: string;
+    label: string;
+}[];

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

@@ -0,0 +1,176 @@
+import { useMemo, useEffect, useState, useCallback } from 'react';
+// Import the pre-built ISO data functions
+import { getCountries, getStatesForCountry, importLanguage, isLanguageRegistered, getRegisteredLanguages } from '../../../data/iso3166';
+/**
+ * React hook for accessing ISO3166 countries and regions data with dynamic language loading
+ * @param language - Language code (supports: en, ru, de, fr, es, zh, hi, pt, ja, ar, it, he)
+ * @param autoImport - Whether to automatically import the language if not registered (default: true)
+ * @param disputeSetting - Territorial dispute perspective (currently only UN is supported)
+ * @returns Object with countries data and helper functions
+ */
+export function useISOData(language = 'en', autoImport = true, disputeSetting = 'UN') {
+    const [isLanguageLoaded, setIsLanguageLoaded] = useState(isLanguageRegistered(language));
+    const [registeredLanguages, setRegisteredLanguages] = useState(getRegisteredLanguages);
+    // Auto-import language if not registered and autoImport is true
+    useEffect(() => {
+        if (!isLanguageRegistered(language) && autoImport && language !== 'en') {
+            importLanguage(language)
+                .then(() => {
+                setIsLanguageLoaded(true);
+                setRegisteredLanguages(getRegisteredLanguages());
+            })
+                .catch((error) => {
+                console.error(`Failed to auto-import language ${language}:`, error);
+            });
+        }
+    }, [language, autoImport]);
+    const data = useMemo(() => {
+        try {
+            // Get countries from pre-built data with language support
+            const countriesArray = getCountries(language);
+            // Transform to our expected format (Record<string, ISOCountry>)
+            const countries = {};
+            countriesArray.forEach((country) => {
+                countries[country.code] = {
+                    iso: country.code,
+                    iso3: country.iso3 || '',
+                    numeric: country.numeric || 0,
+                    name: country.name,
+                };
+            });
+            // Helper to load regions for a specific country
+            const getRegions = (countryCode) => {
+                try {
+                    const states = getStatesForCountry(countryCode, language);
+                    return states.map((state) => ({
+                        iso: state.code,
+                        name: state.name,
+                    }));
+                }
+                catch {
+                    return []; // Return empty array if no regions
+                }
+            };
+            // Find a specific region by ISO code
+            const findRegion = (countryCode, regionCode) => {
+                const regions = getRegions(countryCode);
+                return regions.find((region) => region.iso === regionCode) ?? null;
+            };
+            // Map Google Places state to ISO region (proven 100% success rate)
+            const mapGoogleToISO = (googleState, googleStateLong, countryCode) => {
+                const regions = getRegions(countryCode);
+                if (regions.length === 0)
+                    return null;
+                // Strategy 1: Exact ISO code match (86% success rate)
+                let match = regions.find((r) => r.iso === googleState);
+                if (match)
+                    return match;
+                // Strategy 2: Name matching (14% success rate)
+                match = regions.find((r) => r.name.toLowerCase() === googleState.toLowerCase());
+                if (match)
+                    return match;
+                match = regions.find((r) => r.name.toLowerCase() === googleStateLong.toLowerCase());
+                if (match)
+                    return match;
+                // Strategy 3: Partial name matching (fallback)
+                match = regions.find((r) => r.name.toLowerCase().includes(googleStateLong.toLowerCase()) ||
+                    googleStateLong.toLowerCase().includes(r.name.toLowerCase()));
+                return match ?? null;
+            };
+            return {
+                countries,
+                getRegions,
+                findRegion,
+                mapGoogleToISO,
+                isLanguageLoaded,
+                registeredLanguages,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to load ISO data for language: ${language}`, error);
+            return {
+                countries: {},
+                getRegions: () => [],
+                findRegion: () => null,
+                mapGoogleToISO: () => null,
+                isLanguageLoaded,
+                registeredLanguages,
+            };
+        }
+    }, [language, disputeSetting, isLanguageLoaded, registeredLanguages]);
+    return data;
+}
+/**
+ * Get available languages for ISO data
+ */
+export function getAvailableLanguages() {
+    // Return all available languages (not just registered ones)
+    return ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+}
+/**
+ * Hook to manually import and register a language
+ * @param language - Language code to import
+ * @returns Object with loading state and error handling
+ */
+export function useLanguageImport(language) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const importLanguageData = useCallback(async () => {
+        if (isLanguageRegistered(language)) {
+            return; // Already registered
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            await importLanguage(language);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to import language');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [language]);
+    return {
+        importLanguage: importLanguageData,
+        isLoading,
+        error,
+        isRegistered: isLanguageRegistered(language),
+    };
+}
+/**
+ * Get list of countries as options for select components
+ * @param language - Language code (defaults to 'en')
+ * @param autoImport - Whether to automatically import the language if not registered (default: true)
+ */
+export function useCountryOptions(language = 'en', autoImport = true) {
+    const { countries } = useISOData(language, autoImport);
+    return useMemo(() => {
+        return Object.entries(countries)
+            .map(([code, country]) => ({
+            value: code,
+            label: country.name,
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+    }, [countries]);
+}
+/**
+ * Get list of regions/states for a country as options for select components
+ * @param countryCode - ISO country code
+ * @param language - Language code (defaults to 'en')
+ * @param autoImport - Whether to automatically import the language if not registered (default: true)
+ */
+export function useRegionOptions(countryCode, language = 'en', autoImport = true) {
+    const { getRegions } = useISOData(language, autoImport);
+    return useMemo(() => {
+        if (!countryCode)
+            return [];
+        const regions = getRegions(countryCode);
+        return regions
+            .map((region) => ({
+            value: region.iso,
+            label: region.name,
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+    }, [countryCode, getRegions]);
+}

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

@@ -0,0 +1,65 @@
+/**
+ * Offers Hook using TanStack Query
+ * Handles offers with automatic caching
+ */
+import { Offer } from '../../core/resources/offers';
+import { CheckoutSessionState, OrderSummary, CurrencyOptions } from '../../core/resources/postPurchases';
+export interface UseOffersQueryOptions {
+    /**
+     * Array of offer IDs to fetch
+     */
+    offerIds?: string[];
+    /**
+     * Whether to fetch offers automatically on mount
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Return URL for checkout sessions
+     */
+    returnUrl?: string;
+}
+export interface UseOffersQueryResult {
+    offers: Offer[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    createCheckoutSession: (offerId: string, options?: {
+        returnUrl?: string;
+    }) => Promise<{
+        checkoutUrl: string;
+    }>;
+    payOffer: (offerId: string, orderId?: string) => Promise<void>;
+    transformToCheckout: (offerId: string, options?: {
+        returnUrl?: string;
+    }) => Promise<{
+        checkoutUrl: string;
+    }>;
+    getOffer: (offerId: string) => Offer | undefined;
+    getTotalValue: () => number;
+    getTotalSavings: () => number;
+    payWithCheckoutSession: (checkoutSessionId: string, orderId?: string) => Promise<void>;
+    initCheckoutSession: (offerId: string, orderId: string, customerId?: string) => Promise<{
+        checkoutSessionId: string;
+    }>;
+    getCheckoutSessionState: (offerId: string) => CheckoutSessionState | null;
+    initializeOfferCheckout: (offerId: string) => Promise<void>;
+    getAvailableVariants: (offerId: string, productId: string) => {
+        variantId: string;
+        variantName: string;
+        variantSku: string | null;
+        variantDefault: boolean | null;
+        variantExternalId: string | null;
+        priceId: string;
+        currencyOptions: CurrencyOptions;
+    }[];
+    selectVariant: (offerId: string, productId: string, variantId: string) => Promise<void>;
+    getOrderSummary: (offerId: string) => OrderSummary | null;
+    isLoadingVariants: (offerId: string, productId: string) => boolean;
+    isUpdatingOrderSummary: (offerId: string) => boolean;
+    confirmPurchase: (offerId: string, options?: {
+        draft?: boolean;
+        returnUrl?: string;
+    }) => Promise<void>;
+}
+export declare function useOffersQuery(options?: UseOffersQueryOptions): UseOffersQueryResult;