bctranslate 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bctranslate",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI to transform source files into i18n-ready code with automatic translation via argostranslate",
   "type": "module",
   "bin": {

package/src/generators/locales.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { join } from 'path';
 
 /**
  * Determine the locale directory path based on project type.
@@ -8,6 +8,7 @@ export function getLocaleDir(cwd, project) {
   const candidates = [
     join(cwd, 'src', 'locales'),
     join(cwd, 'src', 'i18n', 'locales'),
+    join(cwd, 'src', 'i18n'),
     join(cwd, 'locales'),
     join(cwd, 'src', 'lang'),
     join(cwd, 'public', 'locales'),
@@ -25,13 +26,53 @@ export function getLocaleDir(cwd, project) {
 }
 
 /**
- * Load an existing locale file, or return empty object.
+ * Flatten a nested JSON object to dot-notation keys.
+ * { home: { notes: 'Notes' } } → { 'home.notes': 'Notes' }
+ */
+function flattenKeys(obj, prefix = '') {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      Object.assign(result, flattenKeys(value, fullKey));
+    } else {
+      result[fullKey] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Unflatten dot-notation keys to a nested JSON object.
+ * { 'home.notes': 'Notes' } → { home: { notes: 'Notes' } }
+ */
+function unflattenKeys(flat) {
+  const result = {};
+  for (const [dotKey, value] of Object.entries(flat)) {
+    const parts = dotKey.split('.');
+    let obj = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (typeof obj[parts[i]] !== 'object' || obj[parts[i]] === null) {
+        obj[parts[i]] = {};
+      }
+      obj = obj[parts[i]];
+    }
+    obj[parts[parts.length - 1]] = value;
+  }
+  return result;
+}
+
+/**
+ * Load an existing locale file and return flat dot-notation keys.
+ * Handles both nested JSON (vue-i18n standard) and legacy flat format.
  */
 export function loadLocale(localeDir, langCode) {
   const filePath = join(localeDir, `${langCode}.json`);
   if (existsSync(filePath)) {
     try {
-      return JSON.parse(readFileSync(filePath, 'utf-8'));
+      const raw = JSON.parse(readFileSync(filePath, 'utf-8'));
+      // Flatten nested objects to dot-notation for internal use
+      return flattenKeys(raw);
     } catch {
       return {};
     }
@@ -41,22 +82,24 @@ export function loadLocale(localeDir, langCode) {
 
 /**
  * Save a locale file, merging with existing keys.
+ * Writes nested JSON (standard for vue-i18n and react-i18next).
  */
-export function saveLocale(localeDir, langCode, newEntries) {
-  mkdirSync(localeDir, { recursive: true });
-
-  const filePath = join(localeDir, `${langCode}.json`);
-  const existing = loadLocale(localeDir, langCode);
-
-  // Merge: new entries take precedence for new keys,
-  // but don't overwrite existing translations (idempotent)
+export function saveLocale(localeDir, langCode, newEntries) {
+  mkdirSync(localeDir, { recursive: true });
+
+  const filePath = join(localeDir, `${langCode}.json`);
+  const existing = loadLocale(localeDir, langCode); // already flat
+
+  // Merge: don't overwrite existing translations
   const merged = { ...existing };
-  for (const [key, value] of Object.entries(newEntries)) {
-    if (!(key in merged)) {
-      merged[key] = value;
-    }
-  }
-
-  writeFileSync(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
-  return filePath;
-}
+  for (const [key, value] of Object.entries(newEntries)) {
+    if (!(key in merged)) {
+      merged[key] = value;
+    }
+  }
+
+  // Write as nested JSON for i18n library compatibility
+  const nested = unflattenKeys(merged);
+  writeFileSync(filePath, JSON.stringify(nested, null, 2) + '\n', 'utf-8');
+  return filePath;
+}

package/src/index.js

@@ -128,7 +128,7 @@ export async function writeFileResult(parseResult, translations, opts) {
 export async function translateAllFiles(files, opts) {
   const { from, to, cwd, project, verbose, localesDir } = opts;
 
-  const resolvedLocaleDir = localesDir || getLocaleDir(cwd, project);
+  const resolvedLocaleDir = opts.outdir ? join(opts.outdir, 'locales') : (localesDir || getLocaleDir(cwd, project));
   const existingTarget    = loadLocale(resolvedLocaleDir, to);
 
   // Phase 1 — parse
@@ -165,6 +165,9 @@ export async function translateAllFiles(files, opts) {
   const allTranslations = { ...existingTarget, ...newTranslations };
 
   // Phase 4 — write files
+  if (!opts.dryRun) {
+    console.log(`  → Locale dir: ${resolvedLocaleDir}`);
+  }
   const results = [];
   for (const parseResult of parsed) {
     try {
@@ -174,7 +177,7 @@ export async function translateAllFiles(files, opts) {
       });
       results.push(r);
     } catch (err) {
-      if (verbose) console.error(`  Write error ${parseResult.filePath}: ${err.message}`);
+      console.error(`  ✗ Write error ${relative(cwd, parseResult.filePath)}: ${err.message}`);
       results.push({ count: 0, skipped: 0, relativePath: relative(cwd, parseResult.filePath) });
     }
   }

package/src/parsers/vue.js

@@ -1,4 +1,7 @@
 import * as compiler from '@vue/compiler-dom';
+import { parse as babelParse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+const traverse = _traverse.default;
 import MagicString from 'magic-string';
 import { contextKey, isTranslatable } from '../utils.js';
 
@@ -30,14 +33,6 @@ const ATTR_WHITELIST = new Set([
  *  - Options API (no setup)
  *    → use  $t('key')         (global plugin property)
  */
-function detectTStyle(source) {
-  const isSetup = /<script\b[^>]*\bsetup\b/i.test(source);
-
-  // Already has:  const { t } = ...   or   const { t, ... } = ...
-  const hasT = /const\s*\{[^}]*\bt\b[^}]*\}\s*=/.test(source);
-
-  return { isSetup, hasT };
-}
 
 /**
  * Parse a .vue file and extract translatable strings.
@@ -46,12 +41,9 @@ export function parseVue(source, filePath) {
   const extracted = [];
   const s = new MagicString(source);
 
-  const { isSetup, hasT } = detectTStyle(source);
-
-  // In templates: use t() for Composition API, $t() for Options API
-  const tpl = (key) => (isSetup || hasT) ? `t('${key}')` : `$t('${key}')`;
-  // In scripts: use t() for setup, this.$t() for options
-  const scr = (key) => isSetup ? `t('${key}')` : `this.$t('${key}')`;
+  // Always use t() for consistency, as promised in the README.
+  const tpl = (key) => `t('${key}')`;
+  const scr = (key) => `t('${key}')`;
 
   // ── Template ────────────────────────────────────────────────────────────────
   const templateMatch = source.match(/<template\b[^>]*>([\s\S]*?)<\/template>/);
@@ -77,12 +69,13 @@ export function parseVue(source, filePath) {
     extractScriptStrings(scriptContent, s, scriptOffset, extracted, filePath, scr);
   }
 
-  // ── Inject `const { t } = useI18n()` if setup but t not yet declared ────────
-  if (extracted.length > 0 && isSetup && !hasT) {
+  // ── Inject `const { t } = useI18n()` if not yet declared ────────
+  if (extracted.length > 0) {
     const scriptSetupMatch = source.match(/(<script\b[^>]*\bsetup\b[^>]*>)([\s\S]*?)<\/script>/i);
-    if (scriptSetupMatch) {
-      const insertAt =
-        source.indexOf(scriptSetupMatch[0]) + scriptSetupMatch[1].length;
+    const hasT = /const\s*\{[^}]*\bt\b[^}]*\}\s*=/.test(source);
+    
+    if (scriptSetupMatch && !hasT) {
+      const insertAt = source.indexOf(scriptSetupMatch[0]) + scriptSetupMatch[1].length;
       const needsImport = !source.includes('useI18n');
       const importLine = needsImport ? `import { useI18n } from 'vue-i18n';\n` : '';
       s.appendRight(insertAt, `\n${importLine}const { t } = useI18n();\n`);
@@ -155,33 +148,104 @@ function walkTemplate(nodes, s, baseOffset, extracted, filePath, tpl) {
 // ── Script string extractor ───────────────────────────────────────────────────
 
 function extractScriptStrings(scriptContent, s, baseOffset, extracted, filePath, scr) {
+  try {
+    const ast = babelParse(scriptContent, {
+      sourceType: 'module',
+      plugins: ['typescript', 'jsx'], // Enable TS and JSX support
+    });
+
+    const replacements = [];
+
+    traverse(ast, {
+      enter(path) {
+        let text;
+
+        if (path.isStringLiteral()) {
+          text = path.node.value;
+        } else if (path.isTemplateLiteral()) {
+          if (path.node.expressions.length > 0 || path.node.quasis.length !== 1) {
+            return;
+          }
+          text = path.node.quasis[0].value.cooked;
+        } else {
+          return;
+        }
+        
+        if (!isTranslatable(text)) return;
+
+        // --- Parent checks to avoid replacing the wrong strings ---
+        if (path.parent.type === 'CallExpression' && path.parent.callee.name === 't') return;
+        if (['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'].includes(path.parent.type)) return;
+        if (path.parent.type === 'ObjectProperty' && path.parent.key === path.node) return;
+        if (path.parent.type === 'Property' && ['name'].includes(path.parent.key.name)) return;
+
+        // --- Passed all checks, schedule replacement ---
+        const key = contextKey(text, filePath);
+        const start = baseOffset + path.node.start;
+        const end = baseOffset + path.node.end;
+        replacements.push({ start, end, key });
+        extracted.push({ key, text, context: 'script' });
+      }
+    });
+
+    // Apply replacements in reverse order to avoid offset issues
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const { start, end, key } = replacements[i];
+      s.overwrite(start, end, scr(key));
+    }
+
+  } catch (e) {
+    console.error('Babel parsing failed:', e);
+    // If babel parsing fails, fallback to regex.
+    extractScriptStringsRegex(scriptContent, s, baseOffset, extracted, filePath, scr);
+  }
+}
+
+
+function extractScriptStringsRegex(scriptContent, s, baseOffset, extracted, filePath, scr) {
+  // This is the old regex-based implementation, kept as a fallback.
   const patterns = [
     /\b(alert|confirm|toast|notify|message\.(?:success|error|warning|info))\s*\(\s*(['"`])((?:(?!\2).)+)\2\s*\)/g,
-    /\b(title|label|placeholder|message|text|description|tooltip|hint|caption|header|subtitle|errorMessage|successMessage)\s*:\s*(['"`])((?:(?!\2).)+)\2/g,
+    /\b(title|label|placeholder|message|text|description|tooltip|hint|caption|header|subtitle|errorMessage|successMessage|emptyText|noData|loadingText|buttonText|confirmText|cancelText|successText|failText|warningText|helperText|hintText)\s*:\s*(['"`])((?:(?!\2).)+)\2/g,
+    /\bref\s*\(\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g,
+    /\bcomputed\s*\(\s*\(\s*\)\s*=>\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g,
   ];
 
   for (const pattern of patterns) {
     let match;
     while ((match = pattern.exec(scriptContent)) !== null) {
-      const text = match[3];
-      if (isTranslatable(text) && text.length > 1) {
-        const key       = contextKey(text, filePath);
-        const quoteChar = match[2];
-        const textStart = baseOffset + match.index + match[0].indexOf(quoteChar + text);
-        const textEnd   = textStart + text.length + 2;
-        s.overwrite(textStart, textEnd, scr(key));
-        extracted.push({ key, text, context: 'script' });
-      }
+      const text = match[3] || match[2];
+      if (!isTranslatable(text) || text.length <= 1) continue;
+      
+      const quoteChar = match[2] || match[1];
+      const innerStr = quoteChar + text + quoteChar;
+      const relPos = match.index + match[0].lastIndexOf(innerStr);
+
+      if (isAlreadyWrappedScript(scriptContent, relPos)) continue;
+
+      const key = contextKey(text, filePath);
+      const textStart = baseOffset + relPos;
+      const textEnd = textStart + innerStr.length;
+
+      s.overwrite(textStart, textEnd, scr(key));
+      extracted.push({ key, text, context: 'script-regex' });
     }
   }
 }
 
+function isAlreadyWrappedScript(scriptContent, pos) {
+  const before = scriptContent.slice(Math.max(0, pos - 30), pos);
+  return /\$?t\s*\(\s*$/.test(before);
+}
+
+
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function isAlreadyWrapped(source, start, end) {
-  // Look back 25 chars for an open t( or $t( call — node is inside an interpolation
+  // Look back 25 chars for an open t( call — node is inside an interpolation
   const before = source.slice(Math.max(0, start - 25), start);
-  return /\$?t\s*\(\s*['"]/.test(before);
+  // Note: We only check for `t` now, not `$t`.
+  return /t\s*\(\s*['"]/.test(before);
 }
 
 function extractTemplateRegex(source, s, extracted, filePath, tpl) {

package/python/t2.py

@@ -1,76 +0,0 @@
-import sys
-import json
-import os
-
-# Suppress TensorFlow logs
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
-
-try:
-    import argostranslate.package
-    import argostranslate.translate
-except ImportError:
-    print(json.dumps({"error": "argostranslate not found. Please run: pip install argostranslate"}), file=sys.stderr)
-    sys.exit(1)
-
-def main():
-    if len(sys.argv) != 3:
-        print(json.dumps({"error": "Usage: python translator.py <from_code> <to_code>"}), file=sys.stderr)
-        sys.exit(1)
-
-    from_code = sys.argv[1]
-    to_code = sys.argv[2]
-
-    try:
-        input_data = sys.stdin.read()
-        batch = json.loads(input_data)
-    except json.JSONDecodeError:
-        print(json.dumps({"error": "Invalid JSON input"}), file=sys.stderr)
-        sys.exit(1)
-
-    try:
-        # 1. Find the installed languages
-        installed_languages = argostranslate.translate.get_installed_languages()
-        from_lang = next((lang for lang in installed_languages if lang.code == from_code), None)
-        to_lang = next((lang for lang in installed_languages if lang.code == to_code), None)
-
-        if not from_lang or not to_lang:
-            # This should ideally be handled by the check in the Node.js bridge,
-            # but as a fallback, we report it here too.
-            available_codes = [l.code for l in installed_languages]
-            print(json.dumps({
-                "error": f"Language pair not installed: {from_code}->{to_code}. Installed: {available_codes}"
-            }), file=sys.stderr)
-            sys.exit(1)
-
-        # 2. Get the translation object
-        translation = from_lang.get_translation(to_lang)
-        if not translation:
-             # This may happen if the translation direction is not supported (e.g., en->en)
-            if from_code == to_code:
-                # If source and target are the same, just return the original text
-                print(json.dumps(batch))
-                sys.exit(0)
-            else:
-                print(json.dumps({"error": f"Translation from {from_code} to {to_code} is not supported by the installed model."}), file=sys.stderr)
-                sys.exit(1)
-
-
-        # 3. Translate texts
-        translated_batch = []
-        for item in batch:
-            original_text = item.get('text', '')
-            translated_text = translation.translate(original_text)
-            translated_batch.append({
-                "key": item.get('key'),
-                "text": translated_text
-            })
-
-        # 4. Output the result as a JSON array
-        print(json.dumps(translated_batch, ensure_ascii=False))
-
-    except Exception as e:
-        print(json.dumps({"error": f"An unexpected error occurred: {str(e)}"}), file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()