@umituz/react-native-localization 1.16.2 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-localization",
-  "version": "1.16.2",
+  "version": "2.0.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

@@ -5,6 +5,7 @@
 
 // Hooks
 export { useLocalization, useLocalizationStore } from './infrastructure/storage/LocalizationStore';
+export { useTranslationFunction } from './infrastructure/hooks/useTranslation';
 
 // Components
 export { LocalizationProvider } from './infrastructure/components/LocalizationProvider';

package/src/infrastructure/config/I18nInitializer.ts

@@ -0,0 +1,113 @@
+/**
+ * i18n Initializer
+ *
+ * Handles i18n configuration and initialization
+ * - Resource building
+ * - i18n setup
+ * - React i18next integration
+ */
+
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import { DEFAULT_LANGUAGE, SUPPORTED_LANGUAGES } from './languages';
+import { TranslationLoader } from './TranslationLoader';
+
+export class I18nInitializer {
+  private static reactI18nextInitialized = false;
+
+  /**
+   * Build resources object for all supported languages
+   */
+  private static buildResources(): Record<string, { translation: any }> {
+    const resources: Record<string, { translation: any }> = {};
+    const packageTranslations = TranslationLoader.loadPackageTranslations();
+    const projectTranslations = TranslationLoader.loadProjectTranslations();
+
+    // 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: TranslationLoader.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;
+  }
+
+  /**
+   * Initialize i18next
+   */
+  static initialize(): void {
+    // Prevent multiple initializations
+    if (i18n.isInitialized) {
+      return;
+    }
+
+    try {
+      // Use initReactI18next once
+      if (!this.reactI18nextInitialized) {
+        i18n.use(initReactI18next);
+        this.reactI18nextInitialized = true;
+      }
+
+      const resources = this.buildResources();
+
+      i18n.init({
+        resources,
+        lng: DEFAULT_LANGUAGE,
+        fallbackLng: DEFAULT_LANGUAGE,
+
+        interpolation: {
+          escapeValue: false, // React already escapes values
+        },
+
+        react: {
+          useSuspense: false, // Disable suspense for React Native
+        },
+
+        compatibilityJSON: 'v3', // Use v3 format for React Native
+        pluralSeparator: '_', // Use underscore separator for plural keys
+        keySeparator: '.', // Use dot separator for nested keys
+
+        debug: typeof __DEV__ !== 'undefined' && __DEV__,
+      });
+
+    } catch (error) {
+      // Don't throw - allow app to continue without i18n
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.error('❌ i18n initialization error:', error);
+      }
+    }
+  }
+
+  /**
+   * Add additional translation resources
+   */
+  static addTranslationResources(resources: Record<string, { translation: any }>): void {
+    for (const [langCode, resource] of Object.entries(resources)) {
+      if (resource.translation) {
+        const existingTranslations = i18n.getResourceBundle(langCode, 'translation') || {};
+        const mergedTranslations = { ...existingTranslations, ...resource.translation };
+        i18n.addResourceBundle(langCode, 'translation', mergedTranslations, true, true);
+      }
+    }
+  }
+}

package/src/infrastructure/config/TranslationLoader.ts

@@ -0,0 +1,69 @@
+/**
+ * Translation Loader
+ *
+ * Handles loading of translations from different sources
+ * - Package translations
+ * - Project translations
+ * - Resource merging
+ */
+
+export class TranslationLoader {
+  /**
+   * Load package translations (en-US only)
+   */
+  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) {
+      return { 'en-US': {} };
+    }
+  }
+
+  /**
+   * Load project translations for all supported languages
+   * Currently returns empty as projects manage their own translations
+   */
+  static loadProjectTranslations(): Record<string, any> {
+    return {};
+  }
+
+  /**
+   * Merge package defaults with project-specific translations
+   */
+  static mergeTranslations(
+    packageTranslations: any,
+    projectTranslations: any
+  ): any {
+    if (!projectTranslations || Object.keys(projectTranslations).length === 0) {
+      return packageTranslations;
+    }
+
+    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]
+          );
+        } else {
+          // Override with project translation
+          merged[key] = projectTranslations[key];
+        }
+      }
+    }
+
+    return merged;
+  }
+}

package/src/infrastructure/config/i18n.ts

@@ -1,215 +1,17 @@
 /**
- * i18next Configuration for Multi-language Support
- * Loads all supported languages from project translations
+ * i18n Configuration Entry Point
  *
- * MULTI-LANGUAGE LOADING:
- * - Loads all languages from project translations
- * - Project translations merged with package defaults
- * - Metro bundler resolves all requires at build time
+ * Delegates to I18nInitializer for setup
+ * Exports i18n instance and utility functions
  */
 
 import i18n from 'i18next';
-import { initReactI18next } from 'react-i18next';
-import { DEFAULT_LANGUAGE, SUPPORTED_LANGUAGES } from './languages';
+import { I18nInitializer } from './I18nInitializer';
 
-/**
- * Load package translations (en-US only)
- */
-const loadPackageTranslations = (): Record<string, any> => {
-  try {
-    // 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 };
-  } catch (error) {
-    // Fallback to empty translations
-    return { 'en-US': {} };
-  }
-};
-
-const packageTranslations = loadPackageTranslations();
-
-/**
- * Load project translations for all supported languages
- * This function is a placeholder for future extensibility
- * Currently returns empty translations as projects should manage their own translations
- */
-const loadProjectTranslations = (): Record<string, any> => {
-  // Projects should create their own localization domains
-  // and manage translations within their app structure
-  // This package provides only the core i18n infrastructure
-  return {};
-};
-
-const projectTranslations = loadProjectTranslations();
-
-/**
- * Translation Resources
- * Merge package defaults with project-specific translations
- * Project translations override package defaults (deep merge)
- */
-const mergeTranslations = (packageTranslations: any, projectTranslations: any): any => {
-  if (!projectTranslations || Object.keys(projectTranslations).length === 0) {
-    return packageTranslations;
-  }
-
-  // Deep merge: project translations override package defaults
-  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] = mergeTranslations(packageTranslations[key], projectTranslations[key]);
-      } else {
-        // Override with project translation
-        merged[key] = projectTranslations[key];
-      }
-    }
-  }
-  
-  return merged;
-};
-
-/**
- * Build resources object for all supported languages
- */
-const buildResources = (): Record<string, { translation: any }> => {
-  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,
-      };
-    }
-  }
+// Initialize i18n immediately
+I18nInitializer.initialize();
 
-  // Ensure en-US is always present
-  if (!resources['en-US']) {
-    resources['en-US'] = {
-      translation: packageTranslations['en-US'] || {},
-    };
-  }
-
-  return resources;
-};
-
-const resources = buildResources();
-
-// Debug: Log loaded resources in development (only once to prevent spam)
-if (typeof globalThis !== 'undefined' && !(globalThis as any).__i18n_resources_logged) {
-  /* eslint-disable-next-line no-console */
-  if (typeof __DEV__ !== 'undefined' && __DEV__) {
-    console.log('🌍 i18n Resources loaded:', {
-      languages: Object.keys(resources),
-      enUSKeys: resources['en-US']?.translation ? Object.keys(resources['en-US'].translation) : [],
-    });
-    (globalThis as any).__i18n_resources_logged = true;
-  }
-}
-
-// Global flag to ensure initReactI18next is only used once
-let reactI18nextInitialized = false;
-
-/**
- * Initialize i18next
- * CRITICAL: Check i18n.isInitialized to prevent multiple initializations
- * This prevents "i18next is already initialized" warnings when module is imported multiple times
- */
-const initializeI18n = () => {
-  // CRITICAL: Check if i18n is already initialized (prevents multiple init calls)
-  if (i18n.isInitialized) {
-    return;
-  }
-
-  try {
-    // Check if initReactI18next is available
-    if (!initReactI18next) {
-      throw new Error('initReactI18next is undefined');
-    }
-    
-    // CRITICAL: Only use initReactI18next once (prevents context registration issues)
-    if (!reactI18nextInitialized) {
-      i18n.use(initReactI18next);
-      reactI18nextInitialized = true;
-    }
-    
-    i18n.init({
-      resources,
-      lng: DEFAULT_LANGUAGE,
-      fallbackLng: DEFAULT_LANGUAGE,
-
-      interpolation: {
-        escapeValue: false, // React already escapes values
-      },
-
-      react: {
-        useSuspense: false, // Disable suspense for React Native
-      },
-
-      compatibilityJSON: 'v3', // Use v3 format for React Native (no Intl.PluralRules support)
-      pluralSeparator: '_', // Use underscore separator for plural keys
-      keySeparator: '.', // Use dot separator for nested keys
-      
-      // Debug options
-      debug: typeof __DEV__ !== 'undefined' && __DEV__,
-    });
-    
-    // Debug: Verify initialization
-    /* eslint-disable-next-line no-console */
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      console.log('✅ i18n initialized:', {
-        language: i18n.language,
-        hasResource: !!i18n.getResourceBundle(i18n.language, 'translation'),
-      });
-    }
-  } catch (error) {
-    /* eslint-disable-next-line no-console */
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      console.error('❌ i18n initialization error:', error);
-    }
-    // Don't throw - allow app to continue without i18n
-  }
-};
-
-// Initialize immediately - no need to defer
-// React Native and React are ready when this module loads
-// Deferring causes race conditions with useTranslation hook
-// CRITICAL: i18n.isInitialized check prevents multiple initializations
-initializeI18n();
-
-/**
- * Add additional translation resources to the existing i18n instance
- * This allows projects to add their own translations to the package translations
- */
-export const addTranslationResources = (resources: Record<string, { translation: any }>) => {
-  for (const [langCode, resource] of Object.entries(resources)) {
-    if (resource.translation) {
-      // Merge with existing translations if any
-      const existingTranslations = i18n.getResourceBundle(langCode, 'translation') || {};
-      const mergedTranslations = { ...existingTranslations, ...resource.translation };
-      i18n.addResourceBundle(langCode, 'translation', mergedTranslations, true, true);
-    }
-  }
-};
+// Export utility functions
+export const addTranslationResources = I18nInitializer.addTranslationResources;
 
 export default i18n;

package/src/infrastructure/hooks/TranslationHook.ts

@@ -0,0 +1,39 @@
+/**
+ * Translation Hook
+ *
+ * Provides translation function with fallback logic
+ * - React i18next integration
+ * - Direct i18n fallback
+ * - Type-safe translation function
+ */
+
+import { useTranslation } from 'react-i18next';
+import i18n from '../config/i18n';
+
+export class TranslationHook {
+  /**
+   * Get translation function with proper fallbacks
+   */
+  static useTranslationFunction(): (key: string, options?: any) => string {
+    // Always call useTranslation hook (React hooks rules)
+    const translationResult = useTranslation(undefined, { i18n });
+
+    // Use react-i18next if available, otherwise fallback to direct i18n
+    if (translationResult?.t && typeof translationResult.t === 'function' && i18n.isInitialized) {
+      return (key: string, options?: any): string => {
+        const result = translationResult.t(key, options);
+        return typeof result === 'string' ? result : String(result);
+      };
+    } else {
+      return (key: string, options?: any): string => {
+        // Fallback to direct i18n.t
+        if (i18n.isInitialized && typeof i18n.t === 'function') {
+          const result = i18n.t(key, options);
+          return typeof result === 'string' ? result : String(result);
+        }
+        // Final fallback: return key
+        return key;
+      };
+    }
+  }
+}

package/src/infrastructure/hooks/useTranslation.ts

@@ -0,0 +1,37 @@
+/**
+ * Translation Hook
+ *
+ * Provides translation function with proper fallbacks
+ * - React i18next integration
+ * - Direct i18n fallback
+ * - Type-safe translation function
+ */
+
+import { useTranslation } from 'react-i18next';
+import i18n from '../config/i18n';
+
+/**
+ * Hook for translation functionality
+ */
+export const useTranslationFunction = (): ((key: string, options?: any) => string) => {
+  // Always call useTranslation hook (React hooks rules)
+  const translationResult = useTranslation(undefined, { i18n });
+
+  // Use react-i18next if available, otherwise fallback to direct i18n
+  if (translationResult?.t && typeof translationResult.t === 'function' && i18n.isInitialized) {
+    return (key: string, options?: any): string => {
+      const result = translationResult.t(key, options);
+      return typeof result === 'string' ? result : String(result);
+    };
+  } else {
+    return (key: string, options?: any): string => {
+      // Fallback to direct i18n.t
+      if (i18n.isInitialized && typeof i18n.t === 'function') {
+        const result = i18n.t(key, options);
+        return typeof result === 'string' ? result : String(result);
+      }
+      // Final fallback: return key
+      return key;
+    };
+  }
+};

package/src/infrastructure/storage/LanguageInitializer.ts

@@ -0,0 +1,95 @@
+/**
+ * Language Initializer
+ *
+ * Handles the initialization of localization system
+ * - Device locale detection
+ * - Language validation and fallback
+ * - i18n setup
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import i18n from '../config/i18n';
+import { DEFAULT_LANGUAGE, getLanguageByCode, getDeviceLocale } from '../config/languages';
+
+// Storage key for language preference
+const LANGUAGE_STORAGE_KEY = '@localization:language';
+
+export class LanguageInitializer {
+  /**
+   * Initialize localization system
+   * Detects device locale and sets up i18n
+   */
+  static async initialize(): Promise<{
+    languageCode: string;
+    isRTL: boolean;
+  }> {
+    try {
+      // Get saved language preference
+      const savedLanguage = await AsyncStorage.getItem(LANGUAGE_STORAGE_KEY) || DEFAULT_LANGUAGE;
+
+      // Determine language code
+      const languageCode = await this.determineLanguageCode(savedLanguage);
+
+      // Validate and get language object
+      const finalLanguage = await this.validateAndSetupLanguage(languageCode);
+
+      return finalLanguage;
+    } catch (error) {
+      // Fallback to default language
+      return await this.setupFallbackLanguage();
+    }
+  }
+
+  /**
+   * Determine which language code to use
+   */
+  private static async determineLanguageCode(savedLanguage: string): Promise<string> {
+    if (savedLanguage && savedLanguage !== DEFAULT_LANGUAGE) {
+      // User has previously selected a language
+      return savedLanguage;
+    } else {
+      // First launch - detect device locale
+      const deviceLocale = getDeviceLocale();
+      // Save detected locale for future launches
+      await AsyncStorage.setItem(LANGUAGE_STORAGE_KEY, deviceLocale);
+      return deviceLocale;
+    }
+  }
+
+  /**
+   * Validate language and set it up in i18n
+   */
+  private static async validateAndSetupLanguage(languageCode: string): Promise<{
+    languageCode: string;
+    isRTL: boolean;
+  }> {
+    const language = getLanguageByCode(languageCode);
+    const finalLanguageCode = language ? languageCode : DEFAULT_LANGUAGE;
+    const finalLanguageObj = getLanguageByCode(finalLanguageCode);
+
+    await i18n.changeLanguage(finalLanguageCode);
+
+    return {
+      languageCode: finalLanguageCode,
+      isRTL: finalLanguageObj?.rtl || false,
+    };
+  }
+
+  /**
+   * Set up fallback language when initialization fails
+   */
+  private static async setupFallbackLanguage(): Promise<{
+    languageCode: string;
+    isRTL: boolean;
+  }> {
+    try {
+      await i18n.changeLanguage(DEFAULT_LANGUAGE);
+      return {
+        languageCode: DEFAULT_LANGUAGE,
+        isRTL: false,
+      };
+    } catch (fallbackError) {
+      throw fallbackError;
+    }
+  }
+}

package/src/infrastructure/storage/LanguageSwitcher.ts

@@ -0,0 +1,83 @@
+/**
+ * Language Switcher
+ *
+ * Handles switching between languages
+ * - Language validation
+ * - Dynamic resource loading
+ * - Persistence
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import i18n from '../config/i18n';
+import { getLanguageByCode } from '../config/languages';
+
+// Storage key for language preference
+const LANGUAGE_STORAGE_KEY = '@localization:language';
+
+export class LanguageSwitcher {
+  /**
+   * Switch to a new language
+   */
+  static async switchLanguage(languageCode: string): Promise<{
+    languageCode: string;
+    isRTL: boolean;
+  }> {
+    const language = getLanguageByCode(languageCode);
+
+    // Validate language exists
+    if (!language) {
+      throw new Error(`Unsupported language: ${languageCode}`);
+    }
+
+    // Load language resources if needed
+    await this.loadLanguageResources(languageCode);
+
+    // Update i18n
+    await i18n.changeLanguage(languageCode);
+
+    // Persist language preference
+    await AsyncStorage.setItem(LANGUAGE_STORAGE_KEY, languageCode);
+
+    return {
+      languageCode,
+      isRTL: language.rtl || false,
+    };
+  }
+
+  /**
+   * Load language resources dynamically
+   */
+  private static async loadLanguageResources(languageCode: string): Promise<void> {
+    if (i18n.hasResourceBundle(languageCode, 'translation')) {
+      return; // Already loaded
+    }
+
+    try {
+      // Try to load project translations from common paths
+      let translations: any = null;
+
+      const loadPaths = [
+        `../../../../../../src/domains/localization/infrastructure/locales/${languageCode}`,
+        `../../../../../../domains/localization/infrastructure/locales/${languageCode}`,
+        `../../../../../../src/locales/${languageCode}`,
+      ];
+
+      for (const path of loadPaths) {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-require-imports
+          translations = require(path);
+          break;
+        } catch {
+          // Try next path
+        }
+      }
+
+      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)
+    }
+  }
+}

package/src/infrastructure/storage/LocalizationStore.ts

@@ -1,23 +1,17 @@
 /**
  * Localization Store
- * Zustand state management for language preferences with AsyncStorage persistence
+ * Zustand state management for language preferences
  *
- * DDD ARCHITECTURE: Uses @umituz/react-native-storage for all storage operations
- * - Type-safe storage with StorageKey
- * - Result pattern for error handling
- * - Single source of truth for all storage
+ * Uses separate classes for initialization, switching, and translation
+ * Follows Single Responsibility Principle
  */
 
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import { create } from 'zustand';
-import { useTranslation } from 'react-i18next';
-import i18n from '../config/i18n';
-import { SUPPORTED_LANGUAGES, DEFAULT_LANGUAGE, getLanguageByCode, getDeviceLocale } from '../config/languages';
+import { SUPPORTED_LANGUAGES, DEFAULT_LANGUAGE, getLanguageByCode } from '../config/languages';
+import { LanguageInitializer } from './LanguageInitializer';
+import { LanguageSwitcher } from './LanguageSwitcher';
 import type { Language } from '../../domain/repositories/ILocalizationRepository';
 
-// Storage key for language preference
-const LANGUAGE_STORAGE_KEY = '@localization:language';
-
 interface LocalizationState {
   currentLanguage: string;
   isRTL: boolean;
@@ -34,123 +28,44 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
   supportedLanguages: SUPPORTED_LANGUAGES,
 
   /**
-   * Initialize localization
-   * DEVICE LOCALE DETECTION:
-   * - First launch (no saved language): Automatically detect device locale
-   * - After manual selection: Use saved language preference
-   * - Fallback: English (en-US) if device locale not supported
+   * Initialize localization system
    */
   initialize: async () => {
-    try {
-      // ✅ CRITICAL FIX: Don't reset isInitialized if already initialized
-      // This prevents UI flash on re-initialization
-      const { isInitialized: alreadyInitialized } = get();
-      if (alreadyInitialized) {
-        return;
-      }
-
-      // Get saved language preference
-      const savedLanguage = await AsyncStorage.getItem(LANGUAGE_STORAGE_KEY) || DEFAULT_LANGUAGE;
-
-      // ✅ DEVICE LOCALE DETECTION: Use device locale on first launch
-      let languageCode: string;
-      if (savedLanguage && savedLanguage !== DEFAULT_LANGUAGE) {
-        // User has previously selected a language → Use their choice
-        languageCode = savedLanguage;
-      } else {
-        // First launch → Detect device locale automatically
-        languageCode = getDeviceLocale();
-        // Save detected locale for future launches
-        await AsyncStorage.setItem(LANGUAGE_STORAGE_KEY, languageCode);
-      }
+    // Prevent re-initialization
+    const { isInitialized: alreadyInitialized } = get();
+    if (alreadyInitialized) {
+      return;
+    }
 
-      // ✅ DEFENSIVE: Validate language exists, fallback to default
-      const language = getLanguageByCode(languageCode);
-      const finalLanguage = language ? languageCode : DEFAULT_LANGUAGE;
-      const finalLanguageObj = getLanguageByCode(finalLanguage);
+    try {
+      const result = await LanguageInitializer.initialize();
 
-      await i18n.changeLanguage(finalLanguage);
-      
       set({
-        currentLanguage: finalLanguage,
-        isRTL: finalLanguageObj?.rtl || false,
-        isInitialized: true, // ✅ Always set true to unblock UI
+        currentLanguage: result.languageCode,
+        isRTL: result.isRTL,
+        isInitialized: true,
       });
     } catch (error) {
-      // Set to default language even on error to prevent app from breaking
-      try {
-        await i18n.changeLanguage(DEFAULT_LANGUAGE);
-        set({
-          currentLanguage: DEFAULT_LANGUAGE,
-          isRTL: false,
-          isInitialized: true, // Set true even on error to unblock UI
-        });
-      } catch (fallbackError) {
-        throw fallbackError;
-      }
+      // Set fallback state even on error
+      set({
+        currentLanguage: DEFAULT_LANGUAGE,
+        isRTL: false,
+        isInitialized: true,
+      });
     }
   },
 
   /**
    * Change language
-   * Updates i18n, state, and persists to AsyncStorage
-   * Dynamically loads language resources if not already loaded
    */
   setLanguage: async (languageCode: string) => {
     try {
-      const language = getLanguageByCode(languageCode);
-
-      // ✅ DEFENSIVE: Early return if unsupported language
-      if (!language) {
-        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)
-        }
-      }
+      const result = await LanguageSwitcher.switchLanguage(languageCode);
 
-      // Update i18n
-      await i18n.changeLanguage(languageCode);
-
-      // Update state
       set({
-        currentLanguage: languageCode,
-        isRTL: language.rtl || false,
+        currentLanguage: result.languageCode,
+        isRTL: result.isRTL,
       });
-
-      // Persist language preference
-      await AsyncStorage.setItem(LANGUAGE_STORAGE_KEY, languageCode);
     } catch (error) {
       throw error;
     }
@@ -160,8 +75,6 @@ export const useLocalizationStore = create<LocalizationState>((set, get) => ({
 /**
  * Hook to use localization
  * Provides current language, RTL state, language switching, and translation function
- * Uses react-i18next's useTranslation hook to ensure proper i18n instance
- * Falls back to direct i18n.t if react-i18next is not ready
  */
 export const useLocalization = () => {
   const {
@@ -175,33 +88,7 @@ export const useLocalization = () => {
 
   const currentLanguageObject = getLanguageByCode(currentLanguage);
 
-  // Always call useTranslation hook (React hooks rules - must be unconditional)
-  // Pass i18n instance explicitly to ensure react-i18next finds it
-  // This fixes the "NO_I18NEXT_INSTANCE" error
-  // Even if i18n is not fully initialized, useTranslation will handle it gracefully
-  // with the explicit i18n instance passed
-  const translationResult = useTranslation(undefined, { i18n });
-  
-  // Use translation function from react-i18next if available and valid
-  // Otherwise fallback to direct i18n.t
-  // Type assertion needed because react-i18next's TFunction can return string | object
-  const t = (translationResult?.t && typeof translationResult.t === 'function' && i18n.isInitialized)
-    ? ((key: string, options?: any): string => {
-        const result = translationResult.t(key, options);
-        return typeof result === 'string' ? result : String(result);
-      })
-    : ((key: string, options?: any): string => {
-        // Fallback to direct i18n.t if react-i18next is not ready
-        if (i18n.isInitialized && typeof i18n.t === 'function') {
-          const result = i18n.t(key, options);
-          return typeof result === 'string' ? result : String(result);
-        }
-        // Final fallback: return key if i18n is not ready
-        return key;
-      }) as (key: string, options?: any) => string;
-
   return {
-    t, // Translation function from react-i18next or i18n fallback
     currentLanguage,
     currentLanguageObject,
     isRTL,