@umituz/react-native-localization 2.3.0 → 2.5.0

package/package.json

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

package/src/index.ts

@@ -1,6 +1,6 @@
 /**
  * React Native Localization
- * Universal localization system with i18n support for React Native apps
+ * i18n with namespace support for React Native apps
  */
 
 // Hooks
@@ -13,10 +13,11 @@ export { LanguageSwitcher } from './infrastructure/components/LanguageSwitcher';
 export { useLanguageNavigation } from './infrastructure/components/useLanguageNavigation';
 
 // Configuration
-export { default as i18n, addTranslationResources } from './infrastructure/config/i18n';
+export { default as i18n } from './infrastructure/config/i18n';
+export { I18nInitializer } from './infrastructure/config/I18nInitializer';
 export {
   SUPPORTED_LANGUAGES,
-  LANGUAGES, // Alias for SUPPORTED_LANGUAGES (backward compatibility)
+  LANGUAGES,
   DEFAULT_LANGUAGE,
   getLanguageByCode,
   isLanguageSupported,

package/src/infrastructure/config/I18nInitializer.ts

@@ -1,10 +1,8 @@
 /**
  * i18n Initializer
  *
- * Handles i18n configuration and initialization with namespace support
- * - Auto-discovers project translations
- * - Namespace-based organization (common, auth, etc.)
- * - React i18next integration
+ * Namespace-based i18n configuration
+ * Usage: t('namespace:key') e.g., t('common:cancel')
  */
 
 import i18n from 'i18next';
@@ -16,48 +14,63 @@ const DEFAULT_NAMESPACE = 'common';
 
 export class I18nInitializer {
   private static reactI18nextInitialized = false;
+  private static appTranslations: Record<string, any> = {};
 
   /**
-   * Build resources object with namespace support
+   * Register app translations (call before initialize)
+   */
+  static registerAppTranslations(translations: Record<string, any>): void {
+    this.appTranslations = translations;
+  }
+
+  /**
+   * Build resources with package + registered app translations
    */
   private static buildResources(): Record<string, Record<string, any>> {
     const packageTranslations = TranslationLoader.loadPackageTranslations();
 
-    // 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 translations (app overrides package)
+    for (const [namespace, translations] of Object.entries(this.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 enUSPackage = packageTranslations['en-US'] || {};
-    const namespaces = Object.keys(enUSPackage);
 
-    // Ensure default namespace is included
-    if (!namespaces.includes(DEFAULT_NAMESPACE)) {
-      namespaces.unshift(DEFAULT_NAMESPACE);
+    const namespaces = new Set([
+      ...Object.keys(enUSPackage),
+      ...Object.keys(this.appTranslations),
+    ]);
+
+    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,39 +92,27 @@ 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 translations at runtime
    */
-  static addTranslationResources(
+  static addTranslations(
     languageCode: string,
     namespaceResources: Record<string, any>
   ): void {

package/src/infrastructure/config/TranslationLoader.ts

@@ -1,58 +1,50 @@
 /**
  * Translation Loader
  *
- * Handles loading of translations from package only
+ * Loads package translations
  */
 
 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
+   * Deep merge translations (override wins)
    */
-  static mergeTranslations(
-    packageTranslations: any,
-    projectTranslations: any
-  ): any {
-    if (!projectTranslations || Object.keys(projectTranslations).length === 0) {
-      return packageTranslations;
+  static mergeTranslations(base: any, override: any): any {
+    if (!override || Object.keys(override).length === 0) {
+      return base;
     }
 
-    const merged = { ...packageTranslations };
+    const merged = { ...base };
 
-    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]
-          );
+    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);
+  }
 }

package/src/infrastructure/config/i18n.ts

@@ -1,14 +1,9 @@
 /**
- * i18n Configuration
+ * i18n Instance
  *
- * Auto-initializes i18n with namespace support
- * Usage: t('namespace:key') e.g., t('common:cancel')
+ * Raw i18n instance - use I18nInitializer for configuration
  */
 
-import { I18nInitializer } from './I18nInitializer';
 import i18n from 'i18next';
 
-I18nInitializer.initialize();
-
-export const addTranslationResources = I18nInitializer.addTranslationResources;
 export default i18n;