@tagadapay/plugin-sdk 3.1.12 → 3.1.24

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(() => { });
+}

package/dist/data/languages.d.ts

@@ -1,81 +1,22 @@
-import type { SupportedLanguage } from './iso3166';
 /**
- * Import and register Russian language data
- * @example
- * import { importRussian } from '@tagadapay/plugin-sdk/data/languages';
- * await importRussian();
+ * Language import utilities — CDN-backed.
+ * All language-specific geodata is now fetched from Vercel Blob CDN,
+ * so these helpers are thin wrappers around ensureGeoDataLoaded().
  */
+import type { SupportedLanguage } from './iso3166';
 export declare function importRussian(): Promise<void>;
-/**
- * Import and register German language data
- */
 export declare function importGerman(): Promise<void>;
-/**
- * Import and register French language data
- */
 export declare function importFrench(): Promise<void>;
-/**
- * Import and register Spanish language data
- */
 export declare function importSpanish(): Promise<void>;
-/**
- * Import and register Chinese language data
- */
 export declare function importChinese(): Promise<void>;
-/**
- * Import and register Hindi language data
- */
 export declare function importHindi(): Promise<void>;
-/**
- * Import and register Portuguese language data
- */
 export declare function importPortuguese(): Promise<void>;
-/**
- * Import and register Japanese language data
- */
 export declare function importJapanese(): Promise<void>;
-/**
- * Import and register Arabic language data
- */
 export declare function importArabic(): Promise<void>;
-/**
- * Import and register Italian language data
- */
 export declare function importItalian(): Promise<void>;
-/**
- * Import and register Hebrew language data
- */
 export declare function importHebrew(): Promise<void>;
-/**
- * Language import functions mapping
- */
-export declare const languageImports: {
-    readonly ru: typeof importRussian;
-    readonly de: typeof importGerman;
-    readonly fr: typeof importFrench;
-    readonly es: typeof importSpanish;
-    readonly zh: typeof importChinese;
-    readonly hi: typeof importHindi;
-    readonly pt: typeof importPortuguese;
-    readonly ja: typeof importJapanese;
-    readonly ar: typeof importArabic;
-    readonly it: typeof importItalian;
-    readonly he: typeof importHebrew;
-};
-/**
- * Import multiple languages at once
- * @param languages - Array of language codes to import
- * @example
- * import { importLanguages } from '@tagadapay/plugin-sdk/data/languages';
- * await importLanguages(['ru', 'de', 'fr']);
- */
+export declare const languageImports: Record<string, () => Promise<void>>;
 export declare function importLanguages(languages: SupportedLanguage[]): Promise<void>;
-/**
- * Import all available languages (except English which is already imported)
- * @example
- * import { importAllLanguages } from '@tagadapay/plugin-sdk/data/languages';
- * await importAllLanguages();
- */
 export declare function importAllLanguages(): Promise<void>;
 export declare const LANGUAGES: {
     aa: {

package/dist/data/languages.js

@@ -1,153 +1,33 @@
-// Language import utilities for modular ISO data loading
-// This file provides convenient functions to import specific languages
-import { registerLanguage } from './iso3166';
 /**
- * Import and register Russian language data
- * @example
- * import { importRussian } from '@tagadapay/plugin-sdk/data/languages';
- * await importRussian();
- */
-export async function importRussian() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const ruDatabase = (await import('iso3166-2-db/i18n/dispute/UN/ru')).default;
-    registerLanguage('ru', ruDatabase);
-}
-/**
- * Import and register German language data
- */
-export async function importGerman() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const deDatabase = (await import('iso3166-2-db/i18n/dispute/UN/de')).default;
-    registerLanguage('de', deDatabase);
-}
-/**
- * Import and register French language data
- */
-export async function importFrench() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const frDatabase = (await import('iso3166-2-db/i18n/dispute/UN/fr')).default;
-    registerLanguage('fr', frDatabase);
-}
-/**
- * Import and register Spanish language data
- */
-export async function importSpanish() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const esDatabase = (await import('iso3166-2-db/i18n/dispute/UN/es')).default;
-    registerLanguage('es', esDatabase);
-}
-/**
- * Import and register Chinese language data
- */
-export async function importChinese() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const zhDatabase = (await import('iso3166-2-db/i18n/dispute/UN/zh')).default;
-    registerLanguage('zh', zhDatabase);
-}
-/**
- * Import and register Hindi language data
- */
-export async function importHindi() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const hiDatabase = (await import('iso3166-2-db/i18n/dispute/UN/hi')).default;
-    registerLanguage('hi', hiDatabase);
-}
-/**
- * Import and register Portuguese language data
- */
-export async function importPortuguese() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const ptDatabase = (await import('iso3166-2-db/i18n/dispute/UN/pt')).default;
-    registerLanguage('pt', ptDatabase);
-}
-/**
- * Import and register Japanese language data
- */
-export async function importJapanese() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const jaDatabase = (await import('iso3166-2-db/i18n/dispute/UN/ja')).default;
-    registerLanguage('ja', jaDatabase);
-}
-/**
- * Import and register Arabic language data
- */
-export async function importArabic() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const arDatabase = (await import('iso3166-2-db/i18n/dispute/UN/ar')).default;
-    registerLanguage('ar', arDatabase);
-}
-/**
- * Import and register Italian language data
- */
-export async function importItalian() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const itDatabase = (await import('iso3166-2-db/i18n/dispute/UN/it')).default;
-    registerLanguage('it', itDatabase);
-}
-/**
- * Import and register Hebrew language data
- */
-export async function importHebrew() {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - iso3166-2-db doesn't have TypeScript definitions
-    const heDatabase = (await import('iso3166-2-db/i18n/dispute/UN/he')).default;
-    registerLanguage('he', heDatabase);
-}
-/**
- * Language import functions mapping
+ * Language import utilities — CDN-backed.
+ * All language-specific geodata is now fetched from Vercel Blob CDN,
+ * so these helpers are thin wrappers around ensureGeoDataLoaded().
  */
+import { ensureGeoDataLoaded } from './iso3166';
+export async function importRussian() { await ensureGeoDataLoaded('ru'); }
+export async function importGerman() { await ensureGeoDataLoaded('de'); }
+export async function importFrench() { await ensureGeoDataLoaded('fr'); }
+export async function importSpanish() { await ensureGeoDataLoaded('es'); }
+export async function importChinese() { await ensureGeoDataLoaded('zh'); }
+export async function importHindi() { await ensureGeoDataLoaded('hi'); }
+export async function importPortuguese() { await ensureGeoDataLoaded('pt'); }
+export async function importJapanese() { await ensureGeoDataLoaded('ja'); }
+export async function importArabic() { await ensureGeoDataLoaded('ar'); }
+export async function importItalian() { await ensureGeoDataLoaded('it'); }
+export async function importHebrew() { await ensureGeoDataLoaded('he'); }
 export const languageImports = {
-    ru: importRussian,
-    de: importGerman,
-    fr: importFrench,
-    es: importSpanish,
-    zh: importChinese,
-    hi: importHindi,
-    pt: importPortuguese,
-    ja: importJapanese,
-    ar: importArabic,
-    it: importItalian,
-    he: importHebrew,
+    ru: importRussian, de: importGerman, fr: importFrench, es: importSpanish,
+    zh: importChinese, hi: importHindi, pt: importPortuguese, ja: importJapanese,
+    ar: importArabic, it: importItalian, he: importHebrew,
 };
-/**
- * Import multiple languages at once
- * @param languages - Array of language codes to import
- * @example
- * import { importLanguages } from '@tagadapay/plugin-sdk/data/languages';
- * await importLanguages(['ru', 'de', 'fr']);
- */
 export async function importLanguages(languages) {
-    const importPromises = languages
-        .filter(lang => lang !== 'en') // English is already imported
-        .map(lang => {
-        const importFn = languageImports[lang];
-        if (!importFn) {
-            console.warn(`No import function found for language: ${lang}`);
-            return Promise.resolve();
-        }
-        return importFn();
-    });
-    await Promise.all(importPromises);
+    await Promise.all(languages
+        .filter(lang => lang !== 'en')
+        .map(lang => ensureGeoDataLoaded(lang)));
 }
-/**
- * Import all available languages (except English which is already imported)
- * @example
- * import { importAllLanguages } from '@tagadapay/plugin-sdk/data/languages';
- * await importAllLanguages();
- */
 export async function importAllLanguages() {
-    const allLanguages = ['ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
-    await importLanguages(allLanguages);
+    const all = ['ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+    await importLanguages(all);
 }
 export const LANGUAGES = {
     aa: {