@tagadapay/plugin-sdk 2.4.39 → 2.5.0

package/dist/v2/core/utils/order.js

@@ -0,0 +1,42 @@
+/**
+ * Order Utility Functions
+ * Pure functions for order data manipulation
+ */
+export class OrderUtils {
+    /**
+     * Get order line items
+     */
+    static getOrderLineItems(order) {
+        return order.items || [];
+    }
+    /**
+     * Get order total
+     */
+    static getOrderTotal(order) {
+        return order.paidAmount || 0;
+    }
+    /**
+     * Get order status
+     */
+    static getOrderStatus(order) {
+        return order.status || 'unknown';
+    }
+    /**
+     * Check if order is completed
+     */
+    static isOrderCompleted(order) {
+        return order.status === 'completed' || order.status === 'fulfilled';
+    }
+    /**
+     * Check if order is pending
+     */
+    static isOrderPending(order) {
+        return order.status === 'pending' || order.status === 'processing';
+    }
+    /**
+     * Check if order is cancelled
+     */
+    static isOrderCancelled(order) {
+        return order.status === 'cancelled' || order.status === 'refunded';
+    }
+}

package/dist/v2/core/utils/orderBump.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Order Bump Utility Functions
+ * Pure functions for order bump data manipulation
+ */
+export interface OrderBumpOffer {
+    id: string;
+    name: string;
+    description: string;
+    price: number;
+    currency: string;
+    imageUrl?: string;
+    isSelected?: boolean;
+}
+export interface OrderBumpPreview {
+    offer: OrderBumpOffer;
+    totalAmount: number;
+    adjustedAmount: number;
+}
+export declare class OrderBumpUtils {
+    /**
+     * Check if order bump offer is valid
+     */
+    static isValidOffer(offer: OrderBumpOffer): boolean;
+    /**
+     * Toggle order bump selection
+     */
+    static toggleSelection(offer: OrderBumpOffer): OrderBumpOffer;
+    /**
+     * Calculate order bump preview
+     */
+    static calculatePreview(offer: OrderBumpOffer, baseAmount?: number): OrderBumpPreview;
+    /**
+     * Get selected order bumps
+     */
+    static getSelectedOffers(offers: OrderBumpOffer[]): OrderBumpOffer[];
+    /**
+     * Get total for selected order bumps
+     */
+    static getSelectedTotal(offers: OrderBumpOffer[]): number;
+}

package/dist/v2/core/utils/orderBump.js

@@ -0,0 +1,47 @@
+/**
+ * Order Bump Utility Functions
+ * Pure functions for order bump data manipulation
+ */
+export class OrderBumpUtils {
+    /**
+     * Check if order bump offer is valid
+     */
+    static isValidOffer(offer) {
+        return !!(offer.id && offer.name && offer.price > 0);
+    }
+    /**
+     * Toggle order bump selection
+     */
+    static toggleSelection(offer) {
+        return {
+            ...offer,
+            isSelected: !offer.isSelected,
+        };
+    }
+    /**
+     * Calculate order bump preview
+     */
+    static calculatePreview(offer, baseAmount = 0) {
+        const totalAmount = baseAmount + offer.price;
+        const adjustedAmount = offer.isSelected ? totalAmount : baseAmount;
+        return {
+            offer,
+            totalAmount,
+            adjustedAmount,
+        };
+    }
+    /**
+     * Get selected order bumps
+     */
+    static getSelectedOffers(offers) {
+        return offers.filter(offer => offer.isSelected);
+    }
+    /**
+     * Get total for selected order bumps
+     */
+    static getSelectedTotal(offers) {
+        return offers
+            .filter(offer => offer.isSelected)
+            .reduce((total, offer) => total + offer.price, 0);
+    }
+}

package/dist/v2/core/utils/pluginConfig.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Plugin Configuration Utility Functions
+ * Pure functions for plugin configuration management
+ */
+export interface PluginConfig<TConfig = Record<string, any>> {
+    storeId?: string;
+    accountId?: string;
+    basePath?: string;
+    config?: TConfig;
+    productId?: string;
+    variants?: Record<string, string>;
+    prices?: Record<string, any>;
+    defaultCurrency?: string;
+    hidePriceId?: string;
+    upsellId?: string;
+    googleApiKey?: string;
+    branding?: any;
+}
+export interface RawPluginConfig<TConfig = Record<string, any>> {
+    storeId?: string;
+    accountId?: string;
+    basePath?: string;
+    config?: TConfig;
+}
+/**
+ * Core plugin config loading function
+ * Handles local dev, production, and raw config
+ */
+export declare const loadPluginConfig: (configVariant?: string, rawConfig?: RawPluginConfig) => Promise<PluginConfig>;
+export declare class PluginConfigUtils {
+    /**
+     * Get plugin configuration from various sources
+     */
+    static getPluginConfig<TConfig = Record<string, any>>(rawConfig?: RawPluginConfig<TConfig>, context?: {
+        storeId?: string;
+        accountId?: string;
+        basePath?: string;
+    }): PluginConfig<TConfig>;
+    /**
+     * Validate plugin configuration
+     */
+    static validateConfig(config: PluginConfig): boolean;
+}

package/dist/v2/core/utils/pluginConfig.js

@@ -0,0 +1,155 @@
+/**
+ * Plugin Configuration Utility Functions
+ * Pure functions for plugin configuration management
+ */
+/**
+ * Load local development configuration
+ */
+const loadLocalDevConfig = async (configVariant = 'default') => {
+    try {
+        // Only try to load local config in development
+        // Use hostname-based detection for better Vite compatibility
+        const isLocalDev = typeof window !== 'undefined' &&
+            (window.location.hostname === 'localhost' ||
+                window.location.hostname.includes('ngrok-free.app') ||
+                window.location.hostname.includes('.localhost') ||
+                window.location.hostname.includes('127.0.0.1'));
+        if (!isLocalDev) {
+            return null;
+        }
+        // Load local store/account config
+        const localResponse = await fetch('/.local.json');
+        if (!localResponse.ok) {
+            return null;
+        }
+        const localConfig = await localResponse.json();
+        // Load deployment config (specified variant or fallback to default)
+        let config = {};
+        let configLoaded = false;
+        try {
+            // Try .tgd.json first (new format), then fallback to .json
+            let deploymentResponse = await fetch(`/config/${configVariant}.tgd.json`);
+            if (!deploymentResponse.ok) {
+                deploymentResponse = await fetch(`/config/${configVariant}.json`);
+            }
+            if (deploymentResponse.ok) {
+                config = await deploymentResponse.json();
+                configLoaded = true;
+            }
+        }
+        catch {
+            // Config fetch failed, will try fallback
+        }
+        // If config didn't load and it's not 'default', try fallback to default
+        if (!configLoaded && configVariant !== 'default') {
+            console.warn(`⚠️ Config variant '${configVariant}' not found, falling back to 'default'`);
+            try {
+                let defaultResponse = await fetch('/config/default.tgd.json');
+                if (!defaultResponse.ok) {
+                    defaultResponse = await fetch('/config/default.json');
+                }
+                if (defaultResponse.ok) {
+                    config = await defaultResponse.json();
+                    configLoaded = true;
+                    console.log(`✅ Fallback to 'default' config successful`);
+                }
+            }
+            catch {
+                // Default config also failed
+            }
+        }
+        // Final warning if no config was loaded
+        if (!configLoaded) {
+            if (configVariant === 'default') {
+                console.warn(`⚠️ No 'default' config found. Create /config/default.tgd.json`);
+            }
+            else {
+                console.warn(`⚠️ Neither '${configVariant}' nor 'default' config found. Create /config/default.tgd.json`);
+            }
+        }
+        const result = {
+            storeId: localConfig.storeId,
+            accountId: localConfig.accountId,
+            basePath: localConfig.basePath,
+            config,
+        };
+        console.log('🛠️ Using local development plugin config:', result);
+        return result;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Load production config from headers and meta tags
+ */
+const loadProductionConfig = async () => {
+    try {
+        // Get headers
+        const response = await fetch(window.location.href, { method: 'HEAD' });
+        const storeId = response.headers.get('X-Plugin-Store-Id') || undefined;
+        const accountId = response.headers.get('X-Plugin-Account-Id') || undefined;
+        const basePath = response.headers.get('X-Plugin-Base-Path') || '/';
+        // Get deployment config from meta tags
+        let config = {};
+        try {
+            const configMeta = document.querySelector('meta[name="x-plugin-config"]');
+            const encodedConfig = configMeta?.getAttribute('content');
+            if (encodedConfig) {
+                const decodedConfig = decodeURIComponent(encodedConfig);
+                config = JSON.parse(decodedConfig);
+            }
+        }
+        catch {
+            // Deployment config is optional
+        }
+        console.log('🏭 Using production plugin config 2:', { storeId, accountId, basePath, config });
+        return { storeId, accountId, basePath, config };
+    }
+    catch {
+        return { basePath: '/', config: {} };
+    }
+};
+/**
+ * Core plugin config loading function
+ * Handles local dev, production, and raw config
+ */
+export const loadPluginConfig = async (configVariant = 'default', rawConfig) => {
+    // If raw config is provided, use it directly
+    if (rawConfig) {
+        console.log('🛠️ Using raw plugin config:', rawConfig);
+        return {
+            storeId: rawConfig.storeId,
+            accountId: rawConfig.accountId,
+            basePath: rawConfig.basePath ?? '/',
+            config: rawConfig.config ?? {},
+        };
+    }
+    // Try local development config
+    const localConfig = await loadLocalDevConfig(configVariant);
+    if (localConfig) {
+        return localConfig;
+    }
+    // Fall back to production config
+    return loadProductionConfig();
+};
+export class PluginConfigUtils {
+    /**
+     * Get plugin configuration from various sources
+     */
+    static getPluginConfig(rawConfig, context) {
+        // Priority: rawConfig > context > defaults
+        return {
+            storeId: rawConfig?.storeId || context?.storeId,
+            accountId: rawConfig?.accountId || context?.accountId,
+            basePath: rawConfig?.basePath || context?.basePath || '/',
+            config: rawConfig?.config || {},
+        };
+    }
+    /**
+     * Validate plugin configuration
+     */
+    static validateConfig(config) {
+        return !!(config.storeId && config.accountId);
+    }
+}

package/dist/v2/core/utils/postPurchases.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Post Purchases Utility Functions
+ * Pure functions for post-purchase offer data manipulation
+ */
+import type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary } from '../resources/postPurchases';
+export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary, };
+export declare class PostPurchasesUtils {
+    /**
+     * Check if post-purchase offer is valid
+     */
+    static isValidOffer(offer: PostPurchaseOffer): boolean;
+    /**
+     * Get offer total amount
+     */
+    static getOfferTotal(offer: PostPurchaseOffer): number;
+    /**
+     * Get offer adjusted total
+     */
+    static getOfferAdjustedTotal(offer: PostPurchaseOffer): number;
+    /**
+     * Check if offer has items
+     */
+    static hasItems(offer: PostPurchaseOffer): boolean;
+    /**
+     * Get offer currency
+     */
+    static getOfferCurrency(offer: PostPurchaseOffer): string;
+    /**
+     * Get offer title
+     */
+    static getOfferTitle(offer: PostPurchaseOffer, locale?: string): string;
+}

package/dist/v2/core/utils/postPurchases.js

@@ -0,0 +1,42 @@
+/**
+ * Post Purchases Utility Functions
+ * Pure functions for post-purchase offer data manipulation
+ */
+export class PostPurchasesUtils {
+    /**
+     * Check if post-purchase offer is valid
+     */
+    static isValidOffer(offer) {
+        return !!(offer.id && offer.summaries && offer.summaries.length > 0);
+    }
+    /**
+     * Get offer total amount
+     */
+    static getOfferTotal(offer) {
+        return offer.summaries?.[0]?.totalAmount || 0;
+    }
+    /**
+     * Get offer adjusted total
+     */
+    static getOfferAdjustedTotal(offer) {
+        return offer.summaries?.[0]?.totalAdjustedAmount || 0;
+    }
+    /**
+     * Check if offer has items
+     */
+    static hasItems(offer) {
+        return !!(offer.offerLineItems && offer.offerLineItems.length > 0);
+    }
+    /**
+     * Get offer currency
+     */
+    static getOfferCurrency(offer) {
+        return offer.summaries?.[0]?.currency || 'USD';
+    }
+    /**
+     * Get offer title
+     */
+    static getOfferTitle(offer, locale = 'en') {
+        return offer.titleTrans?.[locale] || offer.titleTrans?.en || `Offer ${offer.id}`;
+    }
+}

package/dist/v2/core/utils/products.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Products Utility Functions
+ * Pure functions for product data manipulation
+ */
+export interface ProductPrice {
+    id: string;
+    amount: number;
+    currency: string;
+    recurring: boolean;
+    interval?: string;
+    intervalCount?: number;
+    default?: boolean;
+    currencyOptions: Record<string, {
+        amount: number;
+        currency: string;
+    }>;
+}
+export interface ProductVariant {
+    id: string;
+    name: string;
+    description: string;
+    sku?: string;
+    weight?: number;
+    imageUrl?: string;
+    default?: boolean;
+    prices: ProductPrice[];
+}
+export interface Product {
+    id: string;
+    name: string;
+    description: string;
+    imageUrl?: string;
+    variants: ProductVariant[];
+}
+export declare class ProductsUtils {
+    /**
+     * Find a variant by ID within products
+     */
+    static findVariant(products: Product[], variantId: string): ProductVariant | null;
+    /**
+     * Get price for a variant in a specific currency
+     */
+    static getVariantPrice(variant: ProductVariant, currency?: string): ProductPrice | null;
+    /**
+     * Get all variants from products
+     */
+    static getAllVariants(products: Product[]): {
+        product: Product;
+        variant: ProductVariant;
+    }[];
+    /**
+     * Filter variants by predicate
+     */
+    static filterVariants(products: Product[], predicate: (variant: ProductVariant, product: Product) => boolean): {
+        product: Product;
+        variant: ProductVariant;
+    }[];
+}

package/dist/v2/core/utils/products.js

@@ -0,0 +1,64 @@
+/**
+ * Products Utility Functions
+ * Pure functions for product data manipulation
+ */
+export class ProductsUtils {
+    /**
+     * Find a variant by ID within products
+     */
+    static findVariant(products, variantId) {
+        for (const product of products) {
+            const variant = product.variants.find(v => v.id === variantId);
+            if (variant) {
+                return variant;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get price for a variant in a specific currency
+     */
+    static getVariantPrice(variant, currency = 'USD') {
+        const price = variant.prices.find(p => p.currency === currency);
+        if (price) {
+            return price;
+        }
+        // Fallback to default price
+        const defaultPrice = variant.prices.find(p => p.default);
+        if (defaultPrice) {
+            return defaultPrice;
+        }
+        // Return first available price
+        return variant.prices[0] || null;
+    }
+    /**
+     * Get all variants from products
+     */
+    static getAllVariants(products) {
+        const allVariants = [];
+        for (const product of products) {
+            if (product.variants) {
+                for (const variant of product.variants) {
+                    allVariants.push({ product, variant });
+                }
+            }
+        }
+        return allVariants;
+    }
+    /**
+     * Filter variants by predicate
+     */
+    static filterVariants(products, predicate) {
+        const filtered = [];
+        for (const product of products) {
+            if (product.variants) {
+                for (const variant of product.variants) {
+                    if (predicate(variant, product)) {
+                        filtered.push({ product, variant });
+                    }
+                }
+            }
+        }
+        return filtered;
+    }
+}

package/dist/v2/core/utils/promotions.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Promotions Utility Functions
+ * Pure functions for promotion data manipulation
+ */
+import type { Promotion } from '../resources/checkout';
+export type { Promotion };
+export declare class PromotionsUtils {
+    /**
+     * Check if promotion is valid
+     */
+    static isValidPromotion(promotion: Promotion): boolean;
+    /**
+     * Get promotion type
+     */
+    static getPromotionType(promotion: Promotion): string;
+    /**
+     * Check if promotion has rules
+     */
+    static hasRules(promotion: Promotion): boolean;
+    /**
+     * Check if promotion has actions
+     */
+    static hasActions(promotion: Promotion): boolean;
+}

package/dist/v2/core/utils/promotions.js

@@ -0,0 +1,30 @@
+/**
+ * Promotions Utility Functions
+ * Pure functions for promotion data manipulation
+ */
+export class PromotionsUtils {
+    /**
+     * Check if promotion is valid
+     */
+    static isValidPromotion(promotion) {
+        return !!(promotion.id && promotion.name);
+    }
+    /**
+     * Get promotion type
+     */
+    static getPromotionType(promotion) {
+        return promotion.type || 'unknown';
+    }
+    /**
+     * Check if promotion has rules
+     */
+    static hasRules(promotion) {
+        return !!(promotion.rules && promotion.rules.length > 0);
+    }
+    /**
+     * Check if promotion has actions
+     */
+    static hasActions(promotion) {
+        return !!(promotion.actions && promotion.actions.length > 0);
+    }
+}

package/dist/v2/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TagadaPay Plugin SDK v2
+ *
+ * Clean architecture with separated core and react layers:
+ * - core: Pure functions without React dependencies
+ * - react: React hooks and components using core functions
+ */
+export * from './core/utils/pluginConfig';
+export * from './core/utils/products';
+export * from './core/googleAutocomplete';
+export * from './core/isoData';
+export * from './core/utils/currency';
+export type { CheckoutData, CheckoutSession, CheckoutLineItem, CheckoutInitParams, Promotion, } from './core/resources/checkout';
+export type { Order, OrderLineItem, } from './core/utils/order';
+export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary, } from './core/resources/postPurchases';
+export type { Offer, OfferItem, OfferSummary, } from './core/resources/offers';
+export type { OrderBumpOffer, OrderBumpPreview, } from './core/utils/orderBump';
+export type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse, PaymentInstrumentCustomer } from './core/resources/payments';
+export { TagadaProvider, useTagadaContext, useCheckoutToken, usePluginConfig, useGoogleAutocomplete, useGeoLocation, useISOData, getAvailableLanguages, useLanguageImport, useCountryOptions, useRegionOptions, useCheckout, useOrderBump, usePromotions, useProducts, useOrder, usePostPurchases, useOffers, usePayment, useThreeds, useThreedsModal, useCurrency, useApiQuery, useApiMutation, useInvalidateQuery, usePreloadQuery, queryKeys, formatMoney } from './react';

package/dist/v2/index.js

@@ -0,0 +1,15 @@
+/**
+ * TagadaPay Plugin SDK v2
+ *
+ * Clean architecture with separated core and react layers:
+ * - core: Pure functions without React dependencies
+ * - react: React hooks and components using core functions
+ */
+// Core exports (selective to avoid conflicts)
+export * from './core/utils/pluginConfig';
+export * from './core/utils/products';
+export * from './core/googleAutocomplete';
+export * from './core/isoData';
+export * from './core/utils/currency';
+// React exports (hooks and components only, types are exported above)
+export { TagadaProvider, useTagadaContext, useCheckoutToken, usePluginConfig, useGoogleAutocomplete, useGeoLocation, useISOData, getAvailableLanguages, useLanguageImport, useCountryOptions, useRegionOptions, useCheckout, useOrderBump, usePromotions, useProducts, useOrder, usePostPurchases, useOffers, usePayment, useThreeds, useThreedsModal, useCurrency, useApiQuery, useApiMutation, useInvalidateQuery, usePreloadQuery, queryKeys, formatMoney } from './react';

package/dist/v2/react/components/DebugDrawer.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface DebugDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+export declare const DebugDrawer: React.FC<DebugDrawerProps>;
+export default DebugDrawer;