@umituz/react-native-localization 3.7.10 → 3.7.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-localization",
-  "version": "3.7.10",
+  "version": "3.7.12",
   "type": "module",
   "description": "Generic localization system for React Native apps with i18n support",
   "main": "./src/index.ts",
@@ -10,7 +10,11 @@
     "lint": "eslint src --ext .ts,.tsx --max-warnings 0",
     "version:patch": "npm version patch -m 'chore: release v%s'",
     "version:minor": "npm version minor -m 'chore: release v%s'",
-    "version:major": "npm version major -m 'chore: release v%s'"
+    "version:major": "npm version major -m 'chore: release v%s'",
+    "i18n:setup": "node src/scripts/setup-languages.js",
+    "i18n:check": "node src/scripts/sync-translations.js",
+    "i18n:sync": "node src/scripts/sync-translations.js",
+    "i18n:translate": "node src/scripts/translate-missing.js"
   },
   "keywords": [
     "react-native",

package/src/scripts/sync-translations.js

@@ -11,7 +11,6 @@ import path from 'path';
 import { parseTypeScriptFile, generateTypeScriptContent } from './utils/file-parser.js';
 import { addMissingKeys, removeExtraKeys } from './utils/sync-helper.js';
 import { detectNewKeys } from './utils/key-detector.js';
-import { getLangDisplayName } from './utils/translation-config.js';
 import { extractUsedKeys } from './utils/key-extractor.js';
 import { setDeep } from './utils/object-helper.js';
 
@@ -45,21 +44,47 @@ function syncLanguageFile(enUSPath, targetPath, langCode) {
 function processExtraction(srcDir, enUSPath) {
   if (!srcDir) return;
 
-  console.log(`🔍 Scanning source code: ${srcDir}...`);
-  const usedKeys = extractUsedKeys(srcDir);
-  console.log(`   Found ${usedKeys.size} unique keys in code.`);
+  console.log(`🔍 Scanning source code and dependencies: ${srcDir}...`);
+  const usedKeyMap = extractUsedKeys(srcDir);
+  console.log(`   Found ${usedKeyMap.size} unique keys.`);
 
-  const enUS = parseTypeScriptFile(enUSPath);
+  const oldEnUS = parseTypeScriptFile(enUSPath);
+  const newEnUS = {}; 
+  
   let addedCount = 0;
-  for (const key of usedKeys) {
-    if (setDeep(enUS, key, key)) addedCount++;
+  for (const [key, defaultValue] of usedKeyMap) {
+    // Try to keep existing translation if it exists
+    const existingValue = key.split('.').reduce((obj, k) => (obj && obj[k]), oldEnUS);
+    
+    // We treat it as "not translated" if the value is exactly the key string
+    const isActuallyTranslated = typeof existingValue === 'string' && existingValue !== key;
+    const valueToSet = isActuallyTranslated ? existingValue : defaultValue;
+    
+    if (setDeep(newEnUS, key, valueToSet)) {
+      if (!isActuallyTranslated) addedCount++;
+    }
   }
 
-  if (addedCount > 0) {
-    console.log(`   ✨ Added ${addedCount} new keys to en-US.ts`);
-    const content = generateTypeScriptContent(enUS, 'en-US');
-    fs.writeFileSync(enUSPath, content);
-  }
+  // Count keys in objects
+  const getKeysCount = (obj) => {
+    let count = 0;
+    const walk = (o) => {
+      for (const k in o) {
+        if (typeof o[k] === 'object' && o[k] !== null) walk(o[k]);
+        else count++;
+      }
+    };
+    walk(obj);
+    return count;
+  };
+  
+  const oldTotal = getKeysCount(oldEnUS);
+  const newTotal = getKeysCount(newEnUS);
+  const removedCount = oldTotal - (newTotal - addedCount);
+
+  console.log(`   ✨ Optimized en-US.ts: ${addedCount} keys populated/updated, pruned ${Math.max(0, removedCount)} unused.`);
+  const content = generateTypeScriptContent(newEnUS, 'en-US');
+  fs.writeFileSync(enUSPath, content);
 }
 
 export function syncTranslations(targetDir, srcDir) {

package/src/scripts/translate-missing.js

@@ -2,106 +2,91 @@
 
 /**
  * Translate Missing Script
- * Translates missing strings from en-US.ts to all other language files
- * Usage: node translate-missing.js [locales-dir] [src-dir-optional] [lang-code-optional]
+ * Automatically translates missing strings using Google Translate
  */
 
 import fs from 'fs';
 import path from 'path';
-import { getTargetLanguage, isEnglishVariant, getLangDisplayName } from './utils/translation-config.js';
 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 translateLanguageFile(enUSPath, targetPath, langCode) {
-  const targetLang = getTargetLanguage(langCode);
-
-  if (!targetLang) {
-    console.log(`   ⚠️  No language mapping for ${langCode}, skipping`);
-    return { count: 0, newKeys: [] };
-  }
-
-  if (isEnglishVariant(langCode)) {
-    console.log(`   ⏭️  Skipping English variant: ${langCode}`);
-    return { count: 0, newKeys: [] };
-  }
-
-  const enUS = parseTypeScriptFile(enUSPath);
-  let target;
-
-  try {
-    target = parseTypeScriptFile(targetPath);
-  } catch {
-    target = {};
-  }
-
-  const stats = { count: 0, newKeys: [] };
-  await translateObject(enUS, target, targetLang, '', stats);
-
-  if (stats.count > 0) {
-    const content = generateTypeScriptContent(target, langCode);
-    fs.writeFileSync(targetPath, content);
-  }
-
-  return stats;
-}
-
-async function main() {
-  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
-  const srcDir = process.argv[3];
-  const targetLangCode = process.argv[4];
-  
+async function translateMissing(targetDir, srcDir) {
   const localesDir = path.resolve(process.cwd(), targetDir);
   const enUSPath = path.join(localesDir, 'en-US.ts');
-  const indexPath = path.join(localesDir, 'index.ts');
 
-  console.log('🚀 Starting integrated translation workflow...\n');
+  // Integrated Workflow: Ensure setup and sync
+  const skipSync = process.argv.includes('--no-sync');
 
-  // 1. Ensure setup exists (index.ts)
-  if (!fs.existsSync(indexPath)) {
-    console.log('📦 Setup (index.ts) missing. Generating...');
+  if (!fs.existsSync(path.join(localesDir, 'index.ts'))) {
+    console.log('🔄 Initializing localization setup...');
     setupLanguages(targetDir);
-    console.log('');
   }
 
-  // 2. Synchronize keys (includes code scanning if srcDir is provided)
-  console.log('🔄 Checking synchronization...');
-  syncTranslations(targetDir, srcDir);
-  console.log('');
-
-  if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
-    console.error(`❌ Localization files not found in: ${localesDir}`);
-    process.exit(1);
+  if (!skipSync) {
+    console.log('\n🔄 Checking synchronization...');
+    syncTranslations(targetDir, srcDir);
+  } else {
+    console.log('\n⏭️ Skipping synchronization check...');
   }
 
   const files = fs.readdirSync(localesDir)
-    .filter(f => {
-      const isLangFile = f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts';
-      return isLangFile && (!targetLangCode || f === `${targetLangCode}.ts`);
-    })
+    .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
     .sort();
 
-  console.log(`📊 Languages to translate: ${files.length}\n`);
+  console.log(`\n📊 Languages to translate: ${files.length}\n`);
+
+  const enUS = parseTypeScriptFile(enUSPath);
 
-  let totalTranslated = 0;
   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);
-    console.log(`🌍 Translating ${langCode} (${getLangDisplayName(langCode)})...`);
-    const stats = await translateLanguageFile(enUSPath, targetPath, langCode);
-    totalTranslated += stats.count;
+    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) {
-      console.log(`   ✅ Translated ${stats.count} strings`);
+      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 complete`);
+      console.log(`      ✨ Already up to date.`);
     }
   }
 
-  console.log(`\n✅ Workflow completed! (Total translated: ${totalTranslated})`);
+  console.log('\n✅ All translations completed!');
 }
 
-main().catch(error => {
-  console.error('❌ Translation failed:', error.message);
-  process.exit(1);
-});
+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/scripts/utils/file-parser.js

@@ -17,9 +17,12 @@ export function parseTypeScriptFile(filePath) {
   const objectStr = match[1].replace(/;$/, '');
 
   try {
+    // Basic evaluation for simple objects
+    // eslint-disable-next-line no-eval
     return eval(`(${objectStr})`);
   } catch (error) {
-    throw new Error(`Failed to parse object in ${filePath}: ${error.message}`);
+    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
   }
 }
 

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

@@ -3,41 +3,152 @@ import path from 'path';
 
 /**
  * Key Extractor
- * Scans source code for i18n keys
+ * Scans source code and dependencies for i18n keys and their default values
  */
 
+function beautify(key) {
+  const parts = key.split('.');
+  const lastPart = parts[parts.length - 1];
+  return lastPart
+    .replace(/[_-]/g, ' ')
+    .replace(/([A-Z])/g, ' $1')
+    .replace(/^./, str => str.toUpperCase())
+    .trim();
+}
+
 export function extractUsedKeys(srcDir) {
-  const keys = new Set();
-  if (!srcDir) return keys;
+  const keyMap = new Map();
+  if (!srcDir) return keyMap;
 
-  const absoluteSrcDir = path.resolve(process.cwd(), srcDir);
-  if (!fs.existsSync(absoluteSrcDir)) {
-    return keys;
-  }
+  const projectRoot = process.cwd();
+  const absoluteSrcDir = path.resolve(projectRoot, srcDir);
+  
+  // 1. PROJECT SPECIFIC: Read Scenarios and Categories
+  const enumFiles = [
+    { name: 'domains/scenarios/domain/Scenario.ts', type: 'scenario' },
+    { name: 'domains/scenarios/domain/CategoryHierarchy.ts', type: 'category' }
+  ];
+
+  enumFiles.forEach(cfg => {
+    const fullPath = path.resolve(absoluteSrcDir, cfg.name);
+    if (fs.existsSync(fullPath)) {
+      const content = fs.readFileSync(fullPath, 'utf8');
+      
+      if (cfg.type === 'scenario') {
+        const matches = content.matchAll(/([A-Z0-9_]+)\s*=\s*['"`]([a-z0-9_]+)['"`]/g);
+        for (const m of matches) {
+          const val = m[2];
+          const label = beautify(val);
+          keyMap.set(`scenario.${val}.title`, label);
+          keyMap.set(`scenario.${val}.description`, label);
+          keyMap.set(`scenario.${val}.details`, label);
+          keyMap.set(`scenario.${val}.tip`, label);
+        }
+      }
+      
+      if (cfg.type === 'category') {
+        const blockRegex = /\{[\s\S]*?id:\s*(?:MainCategory|SubCategory)\.([A-Z0-9_]+)[\s\S]*?title:\s*['"`](.*?)['"`][\s\S]*?description:\s*['"`](.*?)['"`]/g;
+        let blockMatch;
+        while ((blockMatch = blockRegex.exec(content)) !== null) {
+          const enumName = blockMatch[1];
+          const title = blockMatch[2];
+          const desc = blockMatch[3];
+          
+          const valRegex = new RegExp(`${enumName}\\s*=\\s*['"\`]([a-z0-9_]+)['"\`]`, 'i');
+          const valMatch = content.match(valRegex);
+          const stringVal = valMatch ? valMatch[1] : enumName.toLowerCase();
+
+          keyMap.set(`scenario.main_category.${stringVal}.title`, title);
+          keyMap.set(`scenario.main_category.${stringVal}.description`, desc);
+          keyMap.set(`scenario.sub_category.${stringVal}.title`, title);
+          keyMap.set(`scenario.sub_category.${stringVal}.description`, desc);
+        }
+      }
+    }
+  });
+
+  // 2. Scan directories
+  const scanDirs = [
+    absoluteSrcDir,
+    path.resolve(projectRoot, 'node_modules/@umituz')
+  ];
+
+  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 walk(dir) {
+    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()) {
-        const skipDirs = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets'];
-        if (!skipDirs.includes(file)) {
-          walk(fullPath);
-        }
+        const skipDirs = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets', 'locales', '__tests__'];
+        if (!skipDirs.includes(file)) walk(fullPath);
       } else if (/\.(ts|tsx|js|jsx)$/.test(file)) {
         const content = fs.readFileSync(fullPath, 'utf8');
-        // Regex for t('key') or t("key") or i18n.t('key')
-        const regex = /(?:^|\W)t\(['"]([^'"]+)['"]\)/g;
+        
+        // Pattern 1: t('key')
+        const tRegex = /(?:^|\W)t\(['"`]([^'"`]+)['"`]\)/g;
         let match;
-        while ((match = regex.exec(content)) !== null) {
-          keys.add(match[1]);
+        while ((match = tRegex.exec(content)) !== null) {
+          const key = match[1];
+          if (!key.includes('${') && !keyMap.has(key)) {
+            keyMap.set(key, beautify(key));
+          }
+        }
+
+        // Pattern 2: Global Dot-Notation Strings (non-template)
+        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(' ') && !key.includes('${') && !keyMap.has(key)) {
+            keyMap.set(key, beautify(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];
+          // Find potential option IDs in the same file
+          // We look specifically for strings in arrays [...] to reduce false positives
+          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; // Skip numeric-only strings
+              
+              const dynamicKey = `${prefix}.${id}`;
+              if (!keyMap.has(dynamicKey)) {
+                keyMap.set(dynamicKey, beautify(id));
+              }
+            }
+          }
         }
       }
     }
   }
 
-  walk(absoluteSrcDir);
-  return keys;
+  scanDirs.forEach(dir => walk(dir));
+  
+  return keyMap;
 }

package/src/scripts/utils/translator.js

@@ -1,53 +1,47 @@
-import https from 'https';
-import { shouldSkipWord } from './translation-config.js';
-
 /**
- * Translator
- * Google Translate API integration and translation logic
+ * Translation Utilities
+ * Handles call to translation APIs
  */
 
-export function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
+import { getTargetLanguage, shouldSkipWord } from './translation-config.js';
 
-export async function translateText(text, targetLang) {
-  return new Promise((resolve) => {
-    if (shouldSkipWord(text)) {
-      resolve(text);
-      return;
-    }
+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}`;
-
-    https
-      .get(url, res => {
-        let data = '';
-        res.on('data', chunk => {
-          data += chunk;
-        });
-        res.on('end', () => {
-          try {
-            const parsed = JSON.parse(data);
-            const translated = parsed[0]
-              .map(item => item[0])
-              .join('')
-              .trim();
-            resolve(translated || text);
-          } catch (error) {
-            resolve(text);
-          }
-        });
-      })
-      .on('error', () => {
-        resolve(text);
-      });
-  });
+    
+    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') return false;
+  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) {
@@ -58,40 +52,32 @@ function needsTranslation(value, enValue) {
   return false;
 }
 
-export async function translateObject(enObj, targetObj, targetLang, path = '', stats = { count: 0, newKeys: [] }) {
-  for (const key in enObj) {
-    const currentPath = path ? `${path}.${key}` : key;
+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 (Array.isArray(enValue)) {
-      if (!Array.isArray(targetValue)) targetObj[key] = [];
-      for (let i = 0; i < enValue.length; i++) {
-        if (typeof enValue[i] === 'string' && needsTranslation(targetObj[key][i], enValue[i])) {
-          const translated = await translateText(enValue[i], targetLang);
-          if (translated !== enValue[i]) {
-            const isNewKey = targetObj[key][i] === enValue[i];
-            console.log(`   ${isNewKey ? '🆕 NEW' : '🔄'} ${currentPath}[${i}]: "${enValue[i].substring(0, 40)}"`);
-            targetObj[key][i] = translated;
-            stats.count++;
-            if (isNewKey) stats.newKeys.push(`${currentPath}[${i}]`);
-          }
-          await delay(200);
-        }
-      }
-    } else if (typeof enValue === 'object' && enValue !== null) {
+    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' && needsTranslation(targetValue, enValue)) {
-      const translated = await translateText(enValue, targetLang);
-      const isNewKey = targetValue === undefined;
-      if (translated !== enValue || isNewKey) {
-        console.log(`   ${isNewKey ? '🆕 NEW' : '🔄'} ${currentPath}: "${enValue.substring(0, 40)}"`);
-        targetObj[key] = translated;
-        stats.count++;
-        if (isNewKey) stats.newKeys.push(currentPath);
+    } 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 });
+        }
       }
-      await delay(200);
     }
   }
 }