@umituz/react-native-settings 4.23.35 → 4.23.37

package/src/domains/localization/scripts/translate-missing.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * Translate Missing Script
+ * Automatically translates missing strings using Google Translate
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { parseTypeScriptFile, generateTypeScriptContent } from './utils/file-parser.js';
+import { getTargetLanguage, getLangDisplayName } from './utils/translation-config.js';
+import { translateObject } from './utils/translator.js';
+import { setupLanguages } from './setup-languages.js';
+import { syncTranslations } from './sync-translations.js';
+
+async function translateMissing(targetDir, srcDir) {
+  const localesDir = path.resolve(process.cwd(), targetDir);
+  const enUSPath = path.join(localesDir, 'en-US.ts');
+
+  // Integrated Workflow: Ensure setup and sync
+  const skipSync = process.argv.includes('--no-sync');
+
+  if (!fs.existsSync(path.join(localesDir, 'index.ts'))) {
+    console.log('🔄 Initializing localization setup...');
+    setupLanguages(targetDir);
+  }
+
+  if (!skipSync) {
+    console.log('\n🔄 Checking synchronization...');
+    syncTranslations(targetDir, srcDir);
+  } else {
+    console.log('\n⏭️ Skipping synchronization check...');
+  }
+
+  const files = fs.readdirSync(localesDir)
+    .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
+    .sort();
+
+  console.log(`\n📊 Languages to translate: ${files.length}\n`);
+
+  const enUS = parseTypeScriptFile(enUSPath);
+
+  for (const file of files) {
+    const langCode = file.replace('.ts', '');
+    const targetLang = getTargetLanguage(langCode);
+    const langName = getLangDisplayName(langCode);
+
+    if (!targetLang || targetLang === 'en') continue;
+
+    console.log(`🌍 Translating ${langCode} (${langName})...`);
+    
+    const targetPath = path.join(localesDir, file);
+    const target = parseTypeScriptFile(targetPath);
+    
+    const stats = { count: 0, checked: 0, translatedKeys: [] };
+    await translateObject(enUS, target, targetLang, '', stats);
+    
+    // Clear progress line
+    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+
+    if (stats.count > 0) {
+      const content = generateTypeScriptContent(target, langCode);
+      fs.writeFileSync(targetPath, content);
+      
+      console.log(`      ✅ Successfully translated ${stats.count} keys:`);
+      
+      // Detailed logging of translated keys
+      const displayCount = Math.min(stats.translatedKeys.length, 15);
+      stats.translatedKeys.slice(0, displayCount).forEach(item => {
+        console.log(`         • ${item.key}: "${item.from}" → "${item.to}"`);
+      });
+      
+      if (stats.translatedKeys.length > displayCount) {
+        console.log(`         ... and ${stats.translatedKeys.length - displayCount} more.`);
+      }
+    } else {
+      console.log(`      ✨ Already up to date.`);
+    }
+  }
+
+  console.log('\n✅ All translations completed!');
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
+  const srcDir = process.argv[3];
+  console.log('🚀 Starting integrated translation workflow...');
+  translateMissing(targetDir, srcDir).catch(err => {
+    console.error('\n❌ Translation workflow failed:', err.message);
+    process.exit(1);
+  });
+}

package/src/domains/localization/scripts/utils/file-parser.js

@@ -0,0 +1,78 @@
+import fs from 'fs';
+import { getLangDisplayName } from './translation-config.js';
+
+/**
+ * File Parser
+ * Parse and generate TypeScript translation files
+ */
+
+export function parseTypeScriptFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const match = content.match(/export\s+default\s+(\{[\s\S]*\});?\s*$/);
+
+  if (!match) {
+    throw new Error(`Could not parse TypeScript file: ${filePath}`);
+  }
+
+  const objectStr = match[1].replace(/;$/, '');
+
+  try {
+    // Basic evaluation for simple objects
+    // eslint-disable-next-line no-eval
+    return eval(`(${objectStr})`);
+  } catch (error) {
+    console.warn(`\n⚠️  Warning: Could not fully parse ${filePath}. Files with complex imports/spreads are currently limited.`);
+    return {}; // Return empty to avoid breaking the whole process
+  }
+}
+
+export function stringifyValue(value, indent = 2) {
+  if (typeof value === 'string') {
+    const escaped = value
+      .replace(/\\/g, '\\\\')
+      .replace(/"/g, '\\"')
+      .replace(/\n/g, '\\n');
+    return `"${escaped}"`;
+  }
+
+  if (Array.isArray(value)) {
+    if (value.length === 0) return '[]';
+    const items = value.map(v => stringifyValue(v, indent + 2));
+    return `[${items.join(', ')}]`;
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    const entries = Object.entries(value);
+
+    if (entries.length === 0) {
+      return '{}';
+    }
+
+    const spaces = ' '.repeat(indent);
+    const innerSpaces = ' '.repeat(indent + 2);
+    const entriesStr = entries
+      .sort((a, b) => a[0].localeCompare(b[0]))
+      .map(([k, v]) => {
+        const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : `"${k}"`;
+        return `${innerSpaces}${key}: ${stringifyValue(v, indent + 2)}`;
+      })
+      .join(',\n');
+    return `{\n${entriesStr},\n${spaces}}`;
+  }
+
+  return String(value);
+}
+
+export function generateTypeScriptContent(obj, langCode) {
+  const langName = getLangDisplayName(langCode);
+  const isBase = langCode === 'en-US';
+  const objString = stringifyValue(obj, 0);
+
+  return `/**
+ * ${langName} Translations
+ * ${isBase ? 'Base translations file' : 'Auto-synced from en-US.ts'}
+ */
+
+export default ${objString};
+`;
+}

package/src/domains/localization/scripts/utils/key-detector.js

@@ -0,0 +1,45 @@
+/**
+ * Key Detector
+ * Detects new, missing, and removed keys between source and target objects
+ */
+
+export function detectNewKeys(sourceObj, targetObj, path = '', newKeys = []) {
+  for (const key in sourceObj) {
+    const currentPath = path ? `${path}.${key}` : key;
+    const sourceValue = sourceObj[key];
+    const targetValue = targetObj[key];
+
+    if (!Object.prototype.hasOwnProperty.call(targetObj, key)) {
+      newKeys.push({ path: currentPath, value: sourceValue });
+    } else if (
+      typeof sourceValue === 'object' &&
+      sourceValue !== null &&
+      !Array.isArray(sourceValue)
+    ) {
+      if (typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)) {
+        detectNewKeys(sourceValue, targetValue, currentPath, newKeys);
+      }
+    }
+  }
+  return newKeys;
+}
+
+export function detectMissingKeys(sourceObj, targetObj, path = '', missingKeys = []) {
+  for (const key in targetObj) {
+    const currentPath = path ? `${path}.${key}` : key;
+
+    if (!Object.prototype.hasOwnProperty.call(sourceObj, key)) {
+      missingKeys.push(currentPath);
+    } else if (
+      typeof sourceObj[key] === 'object' &&
+      sourceObj[key] !== null &&
+      !Array.isArray(sourceObj[key]) &&
+      typeof targetObj[key] === 'object' &&
+      targetObj[key] !== null &&
+      !Array.isArray(targetObj[key])
+    ) {
+      detectMissingKeys(sourceObj[key], targetObj[key], currentPath, missingKeys);
+    }
+  }
+  return missingKeys;
+}

package/src/domains/localization/scripts/utils/key-extractor.js

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Generic Key Extractor
+ * Scans source code for i18n translation keys
+ * NO project-specific logic - works for any React Native app
+ */
+
+const IGNORED_DOMAINS = ['.com', '.org', '.net', '.io', '.co', '.app', '.ai', '.gov', '.edu'];
+const IGNORED_EXTENSIONS = [
+  '.ts', '.tsx', '.js', '.jsx', '.json', '.yaml', '.yml',
+  '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.pdf',
+  '.mp4', '.mov', '.avi', '.mp3', '.wav', '.css', '.scss', '.md'
+];
+const IGNORED_LAYOUT_VALS = new Set([
+  'center', 'row', 'column', 'flex', 'absolute', 'relative', 'hidden', 'visible',
+  'transparent', 'bold', 'normal', 'italic', 'contain', 'cover', 'stretch',
+  'top', 'bottom', 'left', 'right', 'middle', 'auto', 'none', 'underline',
+  'capitalize', 'uppercase', 'lowercase', 'solid', 'dotted', 'dashed', 'wrap',
+  'nowrap', 'space-between', 'space-around', 'flex-start', 'flex-end', 'baseline',
+  'react', 'index', 'default', 'string', 'number', 'boolean', 'key', 'id'
+]);
+
+function extractFromFile(content, keyMap) {
+  // Pattern 1: t('key') or t("key")
+  const tRegex = /(?:^|\W)t\(['"`]([^'"`]+)['"`]\)/g;
+  let match;
+  while ((match = tRegex.exec(content)) !== null) {
+    const key = match[1];
+    if (!key.includes('${') && !keyMap.has(key)) {
+      keyMap.set(key, key); // Use key itself as default
+    }
+  }
+
+  // Pattern 2: Dot-notation strings (potential i18n keys)
+  const dotRegex = /['"`]([a-z][a-z0-9_]*\.(?:[a-z0-9_]+\.)+[a-z0-9_]+)['"`]/gi;
+  while ((match = dotRegex.exec(content)) !== null) {
+    const key = match[1];
+    const isIgnoredDomain = IGNORED_DOMAINS.some(ext => key.toLowerCase().endsWith(ext));
+    const isIgnoredExt = IGNORED_EXTENSIONS.some(ext => key.toLowerCase().endsWith(ext));
+    if (!isIgnoredDomain && !isIgnoredExt && !key.includes(' ') && !keyMap.has(key)) {
+      keyMap.set(key, key);
+    }
+  }
+
+  // Pattern 3: Template literals t(`prefix.${var}`)
+  const templateRegex = /t\(\`([a-z0-9_.]+)\.\$\{/g;
+  while ((match = templateRegex.exec(content)) !== null) {
+    const prefix = match[1];
+    const arrayMatches = content.matchAll(/\[([\s\S]*?)\]/g);
+    for (const arrayMatch of arrayMatches) {
+      const inner = arrayMatch[1];
+      const idMatches = inner.matchAll(/['"`]([a-z0-9_]{2,40})['"`]/g);
+      for (const idMatch of idMatches) {
+        const id = idMatch[1];
+        if (IGNORED_LAYOUT_VALS.has(id.toLowerCase())) continue;
+        if (/^[0-9]+$/.test(id)) continue;
+        
+        const dynamicKey = `${prefix}.${id}`;
+        if (!keyMap.has(dynamicKey)) {
+          keyMap.set(dynamicKey, dynamicKey);
+        }
+      }
+    }
+  }
+}
+
+function walkDirectory(dir, keyMap, skipDirs = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets', 'locales', '__tests__']) {
+  if (!fs.existsSync(dir)) return;
+  
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      if (!skipDirs.includes(file)) {
+        walkDirectory(fullPath, keyMap, skipDirs);
+      }
+    } else if (/\.(ts|tsx|js|jsx)$/.test(file)) {
+      const content = fs.readFileSync(fullPath, 'utf8');
+      extractFromFile(content, keyMap);
+    }
+  }
+}
+
+export function extractUsedKeys(srcDir) {
+  const keyMap = new Map();
+  if (!srcDir) return keyMap;
+
+  const projectRoot = process.cwd();
+  const absoluteSrcDir = path.resolve(projectRoot, srcDir);
+  
+  // Scan project source
+  walkDirectory(absoluteSrcDir, keyMap);
+  
+  // Scan @umituz packages for shared keys
+  const packagesDir = path.resolve(projectRoot, 'node_modules/@umituz');
+  if (fs.existsSync(packagesDir)) {
+    walkDirectory(packagesDir, keyMap);
+  }
+  
+  return keyMap;
+}

package/src/domains/localization/scripts/utils/object-helper.js

@@ -0,0 +1,29 @@
+/**
+ * Object Helper
+ * Utilities for deep object manipulation
+ */
+
+/**
+ * Set a value in a nested object, creating intermediate objects if necessary
+ * Returns true if the key was newly added, false if it already existed
+ */
+export function setDeep(obj, path, value) {
+  const keys = path.split('.');
+  let current = obj;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!current[key] || typeof current[key] !== 'object' || Array.isArray(current[key])) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  const lastKey = keys[keys.length - 1];
+  if (current[lastKey] === undefined) {
+    current[lastKey] = value;
+    return true;
+  }
+  
+  return false;
+}

package/src/domains/localization/scripts/utils/sync-helper.js

@@ -0,0 +1,49 @@
+/**
+ * Sync Helper
+ * Helper functions for synchronizing translation keys
+ */
+
+export function addMissingKeys(sourceObj, targetObj, stats = { added: 0, newKeys: [] }) {
+  for (const key in sourceObj) {
+    const sourceValue = sourceObj[key];
+    const isNewKey = !Object.prototype.hasOwnProperty.call(targetObj, key);
+
+    if (isNewKey) {
+      targetObj[key] = sourceValue;
+      stats.added++;
+      stats.newKeys.push(key);
+    } else if (
+      typeof sourceValue === 'object' &&
+      sourceValue !== null &&
+      !Array.isArray(sourceValue)
+    ) {
+      if (!targetObj[key] || typeof targetObj[key] !== 'object') {
+        targetObj[key] = {};
+      }
+      addMissingKeys(sourceValue, targetObj[key], stats);
+    }
+  }
+  return stats;
+}
+
+export function removeExtraKeys(sourceObj, targetObj, stats = { removed: 0, removedKeys: [] }) {
+  for (const key in targetObj) {
+    const isExtraKey = !Object.prototype.hasOwnProperty.call(sourceObj, key);
+
+    if (isExtraKey) {
+      delete targetObj[key];
+      stats.removed++;
+      stats.removedKeys.push(key);
+    } else if (
+      typeof sourceObj[key] === 'object' &&
+      sourceObj[key] !== null &&
+      !Array.isArray(sourceObj[key]) &&
+      typeof targetObj[key] === 'object' &&
+      targetObj[key] !== null &&
+      !Array.isArray(targetObj[key])
+    ) {
+      removeExtraKeys(sourceObj[key], targetObj[key], stats);
+    }
+  }
+  return stats;
+}

package/src/domains/localization/scripts/utils/translation-config.js

@@ -0,0 +1,116 @@
+/**
+ * Translation Configuration
+ * Language mappings and constants for translation system
+ */
+
+export const LANGUAGE_MAP = {
+  'ar-SA': 'ar',
+  'bg-BG': 'bg',
+  'cs-CZ': 'cs',
+  'da-DK': 'da',
+  'de-DE': 'de',
+  'el-GR': 'el',
+  'en-AU': 'en',
+  'en-CA': 'en',
+  'en-GB': 'en',
+  'es-ES': 'es',
+  'es-MX': 'es',
+  'fi-FI': 'fi',
+  'fr-CA': 'fr',
+  'fr-FR': 'fr',
+  'hi-IN': 'hi',
+  'hr-HR': 'hr',
+  'hu-HU': 'hu',
+  'id-ID': 'id',
+  'it-IT': 'it',
+  'ja-JP': 'ja',
+  'ko-KR': 'ko',
+  'ms-MY': 'ms',
+  'nl-NL': 'nl',
+  'no-NO': 'no',
+  'pl-PL': 'pl',
+  'pt-BR': 'pt',
+  'pt-PT': 'pt',
+  'ro-RO': 'ro',
+  'ru-RU': 'ru',
+  'sk-SK': 'sk',
+  'sl-SI': 'sl',
+  'sv-SE': 'sv',
+  'th-TH': 'th',
+  'tl-PH': 'tl',
+  'tr-TR': 'tr',
+  'uk-UA': 'uk',
+  'vi-VN': 'vi',
+  'zh-CN': 'zh-CN',
+  'zh-TW': 'zh-TW',
+};
+
+export const SKIP_WORDS = new Set([
+  'Google',
+  'Apple',
+  'Facebook',
+  'Instagram',
+  'Twitter',
+  'YouTube',
+  'WhatsApp',
+]);
+
+export const LANGUAGE_NAMES = {
+  'ar-SA': 'Arabic (Saudi Arabia)',
+  'bg-BG': 'Bulgarian',
+  'cs-CZ': 'Czech',
+  'da-DK': 'Danish',
+  'de-DE': 'German',
+  'el-GR': 'Greek',
+  'en-AU': 'English (Australia)',
+  'en-CA': 'English (Canada)',
+  'en-GB': 'English (UK)',
+  'en-US': 'English (US)',
+  'es-ES': 'Spanish (Spain)',
+  'es-MX': 'Spanish (Mexico)',
+  'fi-FI': 'Finnish',
+  'fr-CA': 'French (Canada)',
+  'fr-FR': 'French (France)',
+  'hi-IN': 'Hindi',
+  'hr-HR': 'Croatian',
+  'hu-HU': 'Hungarian',
+  'id-ID': 'Indonesian',
+  'it-IT': 'Italian',
+  'ja-JP': 'Japanese',
+  'ko-KR': 'Korean',
+  'ms-MY': 'Malay',
+  'nl-NL': 'Dutch',
+  'no-NO': 'Norwegian',
+  'pl-PL': 'Polish',
+  'pt-BR': 'Portuguese (Brazil)',
+  'pt-PT': 'Portuguese (Portugal)',
+  'ro-RO': 'Romanian',
+  'ru-RU': 'Russian',
+  'sk-SK': 'Slovak',
+  'sl-SI': 'Slovenian',
+  'sv-SE': 'Swedish',
+  'th-TH': 'Thai',
+  'tl-PH': 'Tagalog',
+  'tr-TR': 'Turkish',
+  'uk-UA': 'Ukrainian',
+  'vi-VN': 'Vietnamese',
+  'zh-CN': 'Chinese (Simplified)',
+  'zh-TW': 'Chinese (Traditional)',
+};
+
+export function getLangDisplayName(code) {
+  return LANGUAGE_NAMES[code] || code;
+}
+
+export function getTargetLanguage(langCode) {
+  return LANGUAGE_MAP[langCode];
+}
+
+export function shouldSkipWord(word) {
+  return SKIP_WORDS.has(word);
+}
+
+export function isEnglishVariant(langCode) {
+  const targetLang = LANGUAGE_MAP[langCode];
+  return targetLang === 'en';
+}

package/src/domains/localization/scripts/utils/translator.js

@@ -0,0 +1,83 @@
+/**
+ * Translation Utilities
+ * Handles call to translation APIs
+ */
+
+import { getTargetLanguage, shouldSkipWord } from './translation-config.js';
+
+let lastCallTime = 0;
+const MIN_DELAY = 100; // ms
+
+async function translateText(text, targetLang) {
+  if (!text || typeof text !== 'string') return text;
+  if (shouldSkipWord(text)) return text;
+
+  // Rate limiting
+  const now = Date.now();
+  const waitTime = Math.max(0, MIN_DELAY - (now - lastCallTime));
+  if (waitTime > 0) await new Promise(resolve => setTimeout(resolve, waitTime));
+  lastCallTime = Date.now();
+
+  try {
+    const encodedText = encodeURIComponent(text);
+    const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=en&tl=${targetLang}&dt=t&q=${encodedText}`;
+    
+    const response = await fetch(url);
+    if (!response.ok) return text;
+    
+    const data = await response.json();
+    return data && data[0] && data[0][0] && data[0][0][0] ? data[0][0][0] : text;
+  } catch (error) {
+    return text;
+  }
+}
+
+function needsTranslation(value, enValue) {
+  if (typeof enValue !== 'string' || !enValue.trim()) return false;
+  if (shouldSkipWord(enValue)) return false;
+
+  // CRITICAL OPTIMIZATION: If enValue is a technical key (e.g. "scenario.xxx.title"),
+  // skip translating it to other languages. We only translate REAL English content.
+  const isTechnicalKey = enValue.includes('.') && !enValue.includes(' ');
+  if (isTechnicalKey) return false;
+
+  // If value is missing or same as English, it needs translation
+  if (!value || typeof value !== 'string') return true;
+
+  if (value === enValue) {
+    const isSingleWord = !enValue.includes(' ') && enValue.length < 20;
+    return !isSingleWord;
+  }
+
+  return false;
+}
+
+export async function translateObject(enObj, targetObj, targetLang, path = '', stats = { count: 0, checked: 0, translatedKeys: [] }) {
+  const keys = Object.keys(enObj);
+  
+  if (!stats.translatedKeys) stats.translatedKeys = [];
+
+  for (const key of keys) {
+    const enValue = enObj[key];
+    const targetValue = targetObj[key];
+    const currentPath = path ? `${path}.${key}` : key;
+
+    if (typeof enValue === 'object' && enValue !== null) {
+      if (!targetObj[key] || typeof targetObj[key] !== 'object') targetObj[key] = {};
+      await translateObject(enValue, targetObj[key], targetLang, currentPath, stats);
+    } else if (typeof enValue === 'string') {
+      stats.checked++;
+      if (needsTranslation(targetValue, enValue)) {
+        // Show progress for translations
+        process.stdout.write(`   \r      Progress: ${stats.checked} keys checked, ${stats.count} translated...`);
+        
+        const translated = await translateText(enValue, targetLang);
+        if (translated !== enValue) {
+          targetObj[key] = translated;
+          stats.count++;
+          stats.translatedKeys.push({ key: currentPath, from: enValue, to: translated });
+        }
+      }
+    }
+  }
+}

package/src/domains/notifications/presentation/components/NotificationsSection.tsx

@@ -1,7 +1,7 @@
 import React, { useCallback } from 'react';
 import type { StyleProp, ViewStyle } from 'react-native';
 import { useAppNavigation } from '@umituz/react-native-design-system';
-import { useLocalization } from '@umituz/react-native-localization';
+import { useLocalization } from '../../../localization';
 import { SettingsItemCard } from '../../../../presentation/components/SettingsItemCard';
 
 export interface NotificationsSectionConfig {

package/src/domains/notifications/presentation/screens/NotificationSettingsScreen.tsx

@@ -13,7 +13,7 @@ import {
   useAppDesignTokens,
   useAppNavigation
 } from '@umituz/react-native-design-system';
-import { useLocalization } from '@umituz/react-native-localization';
+import { useLocalization } from '../../../localization';
 import { QuietHoursCard } from '../../quietHours/presentation/components/QuietHoursCard';
 import { SettingRow } from '../components/SettingRow';
 import { RemindersNavRow } from '../components/RemindersNavRow';

package/src/index.ts

@@ -138,6 +138,8 @@ export * from "./domains/dev";
 // Gamification Domain - Achievements, levels, streaks
 export * from "./domains/gamification";
 
+// Localization Domain - i18n, language selection, translations
+export * from "./domains/localization";
 
 // =============================================================================
 // PRESENTATION LAYER - Config Creator Utilities

package/src/presentation/components/SettingsErrorBoundary.tsx

@@ -7,7 +7,7 @@ import React, { Component, ReactNode } from 'react';
 import { View, StyleSheet } from 'react-native';
 import { useAppDesignTokens } from '@umituz/react-native-design-system';
 import { AtomicText, AtomicIcon } from '@umituz/react-native-design-system';
-import { useLocalization } from '@umituz/react-native-localization';
+import { useLocalization } from '../../domains/localization';
 
 interface Props {
   children: ReactNode;

package/src/presentation/navigation/SettingsStackNavigator.tsx

@@ -7,7 +7,7 @@
 
 import React from "react";
 import { useAppDesignTokens, StackNavigator, type StackScreen, type StackNavigatorConfig } from "@umituz/react-native-design-system";
-import { useLocalization, LanguageSelectionScreen } from "@umituz/react-native-localization";
+import { useLocalization, LanguageSelectionScreen } from "../../domains/localization";
 import { NotificationSettingsScreen } from "../../domains/notifications";
 import { AccountScreen } from "@umituz/react-native-auth";
 import { AppearanceScreen } from "../screens/AppearanceScreen";

package/src/presentation/screens/components/SettingsContent.tsx

@@ -1,6 +1,6 @@
 import React, { useMemo } from "react";
 import { View, StyleSheet } from "react-native";
-import { useLocalization } from "@umituz/react-native-localization";
+import { useLocalization } from "../../../domains/localization";
 import { SettingsFooter } from "../../components/SettingsFooter";
 import { SettingsSection } from "../../components/SettingsSection";
 import { DevSettingsSection, DevSettingsProps } from "../../../domains/dev";

package/src/presentation/screens/components/SettingsHeader.tsx

@@ -6,7 +6,7 @@
 import React from "react";
 import { View, Pressable, StyleSheet } from "react-native";
 import { useAppDesignTokens, AtomicIcon, AtomicText, useAppNavigation } from "@umituz/react-native-design-system";
-import { useLocalization } from "@umituz/react-native-localization";
+import { useLocalization } from "../../../domains/localization";
 
 interface SettingsHeaderProps {
   showCloseButton?: boolean;

package/src/presentation/screens/components/sections/FeatureSettingsSection.tsx

@@ -2,7 +2,7 @@ import React from "react";
 import { useAppNavigation } from "@umituz/react-native-design-system";
 import { AppearanceSection } from "../../../../domains/appearance/presentation/components/AppearanceSection";
 import { NotificationsSection } from "../../../../domains/notifications";
-import { useLocalization, getLanguageByCode } from "@umituz/react-native-localization";
+import { useLocalization, getLanguageByCode } from "../../../../domains/localization";
 import { SettingsItemCard } from "../../../components/SettingsItemCard";
 import type { NormalizedConfig } from "../../utils/normalizeConfig";