@tagadapay/plugin-sdk 2.5.0 → 2.6.0

package/dist/v2/react/hooks/useCheckoutQuery.js

@@ -34,14 +34,6 @@ export function useCheckoutQuery(options = {}) {
     }, [providedToken, internalToken]);
     // Use provided token or internal token
     const checkoutToken = providedToken || internalToken;
-    console.log('🔍 [useCheckoutQuery] Query setup:', {
-        providedToken: providedToken ? providedToken.substring(0, 8) + '...' : 'none',
-        internalToken: internalToken ? internalToken.substring(0, 8) + '...' : 'none',
-        finalToken: checkoutToken ? checkoutToken.substring(0, 8) + '...' : 'none',
-        enabled: enabled && !!checkoutToken && isSessionInitialized,
-        currentCurrency: currency.code,
-        isSessionInitialized
-    });
     // Main checkout query
     const { data: checkout, isLoading, error, isSuccess, refetch, } = useQuery({
         queryKey: ['checkout', checkoutToken, currency.code],
@@ -50,12 +42,6 @@ export function useCheckoutQuery(options = {}) {
         staleTime: 30000, // 30 seconds
         refetchOnWindowFocus: false,
     });
-    console.log('🔍 [useCheckoutQuery] Query result:', {
-        hasCheckout: !!checkout,
-        isLoading,
-        error: error?.message,
-        isSuccess
-    });
     // Refresh function
     const refresh = useCallback(async () => {
         if (checkoutToken) {

package/dist/v2/react/hooks/useCheckoutToken.js

@@ -8,7 +8,7 @@ export function useCheckoutToken(options = {}) {
     const { isSessionInitialized } = useTagadaContext();
     const { checkoutToken: providedToken, autoLoadFromToken = true } = options;
     const [checkoutToken, setCheckoutToken] = useState(providedToken || null);
-    const [isLoading, setIsLoading] = useState(false);
+    const [isLoading, _setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [isInitialized, setIsInitialized] = useState(false);
     const hasAutoLoadedRef = useRef(false);
@@ -20,10 +20,6 @@ export function useCheckoutToken(options = {}) {
     // Update token when provided token changes
     useEffect(() => {
         if (providedToken && providedToken !== checkoutToken) {
-            console.log('🔧 useCheckoutToken: Token updated from props', {
-                oldToken: checkoutToken ? checkoutToken.substring(0, 8) + '...' : null,
-                newToken: providedToken.substring(0, 8) + '...'
-            });
             setCheckoutToken(providedToken);
             setIsInitialized(false);
             hasAutoLoadedRef.current = false;
@@ -35,9 +31,6 @@ export function useCheckoutToken(options = {}) {
             const urlParams = new URLSearchParams(window.location.search);
             const urlToken = urlParams.get('checkoutToken') || urlParams.get('token');
             if (urlToken) {
-                console.log('🔧 useCheckoutToken: Auto-loading token from URL', {
-                    tokenPreview: urlToken.substring(0, 8) + '...'
-                });
                 setCheckoutToken(urlToken);
                 hasAutoLoadedRef.current = true;
             }
@@ -48,22 +41,14 @@ export function useCheckoutToken(options = {}) {
         if (!isSessionInitialized || !checkoutToken || isInitialized) {
             return;
         }
-        console.log('🔧 useCheckoutToken: Session initialized, token ready', {
-            tokenPreview: checkoutToken.substring(0, 8) + '...',
-            isSessionInitialized
-        });
         setIsInitialized(true);
     }, [isSessionInitialized, checkoutToken, isInitialized]);
     const setToken = useCallback((token) => {
-        console.log('🔧 useCheckoutToken: Setting token', {
-            tokenPreview: token ? token.substring(0, 8) + '...' : null
-        });
         setCheckoutToken(token);
         setIsInitialized(!!token);
         setError(null);
     }, []);
     const clearToken = useCallback(() => {
-        console.log('🔧 useCheckoutToken: Clearing token');
         setCheckoutToken(null);
         setIsInitialized(false);
         setError(null);

package/dist/v2/react/hooks/useGeoLocation.js

@@ -80,18 +80,15 @@ export function useGeoLocation(options = {}) {
         try {
             const targetIp = customIp || ip;
             const endpoint = targetIp ? `/api/v1/geo?ip=${encodeURIComponent(targetIp)}` : '/api/v1/geo';
-            console.log('[SDK] Fetching geolocation data for IP:', targetIp || 'client IP');
             const geoData = await apiService.fetch(endpoint, {
                 method: 'GET',
                 skipAuth: true, // Geolocation endpoint doesn't require authentication
             });
             setData(geoData);
-            console.log('[SDK] Geolocation data fetched successfully:', geoData);
         }
         catch (err) {
             const errorMessage = err instanceof Error ? err.message : 'Failed to fetch geolocation data';
             setError(errorMessage);
-            console.error('[SDK] Error fetching geolocation data:', err);
         }
         finally {
             setIsLoading(false);

package/dist/v2/react/hooks/useGoogleAutocomplete.js

@@ -18,7 +18,6 @@ export function useGoogleAutocomplete(options) {
     // Inject Google Maps script
     useEffect(() => {
         if (!apiKey) {
-            console.error('Google Maps API key is required');
             return;
         }
         if (scriptLoadedRef.current || window.google?.maps) {
@@ -56,12 +55,11 @@ export function useGoogleAutocomplete(options) {
         script.async = true;
         script.defer = true;
         script.onload = () => {
-            console.log('🗺️ Google Maps API loaded successfully');
             setIsScriptLoaded(true);
             scriptLoadedRef.current = true;
         };
         script.onerror = () => {
-            console.error('Failed to load Google Maps API');
+            // Failed to load Google Maps API
         };
         document.head.appendChild(script);
         // Cleanup function
@@ -90,11 +88,9 @@ export function useGoogleAutocomplete(options) {
     // Search for place predictions
     const searchPlaces = useCallback((input, countryRestriction) => {
         if (!isScriptLoaded) {
-            console.warn('Google Maps API not yet loaded');
             return;
         }
         if (!initializeServices()) {
-            console.error('Google Places services not available');
             return;
         }
         if (input.length < 3) {
@@ -112,12 +108,11 @@ export function useGoogleAutocomplete(options) {
             setIsLoading(false);
             if (status === window.google.maps.places.PlacesServiceStatus.OK && results) {
                 setPredictions(results);
-                console.log(`🔍 Found ${results.length} predictions for "${input}"`);
             }
             else {
                 setPredictions([]);
                 if (status !== window.google.maps.places.PlacesServiceStatus.ZERO_RESULTS) {
-                    console.warn('Google Places prediction failed:', status);
+                    // Prediction failed but not zero results
                 }
             }
         });
@@ -126,12 +121,10 @@ export function useGoogleAutocomplete(options) {
     const getPlaceDetails = useCallback((placeId) => {
         return new Promise((resolve) => {
             if (!isScriptLoaded) {
-                console.warn('Google Maps API not yet loaded');
                 resolve(null);
                 return;
             }
             if (!initializeServices()) {
-                console.error('Google Places services not available');
                 resolve(null);
                 return;
             }
@@ -141,11 +134,9 @@ export function useGoogleAutocomplete(options) {
             };
             placesServiceRef.current.getDetails(request, (place, status) => {
                 if (status === window.google.maps.places.PlacesServiceStatus.OK && place) {
-                    console.log('📍 Got place details:', place);
                     resolve(place);
                 }
                 else {
-                    console.error('Failed to get place details:', status);
                     resolve(null);
                 }
             });
@@ -162,7 +153,6 @@ export function useGoogleAutocomplete(options) {
             country: '',
             postalCode: '',
         };
-        console.log('🏗️ Extracted address components:', place.address_components);
         place.address_components?.forEach((component) => {
             const types = component.types;
             if (types.includes('street_number')) {
@@ -188,7 +178,6 @@ export function useGoogleAutocomplete(options) {
                 extracted.postalCode = component.long_name;
             }
         });
-        console.log('🏗️ Extracted address components:', extracted);
         return extracted;
     }, []);
     // Clear predictions

package/dist/v2/react/hooks/useISOData.js

@@ -20,7 +20,6 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
                 setRegisteredLanguages(getRegisteredLanguages());
             })
                 .catch((error) => {
-                console.error(`Failed to auto-import language ${language}:`, error);
             });
         }
     }, [language, autoImport]);
@@ -86,8 +85,8 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
                 registeredLanguages,
             };
         }
-        catch (error) {
-            console.error(`Failed to load ISO data for language: ${language}`, error);
+        catch (_error) {
+            // Error handling removed
             return {
                 countries: {},
                 getRegions: () => [],

package/dist/v2/react/hooks/useOffersQuery.js

@@ -62,7 +62,6 @@ export function useOffersQuery(options = {}) {
             }
         }
         catch (error) {
-            console.error(`[SDK] Failed to fetch order summary for offer ${offerId}:`, error);
             setCheckoutSessions(prev => ({
                 ...prev,
                 [offerId]: {
@@ -100,40 +99,40 @@ export function useOffersQuery(options = {}) {
         mutationFn: async ({ offerId, returnUrl }) => {
             return await offersResource.createCheckoutSession(offerId, returnUrl);
         },
-        onError: (error) => {
-            console.error('Failed to create checkout session:', error);
+        onError: (_error) => {
+            // Error handling removed
         },
     });
     const payOfferMutation = useMutation({
         mutationFn: async ({ offerId, orderId }) => {
             return await offersResource.payOffer(offerId, orderId);
         },
-        onError: (error) => {
-            console.error('Failed to pay offer:', error);
+        onError: (_error) => {
+            // Error handling removed
         },
     });
     const transformToCheckoutMutation = useMutation({
         mutationFn: async ({ offerId, returnUrl }) => {
             return await offersResource.transformToCheckout(offerId, returnUrl);
         },
-        onError: (error) => {
-            console.error('Failed to transform offer to checkout:', error);
+        onError: (_error) => {
+            // Error handling removed
         },
     });
     const payWithCheckoutSessionMutation = useMutation({
         mutationFn: async ({ checkoutSessionId, orderId }) => {
             return await offersResource.payWithCheckoutSession(checkoutSessionId, orderId);
         },
-        onError: (error) => {
-            console.error('Failed to pay with checkout session:', error);
+        onError: (_error) => {
+            // Error handling removed
         },
     });
     const initCheckoutSessionMutation = useMutation({
         mutationFn: async ({ offerId, orderId, customerId }) => {
             return await offersResource.initCheckoutSession(offerId, orderId, customerId);
         },
-        onError: (error) => {
-            console.error('Failed to initialize checkout session:', error);
+        onError: (_error) => {
+            // Error handling removed
         },
     });
     // Helper functions (matching V1 useOffers exactly)
@@ -208,36 +207,30 @@ export function useOffersQuery(options = {}) {
             return checkoutSessions[offerId] || null;
         },
         initializeOfferCheckout: async (offerId) => {
-            try {
-                // Check if customer ID is available
-                if (!session?.customerId) {
-                    throw new Error('Customer ID is required. Make sure the session is properly initialized.');
-                }
-                // Initialize checkout session using transformToCheckout
-                const initResult = await offersResource.transformToCheckout(offerId, returnUrl);
-                if (!initResult.checkoutUrl) {
-                    throw new Error('Failed to initialize checkout session');
-                }
-                // Extract session ID from checkout URL or use a placeholder
-                const sessionId = 'session_' + offerId; // This would need to be extracted from the actual response
-                // Initialize session state
-                setCheckoutSessions(prev => ({
-                    ...prev,
-                    [offerId]: {
-                        checkoutSessionId: sessionId,
-                        orderSummary: null,
-                        selectedVariants: {},
-                        loadingVariants: {},
-                        isUpdatingSummary: false,
-                    }
-                }));
-                // Fetch order summary with variant options
-                await fetchOrderSummary(offerId, sessionId);
+            // Check if customer ID is available
+            if (!session?.customerId) {
+                throw new Error('Customer ID is required. Make sure the session is properly initialized.');
             }
-            catch (error) {
-                console.error(`[SDK] Failed to initialize checkout for offer ${offerId}:`, error);
-                throw error;
+            // Initialize checkout session using transformToCheckout
+            const initResult = await offersResource.transformToCheckout(offerId, returnUrl);
+            if (!initResult.checkoutUrl) {
+                throw new Error('Failed to initialize checkout session');
             }
+            // Extract session ID from checkout URL or use a placeholder
+            const sessionId = 'session_' + offerId; // This would need to be extracted from the actual response
+            // Initialize session state
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    checkoutSessionId: sessionId,
+                    orderSummary: null,
+                    selectedVariants: {},
+                    loadingVariants: {},
+                    isUpdatingSummary: false,
+                }
+            }));
+            // Fetch order summary with variant options
+            await fetchOrderSummary(offerId, sessionId);
         },
         getAvailableVariants: (offerId, productId) => {
             const sessionState = checkoutSessions[offerId];
@@ -314,10 +307,6 @@ export function useOffersQuery(options = {}) {
                 // Refetch order summary after successful line item update
                 await fetchOrderSummary(offerId, sessionId);
             }
-            catch (error) {
-                console.error(`[SDK] Failed to update variant for offer ${offerId}:`, error);
-                throw error;
-            }
             finally {
                 // Clear loading state for this specific variant
                 setCheckoutSessions(prev => ({

package/dist/v2/react/hooks/useOrderBumpQuery.js

@@ -12,10 +12,12 @@ export function useOrderBumpQuery(options) {
     // Use checkout query only if no checkout is provided
     const { checkout: loadedCheckout } = useCheckoutQuery({
         checkoutToken: checkoutToken || undefined,
-        enabled: !providedCheckout && !!checkoutToken,
+        enabled: !providedCheckout, // Enable if no checkout is provided, regardless of token
     });
     // Use provided checkout or loaded checkout
     const checkout = providedCheckout || loadedCheckout;
+    // Get the actual checkout token from the checkout session
+    const actualCheckoutToken = checkoutToken || checkout?.checkoutSession?.checkoutToken || null;
     // Function to check if order bump is selected
     const checkOrderBumpSelection = useCallback(() => {
         if (!checkout?.checkoutSession?.sessionLineItems) {
@@ -44,18 +46,21 @@ export function useOrderBumpQuery(options) {
             selected,
         });
     }, {
-        onMutate: async ({ selected }) => {
+        onMutate: ({ selected }) => {
             // Optimistic update
             setIsSelected(selected);
             setError(null);
         },
         onSuccess: () => {
             // Invalidate related queries
-            if (checkoutToken) {
-                invalidateCheckout(checkoutToken);
+            // Use the actual checkout token (from parameter or checkout session)
+            const tokenToUse = checkoutToken || checkout?.checkoutSession?.checkoutToken;
+            if (tokenToUse) {
+                invalidateCheckout(String(tokenToUse));
             }
+            // Always invalidate promotions based on checkout session ID
             if (checkout?.checkoutSession?.id) {
-                invalidatePromotions(checkout.checkoutSession.id);
+                invalidatePromotions(String(checkout.checkoutSession.id));
             }
         },
         onError: (err, { selected }) => {
@@ -66,19 +71,18 @@ export function useOrderBumpQuery(options) {
     });
     const toggle = useCallback(async (selected) => {
         if (!checkout?.checkoutSession?.id) {
-            console.warn('useOrderBumpQuery: No checkout session available yet');
             return { success: false, error: 'Checkout session not ready' };
         }
         const targetState = selected ?? !isSelected;
         try {
-            const result = await toggleMutation.mutateAsync({ selected: targetState });
+            await toggleMutation.mutateAsync({ selected: targetState });
             return { success: true };
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
             return { success: false, error: error.message };
         }
-    }, [checkout?.checkoutSession?.id, isSelected, toggleMutation]);
+    }, [checkout?.checkoutSession?.id, isSelected, toggleMutation, offerId, productId, checkoutToken, actualCheckoutToken]);
     return {
         isSelected,
         isToggling: toggleMutation.isPending,

package/dist/v2/react/hooks/usePaymentPolling.js

@@ -32,24 +32,21 @@ export function usePaymentPolling() {
         isPollingRef.current = false;
         currentPaymentIdRef.current = null;
         if (isMountedRef.current) {
-            console.log('Stopped polling payment status');
+            // Component is still mounted
         }
     }, []);
     const startPolling = useCallback((paymentId, options = {}) => {
         if (!paymentId) {
-            console.error('Cannot poll payment status: paymentId is missing');
             return { stop: stopPolling, isPolling: () => false };
         }
         // Prevent multiple polling sessions for the same payment
         if (currentPaymentIdRef.current === paymentId && isPollingRef.current) {
-            console.log('Already polling for payment:', paymentId);
             return { stop: stopPolling, isPolling: () => isPollingRef.current };
         }
         // Clean up any existing polling
         stopPolling();
         // Don't start polling if component is unmounted
         if (!isMountedRef.current) {
-            console.log('Component unmounted, skipping polling start');
             return { stop: stopPolling, isPolling: () => false };
         }
         // Reset attempts counter and set current payment
@@ -57,7 +54,6 @@ export function usePaymentPolling() {
         isPollingRef.current = true;
         currentPaymentIdRef.current = paymentId;
         const { onRequireAction, onSuccess, onFailure, maxAttempts = 20, pollInterval = 1500 } = options;
-        console.log('Starting to poll payment status for:', paymentId);
         const checkPaymentStatus = async () => {
             // Stop if component was unmounted or polling was stopped
             if (!isMountedRef.current || !isPollingRef.current) {
@@ -65,7 +61,6 @@ export function usePaymentPolling() {
             }
             try {
                 attemptsRef.current++;
-                console.log(`Polling attempt ${attemptsRef.current}/${maxAttempts} for payment ${paymentId}`);
                 const payment = await paymentsResource.getPaymentStatus(paymentId);
                 // Check again after async operation
                 if (!isMountedRef.current || !isPollingRef.current) {
@@ -73,13 +68,10 @@ export function usePaymentPolling() {
                 }
                 // Type guard and validation
                 if (!payment?.id) {
-                    console.warn('Invalid payment response received');
                     return;
                 }
-                console.log('Payment status update:', payment);
                 // Check if payment requires action
                 if (payment.requireAction !== 'none' && payment.requireActionData) {
-                    console.log('Payment requires new action, handling...');
                     stopPolling();
                     if (isMountedRef.current && onRequireAction) {
                         onRequireAction(payment, stopPolling);
@@ -89,7 +81,6 @@ export function usePaymentPolling() {
                 // Check for successful payment
                 if (payment.status === 'succeeded' ||
                     (payment.status === 'pending' && payment.subStatus === 'authorized')) {
-                    console.log('Payment succeeded, stopping polling');
                     stopPolling();
                     if (isMountedRef.current && onSuccess) {
                         onSuccess(payment);
@@ -98,7 +89,6 @@ export function usePaymentPolling() {
                 }
                 // Check for failed payment (non-succeeded and not pending)
                 if (payment.status !== 'succeeded' && payment.status !== 'pending') {
-                    console.log('Payment failed, stopping polling');
                     stopPolling();
                     if (isMountedRef.current && onFailure) {
                         onFailure(payment.status || 'Payment failed');
@@ -107,18 +97,15 @@ export function usePaymentPolling() {
                 }
                 // Stop after max attempts
                 if (attemptsRef.current >= maxAttempts) {
-                    console.log('Reached maximum polling attempts');
                     stopPolling();
                     if (isMountedRef.current && onFailure) {
                         onFailure('Payment verification timeout');
                     }
                 }
             }
-            catch (error) {
-                console.error('Error checking payment status:', error);
+            catch (_error) {
                 // Stop polling on repeated errors to prevent infinite loops
                 if (attemptsRef.current >= 3) {
-                    console.log('Multiple errors encountered, stopping polling');
                     stopPolling();
                     if (isMountedRef.current && onFailure) {
                         onFailure('Payment verification failed due to network errors');

package/dist/v2/react/hooks/usePaymentQuery.js

@@ -39,11 +39,9 @@ export function usePaymentQuery() {
     // Handle BasisTheory initialization errors (only log once when state changes)
     useEffect(() => {
         if (btError) {
-            console.error('BasisTheory initialization error:', btError);
             setError('Failed to initialize payment processor: ' + btError.message);
         }
         else if (basisTheory && !error) {
-            console.log('✅ BasisTheory initialized successfully');
             setError(null); // Clear any previous errors
         }
     }, [basisTheory, btError]); // Removed error from dependency to prevent loops
@@ -66,16 +64,14 @@ export function usePaymentQuery() {
         try {
             await paymentsResource.markPaymentActionProcessed(payment.id);
         }
-        catch (error) {
-            console.error('Error setting payment action as processed', error);
+        catch (_error) {
+            // Error handling removed
         }
-        console.log('Processing payment action:', actionData.type);
         switch (actionData.type) {
             case 'threeds_auth':
                 if (actionData.metadata?.threedsSession && !challengeInProgressRef.current) {
                     try {
                         challengeInProgressRef.current = true;
-                        console.log('Starting 3DS challenge...');
                         await startChallenge({
                             sessionId: actionData.metadata.threedsSession.externalSessionId,
                             acsChallengeUrl: actionData.metadata.threedsSession.acsChallengeUrl,
@@ -83,7 +79,6 @@ export function usePaymentQuery() {
                             threeDSVersion: actionData.metadata.threedsSession.messageVersion,
                         }, { provider: options.threedsProvider || 'basis_theory' });
                         challengeInProgressRef.current = false;
-                        console.log('3DS challenge completed');
                         // Start polling after challenge completion
                         if (payment.id) {
                             startPolling(payment.id, {
@@ -98,7 +93,6 @@ export function usePaymentQuery() {
                                     });
                                 },
                                 onFailure: (errorMsg) => {
-                                    console.error('Payment failed:', errorMsg);
                                     setError(errorMsg);
                                     setIsLoading(false);
                                     options.onFailure?.(errorMsg);
@@ -106,10 +100,9 @@ export function usePaymentQuery() {
                             });
                         }
                     }
-                    catch (error) {
+                    catch (_error) {
                         challengeInProgressRef.current = false;
-                        console.error('Error starting 3DS challenge:', error);
-                        const errorMsg = error instanceof Error ? error.message : 'Failed to start 3DS challenge';
+                        const errorMsg = _error instanceof Error ? _error.message : 'Failed to start 3DS challenge';
                         setError(errorMsg);
                         setIsLoading(false);
                         options.onFailure?.(errorMsg);
@@ -148,7 +141,6 @@ export function usePaymentQuery() {
                 initiatedBy: options.initiatedBy,
                 source: options.source,
             });
-            console.log('Payment response:', response);
             setCurrentPaymentId(response.payment?.id);
             if (response.payment.requireAction !== 'none') {
                 await handlePaymentAction(response.payment, options);
@@ -171,7 +163,6 @@ export function usePaymentQuery() {
                         });
                     },
                     onFailure: (errorMsg) => {
-                        console.error('Payment failed:', errorMsg);
                         setError(errorMsg);
                         setIsLoading(false);
                         options.onFailure?.(errorMsg);
@@ -180,12 +171,12 @@ export function usePaymentQuery() {
             }
             return response;
         }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : 'Payment failed';
+        catch (_error) {
+            const errorMsg = _error instanceof Error ? _error.message : 'Payment failed';
             setError(errorMsg);
             setIsLoading(false);
             options.onFailure?.(errorMsg);
-            throw error;
+            throw _error;
         }
     }, [paymentsResource, handlePaymentAction, startPolling]);
     // Process card payment - matches old implementation
@@ -204,19 +195,18 @@ export function usePaymentQuery() {
                     });
                     threedsSessionId = threedsSession.id;
                 }
-                catch (error) {
-                    console.warn('Failed to create 3DS session, proceeding without 3DS:', error);
+                catch (_error) {
                 }
             }
             // 3. Process payment directly
             return await processPaymentDirect(checkoutSessionId, paymentInstrument.id, threedsSessionId, options);
         }
-        catch (error) {
+        catch (_error) {
             setIsLoading(false);
-            const errorMsg = error instanceof Error ? error.message : 'Payment failed';
+            const errorMsg = _error instanceof Error ? _error.message : 'Payment failed';
             setError(errorMsg);
             options.onFailure?.(errorMsg);
-            throw error;
+            throw _error;
         }
     }, [createCardPaymentInstrument, createSession, processPaymentDirect]);
     // Process Apple Pay payment - matches old implementation
@@ -229,12 +219,12 @@ export function usePaymentQuery() {
             // 2. Process payment directly (Apple Pay typically doesn't require 3DS)
             return await processPaymentDirect(checkoutSessionId, paymentInstrument.id, undefined, options);
         }
-        catch (error) {
+        catch (_error) {
             setIsLoading(false);
-            const errorMsg = error instanceof Error ? error.message : 'Apple Pay payment failed';
+            const errorMsg = _error instanceof Error ? _error.message : 'Apple Pay payment failed';
             setError(errorMsg);
             options.onFailure?.(errorMsg);
-            throw error;
+            throw _error;
         }
     }, [createApplePayPaymentInstrument, processPaymentDirect]);
     // Process payment with existing instrument - matches old implementation
@@ -244,12 +234,12 @@ export function usePaymentQuery() {
         try {
             return await processPaymentDirect(checkoutSessionId, paymentInstrumentId, undefined, options);
         }
-        catch (error) {
+        catch (_error) {
             setIsLoading(false);
-            const errorMsg = error instanceof Error ? error.message : 'Payment failed';
+            const errorMsg = _error instanceof Error ? _error.message : 'Payment failed';
             setError(errorMsg);
             options.onFailure?.(errorMsg);
-            throw error;
+            throw _error;
         }
     }, [processPaymentDirect]);
     // Get card payment instruments - matches old implementation
@@ -259,7 +249,6 @@ export function usePaymentQuery() {
             return response;
         }
         catch (error) {
-            console.error('Error fetching card payment instruments:', error);
             const errorMsg = error instanceof Error ? error.message : 'Failed to fetch payment instruments';
             setError(errorMsg);
             throw error;

package/dist/v2/react/hooks/usePluginConfig.d.ts

@@ -11,6 +11,8 @@ export interface UsePluginConfigResult<TConfig = Record<string, any>> {
     storeId?: string;
     accountId?: string;
     basePath?: string;
+    loading: boolean;
+    error?: Error;
     isValid: boolean;
 }
 export declare function usePluginConfig<TConfig = Record<string, any>>(options?: UsePluginConfigOptions): UsePluginConfigResult<TConfig>;

package/dist/v2/react/hooks/usePluginConfig.js

@@ -6,7 +6,7 @@ import { useMemo } from 'react';
 import { useTagadaContext } from '../providers/TagadaProvider';
 import { PluginConfigUtils } from '../../core/utils/pluginConfig';
 export function usePluginConfig(options = {}) {
-    const { pluginConfig } = useTagadaContext();
+    const { pluginConfig, pluginConfigLoading } = useTagadaContext();
     const config = useMemo(() => {
         const baseConfig = PluginConfigUtils.getPluginConfig(options.rawConfig, {
             storeId: pluginConfig.storeId,
@@ -25,12 +25,13 @@ export function usePluginConfig(options = {}) {
     const isValid = useMemo(() => {
         return PluginConfigUtils.validateConfig(config);
     }, [config]);
-    console.log('🔍 [usePluginConfig] Config:', config);
     return {
         config,
         storeId: config.storeId,
         accountId: config.accountId,
         basePath: config.basePath,
+        loading: pluginConfigLoading,
+        error: undefined, // TODO: Add error handling if needed
         isValid,
     };
 }

package/dist/v2/react/hooks/usePostPurchasesQuery.js

@@ -60,7 +60,6 @@ export function usePostPurchasesQuery(options) {
             }
         }
         catch (error) {
-            console.error(`[SDK] Failed to fetch order summary for offer ${offerId}:`, error);
             setCheckoutSessions(prev => ({
                 ...prev,
                 [offerId]: {
@@ -86,10 +85,9 @@ export function usePostPurchasesQuery(options) {
             offers.forEach((offer) => {
                 try {
                     // This is a placeholder - in a full implementation, you'd call initializeOfferCheckout
-                    console.log(`Auto-initializing checkout for offer: ${offer.id}`);
                 }
-                catch (error) {
-                    console.error(`Failed to auto-initialize checkout for offer ${offer.id}:`, error);
+                catch (_error) {
+                    // Error handling removed
                 }
             });
         }
@@ -169,36 +167,18 @@ export function usePostPurchasesQuery(options) {
         refresh: () => void refetch(),
         // V1 compatibility methods
         payWithCheckoutSession: async (checkoutSessionId, orderId) => {
-            try {
-                await postPurchasesResource.payWithCheckoutSession(checkoutSessionId, orderId);
-            }
-            catch (err) {
-                console.error('Failed to pay with checkout session:', err);
-                throw err;
-            }
+            await postPurchasesResource.payWithCheckoutSession(checkoutSessionId, orderId);
         },
         // Missing V1 methods implementations
         initCheckoutSession: async (offerId, orderId) => {
-            try {
-                // Check if customer ID is available
-                if (!session?.customerId) {
-                    throw new Error('Customer ID is required. Make sure the session is properly initialized.');
-                }
-                return await postPurchasesResource.initCheckoutSession(offerId, orderId, session.customerId);
-            }
-            catch (err) {
-                console.error('Failed to initialize checkout session:', err);
-                throw err;
+            // Check if customer ID is available
+            if (!session?.customerId) {
+                throw new Error('Customer ID is required. Make sure the session is properly initialized.');
             }
+            return await postPurchasesResource.initCheckoutSession(offerId, orderId, session.customerId);
         },
         initCheckoutSessionWithVariants: async (offerId, orderId, lineItems) => {
-            try {
-                return await postPurchasesResource.initCheckoutSessionWithVariants(offerId, orderId, lineItems);
-            }
-            catch (err) {
-                console.error('Failed to initialize checkout session with variants:', err);
-                throw err;
-            }
+            return await postPurchasesResource.initCheckoutSessionWithVariants(offerId, orderId, lineItems);
         },
         getOffer: (offerId) => {
             return offers.find(offer => offer.id === offerId);
@@ -247,9 +227,8 @@ export function usePostPurchasesQuery(options) {
                 // Fetch order summary with variant options
                 await fetchOrderSummary(offerId, sessionId);
             }
-            catch (error) {
-                console.error(`[SDK] Failed to initialize checkout for offer ${offerId}:`, error);
-                throw error;
+            catch (_error) {
+                throw _error;
             }
         },
         getAvailableVariants: (offerId, productId) => {
@@ -326,9 +305,8 @@ export function usePostPurchasesQuery(options) {
                 // Refetch order summary after successful line item update
                 await fetchOrderSummary(offerId, sessionState.checkoutSessionId);
             }
-            catch (error) {
-                console.error(`[SDK] Failed to update variant for offer ${offerId}:`, error);
-                throw error;
+            catch (_error) {
+                throw _error;
             }
             finally {
                 // Clear loading state for this specific variant

package/dist/v2/react/hooks/useThreeds.js

@@ -28,11 +28,9 @@ export function useThreeds(options = {}) {
                 const { BasisTheory3ds } = await import('@basis-theory/web-threeds');
                 if (isMounted) {
                     setBasisTheory3ds(() => BasisTheory3ds);
-                    console.log('✅ BasisTheory3ds initialized successfully');
                 }
             }
             catch (err) {
-                console.error('Failed to load BasisTheory3ds:', err);
                 if (isMounted) {
                     setError(err instanceof Error ? err : new Error('Failed to load 3DS library'));
                 }
@@ -45,29 +43,22 @@ export function useThreeds(options = {}) {
     }, []);
     // Create a 3DS session with BasisTheory
     const createBasisTheorySession = useCallback(async (paymentInstrument) => {
-        try {
-            if (!basisTheory3ds) {
-                throw new Error('BasisTheory3ds not loaded yet');
-            }
-            // Use the same API key approach as the working CMS version
-            const apiKey = getBasisTheoryApiKey('production'); // Use production config for now
-            const bt3ds = basisTheory3ds(apiKey);
-            console.log('paymentInstrument paymentInstrument', paymentInstrument?.token);
-            const session = await bt3ds.createSession({
-                tokenId: paymentInstrument.token,
-            });
-            // Create session through our API
-            const threedsSession = await threedsResource.createSession({
-                provider: 'basis_theory',
-                sessionData: session,
-                paymentInstrumentId: paymentInstrument.id,
-            });
-            return threedsSession;
-        }
-        catch (error) {
-            console.error('Error creating BasisTheory 3DS session:', error);
-            throw error;
+        if (!basisTheory3ds) {
+            throw new Error('BasisTheory3ds not loaded yet');
         }
+        // Use the same API key approach as the working CMS version
+        const apiKey = getBasisTheoryApiKey('production'); // Use production config for now
+        const bt3ds = basisTheory3ds(apiKey);
+        const session = await bt3ds.createSession({
+            tokenId: paymentInstrument.token,
+        });
+        // Create session through our API
+        const threedsSession = await threedsResource.createSession({
+            provider: 'basis_theory',
+            sessionData: session,
+            paymentInstrumentId: paymentInstrument.id,
+        });
+        return threedsSession;
     }, [threedsResource, basisTheory3ds]);
     // Generic createSession method that supports multiple providers
     const createSession = useCallback(async (paymentInstrument, options) => {
@@ -111,12 +102,6 @@ export function useThreeds(options = {}) {
                 },
             });
             const bt3ds = basisTheory3ds(apiKey);
-            console.log('bt3ds starting challenge with params', {
-                sessionId,
-                acsChallengeUrl,
-                acsTransactionId,
-                threeDSVersion,
-            });
             const challengeCompletion = await bt3ds.startChallenge({
                 sessionId,
                 acsChallengeUrl,
@@ -130,7 +115,6 @@ export function useThreeds(options = {}) {
             return challengeCompletion;
         }
         catch (error) {
-            console.error('Error starting BasisTheory 3DS challenge:', error);
             closeThreedsModal();
             throw error;
         }

package/dist/v2/react/providers/TagadaProvider.js

@@ -48,9 +48,39 @@ const InitializationLoader = () => (_jsxs("div", { style: {
         }
       ` })] }));
 const TagadaContext = createContext(null);
+// Global instance tracking for TagadaProvider
+let globalTagadaInstance = null;
+let globalTagadaInitialized = false;
 export function TagadaProvider({ children, environment, customApiConfig, debugMode, // Remove default, will be set based on environment
 localConfig, blockUntilSessionReady = false, // Default to new non-blocking behavior
 rawPluginConfig, }) {
+    // Instance tracking
+    const [instanceId] = useState(() => {
+        if (!globalTagadaInstance) {
+            globalTagadaInstance = Math.random().toString(36).substr(2, 9);
+        }
+        return globalTagadaInstance;
+    });
+    const isActiveInstance = useMemo(() => {
+        if (!globalTagadaInitialized) {
+            globalTagadaInitialized = true;
+            console.log(`✅ [TagadaProvider] Instance ${instanceId} is now the active instance`);
+            return true;
+        }
+        else {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is duplicate - blocking execution`);
+            return false;
+        }
+    }, [instanceId]);
+    useEffect(() => {
+        return () => {
+            if (globalTagadaInstance === instanceId) {
+                globalTagadaInitialized = false;
+                globalTagadaInstance = null;
+                console.log(`🧹 [TagadaProvider] Instance ${instanceId} cleanup - allowing new instances`);
+            }
+        };
+    }, [instanceId]);
     // LOCAL DEV ONLY: Use localConfig override if in local development, otherwise use default
     const isLocalDev = typeof window !== 'undefined' &&
         (window.location.hostname === 'localhost' ||
@@ -60,7 +90,7 @@ rawPluginConfig, }) {
     // Debug logging (only log once during initial render)
     const hasLoggedRef = useRef(false);
     if (!hasLoggedRef.current) {
-        console.log('🔍 TagadaProvider Config Debug:', {
+        console.log(`🔍 [TagadaProvider] Instance ${instanceId} Config Debug:`, {
             hostname: typeof window !== 'undefined' ? window.location.hostname : 'SSR',
             isLocalDev,
             localConfig,
@@ -84,6 +114,11 @@ rawPluginConfig, }) {
     const [configLoading, setConfigLoading] = useState(!rawPluginConfig);
     // Load plugin config on mount with the specified variant
     useEffect(() => {
+        // Prevent multiple config loads
+        if (configLoading === false && pluginConfig.storeId) {
+            console.log('🔒 [TagadaProvider] Config already loaded, skipping reload');
+            return;
+        }
         const loadConfig = async () => {
             try {
                 // Use the v2 core loadPluginConfig function
@@ -239,12 +274,21 @@ rawPluginConfig, }) {
     });
     // Initialize session
     const initializeSession = useCallback(async (sessionData) => {
+        if (!isActiveInstance) {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping session initialization`);
+            return;
+        }
         if (!sessionData.storeId || !sessionData.accountId) {
-            console.error('[SDK] Missing required session data');
+            console.error(`[TagadaProvider] Instance ${instanceId} missing required session data`);
+            return;
+        }
+        // Prevent multiple session initializations
+        if (isSessionInitialized) {
+            console.log(`🔒 [TagadaProvider] Instance ${instanceId} session already initialized, skipping`);
             return;
         }
         if (finalDebugMode) {
-            console.debug('[SDK][DEBUG] Initializing session with store config...', sessionData);
+            console.debug(`[TagadaProvider] Instance ${instanceId} [DEBUG] Initializing session with store config...`, sessionData);
         }
         setIsLoading(true);
         try {
@@ -352,15 +396,23 @@ rawPluginConfig, }) {
             setIsInitialized(true);
             setIsLoading(false);
         }
-    }, [apiService, finalDebugMode]);
+    }, [apiService, finalDebugMode, isActiveInstance, instanceId]);
     // Create anonymous token if needed
     const createAnonymousToken = useCallback(async (targetStoreId) => {
+        if (!isActiveInstance) {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping anonymous token creation`);
+            return;
+        }
         if (hasAttemptedAnonymousToken || !targetStoreId) {
+            console.log(`🔒 [TagadaProvider] Instance ${instanceId} anonymous token already attempted or no storeId:`, {
+                hasAttemptedAnonymousToken,
+                targetStoreId,
+            });
             return;
         }
-        console.log('[SDK] 🚀 Starting Phase 3 - Session initialization...');
+        console.log(`[TagadaProvider] Instance ${instanceId} 🚀 Starting Phase 3 - Session initialization...`);
         if (finalDebugMode) {
-            console.debug('[SDK][DEBUG] Creating anonymous token for store:', targetStoreId);
+            console.debug(`[TagadaProvider] Instance ${instanceId} [DEBUG] Creating anonymous token for store:`, targetStoreId);
         }
         setHasAttemptedAnonymousToken(true);
         try {
@@ -405,15 +457,24 @@ rawPluginConfig, }) {
             setIsInitialized(true);
             setIsLoading(false);
         }
-    }, [apiService, hasAttemptedAnonymousToken, initializeSession, finalDebugMode]);
+    }, [apiService, hasAttemptedAnonymousToken, initializeSession, finalDebugMode, isActiveInstance, instanceId]);
     // Initialize token from storage or create anonymous token
     // This runs in the background after phases 1 & 2 complete, but doesn't block rendering
     useEffect(() => {
+        if (!isActiveInstance) {
+            console.log(`🚫 [TagadaProvider] Instance ${instanceId} is not active, skipping token initialization`);
+            return;
+        }
         if (isInitializing.current) {
+            console.log(`🔒 [TagadaProvider] Instance ${instanceId} already initializing, skipping`);
             return;
         }
         // Wait for plugin config to load AND ensure we have a store ID before initializing
         if (configLoading || !storeId) {
+            console.log(`⏳ [TagadaProvider] Instance ${instanceId} waiting for config or storeId:`, {
+                configLoading,
+                storeId,
+            });
             return;
         }
         isInitializing.current = true;
@@ -469,7 +530,7 @@ rawPluginConfig, }) {
             }
         };
         void initializeToken();
-    }, [storeId, createAnonymousToken, initializeSession, configLoading]);
+    }, [storeId, createAnonymousToken, initializeSession, configLoading, isActiveInstance, instanceId]);
     // Update auth state when customer/session changes
     useEffect(() => {
         setAuth({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",