@umituz/react-native-google-translate 1.0.3 → 1.0.5

package/src/scripts/sync.ts

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+/**
+ * Sync Translations Script
+ * Synchronizes translation keys from en-US.ts to all other language files
+ */
+
+import fs from 'fs';
+import path from 'path';
+import {
+  parseTypeScriptFile,
+  generateTypeScriptContent,
+} from './utils/file-parser';
+import {
+  addMissingKeys,
+  removeExtraKeys,
+  type SyncStats,
+} from './utils/sync-helper';
+import { detectNewKeys } from './utils/key-detector';
+import { extractUsedKeys } from './utils/key-extractor';
+import { setDeep, countKeys } from './utils/object-helper';
+
+export interface SyncTranslationsOptions {
+  targetDir: string;
+  srcDir?: string;
+}
+
+export interface SyncLanguageFileResult {
+  added?: number;
+  newKeys?: string[];
+  removed?: number;
+  removedKeys?: string[];
+  changed: boolean;
+  detectedNewKeys: unknown[];
+}
+
+export function syncLanguageFile(
+  enUSPath: string,
+  targetPath: string,
+  langCode: string
+): SyncLanguageFileResult {
+  const enUS = parseTypeScriptFile(enUSPath);
+  let target: Record<string, unknown>;
+
+  try {
+    target = parseTypeScriptFile(targetPath);
+  } catch {
+    target = {};
+  }
+
+  const detectedNewKeys = detectNewKeys(enUS, target);
+  const addStats: SyncStats = { added: 0, newKeys: [] };
+  const removeStats: SyncStats = { removed: 0, removedKeys: [] };
+
+  addMissingKeys(enUS, target, addStats);
+  removeExtraKeys(enUS, target, removeStats);
+
+  const changed = (addStats.added || 0) > 0 || (removeStats.removed || 0) > 0;
+
+  if (changed) {
+    const content = generateTypeScriptContent(target, langCode);
+    fs.writeFileSync(targetPath, content);
+  }
+
+  return {
+    added: addStats.added,
+    newKeys: addStats.newKeys,
+    removed: removeStats.removed,
+    removedKeys: removeStats.removedKeys,
+    changed,
+    detectedNewKeys,
+  };
+}
+
+function processExtraction(srcDir: string | undefined, enUSPath: string): void {
+  if (!srcDir) return;
+
+  console.log(`🔍 Scanning source code and dependencies: ${srcDir}...`);
+  const usedKeyMap = extractUsedKeys(srcDir);
+  console.log(`   Found ${usedKeyMap.size} unique keys.`);
+
+  const oldEnUS = parseTypeScriptFile(enUSPath);
+  const newEnUS: Record<string, unknown> = {};
+
+  let addedCount = 0;
+  for (const [key, defaultValue] of usedKeyMap) {
+    // Try to keep existing translation if it exists
+    const existingValue = key.split('.').reduce((obj: unknown, k: string) => {
+      if (obj && typeof obj === 'object' && k in obj) {
+        return (obj as Record<string, unknown>)[k];
+      }
+      return undefined;
+    }, 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++;
+    }
+  }
+
+  const oldTotal = countKeys(oldEnUS);
+  const newTotal = countKeys(newEnUS);
+  const removedCount = Math.max(0, oldTotal - (newTotal - addedCount));
+
+  console.log(`   ✨ Optimized en-US.ts: ${addedCount} keys populated/updated, pruned ${removedCount} unused.`);
+  const content = generateTypeScriptContent(newEnUS, 'en-US');
+  fs.writeFileSync(enUSPath, content);
+}
+
+export function syncTranslations(options: SyncTranslationsOptions): boolean {
+  const { targetDir, srcDir } = options;
+  const localesDir = path.resolve(process.cwd(), targetDir);
+  const enUSPath = path.join(localesDir, 'en-US.ts');
+
+  if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
+    console.error(`❌ Localization files not found in: ${localesDir}`);
+    return false;
+  }
+
+  processExtraction(srcDir, enUSPath);
+
+  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`);
+  files.forEach(file => {
+    const langCode = file.replace('.ts', '');
+    const targetPath = path.join(localesDir, file);
+    const result = syncLanguageFile(enUSPath, targetPath, langCode);
+    if (result.changed) {
+      console.log(`   🌍 ${langCode}: ✏️  +${result.added || 0} keys, -${result.removed || 0} keys`);
+    }
+  });
+
+  console.log(`\n✅ Synchronization completed!`);
+  return true;
+}
+
+// CLI interface
+export function runSyncTranslations(): void {
+  const targetDir = process.argv[2] || 'src/infrastructure/locales';
+  const srcDir = process.argv[3];
+  console.log('🚀 Starting translation synchronization...\n');
+  syncTranslations({ targetDir, srcDir });
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runSyncTranslations();
+}

package/src/scripts/translate.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+/**
+ * Translate Missing Script
+ * Automatically translates missing strings using Google Translate
+ */
+
+import fs from 'fs';
+import path from 'path';
+import {
+  parseTypeScriptFile,
+  generateTypeScriptContent,
+} from './utils/file-parser';
+import { googleTranslateService, getTargetLanguage, getLanguageDisplayName } from '../infrastructure/services';
+import type { TranslationStats } from '../domain';
+
+// Width of terminal line to clear for progress updates
+const PROGRESS_LINE_WIDTH = 80;
+
+export interface TranslateMissingOptions {
+  targetDir: string;
+  srcDir?: string;
+  skipSync?: boolean;
+}
+
+export async function translateMissing(options: TranslateMissingOptions): Promise<void> {
+  const { targetDir, srcDir, skipSync = false } = options;
+
+  // Initialize the translation service
+  googleTranslateService.initialize({
+    minDelay: 100,
+    maxRetries: 3,
+    timeout: 10000,
+  });
+
+  const localesDir = path.resolve(process.cwd(), targetDir);
+  const enUSPath = path.join(localesDir, 'en-US.ts');
+
+  if (!fs.existsSync(localesDir) || !fs.existsSync(enUSPath)) {
+    console.error(`❌ Localization files not found in: ${localesDir}`);
+    return;
+  }
+
+  const files = fs.readdirSync(localesDir)
+    .filter(f => f.match(/^[a-z]{2}-[A-Z]{2}\.ts$/) && f !== 'en-US.ts')
+    .sort();
+
+  console.log(`\n📊 Languages to translate: ${files.length}\n`);
+
+  const enUS = parseTypeScriptFile(enUSPath);
+
+  for (const file of files) {
+    const langCode = file.replace('.ts', '');
+
+    // Skip English variants
+    const targetLang = getTargetLanguage(langCode);
+    if (!targetLang || targetLang === 'en') {
+      console.log(`⏭️  Skipping ${langCode} (English variant)`);
+      continue;
+    }
+
+    const langName = getLanguageDisplayName(langCode);
+    console.log(`🌍 Translating ${langCode} (${langName})...`);
+
+    const targetPath = path.join(localesDir, file);
+    const target = parseTypeScriptFile(targetPath);
+
+    const stats: TranslationStats = {
+      totalCount: 0,
+      successCount: 0,
+      failureCount: 0,
+      skippedCount: 0,
+      translatedKeys: [],
+    };
+
+    await googleTranslateService.translateObject(
+      enUS,
+      target,
+      targetLang,
+      '',
+      stats
+    );
+
+    // Clear progress line
+    process.stdout.write('\r' + ' '.repeat(PROGRESS_LINE_WIDTH) + '\r');
+
+    if (stats.successCount > 0) {
+      const content = generateTypeScriptContent(target, langCode);
+      fs.writeFileSync(targetPath, content);
+
+      console.log(`      ✅ Successfully translated ${stats.successCount} 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 up to date.`);
+    }
+  }
+
+  console.log('\n✅ All translations completed!');
+}
+
+// CLI interface
+export function runTranslateMissing(): void {
+  const args = process.argv.slice(2).filter(arg => !arg.startsWith('--'));
+  const targetDir = args[0] || 'src/infrastructure/locales';
+  const srcDir = args[1];
+  const skipSync = process.argv.includes('--no-sync');
+
+  console.log('🚀 Starting integrated translation workflow...');
+  translateMissing({ targetDir, srcDir, skipSync }).catch(err => {
+    console.error('\n❌ Translation workflow failed:', err.message);
+    process.exit(1);
+  });
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runTranslateMissing();
+}

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

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import { getLanguageDisplayName } from '../../infrastructure/utils/textValidator.util';
+
+/**
+ * File Parser
+ * Parse and generate TypeScript translation files
+ */
+
+export function parseTypeScriptFile(filePath: string): Record<string, unknown> {
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  // Match: export default { ... } OR export const NAME = { ... }
+  const match = content.match(/export\s+(?:default|const\s+\w+\s*=)\s*(\{[\s\S]*\});?\s*$/);
+
+  if (!match) {
+    throw new Error(`Could not parse TypeScript file: ${filePath}`);
+  }
+
+  const objectStr = match[1].replace(/;$/, '');
+
+  try {
+    // Basic evaluation for simple objects (safe for generated translation files)
+    // Only contains string literals, numbers, booleans, and nested objects
+    // eslint-disable-next-line no-eval
+    return eval(`(${objectStr})`) as Record<string, unknown>;
+  } catch (error) {
+    // File might be a barrel file with named imports
+    const dir = path.dirname(filePath);
+    const importMatches = [...content.matchAll(/import\s*\{\s*(\w+)\s*\}\s*from\s*["']\.\/(\w+)["']/g)];
+
+    if (importMatches.length > 0) {
+      const result: Record<string, unknown> = {};
+      for (const [, varName, moduleName] of importMatches) {
+        const subFilePath = path.join(dir, `${moduleName}.ts`);
+        if (fs.existsSync(subFilePath)) {
+          try {
+            result[varName] = parseTypeScriptFile(subFilePath);
+          } catch (subError) {
+            // Log sub-file parse errors but continue with other files
+            console.warn(`Warning: Could not parse sub-file ${subFilePath}: ${subError instanceof Error ? subError.message : 'Unknown error'}`);
+          }
+        }
+      }
+      if (Object.keys(result).length > 0) {
+        return result;
+      }
+    }
+  }
+
+  return {};
+}
+
+export function stringifyValue(value: unknown, indent = 2): string {
+  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
+      .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)}`;
+      })
+      .join(',\n');
+    return `{\n${entriesStr},\n${spaces}}`;
+  }
+
+  return String(value);
+}
+
+export function generateTypeScriptContent(obj: Record<string, unknown>, langCode: string): string {
+  const langName = getLanguageDisplayName(langCode);
+  const isBase = langCode === 'en-US';
+  const objString = stringifyValue(obj, 0);
+
+  return `/**
+ * ${langName} Translations
+ * ${isBase ? 'Base translations file' : 'Auto-synced from en-US.ts'}
+ */
+
+export default ${objString};
+`;
+}

package/src/scripts/utils/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Scripts Utils
+ * Utility functions for translation scripts
+ */
+
+export * from './file-parser';
+export * from './key-detector';
+export * from './key-extractor';
+export * from './object-helper';
+export * from './sync-helper';

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

@@ -0,0 +1,70 @@
+/**
+ * Key Detector
+ * Detects new, missing, and removed keys between source and target objects
+ */
+
+export interface NewKey {
+  path: string;
+  value: unknown;
+}
+
+export function detectNewKeys(
+  sourceObj: Record<string, unknown>,
+  targetObj: Record<string, unknown>,
+  path = '',
+  newKeys: NewKey[] = []
+): NewKey[] {
+  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 as Record<string, unknown>,
+          targetValue as Record<string, unknown>,
+          currentPath,
+          newKeys
+        );
+      }
+    }
+  }
+  return newKeys;
+}
+
+export function detectMissingKeys(
+  sourceObj: Record<string, unknown>,
+  targetObj: Record<string, unknown>,
+  path = '',
+  missingKeys: string[] = []
+): string[] {
+  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] as Record<string, unknown>,
+        targetObj[key] as Record<string, unknown>,
+        currentPath,
+        missingKeys
+      );
+    }
+  }
+  return missingKeys;
+}

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

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Generic Key Extractor
+ * Scans source code for i18n translation keys
+ */
+
+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 extractFromFile(content: string, keyMap: Map<string, string>): void {
+  // Pattern 1: t('key') or t("key")
+  const tRegex = /(?:^|\W)t\(['"`]([^'"`]+)['"`]\)/g;
+  let match: RegExpExecArray | null;
+  while ((match = tRegex.exec(content)) !== null) {
+    const key = match[1];
+    if (!key.includes('${') && !keyMap.has(key)) {
+      keyMap.set(key, key);
+    }
+  }
+
+  // Pattern 2: Dot-notation strings (potential i18n keys)
+  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(' ') && !keyMap.has(key)) {
+      keyMap.set(key, 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];
+    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;
+
+        const dynamicKey = `${prefix}.${id}`;
+        if (!keyMap.has(dynamicKey)) {
+          keyMap.set(dynamicKey, dynamicKey);
+        }
+      }
+    }
+  }
+}
+
+function walkDirectory(
+  dir: string,
+  keyMap: Map<string, string>,
+  skipDirs: string[] = ['node_modules', '.expo', '.git', 'build', 'ios', 'android', 'assets', 'locales', '__tests__']
+): void {
+  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()) {
+      if (!skipDirs.includes(file)) {
+        walkDirectory(fullPath, keyMap, skipDirs);
+      }
+    } else if (/\.(ts|tsx|js|jsx)$/.test(file)) {
+      const content = fs.readFileSync(fullPath, 'utf8');
+      extractFromFile(content, keyMap);
+    }
+  }
+}
+
+export function extractUsedKeys(srcDir: string): Map<string, string> {
+  const keyMap = new Map<string, string>();
+  if (!srcDir) return keyMap;
+
+  const projectRoot = process.cwd();
+  const absoluteSrcDir = path.resolve(projectRoot, srcDir);
+
+  // Scan project source
+  walkDirectory(absoluteSrcDir, keyMap);
+
+  // Scan @umituz packages for shared keys
+  const packagesDir = path.resolve(projectRoot, 'node_modules/@umituz');
+  if (fs.existsSync(packagesDir)) {
+    walkDirectory(packagesDir, keyMap);
+  }
+
+  return keyMap;
+}

package/src/scripts/utils/object-helper.ts

@@ -0,0 +1,49 @@
+/**
+ * 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: Record<string, unknown>, path: string, value: unknown): boolean {
+  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] as Record<string, unknown>;
+  }
+
+  const lastKey = keys[keys.length - 1];
+  if (current[lastKey] === undefined) {
+    current[lastKey] = value;
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Count all leaf keys in a nested object
+ */
+export function countKeys(obj: Record<string, unknown>): number {
+  let count = 0;
+
+  const walk = (o: Record<string, unknown>): void => {
+    for (const k in o) {
+      if (typeof o[k] === 'object' && o[k] !== null) {
+        walk(o[k] as Record<string, unknown>);
+      } else {
+        count++;
+      }
+    }
+  };
+
+  walk(obj);
+  return count;
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Sync Helper
+ * Helper functions for synchronizing translation keys
+ */
+
+export interface SyncStats {
+  added?: number;
+  newKeys?: string[];
+  removed?: number;
+  removedKeys?: string[];
+}
+
+export function addMissingKeys(
+  sourceObj: Record<string, unknown>,
+  targetObj: Record<string, unknown>,
+  stats: SyncStats = {}
+): SyncStats {
+  stats.added = stats.added || 0;
+  stats.newKeys = stats.newKeys || [];
+
+  for (const key in sourceObj) {
+    const sourceValue = sourceObj[key];
+    const isNewKey = !Object.prototype.hasOwnProperty.call(targetObj, key);
+
+    if (isNewKey) {
+      targetObj[key] = sourceValue;
+      stats.added++;
+      stats.newKeys.push(key);
+    } else if (
+      typeof sourceValue === 'object' &&
+      sourceValue !== null &&
+      !Array.isArray(sourceValue)
+    ) {
+      if (!targetObj[key] || typeof targetObj[key] !== 'object') {
+        targetObj[key] = {};
+      }
+      addMissingKeys(
+        sourceValue as Record<string, unknown>,
+        targetObj[key] as Record<string, unknown>,
+        stats
+      );
+    }
+  }
+  return stats;
+}
+
+export function removeExtraKeys(
+  sourceObj: Record<string, unknown>,
+  targetObj: Record<string, unknown>,
+  stats: SyncStats = {}
+): SyncStats {
+  stats.removed = stats.removed || 0;
+  stats.removedKeys = stats.removedKeys || [];
+
+  for (const key in targetObj) {
+    const isExtraKey = !Object.prototype.hasOwnProperty.call(sourceObj, key);
+
+    if (isExtraKey) {
+      delete targetObj[key];
+      stats.removed++;
+      stats.removedKeys.push(key);
+    } else if (
+      typeof sourceObj[key] === 'object' &&
+      sourceObj[key] !== null &&
+      !Array.isArray(sourceObj[key]) &&
+      typeof targetObj[key] === 'object' &&
+      targetObj[key] !== null &&
+      !Array.isArray(targetObj[key])
+    ) {
+      removeExtraKeys(
+        sourceObj[key] as Record<string, unknown>,
+        targetObj[key] as Record<string, unknown>,
+        stats
+      );
+    }
+  }
+  return stats;
+}