@tagadapay/plugin-sdk 2.4.9 → 2.4.12

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/hooks/useShippingRates.js

@@ -63,7 +63,16 @@ export const useShippingRates = ({ onSuccess, checkout } = {}) => {
                 },
             });
             if (isMountedRef.current) {
-                setShippingRates(response.rates);
+                // Order rates: free ones first, then by ascending amount
+                setShippingRates(response.rates
+                    .slice()
+                    .sort((a, b) => {
+                    if (a.isFree && !b.isFree)
+                        return -1;
+                    if (!a.isFree && b.isFree)
+                        return 1;
+                    return (a.amount ?? 0) - (b.amount ?? 0);
+                }));
             }
         }
         catch (err) {

package/dist/react/index.d.ts

@@ -8,6 +8,7 @@ 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 +26,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';

package/dist/react/index.js

@@ -11,6 +11,7 @@ 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.9",
+  "version": "2.4.12",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",