@tagadapay/plugin-sdk 1.0.2

package/dist/react/config/environment.js

@@ -0,0 +1,132 @@
+'use client';
+/**
+ * Environment configurations for different deployment environments
+ */
+export const ENVIRONMENT_CONFIGS = {
+    production: {
+        baseUrl: 'https://app.tagadapay.com',
+        endpoints: {
+            checkout: {
+                sessionInit: '/api/v1/checkout/session/init',
+                sessionStatus: '/api/v1/checkout/session/status',
+            },
+            customer: {
+                profile: '/api/v1/customer/profile',
+                session: '/api/v1/customer/session',
+            },
+            store: {
+                config: '/api/v1/store/config',
+            },
+        },
+    },
+    development: {
+        baseUrl: 'https://app.tagadapay.dev',
+        endpoints: {
+            checkout: {
+                sessionInit: '/api/v1/checkout/session/init',
+                sessionStatus: '/api/v1/checkout/session/status',
+            },
+            customer: {
+                profile: '/api/v1/customer/profile',
+                session: '/api/v1/customer/session',
+            },
+            store: {
+                config: '/api/v1/store/config',
+            },
+        },
+    },
+    local: {
+        baseUrl: 'http://app.localhost:3000',
+        endpoints: {
+            checkout: {
+                sessionInit: '/api/v1/checkout/session/init',
+                sessionStatus: '/api/v1/checkout/session/status',
+            },
+            customer: {
+                profile: '/api/v1/customer/profile',
+                session: '/api/v1/customer/session',
+            },
+            store: {
+                config: '/api/v1/store/config',
+            },
+        },
+    },
+};
+/**
+ * Get the environment configuration based on the current environment
+ */
+export function getEnvironmentConfig(environment = 'local') {
+    const apiConfig = ENVIRONMENT_CONFIGS[environment];
+    if (!apiConfig) {
+        console.warn(`Unknown environment: ${environment}. Falling back to local.`);
+        return {
+            environment: 'local',
+            apiConfig: ENVIRONMENT_CONFIGS.local,
+        };
+    }
+    return {
+        environment,
+        apiConfig,
+    };
+}
+/**
+ * Build a complete API URL from environment config and endpoint path
+ */
+export function buildApiUrl(config, endpointPath) {
+    return `${config.apiConfig.baseUrl}${endpointPath}`;
+}
+/**
+ * Get a specific endpoint URL
+ */
+export function getEndpointUrl(config, category, endpoint) {
+    const categoryEndpoints = config.apiConfig.endpoints[category];
+    const endpointPath = categoryEndpoints[endpoint];
+    if (!endpointPath) {
+        throw new Error(`Endpoint not found: ${category}.${endpoint}`);
+    }
+    return buildApiUrl(config, endpointPath);
+}
+/**
+ * Auto-detect environment based on hostname, URL patterns, and deployment context
+ * Works with any build tool or deployment system
+ */
+export function detectEnvironment() {
+    // Check if we're in browser
+    if (typeof window === 'undefined') {
+        return 'local'; // SSR fallback
+    }
+    const hostname = window.location.hostname;
+    const href = window.location.href;
+    // Production: deployed to production domains
+    if (hostname === 'app.tagadapay.com' ||
+        hostname.includes('tagadapay.com') ||
+        hostname.includes('yourproductiondomain.com')) {
+        return 'production';
+    }
+    // Development: deployed to staging/dev domains or has dev indicators
+    if (hostname === 'app.tagadapay.dev' ||
+        hostname.includes('tagadapay.dev') || // ✅ app.tagadapay.dev and subdomains
+        hostname.includes('vercel.app') ||
+        hostname.includes('netlify.app') ||
+        hostname.includes('surge.sh') ||
+        hostname.includes('github.io') ||
+        hostname.includes('herokuapp.com') ||
+        hostname.includes('railway.app') ||
+        href.includes('?env=dev') ||
+        href.includes('?dev=true') ||
+        href.includes('#dev')) {
+        return 'development';
+    }
+    // Local: localhost, local IPs, or local domains
+    if (hostname === 'localhost' ||
+        hostname.startsWith('127.') ||
+        hostname.startsWith('192.168.') ||
+        hostname.startsWith('10.') ||
+        hostname.includes('.local') ||
+        hostname === '' ||
+        hostname === '0.0.0.0') {
+        return 'local';
+    }
+    // Default fallback for unknown domains (safer to use development)
+    return 'development';
+}

package/dist/react/config/payment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Payment processor configuration for TagadaPay SDK
+ * These are public API keys - safe to embed in client-side code
+ */
+export interface PaymentConfig {
+    basisTheory: {
+        publicApiKey: string;
+        environment: 'sandbox' | 'production';
+    };
+}
+/**
+ * Payment configurations for different environments
+ */
+export declare const PAYMENT_CONFIGS: Record<string, PaymentConfig>;
+/**
+ * Get payment configuration based on environment
+ */
+export declare function getPaymentConfig(environment?: string): PaymentConfig;
+/**
+ * Get BasisTheory API key for current environment
+ * Falls back to environment variable if available
+ */
+export declare function getBasisTheoryApiKey(environment?: string): string;

package/dist/react/config/payment.js

@@ -0,0 +1,52 @@
+/**
+ * Payment processor configuration for TagadaPay SDK
+ * These are public API keys - safe to embed in client-side code
+ */
+/**
+ * Payment configurations for different environments
+ */
+export const PAYMENT_CONFIGS = {
+    production: {
+        basisTheory: {
+            // TODO: Replace with actual production BasisTheory public API key
+            publicApiKey: 'key_prod_us_pub_PNMB2AiaECJ463K6QAPNU6',
+            environment: 'production',
+        },
+    },
+    development: {
+        basisTheory: {
+            // TODO: Replace with actual development BasisTheory public API key
+            publicApiKey: 'key_test_us_pub_VExdfbFQARn821iqP8zNaq',
+            environment: 'sandbox',
+        },
+    },
+    local: {
+        basisTheory: {
+            // Development/testing API key (sandbox)
+            publicApiKey: 'key_test_us_pub_VExdfbFQARn821iqP8zNaq',
+            environment: 'sandbox',
+        },
+    },
+};
+/**
+ * Get payment configuration based on environment
+ */
+export function getPaymentConfig(environment = 'local') {
+    return PAYMENT_CONFIGS[environment] || PAYMENT_CONFIGS.local;
+}
+/**
+ * Get BasisTheory API key for current environment
+ * Falls back to environment variable if available
+ */
+export function getBasisTheoryApiKey(environment = 'local') {
+    // Check environment variable first (allows override)
+    if (typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_BASIS_THEORY_PUBLIC_API_KEY) {
+        return process.env.NEXT_PUBLIC_BASIS_THEORY_PUBLIC_API_KEY;
+    }
+    if (typeof process !== 'undefined' && process.env?.VITE_BASIS_THEORY_PUBLIC_API_KEY) {
+        return process.env.VITE_BASIS_THEORY_PUBLIC_API_KEY;
+    }
+    // Fall back to embedded configuration
+    const config = getPaymentConfig(environment);
+    return config.basisTheory.publicApiKey;
+}

package/dist/react/hooks/useAuth.d.ts

@@ -0,0 +1,4 @@
+import { AuthState } from '../types';
+export declare function useAuth(): AuthState & {
+    isInitialized: boolean;
+};

package/dist/react/hooks/useAuth.js

@@ -0,0 +1,12 @@
+'use client';
+/**
+ * useAuth - Hook to access authentication state
+ */
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useAuth() {
+    const { auth, isInitialized } = useTagadaContext();
+    return {
+        ...auth,
+        isInitialized,
+    };
+}

package/dist/react/hooks/useCheckout.d.ts

@@ -0,0 +1,262 @@
+export interface CheckoutLineItem {
+    externalProductId?: string | null;
+    externalVariantId?: string | null;
+    variantId?: 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;
+    shippingAddress?: any;
+    billingAddress?: any;
+    customer?: {
+        id: string;
+        email?: string;
+        firstName?: string;
+        lastName?: string;
+        phone?: string;
+        locale?: string;
+    };
+    sessionLineItems: {
+        id: string;
+        quantity: number;
+        priceId: string;
+        variantId: string;
+        productId: string;
+        isOrderBump: boolean;
+        orderBumpType?: string;
+        price: {
+            id: string;
+            amount: number;
+            currency: string;
+            currencyOptions: any;
+            variant: {
+                id: string;
+                name: string;
+                description: string | null;
+                sku: string | null;
+                imageUrl: string | null;
+                product: {
+                    id: string;
+                    name: string;
+                    description: string | null;
+                    imageUrl: string | null;
+                };
+            };
+        };
+    }[];
+    store: {
+        id: string;
+        name: string;
+        domain: string;
+        currency: string;
+        locale: string;
+        presentmentCurrencies: string[];
+        chargeCurrencies: string[];
+        upsells: {
+            id: string;
+            type: string;
+            enabled: boolean;
+            orderBumpOffers: {
+                id: string;
+                type: string;
+                precheck: boolean;
+                variantId: string;
+                productId: string;
+                priceId: string;
+                variant: {
+                    id: string;
+                    name: string;
+                    description: string | null;
+                    imageUrl: string | null;
+                };
+                product: {
+                    id: string;
+                    name: string;
+                    description: string | null;
+                    imageUrl: string | null;
+                };
+                price: {
+                    id: string;
+                    amount: number;
+                    currency: string;
+                };
+            }[];
+        }[];
+        integrations: {
+            id: string;
+            type: string;
+            enabled: boolean;
+            config: any;
+        }[];
+    };
+    shippingRate?: {
+        id: string;
+        shippingRateName: string;
+        amount: number;
+        isFree: boolean;
+    };
+    orders: {
+        id: string;
+        status: string;
+    }[];
+    orderSummaries: {
+        id: string;
+        currency: string;
+        totalAmount: number;
+        totalAdjustedAmount: number;
+        totalPromotionAmount: number;
+        items: any;
+        adjustments: any;
+    }[];
+}
+export interface CheckoutSummary {
+    currency: string;
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    totalPromotionAmount: number;
+    items: {
+        id: string;
+        name: string;
+        description: string | null;
+        imageUrl: string | null;
+        quantity: number;
+        unitAmount: number;
+        amount: number;
+        adjustedAmount: number;
+        currency: string;
+        isOrderBump: boolean;
+        orderBumpType?: string;
+    }[];
+    adjustments: {
+        type: string;
+        description: string;
+        amount: number;
+    }[];
+}
+export interface Promotion {
+    id: string;
+    name: string;
+    description: string | null;
+    type: string;
+    rules: any[];
+    actions: any[];
+}
+export interface CheckoutData {
+    checkoutSession: CheckoutSession;
+    customerIsClubMember: boolean;
+    clubProductId?: string;
+    summary: CheckoutSummary;
+    availablePromotions: Promotion[];
+}
+export interface UseCheckoutOptions {
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+    realTimeUpdates?: boolean;
+    autoInitFromUrl?: boolean;
+    checkoutToken?: string;
+    fallbackToken?: string;
+    autoLoadFromToken?: boolean;
+}
+export interface UseCheckoutResult {
+    checkout: CheckoutData | null;
+    isLoading: boolean;
+    error: Error | null;
+    isInitialized: boolean;
+    initialized: boolean;
+    init: (params: CheckoutInitParams) => Promise<{
+        checkoutUrl: string;
+        checkoutSession: CheckoutSession;
+        checkoutToken: string;
+    }>;
+    getCheckout: (checkoutToken: string) => Promise<CheckoutData>;
+    refresh: () => Promise<void>;
+    updateAddress: (data: {
+        shippingAddress: any;
+        billingAddress?: any;
+    }) => Promise<{
+        success: boolean;
+        shippingCountryChanged: boolean;
+        billingCountryChanged: boolean;
+    }>;
+    setCheckoutInfo: (data: {
+        shippingAddress: any;
+        billingAddress?: any;
+        differentBillingAddress?: boolean;
+    }) => Promise<{
+        success: boolean;
+        errors?: Record<string, {
+            message: string;
+            type: string;
+        }>;
+        shippingCountryChanged?: boolean;
+        billingCountryChanged?: boolean;
+    }>;
+    applyPromotionCode: (code: string) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    removePromotion: (promotionId: string) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    getAppliedPromotions: () => Promise<Promotion[]>;
+    updateLineItems: (lineItems: CheckoutLineItem[]) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    toggleOrderBump: (orderBumpOfferId: string, selected: boolean) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    updateCustomer: (data: {
+        email: string;
+        acceptsMarketing?: boolean;
+    }) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    updateCustomerAndSessionInfo: (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;
+    }>;
+    clear: () => void;
+}
+export declare function useCheckout(options?: UseCheckoutOptions): UseCheckoutResult;