@tagadapay/plugin-sdk 1.0.2

package/dist/react/hooks/useCheckout.js

@@ -0,0 +1,325 @@
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getCheckoutToken } from '../utils/urlUtils';
+import { useCurrency } from '../hooks/useCurrency';
+export function useCheckout(options = {}) {
+    const { apiService } = useTagadaContext();
+    const { code: currentCurrency } = useCurrency();
+    const [checkout, setCheckout] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const { autoRefresh = false, refreshInterval = 30000, autoInitFromUrl = false, checkoutToken: providedToken, fallbackToken, autoLoadFromToken = true, } = options;
+    const refreshTimeoutRef = useRef(null);
+    const currentCheckoutTokenRef = useRef(null);
+    const hasAutoLoadedRef = useRef(false);
+    // Clear refresh timeout on unmount
+    useEffect(() => {
+        return () => {
+            if (refreshTimeoutRef.current) {
+                clearTimeout(refreshTimeoutRef.current);
+            }
+        };
+    }, []);
+    const init = useCallback(async (params) => {
+        // Don't allow init if we already have a checkout token
+        if (providedToken) {
+            console.warn('[Checkout] Cannot init - checkoutToken already provided:', providedToken.substring(0, 8) + '...');
+            throw new Error('Cannot initialize new checkout when checkoutToken is already provided. The existing checkout will be auto-loaded.');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const requestBody = {
+                ...params,
+                returnUrl: params.returnUrl || window.location.origin,
+                customer: {
+                    ...params.customer,
+                    currency: params.customer?.currency || currentCurrency,
+                },
+            };
+            const response = await apiService.fetch('/api/v1/checkout/session/init', {
+                method: 'POST',
+                body: requestBody,
+            });
+            // Get the full checkout data
+            const checkoutData = await getCheckout(response.checkoutToken);
+            setCheckout(checkoutData);
+            setIsInitialized(true);
+            // Update URL with checkout token
+            if (typeof window !== 'undefined' && response.checkoutToken) {
+                const currentUrl = new URL(window.location.href);
+                if (!currentUrl.searchParams.has('checkoutToken')) {
+                    const newUrl = new URL(window.location.href);
+                    newUrl.searchParams.set('checkoutToken', response.checkoutToken);
+                    window.history.replaceState(null, '', newUrl.toString());
+                }
+            }
+            return {
+                checkoutUrl: response.checkoutUrl,
+                checkoutSession: checkoutData.checkoutSession,
+                checkoutToken: response.checkoutToken,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to initialize checkout');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, currentCurrency, providedToken]);
+    const getCheckout = useCallback(async (checkoutToken) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const queryParams = new URLSearchParams();
+            if (currentCurrency) {
+                queryParams.set('currency', currentCurrency);
+            }
+            const url = `/api/v1/checkout-sessions/${checkoutToken}/v2${queryParams.toString() ? `?${queryParams.toString()}` : ''}`;
+            const response = await apiService.fetch(url, {
+                method: 'GET',
+            });
+            setCheckout(response);
+            currentCheckoutTokenRef.current = checkoutToken;
+            setIsInitialized(true);
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to get checkout session');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, currentCurrency]);
+    const refresh = useCallback(async () => {
+        if (!currentCheckoutTokenRef.current) {
+            throw new Error('No checkout session to refresh');
+        }
+        await getCheckout(currentCheckoutTokenRef.current);
+    }, [getCheckout]);
+    const updateAddress = useCallback(async (data) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/address`, {
+                method: 'POST',
+                body: { data },
+            });
+            await refresh();
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to update address');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const setCheckoutInfo = useCallback(async (data) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/checkout-info`, {
+                method: 'POST',
+                body: {
+                    shippingAddress: data.shippingAddress,
+                    billingAddress: data.differentBillingAddress ? data.billingAddress : data.shippingAddress,
+                    differentBillingAddress: data.differentBillingAddress || false,
+                },
+            });
+            if (response.success) {
+                await refresh();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to set checkout info');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const applyPromotionCode = useCallback(async (code) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/promotions/apply`, {
+                method: 'POST',
+                body: { code },
+            });
+            if (response.success) {
+                await refresh();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to apply promotion code');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const removePromotion = useCallback(async (promotionId) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/promotions/${promotionId}`, {
+                method: 'DELETE',
+            });
+            if (response.success) {
+                await refresh();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to remove promotion');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const getAppliedPromotions = useCallback(async () => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/promotions`, {
+                method: 'GET',
+            });
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to get applied promotions');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id]);
+    const updateLineItems = useCallback(async (lineItems) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/line-items`, {
+                method: 'POST',
+                body: { lineItems },
+            });
+            if (response.success) {
+                await refresh();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to update line items');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const toggleOrderBump = useCallback(async (orderBumpOfferId, selected) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/toggle-order-bump`, {
+                method: 'POST',
+                body: { orderBumpOfferId, selected },
+            });
+            if (response.success) {
+                await refresh();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const updateCustomer = useCallback(async (data) => {
+        if (!checkout?.checkoutSession.customerId) {
+            throw new Error('No customer ID available');
+        }
+        try {
+            const response = await apiService.updateCustomer(checkout.checkoutSession.customerId, data);
+            await refresh();
+            return { success: true };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to update customer');
+            console.error('Customer update failed:', error);
+            return { success: false, error: error.message };
+        }
+    }, [apiService, checkout?.checkoutSession.customerId, refresh]);
+    const updateCustomerAndSessionInfo = useCallback(async (data) => {
+        if (!checkout?.checkoutSession.id) {
+            throw new Error('No checkout session available');
+        }
+        try {
+            const response = await apiService.updateCustomerAndSessionInfo(checkout.checkoutSession.id, {
+                customerData: data.customerData,
+                shippingAddress: data.shippingAddress,
+                billingAddress: data.differentBillingAddress ? data.billingAddress : data.shippingAddress,
+                differentBillingAddress: data.differentBillingAddress || false,
+            });
+            if (response.success) {
+                await refresh();
+            }
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to update customer and session info');
+            throw error;
+        }
+    }, [apiService, checkout?.checkoutSession.id, refresh]);
+    const clear = useCallback(() => {
+        setCheckout(null);
+        setError(null);
+        setIsInitialized(false);
+        currentCheckoutTokenRef.current = null;
+        hasAutoLoadedRef.current = false;
+        if (refreshTimeoutRef.current) {
+            clearTimeout(refreshTimeoutRef.current);
+        }
+    }, []);
+    // Auto-load existing checkout session from provided token or URL token
+    useEffect(() => {
+        if (!autoLoadFromToken || hasAutoLoadedRef.current || isInitialized) {
+            return;
+        }
+        // Prioritize provided checkoutToken, then URL token, then fallback
+        const token = providedToken ||
+            getCheckoutToken({
+                currentUrl: true,
+                fallbackToken,
+            });
+        if (token && !isLoading) {
+            console.debug('[Checkout] Auto-loading from token:', {
+                source: providedToken ? 'provided' : 'url/fallback',
+                tokenPreview: token.substring(0, 8) + '...',
+            });
+            hasAutoLoadedRef.current = true;
+            getCheckout(token).catch((err) => {
+                console.error('Auto-load failed:', err);
+                setError(err instanceof Error ? err : new Error('Auto-load failed'));
+                hasAutoLoadedRef.current = false; // Reset to allow retry
+            });
+        }
+    }, [autoLoadFromToken, providedToken, fallbackToken, isInitialized, isLoading, getCheckout]);
+    return {
+        checkout,
+        isLoading,
+        error,
+        isInitialized,
+        initialized: !!checkout?.checkoutSession,
+        init,
+        getCheckout,
+        refresh,
+        updateAddress,
+        setCheckoutInfo,
+        applyPromotionCode,
+        removePromotion,
+        getAppliedPromotions,
+        updateLineItems,
+        toggleOrderBump,
+        updateCustomer,
+        updateCustomerAndSessionInfo,
+        clear,
+    };
+}

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

@@ -0,0 +1,4 @@
+import { Currency } from '../types';
+export declare function useCurrency(): Currency & {
+    format: (amount: number) => string;
+};