@tagadapay/plugin-sdk 2.6.18 → 2.7.2

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

@@ -0,0 +1,53 @@
+export interface UseLoginOptions {
+    /**
+     * Callback when login is successful
+     */
+    onSuccess?: (token: string) => void;
+    /**
+     * Callback when an error occurs
+     */
+    onError?: (error: Error) => void;
+}
+export interface UseLoginResult {
+    /**
+     * Request verification code for email
+     */
+    requestCode: (email: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Verify code and complete login
+     */
+    verifyCode: (email: string, code: string) => Promise<{
+        success: boolean;
+        token?: string;
+        sessionId?: string;
+        error?: string;
+    }>;
+    /**
+     * Combined loading state (true if either request or verify is loading)
+     */
+    isLoading: boolean;
+    /**
+     * Loading state for request code
+     */
+    isRequestingCode: boolean;
+    /**
+     * Loading state for verify code
+     */
+    isVerifyingCode: boolean;
+    /**
+     * Combined error state
+     */
+    error: Error | null;
+    /**
+     * Error from request code
+     */
+    requestCodeError: Error | null;
+    /**
+     * Error from verify code
+     */
+    verifyCodeError: Error | null;
+}
+export declare function useLogin(options?: UseLoginOptions): UseLoginResult;

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

@@ -0,0 +1,75 @@
+'use client';
+/**
+ * useLogin - Hook for authentication (v2)
+ * Handles email/code authentication flow
+ */
+import { useMutation } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { setClientToken } from '../../../react/utils/tokenStorage';
+import { SessionResource } from '../../core/resources/session';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useLogin(options = {}) {
+    const { onSuccess, onError } = options;
+    const { storeId } = usePluginConfig();
+    // Create session resource client
+    const sessionResource = useMemo(() => {
+        try {
+            return new SessionResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize session resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Request code mutation
+    const requestCodeMutation = useMutation({
+        mutationFn: async (email) => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            return await sessionResource.requestCode(email, storeId);
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to request code:', error);
+            onError?.(error);
+        },
+    });
+    // Verify code mutation
+    const verifyCodeMutation = useMutation({
+        mutationFn: async ({ email, code }) => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            const result = await sessionResource.verifyCode(email, code, storeId);
+            if (result.success && result.token) {
+                // Store the token
+                setClientToken(result.token);
+                // Call success callback
+                onSuccess?.(result.token);
+            }
+            return result;
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to verify code:', error);
+            onError?.(error);
+        },
+    });
+    // Action functions
+    const requestCode = useCallback(async (email) => {
+        return await requestCodeMutation.mutateAsync(email);
+    }, [requestCodeMutation]);
+    const verifyCode = useCallback(async (email, code) => {
+        return await verifyCodeMutation.mutateAsync({ email, code });
+    }, [verifyCodeMutation]);
+    return {
+        requestCode,
+        verifyCode,
+        isLoading: requestCodeMutation.isPending || verifyCodeMutation.isPending,
+        isRequestingCode: requestCodeMutation.isPending,
+        isVerifyingCode: verifyCodeMutation.isPending,
+        error: requestCodeMutation.error || verifyCodeMutation.error,
+        requestCodeError: requestCodeMutation.error,
+        verifyCodeError: verifyCodeMutation.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 = {}) => {
@@ -29,7 +57,7 @@ export const useTranslation = (options = {}) => {
         // Check for language query parameter
         if (typeof window !== 'undefined') {
             const urlParams = new URLSearchParams(window.location.search);
-            const langFromQuery = urlParams.get('language');
+            const langFromQuery = urlParams.get('locale');
             if (langFromQuery)
                 return langFromQuery;
         }
@@ -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

@@ -6,11 +6,19 @@ export { ExpressPaymentMethodsProvider } from './providers/ExpressPaymentMethods
 export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
 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';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
+export { useLogin } from './hooks/useLogin';
 export { usePluginConfig } from './hooks/usePluginConfig';
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
 export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
@@ -27,18 +35,28 @@ export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRa
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useTranslation } from './hooks/useTranslation';
 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';
+export type { UseCustomerSubscriptionsOptions, UseCustomerSubscriptionsResult } from './hooks/useCustomerSubscriptions';
 export type { ExpressPaymentMethodsContextType, ExpressPaymentMethodsProviderProps } from './hooks/useExpressPaymentMethods';
+export type { UseLoginOptions, UseLoginResult } from './hooks/useLogin';
 export type { ApplePayButtonProps } from './components/ApplePayButton';
 export type { GooglePayButtonProps } from './components/GooglePayButton';
 export type { GeoLocationData, UseGeoLocationOptions, UseGeoLocationReturn } from './hooks/useGeoLocation';
 export type { ExtractedAddress, GooglePlaceDetails, GooglePrediction, UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult } from './hooks/useGoogleAutocomplete';
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
 export type { UsePluginConfigOptions, UsePluginConfigResult } from './hooks/usePluginConfig';
+export type { TranslateFunction, UseTranslationOptions, UseTranslationResult } from './hooks/useTranslation';
 export type { UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
 export type { UseDiscountsQueryOptions as UseDiscountsOptions, UseDiscountsQueryResult as UseDiscountsResult } from './hooks/useDiscountsQuery';
+export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext, UseFunnelOptions, UseFunnelResult } from './hooks/useFunnel';
 export type { UseOffersQueryOptions as UseOffersOptions, UseOffersQueryResult as UseOffersResult } from './hooks/useOffersQuery';
 export type { UseOrderBumpQueryOptions as UseOrderBumpOptions, UseOrderBumpQueryResult as UseOrderBumpResult } from './hooks/useOrderBumpQuery';
 export type { UseOrderQueryOptions as UseOrderOptions, UseOrderQueryResult as UseOrderResult } from './hooks/useOrderQuery';
@@ -50,6 +68,5 @@ export type { UseShippingRatesQueryOptions as UseShippingRatesOptions, UseShippi
 export type { UseStoreConfigQueryOptions as UseStoreConfigOptions, UseStoreConfigQueryResult as UseStoreConfigResult } from './hooks/useStoreConfigQuery';
 export type { PaymentInstrument, ThreedsChallenge, ThreedsHook, ThreedsOptions, ThreedsProvider, ThreedsSession } from './hooks/useThreeds';
 export type { UseVipOffersQueryOptions as UseVipOffersOptions, UseVipOffersQueryResult as UseVipOffersResult } from './hooks/useVipOffersQuery';
-export type { UseFunnelOptions, UseFunnelResult, FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext } from './hooks/useFunnel';
 export { formatMoney } from '../../react/utils/money';
 export type OrderItem = import('../core/utils/order').OrderLineItem;

package/dist/v2/react/index.js

@@ -9,11 +9,19 @@ export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
 export { GooglePayButton } from './components/GooglePayButton';
 // Hooks
+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';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
+export { useLogin } from './hooks/useLogin';
 export { usePluginConfig } from './hooks/usePluginConfig';
 // TanStack Query hooks (recommended)
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
@@ -31,6 +39,7 @@ export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRa
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
 // Funnel hooks
 export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.6.18",
+  "version": "2.7.2",
   "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"
   },

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

@@ -1,79 +0,0 @@
-/**
- * Single Discount Hook using TanStack Query
- * Fetches a specific discount for a given store
- */
-import { UseQueryResult } from '@tanstack/react-query';
-export interface StoreDiscountRuleAmount {
-    rate: number;
-    amount: number;
-    lock: boolean;
-    date: string;
-}
-export interface StoreDiscountRule {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    promotionId: string;
-    type: string;
-    productId: string | null;
-    minimumQuantity: number | null;
-    minimumAmount: Record<string, StoreDiscountRuleAmount> | null;
-    variantIds: string[] | null;
-}
-export interface StoreDiscountAction {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    promotionId: string;
-    type: string;
-    adjustmentAmount: number | null;
-    adjustmentPercentage: number | null;
-    adjustmentType: string | null;
-    freeShipping: boolean | null;
-    priceIdToAdd: string | null;
-    productIdToAdd: string | null;
-    variantIdToAdd: string | null;
-    subscriptionFreeTrialDuration: number | null;
-    subscriptionFreeTrialDurationType: string | null;
-    targetProductId: string | null;
-    targetVariantIds: string[] | null;
-    maxQuantityDiscounted: number | null;
-    appliesOnEachItem: boolean | null;
-}
-export interface StoreDiscount {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    storeId: string;
-    accountId: string;
-    name: string;
-    code: string;
-    automatic: boolean;
-    usageLimit: number | null;
-    usageCount: number;
-    startDate: string;
-    endDate: string | null;
-    enabled: boolean;
-    archived: boolean;
-    ruleOperator: string;
-    externalId: string | null;
-    combinesWithOrderLevelDiscounts: boolean;
-    combinesWithLineItemDiscounts: boolean;
-    combinesWithShippingDiscounts: boolean;
-    forceCombine: boolean;
-    isTemporary: boolean;
-    rules: StoreDiscountRule[];
-    actions: StoreDiscountAction[];
-}
-export interface UseDiscountQueryOptions {
-    storeId?: string;
-    discountId?: string;
-    enabled?: boolean;
-}
-export interface UseDiscountQueryResult<TData = StoreDiscount> {
-    discount: TData | undefined;
-    isLoading: boolean;
-    error: Error | null;
-    refetch: UseQueryResult<TData>['refetch'];
-}
-export declare function useDiscountQuery<TData = StoreDiscount>(options: UseDiscountQueryOptions): UseDiscountQueryResult<TData>;

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

@@ -1,24 +0,0 @@
-/**
- * Single Discount Hook using TanStack Query
- * Fetches a specific discount for a given store
- */
-import { useMemo } from 'react';
-import { useApiQuery } from './useApiQuery';
-import { usePluginConfig } from './usePluginConfig';
-export function useDiscountQuery(options) {
-    const { storeId: storeIdFromConfig } = usePluginConfig();
-    const { storeId = storeIdFromConfig, discountId, enabled = true } = options;
-    const key = useMemo(() => ['discount', storeId, discountId], [storeId, discountId]);
-    const url = useMemo(() => {
-        if (!storeId || !discountId)
-            return null;
-        return `/api/v1/stores/${storeId}/discounts/${discountId}`;
-    }, [storeId, discountId]);
-    const query = useApiQuery(key, url, { enabled });
-    return {
-        discount: query.data,
-        isLoading: query.isLoading,
-        error: query.error || null,
-        refetch: query.refetch,
-    };
-}