@umituz/react-native-localization 3.7.9 → 3.7.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-localization",
-  "version": "3.7.9",
+  "version": "3.7.11",
   "type": "module",
   "description": "Generic localization system for React Native apps with i18n support",
   "main": "./src/index.ts",

package/src/scripts/setup-languages.js

@@ -9,14 +9,12 @@
 import fs from 'fs';
 import path from 'path';
 
-function main() {
-  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
+export function setupLanguages(targetDir) {
   const localesDir = path.resolve(process.cwd(), targetDir);
 
-  console.log('🚀 Setting up language files...\n');
   if (!fs.existsSync(localesDir)) {
     console.error(`❌ Locales directory not found: ${localesDir}`);
-    process.exit(1);
+    return false;
   }
 
   const files = fs.readdirSync(localesDir)
@@ -52,6 +50,11 @@ export default translations;
 
   fs.writeFileSync(path.join(localesDir, 'index.ts'), content);
   console.log(`✅ Generated index.ts with ${files.length} languages`);
+  return true;
 }
 
-main();
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
+  console.log('🚀 Setting up language files...\n');
+  setupLanguages(targetDir);
+}

package/src/scripts/sync-translations.js

@@ -62,16 +62,13 @@ function processExtraction(srcDir, enUSPath) {
   }
 }
 
-function main() {
-  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
-  const srcDir = process.argv[3];
+export function syncTranslations(targetDir, srcDir) {
   const localesDir = path.resolve(process.cwd(), targetDir);
   const enUSPath = path.join(localesDir, 'en-US.ts');
 
-  console.log('🚀 Starting translation synchronization...\n');
   if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
     console.error(`❌ Localization files not found in: ${localesDir}`);
-    process.exit(1);
+    return false;
   }
 
   processExtraction(srcDir, enUSPath);
@@ -84,16 +81,19 @@ function main() {
   files.forEach(file => {
     const langCode = file.replace('.ts', '');
     const targetPath = path.join(localesDir, file);
-    console.log(`🌍 Syncing ${langCode} (${getLangDisplayName(langCode)})...`);
     const result = syncLanguageFile(enUSPath, targetPath, langCode);
     if (result.changed) {
-      console.log(`   ✏️  +${result.added} keys, -${result.removed} keys`);
-    } else {
-      console.log(`   ✅ Already synchronized`);
+      console.log(`   🌍 ${langCode}: ✏️  +${result.added} keys, -${result.removed} keys`);
     }
   });
 
   console.log(`\n✅ Synchronization completed!`);
+  return true;
 }
 
-main();
+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 translation synchronization...\n');
+  syncTranslations(targetDir, srcDir);
+}

package/src/scripts/translate-missing.js

@@ -3,7 +3,7 @@
 /**
  * Translate Missing Script
  * Translates missing strings from en-US.ts to all other language files
- * Usage: node translate-missing.js [locales-dir] [lang-code-optional]
+ * Usage: node translate-missing.js [locales-dir] [src-dir-optional] [lang-code-optional]
  */
 
 import fs from 'fs';
@@ -11,6 +11,8 @@ import path from 'path';
 import { getTargetLanguage, isEnglishVariant, getLangDisplayName } from './utils/translation-config.js';
 import { parseTypeScriptFile, generateTypeScriptContent } from './utils/file-parser.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);
@@ -47,11 +49,27 @@ async function translateLanguageFile(enUSPath, targetPath, langCode) {
 
 async function main() {
   const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
-  const targetLangCode = process.argv[3];
+  const srcDir = process.argv[3];
+  const targetLangCode = process.argv[4];
+  
   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');
+
+  // 1. Ensure setup exists (index.ts)
+  if (!fs.existsSync(indexPath)) {
+    console.log('📦 Setup (index.ts) missing. Generating...');
+    setupLanguages(targetDir);
+    console.log('');
+  }
+
+  // 2. Synchronize keys (includes code scanning if srcDir is provided)
+  console.log('🔄 Checking synchronization...');
+  syncTranslations(targetDir, srcDir);
+  console.log('');
 
-  console.log('🚀 Starting automatic translation...\n');
   if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
     console.error(`❌ Localization files not found in: ${localesDir}`);
     process.exit(1);
@@ -80,7 +98,7 @@ async function main() {
     }
   }
 
-  console.log(`\n✅ Translation completed! (Total: ${totalTranslated})`);
+  console.log(`\n✅ Workflow completed! (Total translated: ${totalTranslated})`);
 }
 
 main().catch(error => {

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

@@ -11,8 +11,17 @@ export function extractUsedKeys(srcDir) {
   if (!srcDir) return keys;
 
   const absoluteSrcDir = path.resolve(process.cwd(), srcDir);
-  if (!fs.existsSync(absoluteSrcDir)) {
-    return keys;
+  if (!fs.existsSync(absoluteSrcDir)) return keys;
+
+  // Step 1: Find all ScenarioId possible values once
+  const scenarioValues = new Set();
+  const scenarioFile = path.resolve(absoluteSrcDir, 'domains/scenarios/domain/Scenario.ts');
+  if (fs.existsSync(scenarioFile)) {
+    const content = fs.readFileSync(scenarioFile, 'utf8');
+    const matches = content.matchAll(/([A-Z0-9_]+)\s*=\s*['"`]([a-z0-9_]+)['"`]/g);
+    for (const match of matches) {
+      scenarioValues.add(match[2]);
+    }
   }
 
   function walk(dir) {
@@ -23,16 +32,37 @@ export function extractUsedKeys(srcDir) {
 
       if (stat.isDirectory()) {
         const skipDirs = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets'];
-        if (!skipDirs.includes(file)) {
-          walk(fullPath);
-        }
+        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: Standard t('key') calls
+        const tRegex = /(?:^|\W)t\(['"`]([^'"`]+)['"`]\)/g;
         let match;
-        while ((match = regex.exec(content)) !== null) {
-          keys.add(match[1]);
+        while ((match = tRegex.exec(content)) !== null) {
+          if (!match[1].includes('${')) keys.add(match[1]);
+        }
+
+        // Pattern 2: Scenario ID usage
+        // If we see ScenarioId.XXXX or just the string value matching a scenario
+        scenarioValues.forEach(val => {
+          if (content.includes(val)) {
+            keys.add(`scenario.${val}.title`);
+            keys.add(`scenario.${val}.description`);
+            keys.add(`scenario.${val}.details`);
+            keys.add(`scenario.${val}.tip`);
+          }
+        });
+
+        // Pattern 3: Dot-notation keys in configs/literals (e.g. "common.button.save")
+        // We look for at least two segments (one dot)
+        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 isFile = /\.(ts|tsx|js|jsx|png|jpg|jpeg|svg|json)$/i.test(key);
+          if (!isFile && !key.includes(' ') && !key.includes('${')) {
+            keys.add(key);
+          }
         }
       }
     }

package/src/scripts/utils/translator.js

@@ -1,56 +1,51 @@
-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, isSingleWord as checkSingleWord, 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) {
+    if (__DEV__) console.error(`   ❌ Translation error for "${text}":`, error.message);
+    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;
+
+  // If value is missing or same as technical key
   if (!value || typeof value !== 'string') return true;
 
+  // Heuristic: If English value looks like a technical key (e.g. "scenario.xxx.title")
+  // and the target value is exactly the same, it definitely needs translation.
+  const isTechnicalKey = enValue.includes('.') && !enValue.includes(' ');
+  
   if (value === enValue) {
+    if (isTechnicalKey) return true;
     const isSingleWord = !enValue.includes(' ') && enValue.length < 20;
     return !isSingleWord;
   }
@@ -59,39 +54,28 @@ function needsTranslation(value, enValue) {
 }
 
 export async function translateObject(enObj, targetObj, targetLang, path = '', stats = { count: 0, newKeys: [] }) {
-  for (const key in enObj) {
-    const currentPath = path ? `${path}.${key}` : key;
+  const keys = Object.keys(enObj);
+  
+  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)}"`);
+      // Force increment if it looks like a technical key that we just "translated" 
+      // even if the API returned the same string (placeholder)
+      const isTechnicalKey = enValue.includes('.') && !enValue.includes(' ');
+      
+      if (translated !== enValue || isNewKey || (isTechnicalKey && translated === enValue)) {
         targetObj[key] = translated;
         stats.count++;
-        if (isNewKey) stats.newKeys.push(currentPath);
       }
-      await delay(200);
     }
   }
 }