@umituz/react-native-localization 2.3.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-localization",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "English-only localization system for React Native apps with i18n support",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/config/I18nInitializer.ts

@@ -1,10 +1,10 @@
 /**
  * i18n Initializer
  *
- * Handles i18n configuration and initialization with namespace support
- * - Auto-discovers project translations
+ * Handles i18n configuration with namespace support
+ * - Loads package translations
+ * - Loads app translations (merges with package)
  * - Namespace-based organization (common, auth, etc.)
- * - React i18next integration
  */
 
 import i18n from 'i18next';
@@ -18,46 +18,55 @@ export class I18nInitializer {
   private static reactI18nextInitialized = false;
 
   /**
-   * Build resources object with namespace support
+   * Build resources with package + app translations merged
    */
   private static buildResources(): Record<string, Record<string, any>> {
     const packageTranslations = TranslationLoader.loadPackageTranslations();
+    const appTranslations = TranslationLoader.loadAppTranslations();
 
-    // Create namespace-based resources structure
     const resources: Record<string, Record<string, any>> = {
       'en-US': {},
     };
 
-    // Package translations are already in namespace format (alerts, auth, etc.)
     const enUSPackage = packageTranslations['en-US'] || {};
 
-    // Each key in packageTranslations is a namespace
+    // Add package namespaces
     for (const [namespace, translations] of Object.entries(enUSPackage)) {
       resources['en-US'][namespace] = translations;
     }
 
+    // Merge app namespaces (app overrides package)
+    for (const [namespace, translations] of Object.entries(appTranslations)) {
+      if (resources['en-US'][namespace]) {
+        resources['en-US'][namespace] = TranslationLoader.mergeTranslations(
+          resources['en-US'][namespace],
+          translations
+        );
+      } else {
+        resources['en-US'][namespace] = translations;
+      }
+    }
+
     return resources;
   }
 
-  /**
-   * Get all available namespaces from package translations
-   */
   private static getNamespaces(): string[] {
     const packageTranslations = TranslationLoader.loadPackageTranslations();
+    const appTranslations = TranslationLoader.loadAppTranslations();
+
     const enUSPackage = packageTranslations['en-US'] || {};
-    const namespaces = Object.keys(enUSPackage);
+    const namespaces = new Set([
+      ...Object.keys(enUSPackage),
+      ...Object.keys(appTranslations),
+    ]);
 
-    // Ensure default namespace is included
-    if (!namespaces.includes(DEFAULT_NAMESPACE)) {
-      namespaces.unshift(DEFAULT_NAMESPACE);
+    if (!namespaces.has(DEFAULT_NAMESPACE)) {
+      namespaces.add(DEFAULT_NAMESPACE);
     }
 
-    return namespaces;
+    return Array.from(namespaces);
   }
 
-  /**
-   * Initialize i18next with namespace support
-   */
   static initialize(): void {
     if (i18n.isInitialized) {
       return;
@@ -79,37 +88,25 @@ export class I18nInitializer {
         ns: namespaces,
         defaultNS: DEFAULT_NAMESPACE,
         fallbackNS: DEFAULT_NAMESPACE,
-
-        interpolation: {
-          escapeValue: false,
-        },
-
-        react: {
-          useSuspense: false,
-        },
-
+        interpolation: { escapeValue: false },
+        react: { useSuspense: false },
         compatibilityJSON: 'v3',
         pluralSeparator: '_',
         keySeparator: '.',
         nsSeparator: ':',
-
         saveMissing: false,
         missingKeyHandler: false,
-
         debug: false,
       });
-
     } catch (error) {
       if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.error('[Localization] i18n initialization error:', error);
+        console.error('[Localization] init error:', error);
       }
     }
   }
 
   /**
-   * Add additional translation resources with namespace support
-   * @param languageCode - Language code (e.g., 'en-US')
-   * @param namespaceResources - Object with namespace keys and translation objects
+   * Add translation resources at runtime
    */
   static addTranslationResources(
     languageCode: string,

package/src/infrastructure/config/TranslationLoader.ts

@@ -1,58 +1,73 @@
 /**
  * Translation Loader
  *
- * Handles loading of translations from package only
+ * Loads translations from package and app
  */
 
 export class TranslationLoader {
   /**
-   * Load package translations (en-US only)
+   * Load package translations (en-US)
    */
   static loadPackageTranslations(): Record<string, any> {
     try {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       const translations = require('../locales/en-US');
       return { 'en-US': translations.default || translations };
-    } catch (error) {
+    } catch {
       return { 'en-US': {} };
     }
   }
 
   /**
-   * Merge package defaults with project-specific translations
+   * Load app translations from common paths
    */
-  static mergeTranslations(
-    packageTranslations: any,
-    projectTranslations: any
-  ): any {
-    if (!projectTranslations || Object.keys(projectTranslations).length === 0) {
-      return packageTranslations;
+  static loadAppTranslations(): Record<string, any> {
+    const paths = [
+      '@/domains/localization/infrastructure/locales/en-US',
+      './src/domains/localization/infrastructure/locales/en-US',
+      '../../../src/domains/localization/infrastructure/locales/en-US',
+    ];
+
+    for (const path of paths) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const translations = require(path);
+        return translations.default || translations;
+      } catch {
+        continue;
+      }
+    }
+
+    return {};
+  }
+
+  /**
+   * Deep merge translations (app overrides package)
+   */
+  static mergeTranslations(base: any, override: any): any {
+    if (!override || Object.keys(override).length === 0) {
+      return base;
     }
 
-    const merged = { ...packageTranslations };
-
-    for (const key in projectTranslations) {
-      if (projectTranslations.hasOwnProperty(key)) {
-        if (
-          typeof projectTranslations[key] === 'object' &&
-          projectTranslations[key] !== null &&
-          !Array.isArray(projectTranslations[key]) &&
-          typeof packageTranslations[key] === 'object' &&
-          packageTranslations[key] !== null &&
-          !Array.isArray(packageTranslations[key])
-        ) {
-          // Deep merge nested objects
-          merged[key] = this.mergeTranslations(
-            packageTranslations[key],
-            projectTranslations[key]
-          );
+    const merged = { ...base };
+
+    for (const key in override) {
+      if (Object.prototype.hasOwnProperty.call(override, key)) {
+        const baseVal = base[key];
+        const overrideVal = override[key];
+
+        if (this.isObject(baseVal) && this.isObject(overrideVal)) {
+          merged[key] = this.mergeTranslations(baseVal, overrideVal);
         } else {
-          // Override with project translation
-          merged[key] = projectTranslations[key];
+          merged[key] = overrideVal;
         }
       }
     }
 
     return merged;
   }
+
+  private static isObject(val: any): boolean {
+    return val !== null && typeof val === 'object' && !Array.isArray(val);
+  }
 }