@umituz/react-native-localization 3.5.3 → 3.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-localization",
-  "version": "3.5.3",
+  "version": "3.5.5",
   "description": "Generic localization system for React Native apps with i18n support",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -10,13 +10,13 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
-    "prepublishOnly": "ts-node src/scripts/prepublish.ts",
+    "prepublishOnly": "node src/scripts/prepublish.js",
     "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'",
-    "i18n:setup": "ts-node src/scripts/setup-languages.ts",
-    "i18n:sync": "ts-node src/scripts/sync-translations.ts",
-    "i18n:translate": "ts-node src/scripts/translate-missing.ts"
+    "i18n:setup": "node src/scripts/setup-languages.js",
+    "i18n:sync": "node src/scripts/sync-translations.js",
+    "i18n:translate": "node src/scripts/translate-missing.js"
   },
   "keywords": [
     "react-native",

package/src/scripts/prepublish.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Publish Script
+ * Basic checks before publishing
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const SRC_DIR = path.join(PACKAGE_ROOT, 'src');
+
+if (!fs.existsSync(SRC_DIR)) {
+  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;
+  }
+}
+
+if (!allFilesExist) {
+  process.exit(1);
+}

package/src/scripts/setup-languages.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+ * Setup Languages Script
+ * Generates index.ts with all available translation files
+ * Usage: node setup-languages.js [locales-dir]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function main() {
+  const targetDir = process.argv[2] || 'src/domains/localization/translations';
+  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);
+  }
+
+  const files = fs.readdirSync(localesDir)
+    .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},`);
+  });
+
+  const content = `/**
+ * Localization Index
+ * Exports all available translation files
+ * Auto-generated by scripts/setup-languages.js
+ */
+
+${imports.join('\n')}
+
+export const translations = {
+${exports.join('\n')}
+};
+
+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}`);
+}
+
+main();

package/src/scripts/sync-translations.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+/**
+ * Sync Translations Script
+ * Synchronizes translation keys from en-US.ts to all other language files
+ * Usage: node sync-translations.js [locales-dir]
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parseTypeScriptFile, generateTypeScriptContent } = require('./utils/file-parser');
+const { addMissingKeys, removeExtraKeys } = require('./utils/sync-helper');
+const { getLangDisplayName } = require('./utils/translation-config');
+
+function syncLanguageFile(enUSPath, targetPath, langCode) {
+  const enUS = parseTypeScriptFile(enUSPath);
+  let target;
+
+  try {
+    target = parseTypeScriptFile(targetPath);
+  } catch {
+    target = {};
+  }
+
+  const addStats = { added: 0 };
+  const removeStats = { removed: 0 };
+
+  addMissingKeys(enUS, target, addStats);
+  removeExtraKeys(enUS, target, removeStats);
+
+  const changed = addStats.added > 0 || removeStats.removed > 0;
+
+  if (changed) {
+    const content = generateTypeScriptContent(target, langCode);
+    fs.writeFileSync(targetPath, content);
+  }
+
+  return {
+    added: addStats.added,
+    removed: removeStats.removed,
+    changed,
+  };
+}
+
+function main() {
+  const targetDir = process.argv[2] || 'src/domains/localization/translations';
+  const localesDir = path.resolve(process.cwd(), targetDir);
+
+  console.log('🚀 Starting translation synchronization...\n');
+  console.log(`📂 Locales directory: ${localesDir}\n`);
+
+  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}`);
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(localesDir)
+    .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
+    .sort();
+
+  console.log(`📊 Languages to sync: ${files.length}\n`);
+
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  let totalChanged = 0;
+
+  for (const file of files) {
+    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`);
+      totalAdded += result.added;
+      totalRemoved += result.removed;
+      totalChanged++;
+    } 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`);
+  } else {
+    console.log(`\n✅ All languages were already synchronized!`);
+  }
+}
+
+main();

package/src/scripts/translate-missing.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+/**
+ * Translate Missing Script
+ * Translates missing strings from en-US.ts to all other language files
+ * Usage: node translate-missing.js [locales-dir]
+ */
+
+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');
+
+async function translateLanguageFile(enUSPath, targetPath, langCode) {
+  const targetLang = getTargetLanguage(langCode);
+
+  if (!targetLang) {
+    console.log(`   ⚠️  No language mapping for ${langCode}, skipping`);
+    return 0;
+  }
+
+  if (isEnglishVariant(langCode)) {
+    console.log(`   ⏭️  Skipping English variant: ${langCode}`);
+    return 0;
+  }
+
+  const enUS = parseTypeScriptFile(enUSPath);
+  let target;
+
+  try {
+    target = parseTypeScriptFile(targetPath);
+  } catch {
+    target = {};
+  }
+
+  const stats = { count: 0 };
+  await translateObject(enUS, target, targetLang, '', stats);
+
+  if (stats.count > 0) {
+    const content = generateTypeScriptContent(target, langCode);
+    fs.writeFileSync(targetPath, content);
+  }
+
+  return stats.count;
+}
+
+async function main() {
+  const targetDir = process.argv[2] || 'src/domains/localization/translations';
+  const localesDir = path.resolve(process.cwd(), targetDir);
+
+  console.log('🚀 Starting automatic translation...\n');
+  console.log(`📂 Locales directory: ${localesDir}\n`);
+
+  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}`);
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(localesDir)
+    .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
+    .sort();
+
+  console.log(`📊 Languages to translate: ${files.length}`);
+  console.log('⚡ Running with 200ms delay between API calls\n');
+
+  let totalTranslated = 0;
+
+  for (const file of files) {
+    const langCode = file.replace('.ts', '');
+    const targetPath = path.join(localesDir, file);
+
+    console.log(`\n🌍 Translating ${langCode} (${getLangDisplayName(langCode)})...`);
+
+    const count = await translateLanguageFile(enUSPath, targetPath, langCode);
+    totalTranslated += count;
+
+    if (count > 0) {
+      console.log(`   ✅ Translated ${count} strings`);
+    } else {
+      console.log(`   ✓ Already complete`);
+    }
+  }
+
+  console.log(`\n✅ Translation completed!`);
+  console.log(`   Total strings translated: ${totalTranslated}`);
+  console.log(`\n📝 Next: Run 'npm run i18n:setup' to update index.ts`);
+}
+
+main().catch((error) => {
+  console.error('❌ Translation failed:', error.message);
+  process.exit(1);
+});

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

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+/**
+ * File Parser
+ * Parse and generate TypeScript translation files
+ */
+
+const fs = require('fs');
+const { getLangDisplayName } = require('./translation-config');
+
+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 {
+    return eval(`(${objectStr})`);
+  } catch (error) {
+    throw new Error(`Failed to parse object in ${filePath}: ${error.message}`);
+  }
+}
+
+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
+      .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);
+}
+
+function generateTypeScriptContent(obj, langCode) {
+  const langName = getLangDisplayName(langCode);
+  const objString = stringifyValue(obj, 0);
+
+  return `/**
+ * ${langName} Translations
+ * Auto-translated from en-US.ts
+ */
+
+export default ${objString};
+`;
+}
+
+module.exports = {
+  parseTypeScriptFile,
+  generateTypeScriptContent,
+};

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+/**
+ * Sync Helper
+ * Helper functions for synchronizing translation keys
+ */
+
+function addMissingKeys(enObj, targetObj, stats = { added: 0 }) {
+  for (const key in enObj) {
+    if (!Object.prototype.hasOwnProperty.call(targetObj, key)) {
+      targetObj[key] = enObj[key];
+      stats.added++;
+    } else if (
+      typeof enObj[key] === 'object' &&
+      enObj[key] !== null &&
+      !Array.isArray(enObj[key])
+    ) {
+      if (!targetObj[key] || typeof targetObj[key] !== 'object') {
+        targetObj[key] = {};
+      }
+      addMissingKeys(enObj[key], targetObj[key], stats);
+    }
+  }
+  return stats;
+}
+
+function removeExtraKeys(enObj, targetObj, stats = { removed: 0 }) {
+  for (const key in targetObj) {
+    if (!Object.prototype.hasOwnProperty.call(enObj, key)) {
+      delete targetObj[key];
+      stats.removed++;
+    } else if (
+      typeof enObj[key] === 'object' &&
+      enObj[key] !== null &&
+      !Array.isArray(enObj[key]) &&
+      typeof targetObj[key] === 'object' &&
+      targetObj[key] !== null &&
+      !Array.isArray(targetObj[key])
+    ) {
+      removeExtraKeys(enObj[key], targetObj[key], stats);
+    }
+  }
+  return stats;
+}
+
+module.exports = {
+  addMissingKeys,
+  removeExtraKeys,
+};

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

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+/**
+ * Translation Configuration
+ * Language mappings and constants for translation system
+ */
+
+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',
+  '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',
+};
+
+const SKIP_WORDS = new Set([
+  'OK',
+  'Email',
+  'Google',
+  'Apple',
+  'Facebook',
+  'Premium',
+  'Pro',
+  'Plus',
+  'BPM',
+]);
+
+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',
+  '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)',
+};
+
+function getLangDisplayName(code) {
+  return LANGUAGE_NAMES[code] || code;
+}
+
+function getTargetLanguage(langCode) {
+  return LANGUAGE_MAP[langCode];
+}
+
+function shouldSkipWord(word) {
+  return SKIP_WORDS.has(word);
+}
+
+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

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+/**
+ * Translator
+ * Google Translate API integration and translation logic
+ */
+
+const https = require('https');
+const { shouldSkipWord } = require('./translation-config');
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function translateText(text, targetLang) {
+  return new Promise((resolve) => {
+    if (shouldSkipWord(text)) {
+      resolve(text);
+      return;
+    }
+
+    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);
+      });
+  });
+}
+
+function needsTranslation(value, enValue) {
+  if (typeof value !== 'string') return false;
+  if (value === enValue) return true;
+  if (shouldSkipWord(value)) return false;
+  return false;
+}
+
+async function translateObject(enObj, targetObj, targetLang, path = '', stats = { count: 0 }) {
+  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] = [];
+      }
+      for (let i = 0; i < enValue.length; i++) {
+        if (typeof enValue[i] === 'string') {
+          if (needsTranslation(targetObj[key][i], enValue[i])) {
+            const preview = enValue[i].length > 40 ? enValue[i].substring(0, 40) + '...' : enValue[i];
+            console.log(`   🔄 ${currentPath}[${i}]: "${preview}"`);
+            targetObj[key][i] = await translateText(enValue[i], targetLang);
+            stats.count++;
+            await delay(200);
+          }
+        }
+      }
+    } else 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') {
+      if (needsTranslation(targetValue, enValue)) {
+        const preview = enValue.length > 40 ? enValue.substring(0, 40) + '...' : enValue;
+        console.log(`   🔄 ${currentPath}: "${preview}"`);
+        targetObj[key] = await translateText(enValue, targetLang);
+        stats.count++;
+        await delay(200);
+      }
+    }
+  }
+
+  return stats.count;
+}
+
+module.exports = {
+  translateText,
+  translateObject,
+  delay,
+};