@umituz/react-native-localization 2.8.0 → 3.0.1

package/src/infrastructure/config/__tests__/languagesData.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Simple tests for language registry
+ */
+
+import { languageRegistry } from '../../config/languagesData';
+
+describe('LanguageRegistry', () => {
+  beforeEach(() => {
+    languageRegistry.clearLanguages();
+  });
+
+  it('should get default language', () => {
+    const defaultLang = languageRegistry.getDefaultLanguage();
+    expect(defaultLang).toBeDefined();
+    expect(defaultLang.code).toBe('en-US');
+  });
+
+  it('should check if language is supported', () => {
+    const supported = languageRegistry.isLanguageSupported('en-US');
+    expect(supported).toBe(true);
+  });
+
+  it('should check if language is not supported', () => {
+    const supported = languageRegistry.isLanguageSupported('unknown');
+    expect(supported).toBe(false);
+  });
+
+  it('should get language by code', () => {
+    const language = languageRegistry.getLanguageByCode('en-US');
+    expect(language).toBeDefined();
+    expect(language?.code).toBe('en-US');
+  });
+
+  it('should return undefined for unknown code', () => {
+    const language = languageRegistry.getLanguageByCode('unknown');
+    expect(language).toBeUndefined();
+  });
+
+  it('should search languages', () => {
+    const results = languageRegistry.searchLanguages('english');
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  it('should get supported languages', () => {
+    const languages = languageRegistry.getLanguages();
+    expect(Array.isArray(languages)).toBe(true);
+    expect(languages.length).toBeGreaterThan(0);
+  });
+});

package/src/infrastructure/config/languages.ts

@@ -15,7 +15,7 @@
 
 import * as Localization from 'expo-localization';
 import { LANGUAGES as LANGUAGES_DATA } from './languagesData';
-import { Language } from '../../domain/repositories/ILocalizationRepository';
+import type { Language } from '../storage/types/LocalizationState';
 
 // Single source of truth for supported languages
 export const SUPPORTED_LANGUAGES: Language[] = LANGUAGES_DATA;

package/src/infrastructure/config/languagesData.ts

@@ -1,81 +1,111 @@
 /**
  * Language Configuration
- * Strategic language support with 29 languages (top revenue markets only)
- * Optimized for maximum monetization with minimal maintenance cost
- * Generated from App Factory language_config.yaml
+ * Generic language interface and utilities for localization packages
+ * This is a base configuration that can be extended by consuming applications
  */
 
 export interface Language {
   code: string;
   name: string;
   nativeName: string;
-  flag: string;
+  flag?: string;
+  isRTL?: boolean;
 }
 
-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: '🇹🇼' },
+/**
+ * Default language configuration
+ * Applications can override this by providing their own language list
+ */
+export const DEFAULT_LANGUAGES: Language[] = [
+  { code: 'en-US', name: 'English', nativeName: 'English', flag: '🇺🇸', isRTL: false },
 ];
 
 /**
- * Get language by code
+ * Language registry for dynamic language management
  */
+class LanguageRegistry {
+  private languages: Language[] = [...DEFAULT_LANGUAGES];
+
+  /**
+   * Register new languages
+   */
+  registerLanguages(languages: Language[]): void {
+    this.languages = [...this.languages, ...languages];
+    if (__DEV__) {
+      console.log(`[Localization] Registered ${languages.length} languages`);
+    }
+  }
+
+  /**
+   * Get all registered languages
+   */
+  getLanguages(): Language[] {
+    return [...this.languages];
+  }
+
+  /**
+   * Clear all languages (reset to default)
+   */
+  clearLanguages(): void {
+    this.languages = [...DEFAULT_LANGUAGES];
+    if (__DEV__) {
+      console.log('[Localization] Cleared language registry');
+    }
+  }
+
+  /**
+   * Get language by code
+   */
+  getLanguageByCode(code: string): Language | undefined {
+    return this.languages.find(lang => lang.code === code);
+  }
+
+  /**
+   * Search languages by name or native name
+   */
+  searchLanguages(query: string): Language[] {
+    const lowerQuery = query.toLowerCase();
+    return this.languages.filter(
+      lang =>
+        lang.name.toLowerCase().includes(lowerQuery) ||
+        lang.nativeName.toLowerCase().includes(lowerQuery)
+    );
+  }
+
+  /**
+   * Check if language is supported
+   */
+  isLanguageSupported(code: string): boolean {
+    return this.languages.some(lang => lang.code === code);
+  }
+
+  /**
+   * Get default language
+   */
+  getDefaultLanguage(): Language {
+    return this.languages[0] || DEFAULT_LANGUAGES[0];
+  }
+}
+
+// Singleton instance
+export const languageRegistry = new LanguageRegistry();
+
+// Export convenience functions that delegate to registry
 export const getLanguageByCode = (code: string): Language | undefined => {
-  return LANGUAGES.find(lang => lang.code === code);
+  return languageRegistry.getLanguageByCode(code);
 };
 
-/**
- * Get default language (en-US)
- */
-export const getDefaultLanguage = (): Language => {
-  return LANGUAGES.find(lang => lang.code === 'en-US')!;
+export const searchLanguages = (query: string): Language[] => {
+  return languageRegistry.searchLanguages(query);
 };
 
-/**
- * Search languages by name or native name
- */
-export const searchLanguages = (query: string): Language[] => {
-  const lowerQuery = query.toLowerCase();
-  return LANGUAGES.filter(
-    lang =>
-      lang.name.toLowerCase().includes(lowerQuery) ||
-      lang.nativeName.toLowerCase().includes(lowerQuery)
-  );
+export const isLanguageSupported = (code: string): boolean => {
+  return languageRegistry.isLanguageSupported(code);
 };
+
+export const getDefaultLanguage = (): Language => {
+  return languageRegistry.getDefaultLanguage();
+};
+
+// Legacy exports for backward compatibility
+export const LANGUAGES = languageRegistry.getLanguages();

package/src/infrastructure/hooks/__tests__/useTranslation.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Simple tests for useTranslation hook
+ */
+
+import { useTranslationFunction } from '../useTranslation';
+
+// Mock React hooks
+jest.mock('react', () => ({
+  useMemo: jest.fn((fn) => fn()),
+  useCallback: jest.fn((fn) => fn),
+}));
+
+// Mock i18next
+jest.mock('../../config/i18n', () => ({
+  isInitialized: true,
+  t: jest.fn((key) => key),
+  hasResourceBundle: jest.fn(() => false),
+  language: 'en-US',
+}));
+
+describe('useTranslationFunction', () => {
+  it('should return translation function', () => {
+    const { t, clearCache } = useTranslationFunction();
+    
+    expect(typeof t).toBe('function');
+    expect(typeof clearCache).toBe('function');
+  });
+
+  it('should return key when translation not found', () => {
+    const { t } = useTranslationFunction();
+    const result = t('test.key');
+    
+    expect(result).toBe('test.key');
+  });
+
+  it('should handle translation options', () => {
+    const { t } = useTranslationFunction();
+    const result = t('test.key', { count: 1 });
+    
+    expect(typeof result).toBe('string');
+  });
+
+  it('should clear cache', () => {
+    const { t, clearCache } = useTranslationFunction();
+    
+    // Add to cache
+    t('test.key');
+    
+    // Clear cache
+    expect(() => clearCache()).not.toThrow();
+  });
+});

package/src/infrastructure/hooks/useLocalization.ts

@@ -0,0 +1,58 @@
+/**
+ * Localization Hook
+ * Provides a clean interface to localization functionality
+ * Follows Single Responsibility Principle
+ */
+
+import { useCallback } from 'react';
+import { useLocalizationStore } from '../storage/LocalizationStore';
+import { useTranslationFunction } from './useTranslation';
+import type { Language } from '../../domain/repositories/ILocalizationRepository';
+
+/**
+ * Hook to use localization functionality
+ * Provides current language, RTL state, language switching, and translation function
+ */
+export const useLocalization = () => {
+  const store = useLocalizationStore();
+  const { t } = useTranslationFunction();
+
+  const getCurrentLanguageObject = useCallback((): Language | undefined => {
+    return store.getCurrentLanguage();
+  }, [store]);
+
+  const handleSetLanguage = useCallback(async (languageCode: string) => {
+    await store.setLanguage(languageCode);
+  }, [store]);
+
+  const handleInitialize = useCallback(async () => {
+    await store.initialize();
+  }, [store]);
+
+  const isLanguageSupported = useCallback((code: string) => {
+    return store.isLanguageSupported(code);
+  }, [store]);
+
+  const getSupportedLanguages = useCallback(() => {
+    return store.getSupportedLanguages();
+  }, [store]);
+
+  return {
+    // Translation function
+    t,
+    
+    // Current state
+    currentLanguage: store.currentLanguage,
+    currentLanguageObject: getCurrentLanguageObject(),
+    isRTL: store.isRTL,
+    isInitialized: store.isInitialized,
+    
+    // Actions
+    setLanguage: handleSetLanguage,
+    initialize: handleInitialize,
+    
+    // Utilities
+    isLanguageSupported,
+    supportedLanguages: getSupportedLanguages(),
+  };
+};

package/src/infrastructure/hooks/useTranslation.ts

@@ -1,14 +1,26 @@
 /**
  * Translation Hook
  *
- * Provides translation function with proper fallbacks
+ * Provides translation function with proper fallbacks and performance optimization
  * - React i18next integration
- * - Direct i18n fallback
+ * - Memoized translation function
  * - Type-safe translation function
  * - Auto-namespace detection from dot notation
+ * - Performance optimizations
  */
 
+import { useCallback, useMemo } from 'react';
 import i18n from '../config/i18n';
+import { TranslationCache } from '../config/TranslationCache';
+
+export interface TranslationOptions {
+  count?: number;
+  ns?: string | string[];
+  defaultValue?: string;
+  [key: string]: any;
+}
+
+const translationCache = new TranslationCache();
 
 /**
  * Hook for translation functionality
@@ -16,40 +28,83 @@ import i18n from '../config/i18n';
  * - t('namespace:key.subkey') - explicit namespace
  * - t('namespace.key.subkey') - auto-detected namespace (first segment before dot)
  */
-export const useTranslationFunction = (): ((key: string, options?: any) => string) => {
-  return (key: string, options?: any): string => {
-    if (!i18n.isInitialized || typeof i18n.t !== 'function') {
-      return key;
+export const useTranslationFunction = () => {
+  const isInitialized = useMemo(() => i18n.isInitialized, []);
+
+  const translate = useCallback((key: string, options: TranslationOptions = {}): string => {
+    if (!isInitialized || typeof i18n.t !== 'function') {
+      if (__DEV__) {
+        console.warn(`[Localization] i18n not initialized, returning key: ${key}`);
+      }
+      return options.defaultValue || key;
     }
 
+    // Create cache key
+    const cacheKey = `${key}:${JSON.stringify(options)}`;
+    
+    // Check cache first
+    const cached = translationCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    let result: string;
+
     // If key already has namespace separator (:), use as-is
     if (key.includes(':')) {
-      const result = i18n.t(key, options);
-      return typeof result === 'string' ? result : String(result);
-    }
+      const tempResult = i18n.t(key, options);
+      result = typeof tempResult === 'string' ? tempResult : key;
+    } else {
+      // Auto-detect namespace from first dot segment
+      const firstDotIndex = key.indexOf('.');
+      if (firstDotIndex > 0) {
+        const potentialNamespace = key.substring(0, firstDotIndex);
+        const restOfKey = key.substring(firstDotIndex + 1);
+
+        // Check if this namespace exists in i18n resources
+        const hasNamespace = i18n.hasResourceBundle(i18n.language, potentialNamespace);
 
-    // Auto-detect namespace from first dot segment
-    // e.g., 'settings.appearance.title' -> namespace: 'settings', key: 'appearance.title'
-    const firstDotIndex = key.indexOf('.');
-    if (firstDotIndex > 0) {
-      const potentialNamespace = key.substring(0, firstDotIndex);
-      const restOfKey = key.substring(firstDotIndex + 1);
-
-      // Check if this namespace exists in i18n resources
-      const hasNamespace = i18n.hasResourceBundle(i18n.language, potentialNamespace);
-
-      if (hasNamespace) {
-        const namespacedKey = `${potentialNamespace}:${restOfKey}`;
-        const result = i18n.t(namespacedKey, options);
-        // If translation found (not same as key), return it
-        if (result !== namespacedKey && result !== restOfKey) {
-          return typeof result === 'string' ? result : String(result);
+        if (hasNamespace) {
+          const namespacedKey = `${potentialNamespace}:${restOfKey}`;
+          const namespacedResult = i18n.t(namespacedKey, options);
+          
+          // If translation found (not same as key), use it
+          if (namespacedResult !== namespacedKey && namespacedResult !== restOfKey) {
+            result = typeof namespacedResult === 'string' ? namespacedResult : key;
+          } else {
+            // Fallback to original key
+            const fallbackResult = i18n.t(key, options);
+            result = typeof fallbackResult === 'string' ? fallbackResult : key;
+          }
+        } else {
+          // Fallback to original key
+          const tempResult = i18n.t(key, options);
+          result = typeof tempResult === 'string' ? tempResult : key;
         }
+      } else {
+        // No dot, use as-is
+        const noDotResult = i18n.t(key, options);
+        result = typeof noDotResult === 'string' ? noDotResult : key;
       }
     }
 
-    // Fallback: try original key as-is
-    const result = i18n.t(key, options);
-    return typeof result === 'string' ? result : String(result);
+    // Convert to string and cache
+    const finalResult: string = typeof result === 'string' ? result : key;
+    translationCache.set(cacheKey, finalResult);
+
+    return finalResult;
+  }, [isInitialized]);
+
+  // Clear cache when language changes
+  const clearCache = useCallback(() => {
+    translationCache.clear();
+    if (__DEV__) {
+      console.log('[Localization] Translation cache cleared');
+    }
+  }, []);
+
+  return {
+    t: translate,
+    clearCache,
   };
-};
+};

package/src/infrastructure/storage/LanguageInitializer.ts

@@ -9,9 +9,11 @@
 
 import { storageRepository } from '@umituz/react-native-storage';
 import i18n from '../config/i18n';
-import { DEFAULT_LANGUAGE, getLanguageByCode, getDeviceLocale } from '../config/languages';
+import { languageRegistry, getDefaultLanguage } from '../config/languagesData';
+import { getDeviceLocale } from '../config/languages';
 
 const LANGUAGE_STORAGE_KEY = '@localization:language';
+const DEFAULT_LANGUAGE = 'en-US';
 
 export class LanguageInitializer {
   /**
@@ -47,15 +49,15 @@ export class LanguageInitializer {
     languageCode: string;
     isRTL: boolean;
   }> {
-    const language = getLanguageByCode(languageCode);
-    const finalLanguageCode = language ? languageCode : DEFAULT_LANGUAGE;
-    const finalLanguageObj = getLanguageByCode(finalLanguageCode);
+    const language = languageRegistry.getLanguageByCode(languageCode);
+    const finalLanguageCode = language ? languageCode : 'en-US';
+    const finalLanguageObj = languageRegistry.getLanguageByCode(finalLanguageCode);
 
     await i18n.changeLanguage(finalLanguageCode);
 
     return {
       languageCode: finalLanguageCode,
-      isRTL: finalLanguageObj?.rtl || false,
+      isRTL: finalLanguageObj?.isRTL || false,
     };
   }
 

package/src/infrastructure/storage/LanguageSwitcher.ts

@@ -8,7 +8,7 @@
 
 import { storageRepository } from '@umituz/react-native-storage';
 import i18n from '../config/i18n';
-import { getLanguageByCode } from '../config/languages';
+import { languageRegistry } from '../config/languagesData';
 
 const LANGUAGE_STORAGE_KEY = '@localization:language';
 
@@ -20,7 +20,7 @@ export class LanguageSwitcher {
     languageCode: string;
     isRTL: boolean;
   }> {
-    const language = getLanguageByCode(languageCode);
+    const language = languageRegistry.getLanguageByCode(languageCode);
 
     if (!language) {
       throw new Error(`Unsupported language: ${languageCode}`);
@@ -31,7 +31,7 @@ export class LanguageSwitcher {
 
     return {
       languageCode,
-      isRTL: language.rtl || false,
+      isRTL: language.isRTL || false,
     };
   }
 }