@umituz/react-native-settings 4.23.35 → 4.23.36

package/src/domains/localization/infrastructure/config/NamespaceResolver.ts

@@ -0,0 +1,54 @@
+/**
+ * Namespace Resolver
+ * Resolves available namespaces from translations
+ */
+
+import { TranslationLoader } from './TranslationLoader';
+
+const DEFAULT_NAMESPACE = 'common';
+
+export class NamespaceResolver {
+  /**
+   * Get all available namespaces from package and app translations
+   */
+  static getNamespaces(
+    appTranslations: Record<string, any>,
+    languageCode: string
+  ): string[] {
+    const packageTranslations = TranslationLoader.loadPackageTranslations();
+    const packageLang = packageTranslations[languageCode] || {};
+
+    let appNamespaces: string[] = [];
+
+    // Check if appTranslations has language keys (format: xx-XX)
+    const hasLanguageKeys = Object.keys(appTranslations).some(key =>
+      /^[a-z]{2}-[A-Z]{2}$/.test(key)
+    );
+
+    if (hasLanguageKeys) {
+      // If structured by language, get namespaces from the requested language
+      const langTranslations = appTranslations[languageCode];
+      if (langTranslations && typeof langTranslations === 'object') {
+        appNamespaces = Object.keys(langTranslations);
+      }
+    } else {
+      // If structured by namespace (legacy/simple), keys are namespaces
+      appNamespaces = Object.keys(appTranslations);
+    }
+
+    const namespaces = new Set([
+      ...Object.keys(packageLang),
+      ...appNamespaces,
+    ]);
+
+    if (!namespaces.has(DEFAULT_NAMESPACE)) {
+      namespaces.add(DEFAULT_NAMESPACE);
+    }
+
+    return Array.from(namespaces);
+  }
+
+  static getDefaultNamespace(): string {
+    return DEFAULT_NAMESPACE;
+  }
+}

package/src/domains/localization/infrastructure/config/ResourceBuilder.ts

@@ -0,0 +1,72 @@
+/**
+ * Resource Builder
+ * Builds i18n resources from package and app translations
+ */
+
+import { TranslationLoader } from './TranslationLoader';
+
+export class ResourceBuilder {
+  /**
+   * Build resources with package + app translations
+   */
+  static buildResources(
+    appTranslations: Record<string, any>,
+    languageCode: string
+  ): Record<string, Record<string, any>> {
+    const packageTranslations = TranslationLoader.loadPackageTranslations();
+
+    // Initialize with package translations
+    const resources: Record<string, Record<string, any>> = { ...packageTranslations };
+
+    // Note: Do NOT create empty resources for unsupported languages
+    // i18next will properly fallback to fallbackLng when language not in resources
+
+    // Process app translations
+    for (const [key, value] of Object.entries(appTranslations)) {
+      // Check if the key is a language code (format: xx-XX)
+      const isLanguageKey = /^[a-z]{2}-[A-Z]{2}$/.test(key);
+
+      if (isLanguageKey) {
+        // It's a language key (e.g., "en-US")
+        const lang = key;
+
+        // Only process if value has actual content
+        if (value && typeof value === 'object' && Object.keys(value).length > 0) {
+          if (!resources[lang]) {
+            resources[lang] = {};
+          }
+          const namespaces = Object.keys(value);
+          const isFlatMap = namespaces.every(nsKey => typeof value[nsKey] === 'string');
+          
+          if (isFlatMap) {
+            // It's a flat map (e.g. { hello: 'Hello' }), wrap in 'common'
+            const defaultNs = 'common';
+            resources[lang][defaultNs] = TranslationLoader.mergeTranslations(
+              resources[lang][defaultNs] || {},
+              value
+            );
+          } else {
+            // It's already namespaced (e.g. { auth: {...} })
+            for (const [namespace, translations] of Object.entries(value)) {
+              resources[lang][namespace] = TranslationLoader.mergeTranslations(
+                resources[lang][namespace] || {},
+                translations as Record<string, any>
+              );
+            }
+          }
+        }
+      } else {
+        // It's a namespace for the default/current language (backward compatibility)
+        // Only add if the language exists in resources (to prevent creating empty resources)
+        if (value && typeof value === 'object' && resources[languageCode]) {
+          resources[languageCode][key] = TranslationLoader.mergeTranslations(
+            resources[languageCode][key] || {},
+            value
+          );
+        }
+      }
+    }
+
+    return resources;
+  }
+}

package/src/domains/localization/infrastructure/config/TranslationLoader.ts

@@ -0,0 +1,46 @@
+/**
+ * Translation Loader
+ *
+ * Loads package translations
+ */
+
+export class TranslationLoader {
+  /**
+   * Load package translations (empty by default - apps provide their own)
+   */
+  static loadPackageTranslations(): Record<string, any> {
+    // Package doesn't include any translations by default
+    // Consuming applications should provide their own translations
+    return { 'en-US': {} };
+  }
+
+  /**
+   * Deep merge translations (override wins)
+   */
+  static mergeTranslations(base: any, override: any): any {
+    if (!override || Object.keys(override).length === 0) {
+      return base;
+    }
+
+    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 {
+          merged[key] = overrideVal;
+        }
+      }
+    }
+
+    return merged;
+  }
+
+  private static isObject(val: any): boolean {
+    return val !== null && typeof val === 'object' && !Array.isArray(val);
+  }
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Simple tests for language repository
+ */
+
+import { languageRepository } from '../../repository/LanguageRepository';
+
+describe('LanguageRepository', () => {
+  beforeEach(() => {
+    languageRepository.clearLanguages();
+  });
+
+  it('should get default language', () => {
+    const defaultLang = languageRepository.getDefaultLanguage();
+    expect(defaultLang).toBeDefined();
+    expect(defaultLang.code).toBe('en-US');
+  });
+
+  it('should check if language is supported', () => {
+    const supported = languageRepository.isLanguageSupported('en-US');
+    expect(supported).toBe(true);
+  });
+
+  it('should check if language is not supported', () => {
+    const supported = languageRepository.isLanguageSupported('unknown');
+    expect(supported).toBe(false);
+  });
+
+  it('should get language by code', () => {
+    const language = languageRepository.getLanguageByCode('en-US');
+    expect(language).toBeDefined();
+    expect(language?.code).toBe('en-US');
+  });
+
+  it('should return undefined for unknown code', () => {
+    const language = languageRepository.getLanguageByCode('unknown');
+    expect(language).toBeUndefined();
+  });
+
+  it('should search languages', () => {
+    const results = languageRepository.searchLanguages('english');
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  it('should get supported languages', () => {
+    const languages = languageRepository.getLanguages();
+    expect(Array.isArray(languages)).toBe(true);
+    expect(languages.length).toBeGreaterThan(0);
+    // Should now support many languages (29+)
+    expect(languages.length).toBeGreaterThan(20);
+  });
+
+  it('should support newly added languages', () => {
+    expect(languageRepository.isLanguageSupported('cs-CZ')).toBe(true);
+    expect(languageRepository.isLanguageSupported('pt-BR')).toBe(true);
+    expect(languageRepository.isLanguageSupported('zh-TW')).toBe(true);
+    expect(languageRepository.isLanguageSupported('el-GR')).toBe(true);
+  });
+
+  it('should find language attributes correctly', () => {
+    const czech = languageRepository.getLanguageByCode('cs-CZ');
+    expect(czech).toBeDefined();
+    expect(czech?.name).toBe('Czech');
+    expect(czech?.flag).toBe('🇨🇿');
+
+    const brazil = languageRepository.getLanguageByCode('pt-BR');
+    expect(brazil).toBeDefined();
+    expect(brazil?.name).toBe('Portuguese (Brazil)');
+  });
+});

package/src/domains/localization/infrastructure/config/constants/defaultLanguages.ts

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

package/src/domains/localization/infrastructure/config/i18n.ts

@@ -0,0 +1,9 @@
+/**
+ * i18n Instance
+ *
+ * Raw i18n instance - use I18nInitializer for configuration
+ */
+
+import i18n from 'i18next';
+
+export default i18n;

package/src/domains/localization/infrastructure/config/languages.ts

@@ -0,0 +1,28 @@
+/**
+ * Languages Configuration - Main Export
+ * Central export point for all language-related functionality
+ */
+
+import { languageRepository } from '../repository/LanguageRepository';
+import type { Language } from '../storage/types/Language';
+
+// Re-export from DeviceLocale
+export { DEFAULT_LANGUAGE, getDeviceLocale } from './DeviceLocale';
+
+// Re-export from LanguageQuery
+export {
+  getSupportedLanguages,
+  getLanguageByCode,
+  isLanguageSupported,
+  getDefaultLanguage,
+  searchLanguages,
+} from './LanguageQuery';
+
+// Re-export from LocaleMapping
+export { LOCALE_MAPPING } from './LocaleMapping';
+
+// Backward compatibility
+export const getSUPPORTED_LANGUAGES = () => languageRepository.getLanguages();
+export const getLANGUAGES = () => languageRepository.getLanguages();
+export const SUPPORTED_LANGUAGES: Language[] = languageRepository.getLanguages();
+export const LANGUAGES = SUPPORTED_LANGUAGES;

package/src/domains/localization/infrastructure/config/languagesData.ts

@@ -0,0 +1,26 @@
+/**
+ * Language Data Exports
+ * Centralized exports for language management
+ */
+
+import { languageRepository } from '../repository/LanguageRepository';
+import { DEFAULT_LANGUAGES } from './constants/defaultLanguages';
+import type { Language } from '../storage/types/Language';
+
+export { languageRepository };
+export { DEFAULT_LANGUAGES };
+export type { Language };
+
+export const getLanguageByCode = (code: string) =>
+  languageRepository.getLanguageByCode(code);
+
+export const searchLanguages = (query: string) =>
+  languageRepository.searchLanguages(query);
+
+export const isLanguageSupported = (code: string) =>
+  languageRepository.isLanguageSupported(code);
+
+export const getDefaultLanguage = () =>
+  languageRepository.getDefaultLanguage();
+
+export const LANGUAGES = languageRepository.getLanguages();

package/src/domains/localization/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/domains/localization/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/domains/localization/infrastructure/hooks/useLanguageSelection.ts

@@ -0,0 +1,44 @@
+/**
+ * Language Selection Hook
+ * Manages language selection state and filtering
+ */
+
+import { useState, useMemo } from 'react';
+import { useLocalization } from './useLocalization';
+import { searchLanguages } from '../config/LanguageQuery';
+
+export const useLanguageSelection = () => {
+    const { currentLanguage, setLanguage } = useLocalization();
+    const [searchQuery, setSearchQuery] = useState('');
+    const [selectedCode, setSelectedCode] = useState(currentLanguage);
+
+    const filteredLanguages = useMemo(() => {
+        return searchLanguages(searchQuery);
+    }, [searchQuery]);
+
+    const handleLanguageSelect = async (code: string, onComplete?: () => void) => {
+        if (__DEV__) {
+            console.log('[useLanguageSelection] handleLanguageSelect called:', { code, currentLanguage });
+        }
+        setSelectedCode(code);
+        if (__DEV__) {
+            console.log('[useLanguageSelection] Calling setLanguage...');
+        }
+        await setLanguage(code);
+        if (__DEV__) {
+            console.log('[useLanguageSelection] Language changed to:', code);
+        }
+        onComplete?.();
+        if (__DEV__) {
+            console.log('[useLanguageSelection] onComplete callback executed');
+        }
+    };
+
+    return {
+        searchQuery,
+        setSearchQuery,
+        selectedCode,
+        filteredLanguages,
+        handleLanguageSelect,
+    };
+};

package/src/domains/localization/infrastructure/hooks/useLocalization.ts

@@ -0,0 +1,41 @@
+import { useCallback } from 'react';
+import { useLocalizationStore } from '../storage/LocalizationStore';
+import { useTranslationFunction } from './useTranslation';
+import type { Language } from '../../domain/repositories/ILocalizationRepository';
+
+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 {
+    t,
+    currentLanguage: store.currentLanguage,
+    currentLanguageObject: getCurrentLanguageObject(),
+    isRTL: store.isRTL,
+    isInitialized: store.isInitialized,
+    setLanguage: handleSetLanguage,
+    initialize: handleInitialize,
+    isLanguageSupported,
+    supportedLanguages: getSupportedLanguages(),
+  };
+};

package/src/domains/localization/infrastructure/hooks/useTranslation.ts

@@ -0,0 +1,94 @@
+/**
+ * Translation Hook
+ *
+ * Provides translation function with proper language change reactivity
+ * - React i18next integration for automatic language change detection
+ * - Auto-namespace detection from dot notation
+ * - Type-safe translation function
+ */
+
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import i18n from '../config/i18n';
+
+export interface TranslationOptions {
+  count?: number;
+  ns?: string | string[];
+  defaultValue?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Hook for translation functionality
+ * Uses react-i18next for automatic language change reactivity
+ *
+ * Supports both formats:
+ * - t('namespace:key.subkey') - explicit namespace
+ * - t('namespace.key.subkey') - auto-detected namespace (first segment before dot)
+ */
+export const useTranslationFunction = () => {
+  const { t: i18nextT, ready } = useTranslation(undefined, { i18n });
+
+  const translate = useCallback((key: string, defaultValueOrOptions?: string | TranslationOptions): string => {
+    const options: TranslationOptions = typeof defaultValueOrOptions === 'string'
+      ? { defaultValue: defaultValueOrOptions }
+      : defaultValueOrOptions || {};
+
+    if (!ready || !i18n.isInitialized) {
+      return options.defaultValue || key;
+    }
+
+    let finalResult: string;
+    let translationFound = false;
+
+    // If key already has namespace separator (:), use as-is
+    if (key.includes(':')) {
+      const result = i18nextT(key, options);
+      finalResult = typeof result === 'string' ? result : key;
+      translationFound = finalResult !== key && finalResult !== options.defaultValue;
+    } 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);
+        const hasNamespace = i18n.hasResourceBundle(i18n.language, potentialNamespace);
+
+        if (hasNamespace) {
+          const namespacedKey = `${potentialNamespace}:${restOfKey}`;
+          const namespacedResult = i18nextT(namespacedKey, options);
+
+          if (namespacedResult !== namespacedKey && namespacedResult !== restOfKey) {
+            finalResult = typeof namespacedResult === 'string' ? namespacedResult : key;
+            translationFound = true;
+          } else {
+            // Fallback to original key
+            const result = i18nextT(key, options);
+            finalResult = typeof result === 'string' ? result : key;
+            translationFound = finalResult !== key && finalResult !== options.defaultValue;
+          }
+        } else {
+          // Fallback to original key
+          const result = i18nextT(key, options);
+          finalResult = typeof result === 'string' ? result : key;
+          translationFound = finalResult !== key && finalResult !== options.defaultValue;
+        }
+      } else {
+        // Fallback to original key
+        const result = i18nextT(key, options);
+        finalResult = typeof result === 'string' ? result : key;
+        translationFound = finalResult !== key && finalResult !== options.defaultValue;
+      }
+    }
+
+    if (__DEV__ && !translationFound) {
+      console.warn(`[Localization] Translation missing for key: "${key}" in language: "${i18n.language}"`);
+    }
+
+    return finalResult;
+  }, [i18nextT, ready]);
+
+  return {
+    t: translate,
+  };
+};