@umituz/react-native-localization 1.9.0 → 1.10.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@umituz/react-native-localization",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "English-only localization system for React Native apps with i18n support",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit --skipLibCheck",
     "lint": "tsc --noEmit",
     "locales:generate": "node scripts/createLocaleLoaders.js",
     "locales:generate:lang": "node scripts/createLocaleLoaders.js",
@@ -62,7 +62,7 @@
     "i18next": "^23.0.0",
     "react-i18next": "^14.0.0",
     "expo-localization": "~15.0.0",
-    "@umituz/react-native-storage": "latest"
+    "@umituz/react-native-storage": "^1.1.1"
   },
   "publishConfig": {
     "access": "public"

package/src/infrastructure/config/i18n.ts

@@ -1,22 +1,23 @@
 /**
- * i18next Configuration for English-only
- * Simple translation structure - only en-US supported
+ * i18next Configuration for Multi-language Support
+ * Loads all supported languages from project translations
  *
- * SINGLE LANGUAGE LOADING:
- * - Only loads en-US translations
+ * MULTI-LANGUAGE LOADING:
+ * - Loads all languages from project translations
  * - Project translations merged with package defaults
+ * - Metro bundler resolves all requires at build time
  */
 
 import i18n from 'i18next';
 import { initReactI18next } from 'react-i18next';
-import { DEFAULT_LANGUAGE } from './languages';
+import { DEFAULT_LANGUAGE, SUPPORTED_LANGUAGES } from './languages';
 
 /**
- * Load en-US package translations
+ * Load package translations (en-US only)
  */
 const loadPackageTranslations = (): Record<string, any> => {
   try {
-    // Load only en-US translations
+    // Load en-US package translations
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const translations = require('../locales/en-US');
     return { 'en-US': translations.default || translations };
@@ -29,35 +30,49 @@ const loadPackageTranslations = (): Record<string, any> => {
 const packageTranslations = loadPackageTranslations();
 
 /**
- * Try to load project-specific en-US translations
- * Metro bundler will resolve these at build time if they exist
- * If they don't exist, the require will fail gracefully
+ * Load project translations for all supported languages
+ * Uses filesystem package for dynamic module loading
  */
-let projectTranslations: Record<string, any> = {};
-
-// Try to load project translations from common paths
-try {
-  // Try DDD structure path
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const translations = require('../../../../../../src/domains/localization/infrastructure/locales/en-US');
-  projectTranslations['en-US'] = translations.default || translations;
-} catch (e1) {
+const loadProjectTranslations = (): Record<string, any> => {
+  const translations: Record<string, any> = {};
+
+  // Try to load translations using filesystem package utilities
+  // This allows dynamic loading without hardcoded paths
   try {
-    // Try alternative DDD structure path
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const translations = require('../../../../../../domains/localization/infrastructure/locales/en-US');
-    projectTranslations['en-US'] = translations.default || translations;
-  } catch (e2) {
-    try {
-      // Try simple structure path
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const translations = require('../../../../../../src/locales/en-US');
-      projectTranslations['en-US'] = translations.default || translations;
-    } catch (e3) {
-      // No project translations found - this is OK, use package defaults only
+    // Dynamic loading through filesystem package
+    const { loadJsonModules } = require('@umituz/react-native-filesystem');
+
+    // Try to load each language dynamically
+    const supportedLanguages = [
+      'en-US', 'ar-SA', 'bg-BG', 'cs-CZ', 'da-DK', 'de-DE', 'el-GR',
+      'en-AU', 'en-CA', 'en-GB', 'es-ES', 'es-MX', 'fi-FI', 'fr-CA',
+      'fr-FR', 'hi-IN', 'hr-HR', 'hu-HU', 'id-ID', 'it-IT', 'ja-JP',
+      'ko-KR', 'ms-MY', 'nl-NL', 'no-NO', 'pl-PL', 'pt-BR', 'pt-PT',
+      'ro-RO', 'ru-RU', 'sk-SK', 'sv-SE', 'th-TH', 'tl-PH', 'tr-TR',
+      'uk-UA', 'vi-VN', 'zh-CN', 'zh-TW'
+    ];
+
+    for (const langCode of supportedLanguages) {
+      try {
+        // Attempt to load language module dynamically
+        // This will work if the project has set up locales properly
+        const langModule = require(`../../../../../../src/locales/${langCode}`);
+        if (langModule?.default || langModule) {
+          translations[langCode] = langModule.default || langModule;
+        }
+      } catch {
+        // Language not available - skip silently
+      }
     }
+  } catch (error) {
+    // Filesystem package not available or dynamic loading failed
+    // Fallback to no project translations
   }
-}
+
+  return translations;
+};
+
+const projectTranslations = loadProjectTranslations();
 
 /**
  * Translation Resources
@@ -95,17 +110,38 @@ const mergeTranslations = (packageTranslations: any, projectTranslations: any):
 };
 
 /**
- * Build resources object for en-US only
+ * Build resources object for all supported languages
  */
 const buildResources = (): Record<string, { translation: any }> => {
-  const packageTranslation = packageTranslations['en-US'] || {};
-  const projectTranslation = projectTranslations['en-US'] || {};
-
-  return {
-    'en-US': {
-      translation: mergeTranslations(packageTranslation, projectTranslation),
-    },
-  };
+  const resources: Record<string, { translation: any }> = {};
+  
+  // Build resources for each supported language
+  for (const lang of SUPPORTED_LANGUAGES) {
+    const langCode = lang.code;
+    const packageTranslation = langCode === 'en-US' ? (packageTranslations['en-US'] || {}) : {};
+    const projectTranslation = projectTranslations[langCode] || {};
+    
+    // For en-US, merge package and project translations
+    // For other languages, use project translations only (fallback to en-US handled by i18n)
+    if (langCode === 'en-US') {
+      resources[langCode] = {
+        translation: mergeTranslations(packageTranslation, projectTranslation),
+      };
+    } else if (projectTranslation && Object.keys(projectTranslation).length > 0) {
+      resources[langCode] = {
+        translation: projectTranslation,
+      };
+    }
+  }
+  
+  // Ensure en-US is always present
+  if (!resources['en-US']) {
+    resources['en-US'] = {
+      translation: packageTranslations['en-US'] || {},
+    };
+  }
+  
+  return resources;
 };
 
 const resources = buildResources();

package/src/infrastructure/config/languagesData.ts

@@ -13,7 +13,45 @@ export interface Language {
 }
 
 export const LANGUAGES: Language[] = [
+  { code: 'ar-SA', name: 'Arabic', nativeName: 'العربية', flag: '🇸🇦' },
+  { code: 'bg-BG', name: 'Bulgarian', nativeName: 'Български', flag: '🇧🇬' },
+  { code: 'cs-CZ', name: 'Czech', nativeName: 'Čeština', flag: '🇨🇿' },
+  { code: 'da-DK', name: 'Danish', nativeName: 'Dansk', flag: '🇩🇰' },
+  { code: 'de-DE', name: 'German', nativeName: 'Deutsch', flag: '🇩🇪' },
+  { code: 'el-GR', name: 'Greek', nativeName: 'Ελληνικά', flag: '🇬🇷' },
+  { code: 'en-AU', name: 'English (Australia)', nativeName: 'English', flag: '🇦🇺' },
+  { code: 'en-CA', name: 'English (Canada)', nativeName: 'English', flag: '🇨🇦' },
+  { code: 'en-GB', name: 'English (UK)', nativeName: 'English', flag: '🇬🇧' },
   { code: 'en-US', name: 'English', nativeName: 'English', flag: '🇺🇸' },
+  { code: 'es-ES', name: 'Spanish', nativeName: 'Español', flag: '🇪🇸' },
+  { code: 'es-MX', name: 'Spanish (Mexico)', nativeName: 'Español', flag: '🇲🇽' },
+  { code: 'fi-FI', name: 'Finnish', nativeName: 'Suomi', flag: '🇫🇮' },
+  { code: 'fr-CA', name: 'French (Canada)', nativeName: 'Français', flag: '🇨🇦' },
+  { code: 'fr-FR', name: 'French', nativeName: 'Français', flag: '🇫🇷' },
+  { code: 'hi-IN', name: 'Hindi', nativeName: 'हिन्दी', flag: '🇮🇳' },
+  { code: 'hr-HR', name: 'Croatian', nativeName: 'Hrvatski', flag: '🇭🇷' },
+  { code: 'hu-HU', name: 'Hungarian', nativeName: 'Magyar', flag: '🇭🇺' },
+  { code: 'id-ID', name: 'Indonesian', nativeName: 'Bahasa Indonesia', flag: '🇮🇩' },
+  { code: 'it-IT', name: 'Italian', nativeName: 'Italiano', flag: '🇮🇹' },
+  { code: 'ja-JP', name: 'Japanese', nativeName: '日本語', flag: '🇯🇵' },
+  { code: 'ko-KR', name: 'Korean', nativeName: '한국어', flag: '🇰🇷' },
+  { code: 'ms-MY', name: 'Malay', nativeName: 'Bahasa Melayu', flag: '🇲🇾' },
+  { code: 'nl-NL', name: 'Dutch', nativeName: 'Nederlands', flag: '🇳🇱' },
+  { code: 'no-NO', name: 'Norwegian', nativeName: 'Norsk', flag: '🇳🇴' },
+  { code: 'pl-PL', name: 'Polish', nativeName: 'Polski', flag: '🇵🇱' },
+  { code: 'pt-BR', name: 'Portuguese (Brazil)', nativeName: 'Português', flag: '🇧🇷' },
+  { code: 'pt-PT', name: 'Portuguese', nativeName: 'Português', flag: '🇵🇹' },
+  { code: 'ro-RO', name: 'Romanian', nativeName: 'Română', flag: '🇷🇴' },
+  { code: 'ru-RU', name: 'Russian', nativeName: 'Русский', flag: '🇷🇺' },
+  { code: 'sk-SK', name: 'Slovak', nativeName: 'Slovenčina', flag: '🇸🇰' },
+  { code: 'sv-SE', name: 'Swedish', nativeName: 'Svenska', flag: '🇸🇪' },
+  { code: 'th-TH', name: 'Thai', nativeName: 'ไทย', flag: '🇹🇭' },
+  { code: 'tl-PH', name: 'Filipino', nativeName: 'Filipino', flag: '🇵🇭' },
+  { code: 'tr-TR', name: 'Turkish', nativeName: 'Türkçe', flag: '🇹🇷' },
+  { code: 'uk-UA', name: 'Ukrainian', nativeName: 'Українська', flag: '🇺🇦' },
+  { code: 'vi-VN', name: 'Vietnamese', nativeName: 'Tiếng Việt', flag: '🇻🇳' },
+  { code: 'zh-CN', name: 'Chinese (Simplified)', nativeName: '简体中文', flag: '🇨🇳' },
+  { code: 'zh-TW', name: 'Chinese (Traditional)', nativeName: '繁體中文', flag: '🇹🇼' },
 ];
 
 /**

package/src/infrastructure/storage/LocalizationStore.ts

@@ -8,9 +8,9 @@
  * - Single source of truth for all storage
  */
 
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import { create } from 'zustand';
 import { useTranslation } from 'react-i18next';
-import { storageRepository, unwrap } from '@umituz/react-native-storage';
 import i18n from '../config/i18n';
 import { SUPPORTED_LANGUAGES, DEFAULT_LANGUAGE, getLanguageByCode, getDeviceLocale } from '../config/languages';
 import type { Language } from '../../domain/repositories/ILocalizationRepository';
@@ -50,8 +50,7 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
       }
 
       // Get saved language preference
-      const result = await storageRepository.getString(LANGUAGE_STORAGE_KEY, DEFAULT_LANGUAGE);
-      const savedLanguage = unwrap(result, DEFAULT_LANGUAGE);
+      const savedLanguage = await AsyncStorage.getItem(LANGUAGE_STORAGE_KEY) || DEFAULT_LANGUAGE;
 
       // ✅ DEVICE LOCALE DETECTION: Use device locale on first launch
       let languageCode: string;
@@ -62,7 +61,7 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
         // First launch → Detect device locale automatically
         languageCode = getDeviceLocale();
         // Save detected locale for future launches
-        await storageRepository.setString(LANGUAGE_STORAGE_KEY, languageCode);
+        await AsyncStorage.setItem(LANGUAGE_STORAGE_KEY, languageCode);
       }
 
       // ✅ DEFENSIVE: Validate language exists, fallback to default
@@ -95,6 +94,7 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
   /**
    * Change language
    * Updates i18n, state, and persists to AsyncStorage
+   * Dynamically loads language resources if not already loaded
    */
   setLanguage: async (languageCode: string) => {
     try {
@@ -105,6 +105,41 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
         return;
       }
 
+      // ✅ DYNAMIC RESOURCE LOADING: Load language resource if not already loaded
+      if (!i18n.hasResourceBundle(languageCode, 'translation')) {
+        try {
+          // Try to load project translations from common paths
+          let translations: any = null;
+          
+          try {
+            // Try DDD structure path
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            translations = require(`../../../../../../src/domains/localization/infrastructure/locales/${languageCode}`);
+          } catch (e1) {
+            try {
+              // Try alternative DDD structure path
+              // eslint-disable-next-line @typescript-eslint/no-require-imports
+              translations = require(`../../../../../../domains/localization/infrastructure/locales/${languageCode}`);
+            } catch (e2) {
+              try {
+                // Try simple structure path
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                translations = require(`../../../../../../src/locales/${languageCode}`);
+              } catch (e3) {
+                // No translations found - will fallback to en-US
+              }
+            }
+          }
+
+          if (translations) {
+            const translationData = translations.default || translations;
+            i18n.addResourceBundle(languageCode, 'translation', translationData, true, true);
+          }
+        } catch (loadError) {
+          // If loading fails, continue with changeLanguage (will fallback to en-US)
+        }
+      }
+
       // Update i18n
       await i18n.changeLanguage(languageCode);
 
@@ -115,7 +150,7 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
       });
 
       // Persist language preference
-      await storageRepository.setString(LANGUAGE_STORAGE_KEY, languageCode);
+      await AsyncStorage.setItem(LANGUAGE_STORAGE_KEY, languageCode);
     } catch (error) {
       throw error;
     }