@tagadapay/plugin-sdk 2.1.3 → 2.2.0

package/dist/data/iso3166.d.ts

@@ -1,3 +1,5 @@
+export declare const AVAILABLE_LANGUAGES: readonly ["en", "ru", "de", "fr", "es", "zh", "hi", "pt", "ja", "ar", "it", "he"];
+export type SupportedLanguage = typeof AVAILABLE_LANGUAGES[number];
 export interface Country {
     code: string;
     name: string;
@@ -11,14 +13,14 @@ export interface State {
     countryCode: string;
     uniqueKey?: string;
 }
-export declare const getCountries: () => Country[];
-export declare const getAllStates: () => State[];
-export declare const getStatesForCountry: (countryCode: string) => State[];
-export declare const findCountryByName: (countryName: string) => Country | null;
-export declare const findRegionByCode: (regionCode: string) => State | null;
-export declare const isValidCountryCode: (countryCode: string) => boolean;
-export declare const isValidStateCode: (countryCode: string, stateCode: string) => boolean;
-export declare const getCountryWithRegions: (countryCode: string) => {
+export declare const getCountries: (language?: SupportedLanguage) => Country[];
+export declare const getAllStates: (language?: SupportedLanguage) => State[];
+export declare const getStatesForCountry: (countryCode: string, language?: SupportedLanguage) => State[];
+export declare const findCountryByName: (countryName: string, language?: SupportedLanguage) => Country | null;
+export declare const findRegionByCode: (regionCode: string, language?: SupportedLanguage) => State | null;
+export declare const isValidCountryCode: (countryCode: string, language?: SupportedLanguage) => boolean;
+export declare const isValidStateCode: (countryCode: string, stateCode: string, language?: SupportedLanguage) => boolean;
+export declare const getCountryWithRegions: (countryCode: string, language?: SupportedLanguage) => {
     country: {
         code: any;
         name: any;

package/dist/data/iso3166.js

@@ -1,11 +1,70 @@
-// Import the ISO3166 library API functions
+// Import static language databases for better browser compatibility
+// All supported languages from iso3166-2-db package
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-import { getDataSet, reduce } from 'iso3166-2-db';
-// Get the full dataset with default English language
-const worldDatabase = reduce(getDataSet(), 'en');
+import enDatabase from 'iso3166-2-db/i18n/dispute/UN/en';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import ruDatabase from 'iso3166-2-db/i18n/dispute/UN/ru';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import deDatabase from 'iso3166-2-db/i18n/dispute/UN/de';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import frDatabase from 'iso3166-2-db/i18n/dispute/UN/fr';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import esDatabase from 'iso3166-2-db/i18n/dispute/UN/es';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import zhDatabase from 'iso3166-2-db/i18n/dispute/UN/zh';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import hiDatabase from 'iso3166-2-db/i18n/dispute/UN/hi';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import ptDatabase from 'iso3166-2-db/i18n/dispute/UN/pt';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import jaDatabase from 'iso3166-2-db/i18n/dispute/UN/ja';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import arDatabase from 'iso3166-2-db/i18n/dispute/UN/ar';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import itDatabase from 'iso3166-2-db/i18n/dispute/UN/it';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
+import heDatabase from 'iso3166-2-db/i18n/dispute/UN/he';
+// All available languages from iso3166-2-db package
+export const AVAILABLE_LANGUAGES = ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+// Static language database mapping for all supported languages
+const languageDatabases = {
+    en: enDatabase, // English
+    ru: ruDatabase, // Russian
+    de: deDatabase, // German
+    fr: frDatabase, // French
+    es: esDatabase, // Spanish
+    zh: zhDatabase, // Chinese
+    hi: hiDatabase, // Hindi
+    pt: ptDatabase, // Portuguese
+    ja: jaDatabase, // Japanese
+    ar: arDatabase, // Arabic
+    it: itDatabase, // Italian
+    he: heDatabase, // Hebrew
+};
+// Function to get language-specific database
+function getWorldDatabase(language = 'en') {
+    const database = languageDatabases[language];
+    if (!database) {
+        console.warn(`Language ${language} not available, falling back to English`);
+        return languageDatabases.en;
+    }
+    return database;
+}
 // Transform the ISO3166 data into our expected format
-export const getCountries = () => {
+export const getCountries = (language = 'en') => {
+    const worldDatabase = getWorldDatabase(language);
     const countries = [];
     Object.keys(worldDatabase).forEach((countryCode) => {
         const countryData = worldDatabase[countryCode];
@@ -21,7 +80,8 @@ export const getCountries = () => {
     return countries.sort((a, b) => a.name.localeCompare(b.name));
 };
 // Get all states/regions for all countries
-export const getAllStates = () => {
+export const getAllStates = (language = 'en') => {
+    const worldDatabase = getWorldDatabase(language);
     const states = [];
     Object.keys(worldDatabase).forEach((countryCode) => {
         const countryData = worldDatabase[countryCode];
@@ -40,7 +100,8 @@ export const getAllStates = () => {
     return states.sort((a, b) => a.name.localeCompare(b.name));
 };
 // Get states for a specific country
-export const getStatesForCountry = (countryCode) => {
+export const getStatesForCountry = (countryCode, language = 'en') => {
+    const worldDatabase = getWorldDatabase(language);
     const countryData = worldDatabase[countryCode];
     if (!countryData?.regions || !Array.isArray(countryData.regions)) {
         return [];
@@ -55,8 +116,8 @@ export const getStatesForCountry = (countryCode) => {
         .sort((a, b) => a.name.localeCompare(b.name));
 };
 // Find country by name (fuzzy search)
-export const findCountryByName = (countryName) => {
-    const countries = getCountries();
+export const findCountryByName = (countryName, language = 'en') => {
+    const countries = getCountries(language);
     const normalizedSearchName = countryName.toLowerCase().trim();
     // Exact match first
     const exactMatch = countries.find((country) => country.name.toLowerCase() === normalizedSearchName);
@@ -68,24 +129,26 @@ export const findCountryByName = (countryName) => {
     return partialMatch ?? null;
 };
 // Find region by ISO code (e.g., "US-CA" for California)
-export const findRegionByCode = (regionCode) => {
+export const findRegionByCode = (regionCode, language = 'en') => {
     const [countryCode, stateCode] = regionCode.split('-');
     if (!countryCode || !stateCode)
         return null;
-    const states = getStatesForCountry(countryCode);
+    const states = getStatesForCountry(countryCode, language);
     return states.find((state) => state.code === stateCode) ?? null;
 };
 // Validate if a country code exists
-export const isValidCountryCode = (countryCode) => {
+export const isValidCountryCode = (countryCode, language = 'en') => {
+    const worldDatabase = getWorldDatabase(language);
     return Object.prototype.hasOwnProperty.call(worldDatabase, countryCode);
 };
 // Validate if a state code exists for a given country
-export const isValidStateCode = (countryCode, stateCode) => {
-    const states = getStatesForCountry(countryCode);
+export const isValidStateCode = (countryCode, stateCode, language = 'en') => {
+    const states = getStatesForCountry(countryCode, language);
     return states.some((state) => state.code === stateCode);
 };
 // Get country info including regions
-export const getCountryWithRegions = (countryCode) => {
+export const getCountryWithRegions = (countryCode, language = 'en') => {
+    const worldDatabase = getWorldDatabase(language);
     const countryData = worldDatabase[countryCode];
     if (!countryData)
         return null;
@@ -97,6 +160,6 @@ export const getCountryWithRegions = (countryCode) => {
             numeric: countryData.numeric,
             uniqueKey: `country-${countryData.iso}`,
         },
-        regions: getStatesForCountry(countryCode),
+        regions: getStatesForCountry(countryCode, language),
     };
 };

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

@@ -1,3 +1,4 @@
+import { type SupportedLanguage } from '../../data/iso3166';
 export interface ISOCountry {
     iso: string;
     iso3: string;
@@ -16,26 +17,26 @@ export interface UseISODataResult {
 }
 /**
  * React hook for accessing ISO3166 countries and regions data
- * @param language - Language code (en, fr, de, es, etc.)
- * @param disputeSetting - Territorial dispute perspective (UN, RU, UA, TR)
+ * @param language - Language code (supports: en, ru, de, fr, es, zh, hi, pt, ja, ar, it, he)
+ * @param disputeSetting - Territorial dispute perspective (currently only UN is supported)
  * @returns Object with countries data and helper functions
  */
-export declare function useISOData(language?: string, disputeSetting?: string): UseISODataResult;
+export declare function useISOData(language?: SupportedLanguage, disputeSetting?: string): UseISODataResult;
 /**
  * Get available languages for ISO data
  */
-export declare function getAvailableLanguages(): string[];
+export declare function getAvailableLanguages(): SupportedLanguage[];
 /**
  * Get list of countries as options for select components
  */
-export declare function useCountryOptions(language?: string): {
+export declare function useCountryOptions(language?: SupportedLanguage): {
     value: string;
     label: string;
 }[];
 /**
  * Get list of regions/states for a country as options for select components
  */
-export declare function useRegionOptions(countryCode: string, language?: string): {
+export declare function useRegionOptions(countryCode: string, language?: SupportedLanguage): {
     value: string;
     label: string;
 }[];

package/dist/react/hooks/useISOData.js

@@ -1,75 +1,35 @@
-import { useMemo, useState, useEffect } from 'react';
+import { useMemo } from 'react';
+// Import the pre-built ISO data functions
+import { getCountries, getStatesForCountry } from '../../data/iso3166';
 /**
  * React hook for accessing ISO3166 countries and regions data
- * @param language - Language code (en, fr, de, es, etc.)
- * @param disputeSetting - Territorial dispute perspective (UN, RU, UA, TR)
+ * @param language - Language code (supports: en, ru, de, fr, es, zh, hi, pt, ja, ar, it, he)
+ * @param disputeSetting - Territorial dispute perspective (currently only UN is supported)
  * @returns Object with countries data and helper functions
  */
 export function useISOData(language = 'en', disputeSetting = 'UN') {
-    const [isoModule, setIsoModule] = useState(null);
-    const [isLoading, setIsLoading] = useState(true);
-    useEffect(() => {
-        let isMounted = true;
-        const loadModule = async () => {
-            try {
-                // Try dynamic import first (ES modules)
-                const isoModule = await import('iso3166-2-db');
-                if (isMounted) {
-                    setIsoModule(isoModule);
-                    setIsLoading(false);
-                }
-            }
-            catch (importError) {
-                console.error(`Failed to load ISO data module:`, importError);
-                if (isMounted) {
-                    setIsoModule(null);
-                    setIsLoading(false);
-                }
-            }
-        };
-        void loadModule();
-        return () => {
-            isMounted = false;
-        };
-    }, []);
     const data = useMemo(() => {
-        if (isLoading || !isoModule) {
-            return {
-                countries: {},
-                getRegions: () => [],
-                findRegion: () => null,
-                mapGoogleToISO: () => null,
-            };
-        }
         try {
-            const { getDataSet, reduce } = isoModule;
-            // Get the dataset using the iso3166-2-db library
-            const worldDatabase = reduce(getDataSet(), language);
-            // Transform to our expected format
+            // Get countries from pre-built data with language support (now synchronous)
+            const countriesArray = getCountries(language);
+            // Transform to our expected format (Record<string, ISOCountry>)
             const countries = {};
-            Object.keys(worldDatabase).forEach((countryCode) => {
-                const countryData = worldDatabase[countryCode];
-                countries[countryData.iso] = {
-                    iso: countryData.iso,
-                    iso3: countryData.iso3,
-                    numeric: countryData.numeric,
-                    name: countryData.name,
+            countriesArray.forEach((country) => {
+                countries[country.code] = {
+                    iso: country.code,
+                    iso3: country.iso3 || '',
+                    numeric: country.numeric || 0,
+                    name: country.name,
                 };
             });
             // Helper to load regions for a specific country
             const getRegions = (countryCode) => {
                 try {
-                    const countryData = worldDatabase[countryCode];
-                    if (!countryData?.regions) {
-                        return [];
-                    }
-                    return Object.keys(countryData.regions).map((regionCode) => {
-                        const regionData = countryData.regions[regionCode];
-                        return {
-                            iso: regionData.iso,
-                            name: regionData.name,
-                        };
-                    });
+                    const states = getStatesForCountry(countryCode, language);
+                    return states.map((state) => ({
+                        iso: state.code,
+                        name: state.name,
+                    }));
                 }
                 catch {
                     return []; // Return empty array if no regions
@@ -117,14 +77,15 @@ export function useISOData(language = 'en', disputeSetting = 'UN') {
                 mapGoogleToISO: () => null,
             };
         }
-    }, [isoModule, isLoading, language, disputeSetting]);
+    }, [language, disputeSetting]);
     return data;
 }
 /**
  * Get available languages for ISO data
  */
 export function getAvailableLanguages() {
-    return ['en', 'fr', 'de', 'es', 'ru', 'zh', 'ar', 'it', 'pt', 'ja', 'hi'];
+    // Return all statically imported languages for browser compatibility
+    return ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
 }
 /**
  * Get list of countries as options for select components

package/package.json

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