@tagadapay/plugin-sdk 1.0.2

package/dist/react/hooks/useLocale.js

@@ -0,0 +1,43 @@
+'use client';
+/**
+ * useLocale - Hook to access locale data
+ * Only provides locale information, no translation functionality
+ */
+import { useEffect, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useLocale() {
+    const { locale: contextLocale } = useTagadaContext();
+    const [detectedLocale, setDetectedLocale] = useState('en-US');
+    const [detectedLanguageCode, setDetectedLanguageCode] = useState('en');
+    useEffect(() => {
+        // Client-side cookie access
+        const getCookie = (name) => {
+            const value = `; ${document.cookie}`;
+            const parts = value.split(`; ${name}=`);
+            if (parts.length === 2)
+                return parts.pop()?.split(';').shift();
+            return undefined;
+        };
+        // Get URL search parameters
+        const getUrlParam = (name) => {
+            const urlParams = new URLSearchParams(window.location.search);
+            return urlParams.get(name);
+        };
+        const localeFromCookies = getCookie('locale');
+        const localeFromQueryParams = getUrlParam('locale') || getUrlParam('lang');
+        const localeFromBrowser = navigator.language;
+        const finalLocale = localeFromCookies || localeFromQueryParams || localeFromBrowser || 'en-US';
+        // Extract language code from locale (e.g., "en-US" -> "en")
+        const finalLanguageCode = finalLocale?.split('-')[0] || navigator.language?.split('-')[0] || 'en';
+        setDetectedLocale(finalLocale);
+        setDetectedLanguageCode(finalLanguageCode);
+    }, []);
+    // Merge detected locale with context locale
+    const mergedLocale = {
+        ...contextLocale,
+        locale: detectedLocale,
+        language: detectedLanguageCode,
+        region: detectedLocale.split('-')[1] || 'US',
+    };
+    return mergedLocale;
+}

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

@@ -0,0 +1,99 @@
+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;
+    }[];
+}
+export interface Offer {
+    id: string;
+    titleTrans: Record<string, string>;
+    summaries: OfferSummary[];
+}
+export interface UseOffersOptions {
+    /**
+     * 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 UseOffersResult {
+    /**
+     * Array of fetched offers
+     */
+    offers: Offer[];
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Refetch offers
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Generate checkout session for a specific offer
+     */
+    createCheckoutSession: (offerId: string, options?: {
+        returnUrl?: string;
+    }) => Promise<{
+        checkoutUrl: string;
+    }>;
+    /**
+     * Pay for an offer directly
+     */
+    payOffer: (offerId: string) => Promise<void>;
+    /**
+     * Transform offer to checkout session with dynamic variant selection
+     */
+    transformToCheckout: (offerId: string, options?: {
+        returnUrl?: string;
+    }) => Promise<{
+        checkoutUrl: string;
+    }>;
+    /**
+     * Get offer by ID from the loaded offers
+     */
+    getOffer: (offerId: string) => Offer | undefined;
+    /**
+     * Get total value of all offers
+     */
+    getTotalValue: () => number;
+    /**
+     * Get total savings across all offers
+     */
+    getTotalSavings: () => number;
+}
+export declare function useOffers(options: UseOffersOptions): UseOffersResult;

package/dist/react/hooks/useOffers.js

@@ -0,0 +1,115 @@
+import { useState, useCallback, useEffect } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useOffers(options) {
+    const { apiService, environment } = useTagadaContext();
+    const [offers, setOffers] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const { offerIds, enabled = true, returnUrl } = options;
+    const fetchOffers = useCallback(async () => {
+        if (!offerIds.length || !enabled)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            const fetchPromises = offerIds.map(async (offerId) => {
+                const response = await fetch(`${environment.apiConfig.baseUrl}/api/v1/offers/${offerId}`, {
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Store-ID': apiService.getStoredStoreId() || '',
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch offer ${offerId}: ${response.statusText}`);
+                }
+                return response.json();
+            });
+            const fetchedOffers = await Promise.all(fetchPromises);
+            setOffers(fetchedOffers);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch offers');
+            setError(error);
+            console.error('Error fetching offers:', error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, environment.apiConfig.baseUrl, offerIds, enabled]);
+    const createCheckoutSession = useCallback(async (offerId, sessionOptions) => {
+        const response = await fetch(`${environment.apiConfig.baseUrl}/api/v1/offers/${offerId}/checkout`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Store-ID': apiService.getStoredStoreId() || '',
+            },
+            body: JSON.stringify({
+                returnUrl: sessionOptions?.returnUrl || returnUrl || window.location.origin,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to create checkout session: ${response.statusText}`);
+        }
+        return response.json();
+    }, [apiService, environment.apiConfig.baseUrl, returnUrl]);
+    const payOffer = useCallback(async (offerId) => {
+        const response = await fetch(`${environment.apiConfig.baseUrl}/api/v1/offers/${offerId}/pay`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Store-ID': apiService.getStoredStoreId() || '',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to pay offer: ${response.statusText}`);
+        }
+        return response.json();
+    }, [apiService, environment.apiConfig.baseUrl]);
+    const transformToCheckout = useCallback(async (offerId, sessionOptions) => {
+        const response = await fetch(`${environment.apiConfig.baseUrl}/api/v1/offers/${offerId}/transform-to-checkout`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Store-ID': apiService.getStoredStoreId() || '',
+            },
+            body: JSON.stringify({
+                returnUrl: sessionOptions?.returnUrl || returnUrl || window.location.origin,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to transform offer to checkout: ${response.statusText}`);
+        }
+        return response.json();
+    }, [apiService, environment.apiConfig.baseUrl, returnUrl]);
+    const getOffer = useCallback((offerId) => {
+        return offers.find((offer) => offer.id === offerId);
+    }, [offers]);
+    const getTotalValue = useCallback(() => {
+        return offers.reduce((total, offer) => {
+            const firstSummary = offer.summaries[0];
+            return total + (firstSummary?.totalAdjustedAmount || 0);
+        }, 0);
+    }, [offers]);
+    const getTotalSavings = useCallback(() => {
+        return offers.reduce((total, offer) => {
+            const firstSummary = offer.summaries[0];
+            return total + (firstSummary?.totalPromotionAmount || 0);
+        }, 0);
+    }, [offers]);
+    useEffect(() => {
+        void fetchOffers();
+    }, [fetchOffers]);
+    return {
+        offers,
+        isLoading,
+        error,
+        refetch: fetchOffers,
+        createCheckoutSession,
+        payOffer,
+        transformToCheckout,
+        getOffer,
+        getTotalValue,
+        getTotalSavings,
+    };
+}

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

@@ -0,0 +1,44 @@
+import { Order } from '../types';
+export interface UseOrderOptions {
+    /**
+     * Whether to automatically fetch order data when orderId is provided
+     * @default true
+     */
+    autoFetch?: boolean;
+    /**
+     * Order ID to fetch
+     */
+    orderId?: string;
+    /**
+     * Whether the hook is enabled/should run
+     * @default true
+     */
+    enabled?: boolean;
+}
+export interface UseOrderResult {
+    /**
+     * Order data
+     */
+    order: Order | null;
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Fetch order by ID
+     */
+    fetchOrder: (orderId: string) => Promise<Order>;
+    /**
+     * Refetch the current order
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Clear order data
+     */
+    clear: () => void;
+}
+export declare function useOrder(options?: UseOrderOptions): UseOrderResult;

package/dist/react/hooks/useOrder.js

@@ -0,0 +1,77 @@
+'use client';
+import React, { useState, useCallback, useRef } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useOrder(options = {}) {
+    const { autoFetch = true, orderId, enabled = true } = options;
+    const { apiService, session } = useTagadaContext();
+    const [order, setOrder] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const currentOrderIdRef = useRef(null);
+    const fetchOrder = useCallback(async (orderIdToFetch) => {
+        if (!orderIdToFetch) {
+            throw new Error('Order ID is required');
+        }
+        if (!session?.storeId) {
+            throw new Error('Store session is required');
+        }
+        if (!apiService) {
+            throw new Error('API service not available');
+        }
+        setIsLoading(true);
+        setError(null);
+        currentOrderIdRef.current = orderIdToFetch;
+        try {
+            console.log('🔍 Fetching order:', orderIdToFetch);
+            const response = await apiService.fetch(`/api/v1/orders/${encodeURIComponent(orderIdToFetch)}`, {
+                method: 'GET',
+                params: {
+                    storeId: session.storeId,
+                },
+            });
+            const fetchedOrder = response.order;
+            if (!fetchedOrder) {
+                throw new Error('Order not found');
+            }
+            console.log('✅ Order fetched successfully:', fetchedOrder.id);
+            setOrder(fetchedOrder);
+            return fetchedOrder;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch order');
+            console.error('❌ Failed to fetch order:', error);
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, session?.storeId]);
+    const refetch = useCallback(async () => {
+        if (!currentOrderIdRef.current) {
+            throw new Error('No order ID to refetch');
+        }
+        await fetchOrder(currentOrderIdRef.current);
+    }, [fetchOrder]);
+    const clear = useCallback(() => {
+        setOrder(null);
+        setError(null);
+        currentOrderIdRef.current = null;
+    }, []);
+    // Auto-fetch when orderId is provided and options allow it
+    React.useEffect(() => {
+        if (autoFetch && orderId && enabled && session?.storeId) {
+            fetchOrder(orderId).catch((err) => {
+                console.warn('Auto-fetch failed:', err);
+            });
+        }
+    }, [autoFetch, orderId, enabled, session?.storeId, fetchOrder]);
+    return {
+        order,
+        isLoading,
+        error,
+        fetchOrder,
+        refetch,
+        clear,
+    };
+}

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

@@ -0,0 +1,60 @@
+import { Payment } from './usePaymentPolling';
+import { ThreedsProvider } from './useThreeds';
+export interface ApplePayToken {
+    id: string;
+    type: string;
+    card: {
+        bin: string;
+        last4: string;
+        expiration_month: number;
+        expiration_year: number;
+        brand: string;
+    };
+}
+export interface CardPaymentMethod {
+    cardNumber: string;
+    expiryDate: string;
+    cvc: string;
+    cardholderName?: string;
+}
+export interface Order {
+    id: string;
+    status: string;
+    totalAmount: number;
+    currency: string;
+}
+export interface PaymentResponse {
+    paymentId: string;
+    payment: Payment;
+    order?: Order;
+}
+export interface PaymentOptions {
+    enableThreeds?: boolean;
+    threedsProvider?: ThreedsProvider;
+    onSuccess?: (payment: Payment) => void;
+    onFailure?: (error: string) => void;
+    onRequireAction?: (payment: Payment) => void;
+}
+export interface PaymentInstrumentResponse {
+    id: string;
+    token: string;
+    type: string;
+    card?: {
+        maskedCardNumber?: string;
+        expirationMonth?: number;
+        expirationYear?: number;
+        brand?: string;
+    };
+}
+export interface PaymentHook {
+    processCardPayment: (checkoutSessionId: string, cardData: CardPaymentMethod, options?: PaymentOptions) => Promise<PaymentResponse>;
+    processApplePayPayment: (checkoutSessionId: string, applePayToken: ApplePayToken, options?: PaymentOptions) => Promise<PaymentResponse>;
+    processPaymentWithInstrument: (checkoutSessionId: string, paymentInstrumentId: string, options?: PaymentOptions) => Promise<PaymentResponse>;
+    createCardPaymentInstrument: (cardData: CardPaymentMethod) => Promise<PaymentInstrumentResponse>;
+    createApplePayPaymentInstrument: (applePayToken: ApplePayToken) => Promise<PaymentInstrumentResponse>;
+    isLoading: boolean;
+    error: string | null;
+    clearError: () => void;
+    currentPaymentId: string | null;
+}
+export declare function usePayment(): PaymentHook;