@tagadapay/plugin-sdk 2.4.38 → 2.5.0

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');
+    }
+}

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

@@ -0,0 +1,189 @@
+/**
+ * Checkout Resource Client
+ * Axios-based API client for checkout endpoints
+ */
+import { ApiClient } from './apiClient';
+export interface CheckoutLineItem {
+    externalProductId?: string | null;
+    externalVariantId?: string | null;
+    variantId?: string | null;
+    priceId?: string | null;
+    quantity: number;
+}
+export interface CheckoutInitParams {
+    lineItems: CheckoutLineItem[];
+    cartToken?: string;
+    promotionIds?: string[];
+    returnUrl?: string;
+    draft?: boolean;
+    useCustomDomain?: boolean;
+    customerMetadata?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    storeId?: string;
+    customer?: {
+        currency?: string;
+        locale?: string;
+    };
+}
+export interface CheckoutSession {
+    id: string;
+    checkoutToken: string;
+    status: string;
+    storeId: string;
+    accountId: string;
+    customerId: string;
+    draft: boolean;
+    createdAt: string;
+    updatedAt: string;
+    lastActiveDate: string;
+    selectedPresentmentCurrency: string;
+    [key: string]: any;
+}
+export interface CheckoutData {
+    checkoutSession: CheckoutSession;
+    customerIsClubMember: boolean;
+    clubProductId?: string;
+    summary: any;
+    availablePromotions: any[];
+}
+export interface Promotion {
+    id: string;
+    name: string;
+    description: string | null;
+    type: string;
+    rules: any[];
+    actions: any[];
+}
+export declare class CheckoutResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Initialize a new checkout session
+     */
+    initCheckout(params: CheckoutInitParams): Promise<{
+        checkoutUrl: string;
+        checkoutSession: CheckoutSession;
+        checkoutToken: string;
+    }>;
+    /**
+     * Get checkout session by token
+     */
+    getCheckout(checkoutToken: string, currency?: string): Promise<CheckoutData>;
+    /**
+     * Update checkout address
+     */
+    updateAddress(checkoutSessionId: string, data: {
+        shippingAddress: any;
+        billingAddress?: any;
+    }): Promise<{
+        success: boolean;
+        errors?: Record<string, {
+            message: string;
+            type: string;
+        }>;
+        shippingCountryChanged: boolean;
+        billingCountryChanged: boolean;
+    }>;
+    /**
+     * Set checkout info
+     */
+    setCheckoutInfo(checkoutSessionId: string, data: {
+        shippingAddress: any;
+        billingAddress?: any;
+        differentBillingAddress?: boolean;
+    }): Promise<{
+        success: boolean;
+        errors?: Record<string, {
+            message: string;
+            type: string;
+        }>;
+        shippingCountryChanged?: boolean;
+        billingCountryChanged?: boolean;
+    }>;
+    /**
+     * Apply promotion code
+     */
+    applyPromotionCode(checkoutSessionId: string, code: string): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Remove promotion
+     */
+    removePromotion(checkoutSessionId: string, promotionId: string): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Get applied promotions
+     */
+    getAppliedPromotions(checkoutSessionId: string): Promise<Promotion[]>;
+    /**
+     * Update line items
+     */
+    updateLineItems(checkoutSessionId: string, lineItems: CheckoutLineItem[]): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Add line items
+     */
+    addLineItems(checkoutSessionId: string, lineItems: CheckoutLineItem[]): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Remove line items
+     */
+    removeLineItems(checkoutSessionId: string, lineItems: {
+        variantId: string;
+        quantity?: number;
+    }[]): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Set item quantity
+     */
+    setItemQuantity(checkoutSessionId: string, variantId: string, quantity: number, priceId?: string): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Toggle order bump
+     */
+    toggleOrderBump(checkoutSessionId: string, orderBumpOfferId: string, selected: boolean): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Update customer
+     */
+    updateCustomer(checkoutSessionId: string, data: {
+        email: string;
+        acceptsMarketing?: boolean;
+    }): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * Update customer and session info
+     */
+    updateCustomerAndSessionInfo(checkoutSessionId: string, data: {
+        customerData: {
+            email: string;
+            acceptsMarketing?: boolean;
+        };
+        shippingAddress: any;
+        billingAddress?: any;
+        differentBillingAddress?: boolean;
+    }): Promise<{
+        success: boolean;
+        errors?: Record<string, {
+            message: string;
+            type: string;
+        }>;
+        shippingCountryChanged?: boolean;
+        billingCountryChanged?: boolean;
+    }>;
+}

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

@@ -0,0 +1,119 @@
+/**
+ * Checkout Resource Client
+ * Axios-based API client for checkout endpoints
+ */
+export class CheckoutResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Initialize a new checkout session
+     */
+    async initCheckout(params) {
+        return this.apiClient.post('/api/v1/checkout/session/init', params);
+    }
+    /**
+     * Get checkout session by token
+     */
+    async getCheckout(checkoutToken, currency) {
+        const queryParams = new URLSearchParams();
+        if (currency) {
+            queryParams.set('currency', currency);
+        }
+        const url = `/api/v1/checkout-sessions/${checkoutToken}/v2${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+        return this.apiClient.get(url);
+    }
+    /**
+     * Update checkout address
+     */
+    async updateAddress(checkoutSessionId, data) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/address`, {
+            data,
+        });
+    }
+    /**
+     * Set checkout info
+     */
+    async setCheckoutInfo(checkoutSessionId, data) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/checkout-info`, {
+            shippingAddress: data.shippingAddress,
+            billingAddress: data.differentBillingAddress ? data.billingAddress : data.shippingAddress,
+            differentBillingAddress: data.differentBillingAddress || false,
+        });
+    }
+    /**
+     * Apply promotion code
+     */
+    async applyPromotionCode(checkoutSessionId, code) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/promotions/apply`, {
+            code,
+        });
+    }
+    /**
+     * Remove promotion
+     */
+    async removePromotion(checkoutSessionId, promotionId) {
+        return this.apiClient.delete(`/api/v1/checkout-sessions/${checkoutSessionId}/promotions/${promotionId}`);
+    }
+    /**
+     * Get applied promotions
+     */
+    async getAppliedPromotions(checkoutSessionId) {
+        return this.apiClient.get(`/api/v1/checkout-sessions/${checkoutSessionId}/promotions`);
+    }
+    /**
+     * Update line items
+     */
+    async updateLineItems(checkoutSessionId, lineItems) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/line-items`, {
+            lineItems,
+        });
+    }
+    /**
+     * Add line items
+     */
+    async addLineItems(checkoutSessionId, lineItems) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/line-items/add`, {
+            lineItems,
+        });
+    }
+    /**
+     * Remove line items
+     */
+    async removeLineItems(checkoutSessionId, lineItems) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/line-items/remove`, {
+            lineItems,
+        });
+    }
+    /**
+     * Set item quantity
+     */
+    async setItemQuantity(checkoutSessionId, variantId, quantity, priceId) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/line-items/set-quantity`, {
+            variantId,
+            quantity,
+            priceId,
+        });
+    }
+    /**
+     * Toggle order bump
+     */
+    async toggleOrderBump(checkoutSessionId, orderBumpOfferId, selected) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/toggle-order-bump`, {
+            orderBumpOfferId,
+            selected,
+        });
+    }
+    /**
+     * Update customer
+     */
+    async updateCustomer(checkoutSessionId, data) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/customer`, data);
+    }
+    /**
+     * Update customer and session info
+     */
+    async updateCustomerAndSessionInfo(checkoutSessionId, data) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/customer-and-session-info`, data);
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Resource Clients
+ * Axios-based API clients for all endpoints
+ */
+export * from './apiClient';
+export * from './products';
+export * from './orders';
+export * from './payments';
+export * from './checkout';
+export * from './promotions';
+export * from './postPurchases';
+export * from './offers';
+export * from './threeds';

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

@@ -0,0 +1,13 @@
+/**
+ * Resource Clients
+ * Axios-based API clients for all endpoints
+ */
+export * from './apiClient';
+export * from './products';
+export * from './orders';
+export * from './payments';
+export * from './checkout';
+export * from './promotions';
+export * from './postPurchases';
+export * from './offers';
+export * from './threeds';

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

@@ -0,0 +1,98 @@
+/**
+ * Offers Resource Client
+ * Axios-based API client for offers endpoints
+ */
+import { ApiClient } from './apiClient';
+export interface OfferItem {
+    id: string;
+    product: {
+        name: string;
+        description: string;
+    };
+    variant: {
+        name: string;
+        imageUrl: string;
+    };
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    adjustedAmount: number;
+    currency: string;
+}
+export interface OfferSummary {
+    items: OfferItem[];
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    totalPromotionAmount: number;
+    currency: string;
+    adjustments: {
+        type: string;
+        description: string;
+        amount: number;
+    }[];
+}
+import type { CurrencyOptions, VariantOption, OrderSummaryItem, OrderSummary, CheckoutSessionState } from './postPurchases';
+export type { CurrencyOptions, VariantOption, OrderSummaryItem, OrderSummary, CheckoutSessionState };
+export interface Offer {
+    id: string;
+    titleTrans: Record<string, string>;
+    summaries: OfferSummary[];
+}
+export declare class OffersResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get offers for a store
+     */
+    getOffers(storeId: string): Promise<Offer[]>;
+    /**
+     * Get offers by IDs
+     */
+    getOffersByIds(storeId: string, offerIds: string[]): Promise<Offer[]>;
+    /**
+     * Initialize checkout session for an offer
+     */
+    initCheckoutSession(offerId: string, orderId: string, customerId?: string): Promise<{
+        checkoutSessionId: string;
+    }>;
+    /**
+     * Create checkout session for an offer
+     */
+    createCheckoutSession(offerId: string, returnUrl?: string): Promise<{
+        checkoutUrl: string;
+    }>;
+    /**
+     * Pay with checkout session
+     */
+    payWithCheckoutSession(checkoutSessionId: string, orderId?: string): Promise<void>;
+    /**
+     * Pay for an offer directly
+     */
+    payOffer(offerId: string, orderId?: string): Promise<any>;
+    /**
+     * Transform offer to checkout session with dynamic variant selection
+     */
+    transformToCheckout(offerId: string, returnUrl?: string): Promise<{
+        checkoutUrl: string;
+    }>;
+    /**
+     * Initialize checkout session for an offer with variants (similar to postPurchases)
+     */
+    initCheckoutSessionWithVariants(offerId: string, lineItems: {
+        variantId: string;
+        quantity: number;
+    }[], returnUrl?: string): Promise<{
+        checkoutSessionId: string;
+    }>;
+    /**
+     * Get order summary for a checkout session
+     */
+    getOrderSummary(sessionId: string, includeVariantOptions?: boolean): Promise<any>;
+    /**
+     * Update line items for a checkout session
+     */
+    updateLineItems(sessionId: string, lineItems: {
+        variantId: string;
+        quantity: number;
+    }[]): Promise<any>;
+}