@tagadapay/plugin-sdk 2.7.0 → 2.7.3

package/dist/v2/core/resources/credits.js

@@ -0,0 +1,21 @@
+/**
+ * Credits Resource Client
+ * Handles credits-related API operations
+ */
+export class CreditsResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get customer credit balance and transaction history
+     */
+    async getCustomerCredits(customerId, storeId) {
+        return this.apiClient.get(`/api/v1/credits/balance/${customerId}/${storeId}`);
+    }
+    /**
+     * Redeem a product using credits
+     */
+    async redeemProduct(data) {
+        return this.apiClient.post('/api/v1/credits/redeem', data);
+    }
+}

package/dist/v2/core/resources/index.d.ts

@@ -4,6 +4,7 @@
  */
 export * from './apiClient';
 export * from './checkout';
+export * from './credits';
 export * from './customer';
 export * from './discounts';
 export * from './funnel';

package/dist/v2/core/resources/index.js

@@ -4,6 +4,7 @@
  */
 export * from './apiClient';
 export * from './checkout';
+export * from './credits';
 export * from './customer';
 export * from './discounts';
 export * from './funnel';

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

@@ -27,6 +27,20 @@ export type RawPluginConfig<TConfig = Record<string, any>> = {
  * Handles local dev, production, and raw config
  */
 export declare const loadPluginConfig: (configVariant?: string, rawConfig?: RawPluginConfig) => Promise<PluginConfig>;
+/**
+ * Helper to load local config file for development (from /config directory)
+ * Returns the config object that can be passed to TagadaProvider
+ */
+export declare function loadLocalConfig(configName?: string): Promise<Record<string, unknown> | null>;
+export interface CreateRawPluginConfigOptions {
+    config?: any;
+}
+/**
+ * Creates a RawPluginConfig object from provided options
+ * @param options - Configuration options including storeId, accountId, basePath, configName, or a direct config object
+ * @returns A RawPluginConfig object or undefined if required fields are missing
+ */
+export declare function createRawPluginConfig(options?: CreateRawPluginConfigOptions): Promise<RawPluginConfig | undefined>;
 export declare class PluginConfigUtils {
     /**
      * Get plugin configuration from various sources

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

@@ -88,33 +88,16 @@ const getMetaContent = (name) => {
     return metaTag?.getAttribute('content') || undefined;
 };
 /**
- * Load production config from headers and meta tags
+ * Load production config from meta tags
+ * Meta tags are injected by the plugin middleware during HTML serving
+ * This avoids making an additional HEAD request (~300ms savings)
  */
 const loadProductionConfig = async () => {
     try {
-        // Try to get headers first
-        let storeId;
-        let accountId;
-        let basePath;
-        try {
-            const response = await fetch(window.location.href, { method: 'HEAD' });
-            storeId = response.headers.get('X-Plugin-Store-Id') || undefined;
-            accountId = response.headers.get('X-Plugin-Account-Id') || undefined;
-            basePath = response.headers.get('X-Plugin-Base-Path') || undefined;
-        }
-        catch {
-            // Headers fetch failed, will fallback to meta tags
-        }
-        // Fallback to meta tags if headers are not available
-        if (!storeId) {
-            storeId = getMetaContent('x-plugin-store-id');
-        }
-        if (!accountId) {
-            accountId = getMetaContent('x-plugin-account-id');
-        }
-        if (!basePath) {
-            basePath = getMetaContent('x-plugin-base-path') || '/';
-        }
+        // Read store/account info from meta tags (injected by middleware)
+        const storeId = getMetaContent('x-plugin-store-id');
+        const accountId = getMetaContent('x-plugin-account-id');
+        const basePath = getMetaContent('x-plugin-base-path') || '/';
         // Get deployment config from meta tags
         let config = {};
         try {
@@ -129,17 +112,22 @@ const loadProductionConfig = async () => {
         }
         // Final validation and warnings
         if (!storeId) {
-            console.warn('⚠️ Plugin config: Store ID not found in headers or meta tags');
+            console.warn('⚠️ Plugin config: Store ID not found in meta tags');
         }
         if (!accountId) {
-            console.warn('⚠️ Plugin config: Account ID not found in headers or meta tags');
+            console.warn('⚠️ Plugin config: Account ID not found in meta tags');
         }
-        const result = { storeId, accountId, basePath: basePath || '/', config };
-        console.log('🏭 Using production plugin config:', result);
+        const result = { storeId, accountId, basePath, config };
+        console.log('🚀 Plugin config loaded from meta tags (no HEAD request needed):', {
+            storeId,
+            accountId,
+            basePath,
+            configKeys: Object.keys(config)
+        });
         return result;
     }
     catch (error) {
-        console.warn('Failed to load production config, using defaults:', error);
+        console.warn('⚠️ Failed to load production config from meta tags, using defaults:', error);
         return { basePath: '/', config: {} };
     }
 };
@@ -166,6 +154,85 @@ export const loadPluginConfig = async (configVariant = 'default', rawConfig) =>
     // Fall back to production config
     return loadProductionConfig();
 };
+/**
+ * Helper to load local config file for development (from /config directory)
+ * Returns the config object that can be passed to TagadaProvider
+ */
+export async function loadLocalConfig(configName = 'default') {
+    try {
+        // Only load in localhost
+        const isLocalhost = typeof window !== 'undefined' &&
+            (window.location.hostname === 'localhost' ||
+                window.location.hostname.includes('.localhost') ||
+                window.location.hostname.includes('127.0.0.1'));
+        if (!isLocalhost) {
+            return null;
+        }
+        // Try .tgd.json first, then .json, then .config.json
+        const possiblePaths = [
+            `/config/${configName}.tgd.json`,
+            `/config/${configName}.json`,
+            `/config/${configName}.config.json`,
+        ];
+        for (const path of possiblePaths) {
+            try {
+                const response = await fetch(path);
+                if (response.ok) {
+                    const config = await response.json();
+                    console.log(`✅ [loadLocalConfig] Loaded config from ${path}:`, {
+                        configName: config.configName,
+                        hasBranding: !!config.branding,
+                    });
+                    return config;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        console.warn(`⚠️ [loadLocalConfig] No config found for '${configName}'`);
+        return null;
+    }
+    catch (error) {
+        console.error('[loadLocalConfig] Error loading config:', error);
+        return null;
+    }
+}
+/**
+ * Creates a RawPluginConfig object from provided options
+ * @param options - Configuration options including storeId, accountId, basePath, configName, or a direct config object
+ * @returns A RawPluginConfig object or undefined if required fields are missing
+ */
+export async function createRawPluginConfig(options) {
+    try {
+        const storeId = process.env.TAGADA_STORE_ID;
+        const accountId = process.env.TAGADA_ACCOUNT_ID;
+        const basePath = process.env.TAGADA_BASE_PATH;
+        const configName = process.env.TAGADA_CONFIG_NAME;
+        if (storeId) {
+            console.warn('[createRawPluginConfig] No storeId provided');
+            return undefined;
+        }
+        const resolvedConfig = options?.config ?? await loadLocalConfig(configName);
+        const rawConfig = {
+            storeId: storeId,
+            accountId: accountId,
+            basePath: basePath || '/',
+            config: resolvedConfig,
+        };
+        console.log('[createRawPluginConfig] Created raw plugin config:', {
+            hasStoreId: !!rawConfig.storeId,
+            hasAccountId: !!rawConfig.accountId,
+            basePath: rawConfig.basePath,
+            hasConfig: !!rawConfig.config,
+        });
+        return rawConfig;
+    }
+    catch (error) {
+        console.error('[createRawPluginConfig] Error creating config:', error);
+        return undefined;
+    }
+}
 export class PluginConfigUtils {
     /**
      * Get plugin configuration from various sources

package/dist/v2/index.d.ts

@@ -10,6 +10,7 @@ export * from './core/isoData';
 export * from './core/utils/currency';
 export * from './core/utils/pluginConfig';
 export * from './core/utils/products';
+export * from './core/pathRemapping';
 export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, Promotion } from './core/resources/checkout';
 export type { Order, OrderLineItem } from './core/utils/order';
 export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary } from './core/resources/postPurchases';

package/dist/v2/index.js

@@ -11,5 +11,7 @@ export * from './core/isoData';
 export * from './core/utils/currency';
 export * from './core/utils/pluginConfig';
 export * from './core/utils/products';
+// Path remapping helpers (framework-agnostic)
+export * from './core/pathRemapping';
 // React exports (hooks and components only, types are exported above)
 export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useAuth, useCheckout, useCheckoutToken, useClubOffers, useCountryOptions, useCurrency, useCustomer, useCustomerInfos, useCustomerOrders, useCustomerSubscriptions, useDiscounts, useExpressPaymentMethods, useFunnel, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useLogin, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useSimpleFunnel, useStoreConfig, useTagadaContext, useThreeds, useThreedsModal, useTranslation, useVipOffers } from './react';

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

@@ -0,0 +1,67 @@
+import { CreditTransaction, RedeemProductResponse } from '../../core/resources/credits';
+export interface UseCreditsOptions {
+    /**
+     * Customer ID to fetch credits for
+     */
+    customerId?: string | null;
+    /**
+     * Whether to fetch credits automatically on mount
+     * @default true
+     */
+    enabled?: boolean;
+}
+export interface UseCreditsResult {
+    /**
+     * Customer credit balance
+     */
+    balance: number;
+    /**
+     * Lifetime credits earned
+     */
+    lifetimeEarned: number;
+    /**
+     * Lifetime credits spent
+     */
+    lifetimeSpent: number;
+    /**
+     * Credit transaction history
+     */
+    transactions: CreditTransaction[];
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Refetch credit balance and history
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Redeem a product using credits
+     */
+    redeemProduct: (data: {
+        productId?: string;
+        variantId: string;
+        quantity?: number;
+    }) => Promise<RedeemProductResponse>;
+    /**
+     * Check if customer has enough credits for a purchase
+     */
+    hasEnoughCredits: (amount: number) => boolean;
+    /**
+     * Get transaction by ID
+     */
+    getTransaction: (transactionId: string) => CreditTransaction | undefined;
+    /**
+     * Redemption mutation state
+     */
+    isRedeeming: boolean;
+    /**
+     * Redemption error state
+     */
+    redeemError: Error | null;
+}
+export declare function useCredits(options?: UseCreditsOptions): UseCreditsResult;

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

@@ -0,0 +1,80 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { CreditsResource } from '../../core/resources/credits';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCredits(options = {}) {
+    const { customerId = null, enabled = true } = options;
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const queryClient = useQueryClient();
+    // Create credits resource client
+    const creditsResource = useMemo(() => {
+        try {
+            return new CreditsResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize credits resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-credits', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer credits using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await creditsResource.getCustomerCredits(customerId, storeId);
+        },
+        staleTime: 30 * 1000, // 30 seconds - fresher than most resources
+        refetchOnWindowFocus: true, // Refetch on window focus for up-to-date balance
+    });
+    // Redeem product mutation
+    const redeemMutation = useMutation({
+        mutationFn: async (redeemData) => {
+            return await creditsResource.redeemProduct(redeemData);
+        },
+        onSuccess: () => {
+            // Invalidate credits query to refetch updated balance
+            void queryClient.invalidateQueries({ queryKey });
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to redeem product with credits:', error);
+        },
+    });
+    // Helper functions
+    const hasEnoughCredits = useCallback((amount) => {
+        return (data?.balance ?? 0) >= amount;
+    }, [data?.balance]);
+    const getTransaction = useCallback((transactionId) => {
+        return data?.transactions.find((tx) => tx.id === transactionId);
+    }, [data?.transactions]);
+    const redeemProduct = useCallback(async (redeemData) => {
+        return await redeemMutation.mutateAsync(redeemData);
+    }, [redeemMutation]);
+    return {
+        balance: data?.balance ?? 0,
+        lifetimeEarned: data?.lifetimeEarned ?? 0,
+        lifetimeSpent: data?.lifetimeSpent ?? 0,
+        transactions: data?.transactions ?? [],
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        redeemProduct,
+        hasEnoughCredits,
+        getTransaction,
+        isRedeeming: redeemMutation.isPending,
+        redeemError: redeemMutation.error,
+    };
+}

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

@@ -1,3 +1,4 @@
+import { ReactNode } from 'react';
 import { LanguageCode } from '../../../data/languages';
 export type TranslationText = {
     [key in LanguageCode | string]?: string;
@@ -5,14 +6,22 @@ export type TranslationText = {
 export interface UseTranslationOptions {
     defaultLanguage?: string;
 }
-export type TranslateFunction = (text: TranslationText | string | undefined, fallback?: string, languageCode?: string) => string;
+export type TranslationParams = {
+    [key: string]: string | number | ((children: ReactNode) => ReactNode);
+};
+export interface TranslateFunction {
+    (text: TranslationText | string | undefined, fallback?: string): string;
+    (text: TranslationText | string | undefined, fallback: string | undefined, params: undefined, languageCode: string): string;
+    (text: TranslationText | string | undefined, fallback?: string, params?: TranslationParams, languageCode?: string): string | ReactNode;
+}
 export interface UseTranslationResult {
     /**
      * Translate function that handles multi-language text objects
      * @param text - The text to translate (can be a string or MultiLangText object)
      * @param fallback - Optional fallback text if translation is not found
+     * @param params - Optional parameters for string interpolation (e.g., {count: 10} for 'User has {count} points') or tag wrapping with functions (e.g., {i: (val) => <b>{val}</b>} for '<i>text</i>')
      * @param languageCode - Optional language code to override the current locale
-     * @returns The translated string
+     * @returns The translated string or ReactNode (when using function params for tag wrapping)
      */
     t: TranslateFunction;
     /**
@@ -39,8 +48,36 @@ export interface UseTranslationResult {
  * // With fallback
  * const withFallback = t(multiLangText, 'Default text');
  *
+ * // With params interpolation
+ * const withParams = t('User has {count} points', '', { count: 10 });
+ * // Result: 'User has 10 points'
+ *
+ * // Escaped brackets are treated as literal text
+ * const escaped = t('Use \\{count\\} as placeholder', '', { count: 10 });
+ * // Result: 'Use {count} as placeholder'
+ *
+ * // With function params for tag wrapping
+ * const withTags = t('This is <i>formatted</i>', '', {
+ *   i: (value) => <b>{value}</b>
+ * });
+ * // Result: ReactNode with <b>formatted</b>
+ *
+ * // Escaped tags are treated as literal text
+ * const escapedTags = t('This is \\<i>not formatted\\</i>', '', {
+ *   i: (value) => <b>{value}</b>
+ * });
+ * // Result: 'This is <i>not formatted</i>'
+ *
+ * // Mix of placeholders and tags
+ * const mixed = t('User {name} has <b>{count}</b> points', '', {
+ *   name: 'John',
+ *   count: 10,
+ *   b: (value) => <strong>{value}</strong>
+ * });
+ * // Result: ReactNode with 'User John has <strong>10</strong> points'
+ *
  * // Override locale
- * const inFrench = t(multiLangText, '', 'fr');
+ * const inFrench = t(multiLangText, '', undefined, 'fr');
  * ```
  */
 export declare const useTranslation: (options?: UseTranslationOptions) => UseTranslationResult;

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

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import React, { useCallback, useMemo } from 'react';
 /**
  * Hook for translating multi-language text objects
  *
@@ -18,8 +18,36 @@ import { useCallback, useMemo } from 'react';
  * // With fallback
  * const withFallback = t(multiLangText, 'Default text');
  *
+ * // With params interpolation
+ * const withParams = t('User has {count} points', '', { count: 10 });
+ * // Result: 'User has 10 points'
+ *
+ * // Escaped brackets are treated as literal text
+ * const escaped = t('Use \\{count\\} as placeholder', '', { count: 10 });
+ * // Result: 'Use {count} as placeholder'
+ *
+ * // With function params for tag wrapping
+ * const withTags = t('This is <i>formatted</i>', '', {
+ *   i: (value) => <b>{value}</b>
+ * });
+ * // Result: ReactNode with <b>formatted</b>
+ *
+ * // Escaped tags are treated as literal text
+ * const escapedTags = t('This is \\<i>not formatted\\</i>', '', {
+ *   i: (value) => <b>{value}</b>
+ * });
+ * // Result: 'This is <i>not formatted</i>'
+ *
+ * // Mix of placeholders and tags
+ * const mixed = t('User {name} has <b>{count}</b> points', '', {
+ *   name: 'John',
+ *   count: 10,
+ *   b: (value) => <strong>{value}</strong>
+ * });
+ * // Result: ReactNode with 'User John has <strong>10</strong> points'
+ *
  * // Override locale
- * const inFrench = t(multiLangText, '', 'fr');
+ * const inFrench = t(multiLangText, '', undefined, 'fr');
  * ```
  */
 export const useTranslation = (options = {}) => {
@@ -40,22 +68,106 @@ export const useTranslation = (options = {}) => {
         }
         return defaultLanguage;
     }, [defaultLanguage]);
-    const t = useCallback((text, fallback, languageCode) => {
+    const t = useCallback((text, fallback, params, languageCode) => {
+        // Helper function to interpolate params into the translated string
+        const interpolate = (str, params) => {
+            if (!params) {
+                // Even without params, we need to unescape any escaped characters
+                return str.replace(/\\([{}<>])/g, '$1');
+            }
+            // First, process tag-based interpolation for functions
+            // Match tags like <i>content</i> but not \<i>content</i>
+            const tagRegex = /(?<!\\)<(\w+)>(.*?)(?<!\\)<\/\1>/g;
+            const hasTags = tagRegex.test(str);
+            if (hasTags) {
+                // Reset regex lastIndex for reuse
+                tagRegex.lastIndex = 0;
+                const parts = [];
+                let lastIndex = 0;
+                let match;
+                let hasReactNodes = false;
+                while ((match = tagRegex.exec(str)) !== null) {
+                    const [fullMatch, tagName, content] = match;
+                    const param = params[tagName];
+                    // Add text before the match
+                    if (match.index > lastIndex) {
+                        parts.push(str.substring(lastIndex, match.index));
+                    }
+                    // If param is a function, call it with the content
+                    if (typeof param === 'function') {
+                        parts.push(param(content));
+                        hasReactNodes = true;
+                    }
+                    else {
+                        // If not a function, keep the original tag
+                        parts.push(fullMatch);
+                    }
+                    lastIndex = match.index + fullMatch.length;
+                }
+                // Add remaining text after last match
+                if (lastIndex < str.length) {
+                    parts.push(str.substring(lastIndex));
+                }
+                // If we have React nodes, process placeholder interpolation for each string part
+                if (hasReactNodes) {
+                    const processedParts = parts.map((part, index) => {
+                        if (typeof part === 'string') {
+                            // Process {key} placeholders in string parts
+                            let processed = Object.entries(params).reduce((acc, [key, value]) => {
+                                if (typeof value !== 'function') {
+                                    const regex = new RegExp(`(?<!\\\\)\\{${key}\\}`, 'g');
+                                    return acc.replace(regex, String(value));
+                                }
+                                return acc;
+                            }, part);
+                            // Unescape escaped characters
+                            processed = processed.replace(/\\([{}<>])/g, '$1');
+                            return processed;
+                        }
+                        return part;
+                    });
+                    // If only one part and it's a string, return as string
+                    if (processedParts.length === 1 && typeof processedParts[0] === 'string') {
+                        return processedParts[0];
+                    }
+                    // Return array of React nodes
+                    return processedParts.map((part, index) => typeof part === 'string' ? part : React.createElement('span', { key: index }, part));
+                }
+                // If no React nodes, continue with normal string processing
+                str = parts.join('');
+            }
+            // Process {key} placeholders for string/number values
+            let result = Object.entries(params).reduce((acc, [key, value]) => {
+                if (typeof value !== 'function') {
+                    const regex = new RegExp(`(?<!\\\\)\\{${key}\\}`, 'g');
+                    return acc.replace(regex, String(value));
+                }
+                return acc;
+            }, str);
+            // Remove escape characters from escaped characters (\{ -> {, \} -> }, \< -> <, \> -> >)
+            result = result.replace(/\\([{}<>])/g, '$1');
+            return result;
+        };
         if (!text)
-            return fallback || '';
+            return interpolate(fallback || '', params);
         if (typeof text === 'string')
-            return text;
+            return interpolate(text, params);
         const targetLocale = languageCode || locale;
-        if (text[targetLocale])
-            return text[targetLocale];
-        if (fallback)
-            return fallback;
-        if (text[defaultLanguage])
-            return text[defaultLanguage];
-        const firstAvailable = Object.values(text).find((value) => value !== undefined && value !== '');
-        if (firstAvailable)
-            return firstAvailable;
-        return '';
+        let translatedText = '';
+        if (text[targetLocale]) {
+            translatedText = text[targetLocale];
+        }
+        else if (fallback) {
+            translatedText = fallback;
+        }
+        else if (text[defaultLanguage]) {
+            translatedText = text[defaultLanguage];
+        }
+        else {
+            const firstAvailable = Object.values(text).find((value) => value !== undefined && value !== '');
+            translatedText = firstAvailable || '';
+        }
+        return interpolate(translatedText, params);
     }, [locale, defaultLanguage]);
     return { t, locale };
 };

package/dist/v2/react/index.d.ts

@@ -9,6 +9,7 @@ export { GooglePayButton } from './components/GooglePayButton';
 export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
 export { useClubOffers } from './hooks/useClubOffers';
+export { useCredits } from './hooks/useCredits';
 export { useCustomer } from './hooks/useCustomer';
 export { useCustomerInfos } from './hooks/useCustomerInfos';
 export { useCustomerOrders } from './hooks/useCustomerOrders';
@@ -39,6 +40,7 @@ export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
 export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';
 export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
 export type { ClubOffer, ClubOfferItem, ClubOfferLineItem, ClubOfferSummary, UseClubOffersOptions, UseClubOffersResult } from './hooks/useClubOffers';
+export type { UseCreditsOptions, UseCreditsResult } from './hooks/useCredits';
 export type { UseCustomerResult } from './hooks/useCustomer';
 export type { UseCustomerInfosOptions, UseCustomerInfosResult } from './hooks/useCustomerInfos';
 export type { UseCustomerOrdersOptions, UseCustomerOrdersResult } from './hooks/useCustomerOrders';

package/dist/v2/react/index.js

@@ -12,6 +12,7 @@ export { GooglePayButton } from './components/GooglePayButton';
 export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
 export { useClubOffers } from './hooks/useClubOffers';
+export { useCredits } from './hooks/useCredits';
 export { useCustomer } from './hooks/useCustomer';
 export { useCustomerInfos } from './hooks/useCustomerInfos';
 export { useCustomerOrders } from './hooks/useCustomerOrders';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.7.0",
+  "version": "2.7.3",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -63,6 +63,7 @@
     "@tanstack/react-query": "^5.90.2",
     "axios": "^1.10.0",
     "iso3166-2-db": "^2.3.11",
+    "path-to-regexp": "^8.2.0",
     "react-intl": "^7.1.11",
     "swr": "^2.3.6"
   },