@umituz/react-native-localization 3.7.7 → 3.7.9

package/package.json

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

package/src/scripts/prepublish.js

@@ -5,30 +5,32 @@
  * Basic checks before publishing
  */
 
-const fs = require('fs');
-const path = require('path');
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
 const SRC_DIR = path.join(PACKAGE_ROOT, 'src');
 
 if (!fs.existsSync(SRC_DIR)) {
+  console.error('❌ src directory not found');
   process.exit(1);
 }
 
 const mainFiles = [
   'src/index.ts',
   'src/infrastructure/config/i18n.ts',
-  'src/infrastructure/storage/LocalizationStore.ts',
 ];
 
-let allFilesExist = true;
 for (const file of mainFiles) {
   const filePath = path.join(PACKAGE_ROOT, file);
   if (!fs.existsSync(filePath)) {
-    allFilesExist = false;
+    console.error(`❌ Missing mandatory file: ${file}`);
+    process.exit(1);
   }
 }
 
-if (!allFilesExist) {
-  process.exit(1);
-}
+console.log('✅ Pre-publish checks passed!');

package/src/scripts/setup-languages.js

@@ -6,16 +6,14 @@
  * Usage: node setup-languages.js [locales-dir]
  */
 
-const fs = require('fs');
-const path = require('path');
+import fs from 'fs';
+import path from 'path';
 
 function main() {
-  const targetDir = process.argv[2] || 'src/domains/localization/translations';
+  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
   const localesDir = path.resolve(process.cwd(), targetDir);
 
   console.log('🚀 Setting up language files...\n');
-  console.log(`📂 Locales directory: ${localesDir}\n`);
-
   if (!fs.existsSync(localesDir)) {
     console.error(`❌ Locales directory not found: ${localesDir}`);
     process.exit(1);
@@ -25,16 +23,12 @@ function main() {
     .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/))
     .sort();
 
-  console.log(`📊 Found ${files.length} language files:\n`);
-
   const imports = [];
   const exports = [];
 
   files.forEach(file => {
     const code = file.replace('.ts', '');
     const varName = code.replace(/-([a-z0-9])/g, (g) => g[1].toUpperCase()).replace('-', '');
-
-    console.log(`   📄 ${code}`);
     imports.push(`import ${varName} from "./${code}";`);
     exports.push(`  "${code}": ${varName},`);
   });
@@ -56,11 +50,8 @@ export type TranslationKey = keyof typeof translations;
 export default translations;
 `;
 
-  const indexPath = path.join(localesDir, 'index.ts');
-  fs.writeFileSync(indexPath, content);
-
-  console.log(`\n✅ Generated index.ts with ${files.length} languages`);
-  console.log(`   Output: ${indexPath}`);
+  fs.writeFileSync(path.join(localesDir, 'index.ts'), content);
+  console.log(`✅ Generated index.ts with ${files.length} languages`);
 }
 
 main();

package/src/scripts/sync-translations.js

@@ -3,15 +3,17 @@
 /**
  * Sync Translations Script
  * Synchronizes translation keys from en-US.ts to all other language files
- * Usage: node sync-translations.js [locales-dir]
+ * Usage: node sync-translations.js [locales-dir] [src-dir-optional]
  */
 
-const fs = require('fs');
-const path = require('path');
-const { parseTypeScriptFile, generateTypeScriptContent } = require('./utils/file-parser');
-const { addMissingKeys, removeExtraKeys } = require('./utils/sync-helper');
-const { detectNewKeys } = require('./utils/key-detector');
-const { getLangDisplayName } = require('./utils/translation-config');
+import fs from 'fs';
+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';
 
 function syncLanguageFile(enUSPath, targetPath, langCode) {
   const enUS = parseTypeScriptFile(enUSPath);
@@ -37,113 +39,61 @@ function syncLanguageFile(enUSPath, targetPath, langCode) {
     fs.writeFileSync(targetPath, content);
   }
 
-  return {
-    added: addStats.added,
-    removed: removeStats.removed,
-    newKeys,
-    removedKeys: removeStats.removedKeys,
-    changed,
-  };
+  return { ...addStats, ...removeStats, newKeys, changed };
 }
 
-function main() {
-  const targetDir = process.argv[2] || 'src/domains/localization/translations';
-  const targetLangCode = process.argv[3];
-  const localesDir = path.resolve(process.cwd(), targetDir);
+function processExtraction(srcDir, enUSPath) {
+  if (!srcDir) return;
 
-  console.log('🚀 Starting translation synchronization...\n');
-  console.log(`📂 Locales directory: ${localesDir}`);
-  if (targetLangCode) {
-    console.log(`🎯 Target language: ${targetLangCode}`);
+  console.log(`🔍 Scanning source code: ${srcDir}...`);
+  const usedKeys = extractUsedKeys(srcDir);
+  console.log(`   Found ${usedKeys.size} unique keys in code.`);
+
+  const enUS = parseTypeScriptFile(enUSPath);
+  let addedCount = 0;
+  for (const key of usedKeys) {
+    if (setDeep(enUS, key, key)) addedCount++;
   }
-  console.log('');
 
-  if (!fs.existsSync(localesDir)) {
-    console.error(`❌ Locales directory not found: ${localesDir}`);
-    process.exit(1);
+  if (addedCount > 0) {
+    console.log(`   ✨ Added ${addedCount} new keys to en-US.ts`);
+    const content = generateTypeScriptContent(enUS, 'en-US');
+    fs.writeFileSync(enUSPath, content);
   }
+}
 
+function main() {
+  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
+  const srcDir = process.argv[3];
+  const localesDir = path.resolve(process.cwd(), targetDir);
   const enUSPath = path.join(localesDir, 'en-US.ts');
-  if (!fs.existsSync(enUSPath)) {
-    console.error(`❌ Base file not found: ${enUSPath}`);
+
+  console.log('🚀 Starting translation synchronization...\n');
+  if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
+    console.error(`❌ Localization files not found in: ${localesDir}`);
     process.exit(1);
   }
 
+  processExtraction(srcDir, enUSPath);
+
   const files = fs.readdirSync(localesDir)
-    .filter(f => {
-      const isLangFile = f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts';
-      if (!isLangFile) return false;
-      if (targetLangCode) {
-        return f === `${targetLangCode}.ts`;
-      }
-      return true;
-    })
+    .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
     .sort();
 
-  if (targetLangCode && files.length === 0) {
-    console.warn(`⚠️  Target language file ${targetLangCode}.ts not found in ${targetDir}`);
-  }
-
   console.log(`📊 Languages to sync: ${files.length}\n`);
-
-  let totalAdded = 0;
-  let totalRemoved = 0;
-  let totalChanged = 0;
-  const allNewKeys = [];
-
-  for (const file of files) {
+  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) {
-      if (result.newKeys.length > 0) {
-        console.log(`   🆕 ${result.newKeys.length} new keys added:`);
-        result.newKeys.slice(0, 5).forEach(({ path }) => {
-          console.log(`      • ${path}`);
-        });
-        if (result.newKeys.length > 5) {
-          console.log(`      ... and ${result.newKeys.length - 5} more`);
-        }
-        allNewKeys.push(...result.newKeys.map(k => k.path));
-      }
-      if (result.removedKeys.length > 0) {
-        console.log(`   🗑️  ${result.removedKeys.length} obsolete keys removed`);
-      }
-      totalAdded += result.added;
-      totalRemoved += result.removed;
-      totalChanged++;
+      console.log(`   ✏️  +${result.added} keys, -${result.removed} keys`);
     } else {
       console.log(`   ✅ Already synchronized`);
     }
-  }
+  });
 
-  console.log(`\n📊 Summary:`);
-  console.log(`   Languages processed: ${files.length}`);
-  console.log(`   Files changed: ${totalChanged}`);
-  console.log(`   Keys added: ${totalAdded}`);
-  console.log(`   Keys removed: ${totalRemoved}`);
-
-  if (totalChanged > 0) {
-    console.log(`\n✅ Synchronization completed!`);
-    console.log(`   Next: Run 'npm run i18n:translate' to translate new keys`);
-
-    if (allNewKeys.length > 0) {
-      const uniqueKeys = [...new Set(allNewKeys)];
-      console.log(`\n📝 New keys that need translation (${uniqueKeys.length}):`);
-      uniqueKeys.slice(0, 10).forEach(key => {
-        console.log(`   • ${key}`);
-      });
-      if (uniqueKeys.length > 10) {
-        console.log(`   ... and ${uniqueKeys.length - 10} more`);
-      }
-    }
-  } else {
-    console.log(`\n✅ All languages were already synchronized!`);
-  }
+  console.log(`\n✅ Synchronization completed!`);
 }
 
 main();

package/src/scripts/translate-missing.js

@@ -3,14 +3,14 @@
 /**
  * Translate Missing Script
  * Translates missing strings from en-US.ts to all other language files
- * Usage: node translate-missing.js [locales-dir]
+ * Usage: node translate-missing.js [locales-dir] [lang-code-optional]
  */
 
-const fs = require('fs');
-const path = require('path');
-const { getTargetLanguage, isEnglishVariant, getLangDisplayName } = require('./utils/translation-config');
-const { parseTypeScriptFile, generateTypeScriptContent } = require('./utils/file-parser');
-const { translateObject } = require('./utils/translator');
+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 { translateObject } from './utils/translator.js';
 
 async function translateLanguageFile(enUSPath, targetPath, langCode) {
   const targetLang = getTargetLanguage(langCode);
@@ -46,78 +46,44 @@ async function translateLanguageFile(enUSPath, targetPath, langCode) {
 }
 
 async function main() {
-  const targetDir = process.argv[2] || 'src/domains/localization/translations';
+  const targetDir = process.argv[2] || 'src/domains/localization/infrastructure/locales';
   const targetLangCode = process.argv[3];
   const localesDir = path.resolve(process.cwd(), targetDir);
+  const enUSPath = path.join(localesDir, 'en-US.ts');
 
   console.log('🚀 Starting automatic translation...\n');
-  console.log(`📂 Locales directory: ${localesDir}`);
-  if (targetLangCode) {
-    console.log(`🎯 Target language: ${targetLangCode}`);
-  }
-  console.log('');
-
-  if (!fs.existsSync(localesDir)) {
-    console.error(`❌ Locales directory not found: ${localesDir}`);
-    process.exit(1);
-  }
-
-  const enUSPath = path.join(localesDir, 'en-US.ts');
-  if (!fs.existsSync(enUSPath)) {
-    console.error(`❌ Base file not found: ${enUSPath}`);
+  if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
+    console.error(`❌ Localization files not found in: ${localesDir}`);
     process.exit(1);
   }
 
   const files = fs.readdirSync(localesDir)
     .filter(f => {
       const isLangFile = f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts';
-      if (!isLangFile) return false;
-      if (targetLangCode) {
-        return f === `${targetLangCode}.ts`;
-      }
-      return true;
+      return isLangFile && (!targetLangCode || f === `${targetLangCode}.ts`);
     })
     .sort();
 
-  if (targetLangCode && files.length === 0) {
-    console.warn(`⚠️  Target language file ${targetLangCode}.ts not found in ${targetDir}`);
-  }
-
-  console.log(`📊 Languages to translate: ${files.length}`);
-  console.log('⚡ Running with 200ms delay between API calls\n');
+  console.log(`📊 Languages to translate: ${files.length}\n`);
 
   let totalTranslated = 0;
-  let totalNewKeys = 0;
-
   for (const file of files) {
     const langCode = file.replace('.ts', '');
     const targetPath = path.join(localesDir, file);
-
-    console.log(`\n🌍 Translating ${langCode} (${getLangDisplayName(langCode)})...`);
-
+    console.log(`🌍 Translating ${langCode} (${getLangDisplayName(langCode)})...`);
     const stats = await translateLanguageFile(enUSPath, targetPath, langCode);
     totalTranslated += stats.count;
-    totalNewKeys += stats.newKeys.length;
-
     if (stats.count > 0) {
       console.log(`   ✅ Translated ${stats.count} strings`);
-      if (stats.newKeys.length > 0) {
-        console.log(`   🆕 ${stats.newKeys.length} new keys translated`);
-      }
     } else {
       console.log(`   ✓ Already complete`);
     }
   }
 
-  console.log(`\n✅ Translation completed!`);
-  console.log(`   Total strings translated: ${totalTranslated}`);
-  if (totalNewKeys > 0) {
-    console.log(`   New keys translated: ${totalNewKeys}`);
-  }
-  console.log(`\n📝 Next: Run 'npm run i18n:setup' to update index.ts`);
+  console.log(`\n✅ Translation completed! (Total: ${totalTranslated})`);
 }
 
-main().catch((error) => {
+main().catch(error => {
   console.error('❌ Translation failed:', error.message);
   process.exit(1);
 });

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

@@ -1,14 +1,12 @@
-#!/usr/bin/env node
+import fs from 'fs';
+import { getLangDisplayName } from './translation-config.js';
 
 /**
  * File Parser
  * Parse and generate TypeScript translation files
  */
 
-const fs = require('fs');
-const { getLangDisplayName } = require('./translation-config');
-
-function parseTypeScriptFile(filePath) {
+export function parseTypeScriptFile(filePath) {
   const content = fs.readFileSync(filePath, 'utf8');
   const match = content.match(/export\s+default\s+(\{[\s\S]*\});?\s*$/);
 
@@ -25,7 +23,7 @@ function parseTypeScriptFile(filePath) {
   }
 }
 
-function stringifyValue(value, indent = 2) {
+export function stringifyValue(value, indent = 2) {
   if (typeof value === 'string') {
     const escaped = value
       .replace(/\\/g, '\\\\')
@@ -50,6 +48,7 @@ function stringifyValue(value, indent = 2) {
     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)}`;
@@ -61,20 +60,16 @@ function stringifyValue(value, indent = 2) {
   return String(value);
 }
 
-function generateTypeScriptContent(obj, langCode) {
+export function generateTypeScriptContent(obj, langCode) {
   const langName = getLangDisplayName(langCode);
+  const isBase = langCode === 'en-US';
   const objString = stringifyValue(obj, 0);
 
   return `/**
  * ${langName} Translations
- * Auto-translated from en-US.ts
+ * ${isBase ? 'Base translations file' : 'Auto-synced from en-US.ts'}
  */
 
 export default ${objString};
 `;
 }
-
-module.exports = {
-  parseTypeScriptFile,
-  generateTypeScriptContent,
-};

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

@@ -1,52 +1,45 @@
-#!/usr/bin/env node
-
 /**
  * Key Detector
  * Detects new, missing, and removed keys between source and target objects
  */
 
-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];
+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);
-            }
-        }
+    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;
+  }
+  return newKeys;
 }
 
-function detectMissingKeys(sourceObj, targetObj, path = '', missingKeys = []) {
-    for (const key in targetObj) {
-        const currentPath = path ? `${path}.${key}` : key;
+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);
-        }
+    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;
+  }
+  return missingKeys;
 }
-
-module.exports = {
-    detectNewKeys,
-    detectMissingKeys,
-};

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

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Key Extractor
+ * Scans source code for i18n keys
+ */
+
+export function extractUsedKeys(srcDir) {
+  const keys = new Set();
+  if (!srcDir) return keys;
+
+  const absoluteSrcDir = path.resolve(process.cwd(), srcDir);
+  if (!fs.existsSync(absoluteSrcDir)) {
+    return keys;
+  }
+
+  function walk(dir) {
+    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);
+        }
+      } 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;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+          keys.add(match[1]);
+        }
+      }
+    }
+  }
+
+  walk(absoluteSrcDir);
+  return keys;
+}

package/src/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/scripts/utils/sync-helper.js

@@ -1,11 +1,9 @@
-#!/usr/bin/env node
-
 /**
  * Sync Helper
  * Helper functions for synchronizing translation keys
  */
 
-function addMissingKeys(sourceObj, targetObj, stats = { added: 0, newKeys: [] }) {
+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);
@@ -28,7 +26,7 @@ function addMissingKeys(sourceObj, targetObj, stats = { added: 0, newKeys: [] })
   return stats;
 }
 
-function removeExtraKeys(sourceObj, targetObj, stats = { removed: 0, removedKeys: [] }) {
+export function removeExtraKeys(sourceObj, targetObj, stats = { removed: 0, removedKeys: [] }) {
   for (const key in targetObj) {
     const isExtraKey = !Object.prototype.hasOwnProperty.call(sourceObj, key);
 
@@ -49,8 +47,3 @@ function removeExtraKeys(sourceObj, targetObj, stats = { removed: 0, removedKeys
   }
   return stats;
 }
-
-module.exports = {
-  addMissingKeys,
-  removeExtraKeys,
-};

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

@@ -1,11 +1,9 @@
-#!/usr/bin/env node
-
 /**
  * Translation Configuration
  * Language mappings and constants for translation system
  */
 
-const LANGUAGE_MAP = {
+export const LANGUAGE_MAP = {
   'ar-SA': 'ar',
   'bg-BG': 'bg',
   'cs-CZ': 'cs',
@@ -47,7 +45,7 @@ const LANGUAGE_MAP = {
   'zh-TW': 'zh-TW',
 };
 
-const SKIP_WORDS = new Set([
+export const SKIP_WORDS = new Set([
   'Google',
   'Apple',
   'Facebook',
@@ -57,7 +55,7 @@ const SKIP_WORDS = new Set([
   'WhatsApp',
 ]);
 
-const LANGUAGE_NAMES = {
+export const LANGUAGE_NAMES = {
   'ar-SA': 'Arabic (Saudi Arabia)',
   'bg-BG': 'Bulgarian',
   'cs-CZ': 'Czech',
@@ -100,29 +98,19 @@ const LANGUAGE_NAMES = {
   'zh-TW': 'Chinese (Traditional)',
 };
 
-function getLangDisplayName(code) {
+export function getLangDisplayName(code) {
   return LANGUAGE_NAMES[code] || code;
 }
 
-function getTargetLanguage(langCode) {
+export function getTargetLanguage(langCode) {
   return LANGUAGE_MAP[langCode];
 }
 
-function shouldSkipWord(word) {
+export function shouldSkipWord(word) {
   return SKIP_WORDS.has(word);
 }
 
-function isEnglishVariant(langCode) {
+export function isEnglishVariant(langCode) {
   const targetLang = LANGUAGE_MAP[langCode];
   return targetLang === 'en';
 }
-
-module.exports = {
-  LANGUAGE_MAP,
-  SKIP_WORDS,
-  LANGUAGE_NAMES,
-  getLangDisplayName,
-  getTargetLanguage,
-  shouldSkipWord,
-  isEnglishVariant,
-};

package/src/scripts/utils/translator.js

@@ -1,18 +1,16 @@
-#!/usr/bin/env node
+import https from 'https';
+import { shouldSkipWord } from './translation-config.js';
 
 /**
  * Translator
  * Google Translate API integration and translation logic
  */
 
-const https = require('https');
-const { shouldSkipWord } = require('./translation-config');
-
-function delay(ms) {
+export function delay(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-async function translateText(text, targetLang) {
+export async function translateText(text, targetLang) {
   return new Promise((resolve) => {
     if (shouldSkipWord(text)) {
       resolve(text);
@@ -49,82 +47,51 @@ async function translateText(text, targetLang) {
 
 function needsTranslation(value, enValue) {
   if (typeof enValue !== 'string') return false;
-
   if (shouldSkipWord(enValue)) return false;
-
   if (!value || typeof value !== 'string') return true;
 
   if (value === enValue) {
     const isSingleWord = !enValue.includes(' ') && enValue.length < 20;
-    if (isSingleWord) {
-      return false;
-    }
-    return true;
+    return !isSingleWord;
   }
 
   return false;
 }
 
-async function translateObject(enObj, targetObj, targetLang, path = '', stats = { count: 0, newKeys: [] }) {
+export async function translateObject(enObj, targetObj, targetLang, path = '', stats = { count: 0, newKeys: [] }) {
   for (const key in enObj) {
     const currentPath = path ? `${path}.${key}` : key;
     const enValue = enObj[key];
     const targetValue = targetObj[key];
 
     if (Array.isArray(enValue)) {
-      if (!Array.isArray(targetValue)) {
-        targetObj[key] = [];
-      }
+      if (!Array.isArray(targetValue)) targetObj[key] = [];
       for (let i = 0; i < enValue.length; i++) {
-        if (typeof enValue[i] === 'string') {
-          if (needsTranslation(targetObj[key][i], enValue[i])) {
-            const translated = await translateText(enValue[i], targetLang);
-
-            if (translated !== enValue[i]) {
-              const preview = enValue[i].length > 40 ? enValue[i].substring(0, 40) + '...' : enValue[i];
-              const isNewKey = targetObj[key][i] === enValue[i];
-              const prefix = isNewKey ? '🆕 NEW' : '🔄';
-              console.log(`   ${prefix} ${currentPath}[${i}]: "${preview}"`);
-
-              targetObj[key][i] = translated;
-              stats.count++;
-              if (isNewKey) stats.newKeys.push(`${currentPath}[${i}]`);
-            }
-
-            await delay(200);
+        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 (!targetObj[key] || typeof targetObj[key] !== 'object') {
-        targetObj[key] = {};
-      }
+      if (!targetObj[key] || typeof targetObj[key] !== 'object') targetObj[key] = {};
       await translateObject(enValue, targetObj[key], targetLang, currentPath, stats);
-    } else if (typeof enValue === 'string') {
-      if (needsTranslation(targetValue, enValue)) {
-        const translated = await translateText(enValue, targetLang);
-        const isNewKey = targetValue === undefined;
-
-        if (translated !== enValue || isNewKey) {
-          const preview = enValue.length > 40 ? enValue.substring(0, 40) + '...' : enValue;
-          const prefix = isNewKey ? '🆕 NEW' : '🔄';
-          console.log(`   ${prefix} ${currentPath}: "${preview}"`);
-
-          targetObj[key] = translated;
-          stats.count++;
-          if (isNewKey) stats.newKeys.push(currentPath);
-        }
-
-        await delay(200);
+    } 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);
       }
+      await delay(200);
     }
   }
-
-  return stats.count;
 }
-
-module.exports = {
-  translateText,
-  translateObject,
-  delay,
-};