@tagadapay/plugin-sdk 2.4.10 → 2.4.14

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

@@ -0,0 +1,93 @@
+export interface ClubOfferItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    product: {
+        name: string;
+        description: string;
+    };
+    variant: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        grams: number;
+    };
+    unitAmount: number;
+    quantity: number;
+    amount: number;
+    adjustedAmount: number;
+}
+export interface ClubOfferSummary {
+    currency: string;
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    items: ClubOfferItem[];
+}
+export interface ClubOfferLineItem {
+    id: string;
+    quantity: number;
+    price: {
+        variant: {
+            id: string;
+            name: string;
+            description: string | null;
+            imageUrl: string;
+            grams: number;
+            product: {
+                id: string;
+                name: string;
+                description: string;
+            };
+        };
+    };
+}
+export interface ClubOffer {
+    id: string;
+    titleTrans: {
+        en: string;
+    };
+    summaries: ClubOfferSummary[];
+    offerLineItems: ClubOfferLineItem[];
+}
+export interface UseClubOffersOptions {
+    /**
+     * Whether to fetch club offers automatically on mount
+     * @default true
+     */
+    enabled?: boolean;
+}
+export interface UseClubOffersResult {
+    /**
+     * Array of fetched club offers
+     */
+    offers: ClubOffer[];
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Refetch club offers
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Get club offer by ID from the loaded offers
+     */
+    getOffer: (offerId: string) => ClubOffer | undefined;
+    /**
+     * Get total value of all club offers
+     */
+    getTotalValue: () => number;
+    /**
+     * Get total savings across all club offers
+     */
+    getTotalSavings: () => number;
+    /**
+     * Clear error state
+     */
+    clearError: () => void;
+}
+export declare function useClubOffers(options?: UseClubOffersOptions): UseClubOffersResult;

package/dist/react/hooks/useClubOffers.js

@@ -0,0 +1,71 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { usePluginConfig } from './usePluginConfig';
+export function useClubOffers(options = {}) {
+    const { apiService } = useTagadaContext();
+    const { storeId } = usePluginConfig();
+    const [offers, setOffers] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const { enabled = true } = options;
+    const clearError = useCallback(() => {
+        setError(null);
+    }, []);
+    const fetchClubOffers = useCallback(async () => {
+        if (!enabled)
+            return;
+        setIsLoading(true);
+        setError(null);
+        try {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            const responseData = await apiService.fetch(`/api/v1/stores/${storeId}/offers`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                params: {
+                    type: 'club',
+                },
+            });
+            setOffers(responseData.offers || []);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch club offers');
+            setError(error);
+            console.error('Error fetching club offers:', error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [apiService, storeId, enabled]);
+    const getOffer = useCallback((offerId) => {
+        return offers.find((offer) => offer.id === offerId);
+    }, [offers]);
+    const getTotalValue = useCallback(() => {
+        return offers.reduce((total, offer) => {
+            const firstSummary = offer.summaries[0];
+            return total + (firstSummary?.totalAdjustedAmount || 0);
+        }, 0);
+    }, [offers]);
+    const getTotalSavings = useCallback(() => {
+        return offers.reduce((total, offer) => {
+            const firstSummary = offer.summaries[0];
+            return total + (firstSummary?.totalAmount - firstSummary?.totalAdjustedAmount || 0);
+        }, 0);
+    }, [offers]);
+    useEffect(() => {
+        void fetchClubOffers();
+    }, [fetchClubOffers]);
+    return {
+        offers,
+        isLoading,
+        error,
+        refetch: fetchClubOffers,
+        getOffer,
+        getTotalValue,
+        getTotalSavings,
+        clearError,
+    };
+}

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

@@ -0,0 +1,137 @@
+export interface GeoLocationData {
+    ip_address?: string | null;
+    city?: string | null;
+    city_geoname_id?: number | null;
+    region?: string | null;
+    region_iso_code?: string | null;
+    region_geoname_id?: number | null;
+    postal_code?: string | null;
+    country?: string | null;
+    country_code?: string | null;
+    country_geoname_id?: number | null;
+    country_is_eu?: boolean | null;
+    continent?: string | null;
+    continent_code?: string | null;
+    continent_geoname_id?: number | null;
+    latitude?: number | null;
+    longitude?: number | null;
+    security?: {
+        is_vpn?: boolean | null;
+    } | null;
+    timezone?: {
+        name?: string | null;
+        abbreviation?: string | null;
+        gmt_offset?: number | null;
+        current_time?: string | null;
+        is_dst?: boolean | null;
+    } | null;
+    currency?: {
+        currency_name?: string | null;
+        currency_code?: string | null;
+    } | null;
+    connection?: {
+        autonomous_system_number?: number | null;
+        autonomous_system_organization?: string | null;
+        connection_type?: string | null;
+        isp_name?: string | null;
+        organization_name?: string | null;
+    } | null;
+    flag?: {
+        emoji?: string | null;
+        unicode?: string | null;
+        png?: string | null;
+        svg?: string | null;
+    } | null;
+    as?: string | null;
+    isp?: string | null;
+    lat?: number | null;
+    lon?: number | null;
+    org?: string | null;
+    query?: string | null;
+    regionName?: string | null;
+    status?: string | null;
+    zip?: string | null;
+    error?: string;
+}
+export interface UseGeoLocationOptions {
+    /**
+     * Whether to automatically fetch geolocation data on mount
+     * @default true
+     */
+    autoFetch?: boolean;
+    /**
+     * Custom IP address to fetch geolocation for
+     * If not provided, will use the client's IP
+     */
+    ip?: string;
+    /**
+     * Whether to refetch data when the hook mounts
+     * @default false
+     */
+    refetchOnMount?: boolean;
+}
+export interface UseGeoLocationReturn {
+    /**
+     * The geolocation data
+     */
+    data: GeoLocationData | null;
+    /**
+     * Whether the request is currently loading
+     */
+    isLoading: boolean;
+    /**
+     * Any error that occurred during the request
+     */
+    error: string | null;
+    /**
+     * Function to manually fetch geolocation data
+     */
+    fetchGeoData: (ip?: string) => Promise<void>;
+    /**
+     * Function to clear the current data and error state
+     */
+    clearData: () => void;
+    /**
+     * Whether the data is from localhost/development
+     */
+    isLocalhost: boolean;
+    /**
+     * Whether the current IP is valid
+     */
+    isValidIP: boolean;
+}
+/**
+ * Hook to fetch and manage geolocation data
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { data, isLoading, error, fetchGeoData } = useGeoLocation();
+ *
+ *   if (isLoading) return <div>Loading location...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Country: {data?.country}</p>
+ *       <p>City: {data?.city}</p>
+ *       <p>IP: {data?.ip_address}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { fetchGeoData } = useGeoLocation({ autoFetch: false });
+ *
+ *   const handleClick = () => {
+ *     fetchGeoData('8.8.8.8'); // Fetch for specific IP
+ *   };
+ *
+ *   return <button onClick={handleClick}>Get Location for Google DNS</button>;
+ * }
+ * ```
+ */
+export declare function useGeoLocation(options?: UseGeoLocationOptions): UseGeoLocationReturn;

package/dist/react/hooks/useGeoLocation.js

@@ -0,0 +1,125 @@
+'use client';
+import { useCallback, useEffect, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+/**
+ * Hook to fetch and manage geolocation data
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { data, isLoading, error, fetchGeoData } = useGeoLocation();
+ *
+ *   if (isLoading) return <div>Loading location...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       <p>Country: {data?.country}</p>
+ *       <p>City: {data?.city}</p>
+ *       <p>IP: {data?.ip_address}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { fetchGeoData } = useGeoLocation({ autoFetch: false });
+ *
+ *   const handleClick = () => {
+ *     fetchGeoData('8.8.8.8'); // Fetch for specific IP
+ *   };
+ *
+ *   return <button onClick={handleClick}>Get Location for Google DNS</button>;
+ * }
+ * ```
+ */
+export function useGeoLocation(options = {}) {
+    const { autoFetch = true, ip, refetchOnMount = false } = options;
+    const { apiService } = useTagadaContext();
+    const [data, setData] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    // Helper function to check if IP is localhost
+    const isLocalhost = useCallback((ipAddress) => {
+        if (!ipAddress)
+            return false;
+        return ipAddress === '127.0.0.1' || ipAddress === '::1' || ipAddress === 'localhost';
+    }, []);
+    // Helper function to validate IP address format
+    const isValidIP = useCallback((ipAddress) => {
+        if (!ipAddress)
+            return false;
+        // IPv4 regex pattern
+        const ipv4Pattern = /^(\d{1,3}\.){3}\d{1,3}$/;
+        // IPv6 regex pattern (simplified)
+        const ipv6Pattern = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+        if (!ipv4Pattern.test(ipAddress) && !ipv6Pattern.test(ipAddress)) {
+            return false;
+        }
+        // Additional validation for IPv4
+        if (ipv4Pattern.test(ipAddress)) {
+            const parts = ipAddress.split('.');
+            return parts.every((part) => {
+                const num = parseInt(part, 10);
+                return num >= 0 && num <= 255;
+            });
+        }
+        return true;
+    }, []);
+    // Function to fetch geolocation data
+    const fetchGeoData = useCallback(async (customIp) => {
+        if (!apiService) {
+            setError('API service not available');
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        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);
+        }
+    }, [apiService, ip]);
+    // Function to clear data and error state
+    const clearData = useCallback(() => {
+        setData(null);
+        setError(null);
+    }, []);
+    // Auto-fetch on mount if enabled
+    useEffect(() => {
+        if (autoFetch && apiService) {
+            fetchGeoData();
+        }
+    }, [autoFetch, apiService, fetchGeoData]);
+    // Refetch on mount if enabled
+    useEffect(() => {
+        if (refetchOnMount && apiService) {
+            fetchGeoData();
+        }
+    }, [refetchOnMount, apiService, fetchGeoData]);
+    return {
+        data,
+        isLoading,
+        error,
+        fetchGeoData,
+        clearData,
+        isLocalhost: isLocalhost(data?.ip_address),
+        isValidIP: isValidIP(data?.ip_address),
+    };
+}

package/dist/react/index.d.ts

@@ -4,10 +4,12 @@
 export { TagadaProvider } from './providers/TagadaProvider';
 export { useAuth } from './hooks/useAuth';
 export { useCheckout } from './hooks/useCheckout';
+export { useClubOffers } from './hooks/useClubOffers';
 export { useCurrency } from './hooks/useCurrency';
 export { useCustomer } from './hooks/useCustomer';
 export { useDiscounts } from './hooks/useDiscounts';
 export { useEnvironment } from './hooks/useEnvironment';
+export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { useLocale } from './hooks/useLocale';
 export { useLogin } from './hooks/useLogin';
@@ -25,6 +27,7 @@ export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath
 export type { PluginConfig } from './hooks/usePluginConfig';
 export { getAvailableLanguages, useCountryOptions, useISOData, useRegionOptions } from './hooks/useISOData';
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
+export type { GeoLocationData, UseGeoLocationOptions, UseGeoLocationReturn } from './hooks/useGeoLocation';
 export type { ExtractedAddress, GoogleAddressComponent, GooglePlaceDetails, GooglePrediction, UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult } from './hooks/useGoogleAutocomplete';
 export { useOrder } from './hooks/useOrder';
 export type { UseOrderOptions, UseOrderResult } from './hooks/useOrder';
@@ -39,6 +42,7 @@ export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSessio
 export type { Discount, DiscountCodeValidation, UseDiscountsOptions, UseDiscountsResult } from './hooks/useDiscounts';
 export type { OrderBumpPreview, UseOrderBumpOptions, UseOrderBumpResult } from './hooks/useOrderBump';
 export type { UseVipOffersOptions, UseVipOffersResult, VipOffer, VipPreviewResponse } from './hooks/useVipOffers';
+export type { ClubOffer, ClubOfferItem, ClubOfferLineItem, ClubOfferSummary, UseClubOffersOptions, UseClubOffersResult } from './hooks/useClubOffers';
 export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferLineItem, PostPurchaseOfferSummary, UsePostPurchasesOptions, UsePostPurchasesResult } from './hooks/usePostPurchases';
 export type { Payment, PaymentPollingHook, PollingOptions } from './hooks/usePaymentPolling';
 export type { PaymentInstrument, ThreedsChallenge, ThreedsHook, ThreedsOptions, ThreedsProvider, ThreedsSession } from './hooks/useThreeds';

package/dist/react/index.js

@@ -7,10 +7,12 @@ export { TagadaProvider } from './providers/TagadaProvider';
 // Hook exports
 export { useAuth } from './hooks/useAuth';
 export { useCheckout } from './hooks/useCheckout';
+export { useClubOffers } from './hooks/useClubOffers';
 export { useCurrency } from './hooks/useCurrency';
 export { useCustomer } from './hooks/useCustomer';
 export { useDiscounts } from './hooks/useDiscounts';
 export { useEnvironment } from './hooks/useEnvironment';
+export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { useLocale } from './hooks/useLocale';
 export { useLogin } from './hooks/useLogin';

package/package.json

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