@tagadapay/plugin-sdk 3.1.12 → 3.1.22

package/build-cdn.js

@@ -4,8 +4,10 @@
  * Build script for creating standalone CDN bundles
  * 
  * This creates:
- * - dist/external-tracker.min.js - Minified UMD bundle for CDN
+ * - dist/external-tracker.min.js - Minified UMD bundle for CDN (tracking only)
  * - dist/external-tracker.js - Non-minified for debugging
+ * - dist/tagada-sdk.min.js - Full standalone SDK bundle for CDN
+ * - dist/tagada-sdk.js - Non-minified for debugging
  * 
  * Usage:
  *   node build-cdn.js
@@ -14,16 +16,23 @@
 
 const esbuild = require('esbuild');
 const path = require('path');
+const fs = require('fs');
 
-const ENTRY_POINT = path.join(__dirname, 'src/v2/standalone/external-tracker.ts');
+const TRACKER_ENTRY = path.join(__dirname, 'src/v2/standalone/external-tracker.ts');
+const SDK_ENTRY = path.join(__dirname, 'src/v2/standalone/index.ts');
 const OUT_DIR = path.join(__dirname, 'dist');
 
 async function build() {
-  console.log('🔨 Building external-tracker CDN bundles...\n');
+  console.log('🔨 Building CDN bundles...\n');
 
+  // ==========================================================================
+  // EXTERNAL TRACKER (lightweight, tracking only)
+  // ==========================================================================
+  console.log('📦 Building external-tracker...');
+  
   // Build minified UMD bundle
   await esbuild.build({
-    entryPoints: [ENTRY_POINT],
+    entryPoints: [TRACKER_ENTRY],
     bundle: true,
     minify: true,
     sourcemap: true,
@@ -59,7 +68,7 @@ if (typeof window !== 'undefined' && TagadaTrackerBundle && TagadaTrackerBundle.
 
   // Build non-minified version for debugging
   await esbuild.build({
-    entryPoints: [ENTRY_POINT],
+    entryPoints: [TRACKER_ENTRY],
     bundle: true,
     minify: false,
     sourcemap: false,
@@ -90,19 +99,128 @@ if (typeof window !== 'undefined' && TagadaTrackerBundle && TagadaTrackerBundle.
 
   console.log('  ✅ dist/external-tracker.js (non-minified for debugging)');
 
+  // ==========================================================================
+  // FULL STANDALONE SDK (createTagadaClient, config loading, hot reload, etc.)
+  // ==========================================================================
+  console.log('\n📦 Building tagada-sdk (full standalone SDK)...');
+  
+  // Build minified SDK bundle
+  await esbuild.build({
+    entryPoints: [SDK_ENTRY],
+    bundle: true,
+    minify: true,
+    sourcemap: true,
+    target: ['es2018', 'chrome58', 'firefox57', 'safari11', 'edge79'],
+    format: 'iife',
+    globalName: 'TagadaSDKBundle',
+    outfile: path.join(OUT_DIR, 'tagada-sdk.min.js'),
+    external: [],
+    define: {
+      'process.env.NODE_ENV': '"production"',
+    },
+    footer: {
+      js: `
+// Expose SDK under window.tgd namespace (clean, single global)
+if (typeof window !== 'undefined' && TagadaSDKBundle) {
+  window.tgd = window.tgd || {};
+  // Core
+  window.tgd.createTagadaClient = TagadaSDKBundle.createTagadaClient;
+  // Config utilities
+  window.tgd.getPluginConfig = TagadaSDKBundle.getPluginConfig;
+  window.tgd.loadPluginConfig = TagadaSDKBundle.loadPluginConfig;
+  // Hot reload
+  window.tgd.onConfigUpdate = TagadaSDKBundle.onConfigUpdate;
+  window.tgd.sendConfigUpdate = TagadaSDKBundle.sendConfigUpdate;
+  window.tgd.broadcastConfigUpdate = TagadaSDKBundle.broadcastConfigUpdate;
+  // Currency
+  window.tgd.formatMoney = TagadaSDKBundle.formatMoney;
+  // Script injection (auto-runs on load, but can be manually called)
+  window.tgd.injectStepConfigScripts = TagadaSDKBundle.injectStepConfigScripts;
+  // Full bundle reference
+  window.tgd.sdk = TagadaSDKBundle;
+}
+      `.trim(),
+    },
+    banner: {
+      js: `/**
+ * TagadaPay SDK v${require('./package.json').version}
+ * CDN Bundle - Full standalone SDK for external/vanilla pages
+ * Usage: window.tgd.createTagadaClient(), window.tgd.formatMoney(), etc.
+ * @license MIT
+ */`,
+    },
+  });
+
+  console.log('  ✅ dist/tagada-sdk.min.js (minified + sourcemap)');
+
+  // Build non-minified SDK version for debugging
+  await esbuild.build({
+    entryPoints: [SDK_ENTRY],
+    bundle: true,
+    minify: false,
+    sourcemap: false,
+    target: ['es2018', 'chrome58', 'firefox57', 'safari11', 'edge79'],
+    format: 'iife',
+    globalName: 'TagadaSDKBundle',
+    outfile: path.join(OUT_DIR, 'tagada-sdk.js'),
+    external: [],
+    define: {
+      'process.env.NODE_ENV': '"development"',
+    },
+    footer: {
+      js: `
+// Expose SDK under window.tgd namespace (clean, single global)
+if (typeof window !== 'undefined' && TagadaSDKBundle) {
+  window.tgd = window.tgd || {};
+  window.tgd.createTagadaClient = TagadaSDKBundle.createTagadaClient;
+  window.tgd.getPluginConfig = TagadaSDKBundle.getPluginConfig;
+  window.tgd.loadPluginConfig = TagadaSDKBundle.loadPluginConfig;
+  window.tgd.onConfigUpdate = TagadaSDKBundle.onConfigUpdate;
+  window.tgd.sendConfigUpdate = TagadaSDKBundle.sendConfigUpdate;
+  window.tgd.broadcastConfigUpdate = TagadaSDKBundle.broadcastConfigUpdate;
+  window.tgd.formatMoney = TagadaSDKBundle.formatMoney;
+  window.tgd.injectStepConfigScripts = TagadaSDKBundle.injectStepConfigScripts;
+  window.tgd.sdk = TagadaSDKBundle;
+}
+      `.trim(),
+    },
+    banner: {
+      js: `/**
+ * TagadaPay SDK v${require('./package.json').version}
+ * CDN Bundle - Full standalone SDK (Debug Build)
+ * Usage: window.tgd.createTagadaClient(), window.tgd.formatMoney(), etc.
+ * @license MIT
+ */`,
+    },
+  });
+
+  console.log('  ✅ dist/tagada-sdk.js (non-minified for debugging)');
+
   // Get file sizes
-  const fs = require('fs');
-  const minSize = fs.statSync(path.join(OUT_DIR, 'external-tracker.min.js')).size;
-  const fullSize = fs.statSync(path.join(OUT_DIR, 'external-tracker.js')).size;
+  const trackerMinSize = fs.statSync(path.join(OUT_DIR, 'external-tracker.min.js')).size;
+  const trackerFullSize = fs.statSync(path.join(OUT_DIR, 'external-tracker.js')).size;
+  const sdkMinSize = fs.statSync(path.join(OUT_DIR, 'tagada-sdk.min.js')).size;
+  const sdkFullSize = fs.statSync(path.join(OUT_DIR, 'tagada-sdk.js')).size;
 
   console.log('\n📦 Bundle sizes:');
-  console.log(`   external-tracker.min.js: ${(minSize / 1024).toFixed(2)} KB`);
-  console.log(`   external-tracker.js:     ${(fullSize / 1024).toFixed(2)} KB`);
+  console.log(`   external-tracker.min.js: ${(trackerMinSize / 1024).toFixed(2)} KB`);
+  console.log(`   external-tracker.js:     ${(trackerFullSize / 1024).toFixed(2)} KB`);
+  console.log(`   tagada-sdk.min.js:       ${(sdkMinSize / 1024).toFixed(2)} KB`);
+  console.log(`   tagada-sdk.js:           ${(sdkFullSize / 1024).toFixed(2)} KB`);
 
   console.log('\n✨ CDN build complete!\n');
   console.log('Usage via CDN:');
+  console.log('');
+  console.log('  // External Tracker (lightweight, tracking only):');
   console.log('  <script src="https://cdn.jsdelivr.net/npm/@tagadapay/plugin-sdk/dist/external-tracker.min.js"></script>');
-  console.log('  <script>TagadaTracker.init({ storeId: "store_xxx", ... });</script>\n');
+  console.log('  <script>TagadaTracker.init({ storeId: "store_xxx", ... });</script>');
+  console.log('');
+  console.log('  // Full SDK (createTagadaClient, config, hot reload):');
+  console.log('  <script src="https://cdn.jsdelivr.net/npm/@tagadapay/plugin-sdk/dist/tagada-sdk.min.js"></script>');
+  console.log('  <script>');
+  console.log('    const client = createTagadaClient({ features: { funnel: true } });');
+  console.log('    client.subscribe((state) => console.log(state));');
+  console.log('  </script>\n');
 }
 
 build().catch((err) => {

package/dist/data/iso3166.d.ts

@@ -1,33 +1,16 @@
-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];
-/**
- * Register a language database for use
- * @param language - Language code
- * @param database - The language database from iso3166-2-db
- * @example
- * import ruDatabase from 'iso3166-2-db/i18n/dispute/UN/ru';
- * registerLanguage('ru', ruDatabase);
- */
-export declare function registerLanguage(language: SupportedLanguage, database: any): void;
-/**
- * Check if a language is registered
- * @param language - Language code to check
- * @returns true if the language is registered
- */
-export declare function isLanguageRegistered(language: SupportedLanguage): boolean;
-/**
- * Get list of registered languages
- * @returns Array of registered language codes
- */
-export declare function getRegisteredLanguages(): SupportedLanguage[];
 /**
- * Dynamically import and register a language
- * @param language - Language code to import
- * @returns Promise that resolves when language is registered
- * @example
- * await importLanguage('ru');
+ * Geodata — CDN-backed country/region data.
+ *
+ * Instead of bundling the 775KB iso3166-2-db package, we fetch slim JSON
+ * from Vercel Blob CDN on demand:
+ *   - countries.json (~10KB) — fetched once on first getCountries() call
+ *   - regions.json   (~95KB) — fetched lazily on first getStatesForCountry() call
+ *
+ * Both are cached in memory after first fetch. The API surface is identical
+ * to the previous static-import version so all consumers work unchanged.
  */
-export declare function importLanguage(language: SupportedLanguage): Promise<void>;
+export declare const AVAILABLE_LANGUAGES: readonly ["en", "ru", "de", "da", "fr", "es", "zh", "hi", "pt", "ja", "ar", "it", "he"];
+export type SupportedLanguage = typeof AVAILABLE_LANGUAGES[number];
 export interface Country {
     code: string;
     name: string;
@@ -41,20 +24,27 @@ export interface State {
     countryCode: string;
     uniqueKey?: string;
 }
+export declare function ensureCountriesLoaded(language?: SupportedLanguage): Promise<void>;
+export declare function ensureRegionsLoaded(language?: SupportedLanguage): Promise<void>;
+export declare function ensureGeoDataLoaded(language?: SupportedLanguage): Promise<void>;
 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 getAllStates: (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;
-        iso3: any;
-        numeric: any;
+        code: string;
+        name: string;
+        iso3: string | undefined;
+        numeric: number | undefined;
         uniqueKey: string;
     };
     regions: State[];
 } | null;
+export declare function registerLanguage(_language: SupportedLanguage, _database: any): void;
+export declare function isLanguageRegistered(language: SupportedLanguage): boolean;
+export declare function getRegisteredLanguages(): SupportedLanguage[];
+export declare function importLanguage(language: SupportedLanguage): Promise<void>;

package/dist/data/iso3166.js

@@ -1,230 +1,166 @@
-// Modular language database system - import only what you need
-// English is imported by default as fallback
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-import enDatabase from 'iso3166-2-db/i18n/dispute/UN/en';
-// All available languages from iso3166-2-db package
-export const AVAILABLE_LANGUAGES = ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
-// Dynamic language database registry - starts with English only
-const languageDatabases = {
-    en: enDatabase, // English (always available)
-};
 /**
- * Register a language database for use
- * @param language - Language code
- * @param database - The language database from iso3166-2-db
- * @example
- * import ruDatabase from 'iso3166-2-db/i18n/dispute/UN/ru';
- * registerLanguage('ru', ruDatabase);
+ * Geodata — CDN-backed country/region data.
+ *
+ * Instead of bundling the 775KB iso3166-2-db package, we fetch slim JSON
+ * from Vercel Blob CDN on demand:
+ *   - countries.json (~10KB) — fetched once on first getCountries() call
+ *   - regions.json   (~95KB) — fetched lazily on first getStatesForCountry() call
+ *
+ * Both are cached in memory after first fetch. The API surface is identical
+ * to the previous static-import version so all consumers work unchanged.
  */
-export function registerLanguage(language, database) {
-    if (!AVAILABLE_LANGUAGES.includes(language)) {
-        console.warn(`Language ${language} is not supported. Available languages: ${AVAILABLE_LANGUAGES.join(', ')}`);
-        return;
-    }
-    languageDatabases[language] = database;
+// CDN base serving the pre-built slim geodata (uploaded by scripts/build-geodata-cdn.ts)
+const GEODATA_CDN_BASE = 'https://cvwnizdbugpz6jwk.public.blob.vercel-storage.com/geodata/v1';
+export const AVAILABLE_LANGUAGES = ['en', 'ru', 'de', 'da', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+// ─── In-memory cache ─────────────────────────────────────────────────────────
+const countriesCache = new Map();
+const regionsCache = new Map();
+const inflightCountries = new Map();
+const inflightRegions = new Map();
+// ─── CDN fetchers (deduplicated, cached) ─────────────────────────────────────
+async function fetchCountriesRaw(language) {
+    const cached = countriesCache.get(language);
+    if (cached)
+        return cached;
+    // Deduplicate concurrent fetches for the same language
+    let inflight = inflightCountries.get(language);
+    if (inflight)
+        return inflight;
+    inflight = (async () => {
+        const url = `${GEODATA_CDN_BASE}/${language}/countries.json`;
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+        const data = await res.json();
+        countriesCache.set(language, data);
+        inflightCountries.delete(language);
+        return data;
+    })();
+    inflightCountries.set(language, inflight);
+    return inflight;
 }
-/**
- * Check if a language is registered
- * @param language - Language code to check
- * @returns true if the language is registered
- */
-export function isLanguageRegistered(language) {
-    return language in languageDatabases;
+async function fetchRegionsRaw(language) {
+    const cached = regionsCache.get(language);
+    if (cached)
+        return cached;
+    let inflight = inflightRegions.get(language);
+    if (inflight)
+        return inflight;
+    inflight = (async () => {
+        const url = `${GEODATA_CDN_BASE}/${language}/regions.json`;
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+        const data = await res.json();
+        regionsCache.set(language, data);
+        inflightRegions.delete(language);
+        return data;
+    })();
+    inflightRegions.set(language, inflight);
+    return inflight;
 }
-/**
- * Get list of registered languages
- * @returns Array of registered language codes
- */
-export function getRegisteredLanguages() {
-    return Object.keys(languageDatabases);
+// ─── Synchronous accessors (return cached data, empty if not yet loaded) ─────
+// These preserve the existing synchronous API. Consumers should call
+// ensureCountriesLoaded / ensureRegionsLoaded first (the useISOData hook does).
+function getCountriesCached(language) {
+    return countriesCache.get(language) || countriesCache.get('en') || {};
 }
-/**
- * Dynamically import and register a language
- * @param language - Language code to import
- * @returns Promise that resolves when language is registered
- * @example
- * await importLanguage('ru');
- */
-export async function importLanguage(language) {
-    if (isLanguageRegistered(language)) {
-        return; // Already registered
-    }
-    try {
-        let database;
-        switch (language) {
-            case 'ru':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/ru')).default;
-                break;
-            case 'de':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/de')).default;
-                break;
-            case 'fr':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/fr')).default;
-                break;
-            case 'es':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/es')).default;
-                break;
-            case 'zh':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/zh')).default;
-                break;
-            case 'hi':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/hi')).default;
-                break;
-            case 'pt':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/pt')).default;
-                break;
-            case 'ja':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/ja')).default;
-                break;
-            case 'ar':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/ar')).default;
-                break;
-            case 'it':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/it')).default;
-                break;
-            case 'he':
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-                database = (await import('iso3166-2-db/i18n/dispute/UN/he')).default;
-                break;
-            default:
-                throw new Error(`Language ${language} is not supported`);
-        }
-        registerLanguage(language, database);
-    }
-    catch (error) {
-        console.error(`Failed to import language ${language}:`, error);
-        throw new Error(`Failed to import language ${language}`);
-    }
+function getRegionsCached(language) {
+    return regionsCache.get(language) || regionsCache.get('en') || {};
 }
-// 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. Use importLanguage('${language}') to load it.`);
-        return languageDatabases.en;
-    }
-    return database;
+// ─── Public async loaders (call these before using sync getters) ─────────────
+export async function ensureCountriesLoaded(language = 'en') {
+    await fetchCountriesRaw(language);
 }
-// Transform the ISO3166 data into our expected format
+export async function ensureRegionsLoaded(language = 'en') {
+    await fetchRegionsRaw(language);
+}
+export async function ensureGeoDataLoaded(language = 'en') {
+    await Promise.all([fetchCountriesRaw(language), fetchRegionsRaw(language)]);
+}
+// ─── Backward-compatible sync API ────────────────────────────────────────────
+// These match the old iso3166.ts signatures exactly.
 export const getCountries = (language = 'en') => {
-    const worldDatabase = getWorldDatabase(language);
-    const countries = [];
-    Object.keys(worldDatabase).forEach((countryCode) => {
-        const countryData = worldDatabase[countryCode];
-        countries.push({
-            code: countryData.iso, // iso3166-1 alpha-2 code
-            name: countryData.name,
-            iso3: countryData.iso3, // iso3166-1 alpha-3 code
-            numeric: countryData.numeric,
-            uniqueKey: `country-${countryData.iso}`,
-        });
-    });
-    // Sort countries alphabetically by name
-    return countries.sort((a, b) => a.name.localeCompare(b.name));
-};
-// Get all states/regions for all countries
-export const getAllStates = (language = 'en') => {
-    const worldDatabase = getWorldDatabase(language);
-    const states = [];
-    Object.keys(worldDatabase).forEach((countryCode) => {
-        const countryData = worldDatabase[countryCode];
-        if (countryData.regions && Array.isArray(countryData.regions)) {
-            countryData.regions.forEach((region, index) => {
-                states.push({
-                    code: region.iso, // iso3166-2 code (the part after the dash)
-                    name: region.name,
-                    countryCode: countryData.iso,
-                    uniqueKey: `state-${countryData.iso}-${region.iso}-${index}`,
-                });
-            });
-        }
-    });
-    // Sort states alphabetically by name
-    return states.sort((a, b) => a.name.localeCompare(b.name));
+    const raw = getCountriesCached(language);
+    return Object.entries(raw)
+        .map(([code, c]) => ({
+        code,
+        name: c.n,
+        iso3: c.i3,
+        numeric: c.nu,
+        uniqueKey: `country-${code}`,
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
 };
-// Get states for a specific country
 export const getStatesForCountry = (countryCode, language = 'en') => {
-    const worldDatabase = getWorldDatabase(language);
-    const countryData = worldDatabase[countryCode];
-    if (!countryData?.regions || !Array.isArray(countryData.regions)) {
+    const raw = getRegionsCached(language);
+    const tuples = raw[countryCode];
+    if (!tuples)
         return [];
-    }
-    return countryData.regions
-        .map((region, index) => ({
-        code: region.iso,
-        name: region.name,
-        countryCode: countryData.iso,
-        uniqueKey: `state-${countryData.iso}-${region.iso}-${index}`,
+    return tuples
+        .map(([iso, name], i) => ({
+        code: iso,
+        name,
+        countryCode,
+        uniqueKey: `state-${countryCode}-${iso}-${i}`,
     }))
         .sort((a, b) => a.name.localeCompare(b.name));
 };
-// Find country by name (fuzzy search)
+export const getAllStates = (language = 'en') => {
+    const raw = getRegionsCached(language);
+    const states = [];
+    for (const [countryCode, tuples] of Object.entries(raw)) {
+        tuples.forEach(([iso, name], i) => {
+            states.push({ code: iso, name, countryCode, uniqueKey: `state-${countryCode}-${iso}-${i}` });
+        });
+    }
+    return states.sort((a, b) => a.name.localeCompare(b.name));
+};
 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);
-    if (exactMatch)
-        return exactMatch;
-    // Partial match
-    const partialMatch = countries.find((country) => country.name.toLowerCase().includes(normalizedSearchName) ||
-        normalizedSearchName.includes(country.name.toLowerCase()));
-    return partialMatch ?? null;
+    const needle = countryName.toLowerCase().trim();
+    return countries.find(c => c.name.toLowerCase() === needle)
+        || countries.find(c => c.name.toLowerCase().includes(needle) || needle.includes(c.name.toLowerCase()))
+        || null;
 };
-// Find region by ISO code (e.g., "US-CA" for California)
 export const findRegionByCode = (regionCode, language = 'en') => {
     const [countryCode, stateCode] = regionCode.split('-');
     if (!countryCode || !stateCode)
         return null;
-    const states = getStatesForCountry(countryCode, language);
-    return states.find((state) => state.code === stateCode) ?? null;
+    return getStatesForCountry(countryCode, language).find(s => s.code === stateCode) ?? null;
 };
-// Validate if a country code exists
 export const isValidCountryCode = (countryCode, language = 'en') => {
-    const worldDatabase = getWorldDatabase(language);
-    return Object.prototype.hasOwnProperty.call(worldDatabase, countryCode);
+    return countryCode in getCountriesCached(language);
 };
-// Validate if a state code exists for a given country
 export const isValidStateCode = (countryCode, stateCode, language = 'en') => {
-    const states = getStatesForCountry(countryCode, language);
-    return states.some((state) => state.code === stateCode);
+    return getStatesForCountry(countryCode, language).some(s => s.code === stateCode);
 };
-// Get country info including regions
 export const getCountryWithRegions = (countryCode, language = 'en') => {
-    const worldDatabase = getWorldDatabase(language);
-    const countryData = worldDatabase[countryCode];
-    if (!countryData)
+    const raw = getCountriesCached(language);
+    const c = raw[countryCode];
+    if (!c)
         return null;
     return {
-        country: {
-            code: countryData.iso,
-            name: countryData.name,
-            iso3: countryData.iso3,
-            numeric: countryData.numeric,
-            uniqueKey: `country-${countryData.iso}`,
-        },
+        country: { code: countryCode, name: c.n, iso3: c.i3, numeric: c.nu, uniqueKey: `country-${countryCode}` },
         regions: getStatesForCountry(countryCode, language),
     };
 };
+// ─── Language management (backward-compat) ───────────────────────────────────
+export function registerLanguage(_language, _database) {
+    // No-op: CDN mode doesn't need manual registration
+}
+export function isLanguageRegistered(language) {
+    return countriesCache.has(language);
+}
+export function getRegisteredLanguages() {
+    return [...countriesCache.keys()];
+}
+export async function importLanguage(language) {
+    await ensureGeoDataLoaded(language);
+}
+// ─── Prefetch ────────────────────────────────────────────────────────────────
+// Kick off English fetch the moment this module is imported so the country
+// dropdown is populated by the time the React tree renders.
+if (typeof globalThis !== 'undefined' && typeof fetch !== 'undefined') {
+    ensureGeoDataLoaded('en').catch(() => { });
+}