@umituz/react-native-localization 3.7.10 → 3.7.11

package/package.json

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

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);
     }
   }
 }