@tagadapay/plugin-sdk 2.4.39 → 2.5.2

package/dist/react/hooks/usePostPurchases.js

@@ -24,7 +24,7 @@ export function usePostPurchases(options) {
             // Auto-initialize checkout sessions if enabled
             if (autoInitializeCheckout && fetchedOffers.length > 0) {
                 for (const offer of fetchedOffers) {
-                    await initializeOfferCheckout(offer.id);
+                    void initializeOfferCheckout(offer.id);
                 }
             }
         }
@@ -69,9 +69,13 @@ export function usePostPurchases(options) {
             method: 'POST',
             body: JSON.stringify({
                 checkoutSessionId,
+                draft: false,
+                returnUrl: window.location.href,
                 metadata: {
                     comingFromPostPurchase: true,
                     postOrder: orderId,
+                    upsell: true,
+                    source: 'post_purchase_offer',
                 },
             }),
         });
@@ -244,6 +248,8 @@ export function usePostPurchases(options) {
                 metadata: {
                     comingFromPostPurchase: true,
                     postOrder: orderId,
+                    upsell: true,
+                    source: 'post_purchase_offer',
                 },
             }),
         });
@@ -268,17 +274,17 @@ export function usePostPurchases(options) {
         }));
     }, [checkoutSessions]);
     const getOrderSummary = useCallback((offerId) => {
-        return checkoutSessions[offerId]?.orderSummary || null;
+        return checkoutSessions[offerId]?.orderSummary ?? null;
     }, [checkoutSessions]);
     const isLoadingVariants = useCallback((offerId, productId) => {
-        return checkoutSessions[offerId]?.loadingVariants?.[productId] || false;
+        return checkoutSessions[offerId]?.loadingVariants?.[productId] ?? false;
     }, [checkoutSessions]);
     const isUpdatingOrderSummary = useCallback((offerId) => {
-        return checkoutSessions[offerId]?.isUpdatingSummary || false;
+        return checkoutSessions[offerId]?.isUpdatingSummary ?? false;
     }, [checkoutSessions]);
     useEffect(() => {
         if (enabled && orderId) {
-            fetchOffers();
+            void fetchOffers();
         }
     }, [enabled, orderId, fetchOffers]);
     const getOffer = useCallback((offerId) => {

package/dist/react/index.d.ts

@@ -15,6 +15,10 @@ export { useLocale } from './hooks/useLocale';
 export { useLogin } from './hooks/useLogin';
 export { useOffers } from './hooks/useOffers';
 export { useOrderBump } from './hooks/useOrderBump';
+export { useOrderBumpV2 } from './hooks/useOrderBumpV2';
+export { useOrderBumpV3 } from './hooks/useOrderBumpV3';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useCheckoutSession } from './hooks/useCheckoutSession';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
@@ -41,6 +45,10 @@ export type { AuthState, Currency, Customer, Environment, EnvironmentConfig, Loc
 export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, CheckoutSessionPreview, Promotion, UseCheckoutOptions, UseCheckoutResult } from './hooks/useCheckout';
 export type { Discount, DiscountCodeValidation, UseDiscountsOptions, UseDiscountsResult } from './hooks/useDiscounts';
 export type { OrderBumpPreview, UseOrderBumpOptions, UseOrderBumpResult } from './hooks/useOrderBump';
+export type { UseOrderBumpV2Options, UseOrderBumpV2Result } from './hooks/useOrderBumpV2';
+export type { UseOrderBumpV3Options, UseOrderBumpV3Result } from './hooks/useOrderBumpV3';
+export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
+export type { UseCheckoutSessionOptions, UseCheckoutSessionResult } from './hooks/useCheckoutSession';
 export type { UseVipOffersOptions, UseVipOffersResult, VipOffer, VipPreviewResponse } from './hooks/useVipOffers';
 export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferLineItem, PostPurchaseOfferSummary, UsePostPurchasesOptions, UsePostPurchasesResult } from './hooks/usePostPurchases';
 export type { Payment, PaymentPollingHook, PollingOptions } from './hooks/usePaymentPolling';

package/dist/react/index.js

@@ -18,6 +18,10 @@ export { useLocale } from './hooks/useLocale';
 export { useLogin } from './hooks/useLogin';
 export { useOffers } from './hooks/useOffers';
 export { useOrderBump } from './hooks/useOrderBump';
+export { useOrderBumpV2 } from './hooks/useOrderBumpV2';
+export { useOrderBumpV3 } from './hooks/useOrderBumpV3';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useCheckoutSession } from './hooks/useCheckoutSession';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';

package/dist/react/services/apiService.d.ts

@@ -49,6 +49,7 @@ export declare class ApiService {
     private onTokenClear?;
     constructor(options: ApiServiceOptions);
     updateToken(token: string | null): void;
+    getCurrentToken(): string | null;
     updateConfig(config: EnvironmentConfig): void;
     /**
      * Store the store ID in localStorage (deprecated - use usePluginConfig instead)

package/dist/react/services/apiService.js

@@ -10,6 +10,9 @@ export class ApiService {
     updateToken(token) {
         this.token = token;
     }
+    getCurrentToken() {
+        return this.token;
+    }
     updateConfig(config) {
         this.config = config;
     }

package/dist/v2/core/googleAutocomplete.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Google Autocomplete Core
+ * Pure functions for Google Places API integration
+ */
+export interface GooglePrediction {
+    place_id: string;
+    description: string;
+    structured_formatting?: {
+        main_text: string;
+        secondary_text: string;
+    };
+}
+export interface GooglePlaceDetails {
+    place_id: string;
+    formatted_address: string;
+    address_components: {
+        long_name: string;
+        short_name: string;
+        types: string[];
+    }[];
+    geometry: {
+        location: {
+            lat: number;
+            lng: number;
+        };
+    };
+}
+export interface AddressComponents {
+    streetNumber?: string;
+    route?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    countryCode?: string;
+    locality?: string;
+    administrativeAreaLevel1?: string;
+    administrativeAreaLevel1Long?: string;
+    iso?: string;
+}
+export declare class GoogleAutocompleteCore {
+    private static apiKey;
+    private static service;
+    /**
+     * Initialize Google Places API
+     */
+    static initialize(apiKey: string): void;
+    /**
+     * Search for places
+     */
+    static searchPlaces(input: string, options?: {
+        types?: string[];
+        componentRestrictions?: {
+            country: string;
+        };
+    }): Promise<GooglePrediction[]>;
+    /**
+     * Get place details
+     */
+    static getPlaceDetails(placeId: string): Promise<GooglePlaceDetails | null>;
+    /**
+     * Extract address components from place details
+     */
+    static extractAddressComponents(placeDetails: GooglePlaceDetails): AddressComponents;
+}

package/dist/v2/core/googleAutocomplete.js

@@ -0,0 +1,94 @@
+/**
+ * Google Autocomplete Core
+ * Pure functions for Google Places API integration
+ */
+export class GoogleAutocompleteCore {
+    /**
+     * Initialize Google Places API
+     */
+    static initialize(apiKey) {
+        this.apiKey = apiKey;
+        if (typeof window !== 'undefined' && window.google) {
+            this.service = new window.google.maps.places.AutocompleteService();
+        }
+    }
+    /**
+     * Search for places
+     */
+    static async searchPlaces(input, options = {}) {
+        if (!this.service || !input.trim()) {
+            return [];
+        }
+        return new Promise((resolve, reject) => {
+            this.service.getPlacePredictions({
+                input,
+                types: options.types || ['address'],
+                componentRestrictions: options.componentRestrictions,
+            }, (predictions, status) => {
+                if (status === window.google.maps.places.PlacesServiceStatus.OK && predictions) {
+                    resolve(predictions);
+                }
+                else {
+                    resolve([]);
+                }
+            });
+        });
+    }
+    /**
+     * Get place details
+     */
+    static async getPlaceDetails(placeId) {
+        if (typeof window === 'undefined' || !window.google) {
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            const service = new window.google.maps.places.PlacesService(document.createElement('div'));
+            service.getDetails({
+                placeId,
+                fields: ['place_id', 'formatted_address', 'address_components', 'geometry'],
+            }, (place, status) => {
+                if (status === window.google.maps.places.PlacesServiceStatus.OK && place) {
+                    resolve(place);
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    /**
+     * Extract address components from place details
+     */
+    static extractAddressComponents(placeDetails) {
+        const components = {};
+        for (const component of placeDetails.address_components) {
+            const types = component.types;
+            if (types.includes('street_number')) {
+                components.streetNumber = component.long_name;
+            }
+            else if (types.includes('route')) {
+                components.route = component.long_name;
+            }
+            else if (types.includes('locality')) {
+                components.city = component.long_name;
+                components.locality = component.long_name;
+            }
+            else if (types.includes('administrative_area_level_1')) {
+                components.state = component.long_name;
+                components.administrativeAreaLevel1 = component.short_name;
+                components.administrativeAreaLevel1Long = component.long_name;
+            }
+            else if (types.includes('postal_code')) {
+                components.postalCode = component.long_name;
+            }
+            else if (types.includes('country')) {
+                components.country = component.long_name;
+                components.countryCode = component.short_name;
+                components.iso = component.short_name;
+            }
+        }
+        return components;
+    }
+}
+GoogleAutocompleteCore.apiKey = null;
+GoogleAutocompleteCore.service = null;

package/dist/v2/core/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core functions and utilities for TagadaPay Plugin SDK v2
+ * Structured with utils (pure functions) and resources (API clients)
+ */
+export * from './utils';
+export * from './resources';
+export * from './googleAutocomplete';
+export * from './isoData';

package/dist/v2/core/index.js

@@ -0,0 +1,11 @@
+/**
+ * Core functions and utilities for TagadaPay Plugin SDK v2
+ * Structured with utils (pure functions) and resources (API clients)
+ */
+// Export utilities (pure functions)
+export * from './utils';
+// Export resources (axios-based API clients)
+export * from './resources';
+// Export legacy files that are still needed
+export * from './googleAutocomplete';
+export * from './isoData';

package/dist/v2/core/isoData.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ISO Data Core
+ * Pure functions for country and region data management
+ * Uses the existing iso3166 data functions
+ */
+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 declare class ISODataCore {
+    /**
+     * Get countries data for a specific language
+     */
+    static getCountriesData(language?: SupportedLanguage): Record<string, ISOCountry>;
+    /**
+     * Get regions for a specific country
+     */
+    static getRegions(countryCode: string, language?: SupportedLanguage): ISORegion[];
+    /**
+     * Find a specific region by ISO code
+     */
+    static findRegion(countryCode: string, regionCode: string, language?: SupportedLanguage): ISORegion | null;
+    /**
+     * Map Google Places state to ISO region (proven 100% success rate)
+     */
+    static mapGoogleToISO(googleState: string, googleStateLong: string, countryCode: string, language?: SupportedLanguage): ISORegion | null;
+    /**
+     * Check if language is registered
+     */
+    static isLanguageRegistered(language: SupportedLanguage): boolean;
+    /**
+     * Get registered languages
+     */
+    static getRegisteredLanguages(): SupportedLanguage[];
+    /**
+     * Import language data
+     */
+    static importLanguage(language: SupportedLanguage): Promise<void>;
+    /**
+     * Get available languages for ISO data
+     */
+    static getAvailableLanguages(): SupportedLanguage[];
+}

package/dist/v2/core/isoData.js

@@ -0,0 +1,103 @@
+/**
+ * ISO Data Core
+ * Pure functions for country and region data management
+ * Uses the existing iso3166 data functions
+ */
+// Import the pre-built ISO data functions
+import { getCountries, getStatesForCountry, importLanguage, isLanguageRegistered, getRegisteredLanguages } from '../../data/iso3166';
+export class ISODataCore {
+    /**
+     * Get countries data for a specific language
+     */
+    static getCountriesData(language = 'en') {
+        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,
+                };
+            });
+            return countries;
+        }
+        catch (error) {
+            console.error(`Failed to load ISO data for language: ${language}`, error);
+            return {};
+        }
+    }
+    /**
+     * Get regions for a specific country
+     */
+    static getRegions(countryCode, language = 'en') {
+        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
+     */
+    static findRegion(countryCode, regionCode, language = 'en') {
+        const regions = this.getRegions(countryCode, language);
+        return regions.find((region) => region.iso === regionCode) ?? null;
+    }
+    /**
+     * Map Google Places state to ISO region (proven 100% success rate)
+     */
+    static mapGoogleToISO(googleState, googleStateLong, countryCode, language = 'en') {
+        const regions = this.getRegions(countryCode, language);
+        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;
+    }
+    /**
+     * Check if language is registered
+     */
+    static isLanguageRegistered(language) {
+        return isLanguageRegistered(language);
+    }
+    /**
+     * Get registered languages
+     */
+    static getRegisteredLanguages() {
+        return getRegisteredLanguages();
+    }
+    /**
+     * Import language data
+     */
+    static async importLanguage(language) {
+        return importLanguage(language);
+    }
+    /**
+     * Get available languages for ISO data
+     */
+    static getAvailableLanguages() {
+        // Return all available languages (not just registered ones)
+        return ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+    }
+}

package/dist/v2/core/resources/apiClient.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base API Client using Axios
+ * Shared between all resource clients
+ */
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+export interface ApiClientConfig {
+    baseURL: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export declare class ApiClient {
+    axios: AxiosInstance;
+    private currentToken;
+    constructor(config: ApiClientConfig);
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
+    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    setHeader(key: string, value: string): void;
+    removeHeader(key: string): void;
+    updateToken(token: string | null): void;
+    getCurrentToken(): string | null;
+    updateConfig(config: Partial<ApiClientConfig>): void;
+}

package/dist/v2/core/resources/apiClient.js

@@ -0,0 +1,95 @@
+/**
+ * Base API Client using Axios
+ * Shared between all resource clients
+ */
+import axios from 'axios';
+export class ApiClient {
+    constructor(config) {
+        this.currentToken = null;
+        this.axios = axios.create({
+            baseURL: config.baseURL,
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+                ...config.headers,
+            },
+        });
+        // Request interceptor for logging and auth
+        this.axios.interceptors.request.use((config) => {
+            console.log(`[SDK] Making ${config.method?.toUpperCase()} request to: ${config.baseURL}${config.url}`);
+            console.log('[SDK] Request headers:', config.headers);
+            if (config.data) {
+                console.log('[SDK] Request body:', config.data);
+            }
+            return config;
+        }, (error) => {
+            console.error('[SDK] Request error:', error);
+            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+        });
+        // Response interceptor for logging
+        this.axios.interceptors.response.use((response) => {
+            console.log('[SDK] Response status:', response.status);
+            console.log('[SDK] Response data:', response.data);
+            return response;
+        }, (error) => {
+            console.error('[SDK] Response error:', error);
+            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    // Convenience methods
+    async get(url, config) {
+        const response = await this.axios.get(url, config);
+        return response.data;
+    }
+    async post(url, data, config) {
+        const response = await this.axios.post(url, data, config);
+        return response.data;
+    }
+    async put(url, data, config) {
+        const response = await this.axios.put(url, data, config);
+        return response.data;
+    }
+    async patch(url, data, config) {
+        const response = await this.axios.patch(url, data, config);
+        return response.data;
+    }
+    async delete(url, config) {
+        const response = await this.axios.delete(url, config);
+        return response.data;
+    }
+    // Update headers (useful for auth tokens)
+    setHeader(key, value) {
+        this.axios.defaults.headers.common[key] = value;
+    }
+    removeHeader(key) {
+        delete this.axios.defaults.headers.common[key];
+    }
+    // Token management methods (matching old ApiService pattern)
+    updateToken(token) {
+        this.currentToken = token;
+        if (token) {
+            this.setHeader('x-cms-token', token);
+            console.log('[SDK] Token updated in ApiClient:', token.substring(0, 8) + '...');
+        }
+        else {
+            this.removeHeader('x-cms-token');
+            console.log('[SDK] Token removed from ApiClient');
+        }
+    }
+    getCurrentToken() {
+        return this.currentToken;
+    }
+    // Update configuration (useful for environment changes)
+    updateConfig(config) {
+        if (config.baseURL) {
+            this.axios.defaults.baseURL = config.baseURL;
+        }
+        if (config.timeout) {
+            this.axios.defaults.timeout = config.timeout;
+        }
+        if (config.headers) {
+            Object.assign(this.axios.defaults.headers.common, config.headers);
+        }
+        console.log('[SDK] ApiClient configuration updated');
+    }
+}