bctranslate 1.0.3 → 1.0.4

package/package.json

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

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

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,64 +148,87 @@ function walkTemplate(nodes, s, baseOffset, extracted, filePath, tpl) {
 // ── Script string extractor ───────────────────────────────────────────────────
 
 function extractScriptStrings(scriptContent, s, baseOffset, extracted, filePath, scr) {
-  // Pattern A: alert/confirm/toast/notify calls  →  match[2]=quote, match[3]=text
-  // Pattern B: UI object property string values  →  match[2]=quote, match[3]=text
-  const patternsAB = [
+  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|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 patternsAB) {
+  for (const pattern of patterns) {
     let match;
     while ((match = pattern.exec(scriptContent)) !== null) {
-      const text = match[3];
+      const text = match[3] || match[2];
       if (!isTranslatable(text) || text.length <= 1) continue;
-      const quoteChar = match[2];
-      const relPos = match.index + match[0].indexOf(quoteChar + text);
-      if (isAlreadyWrappedScript(scriptContent, relPos)) continue;
-      const key      = contextKey(text, filePath);
-      const textStart = baseOffset + relPos;
-      const textEnd   = textStart + text.length + 2;
-      s.overwrite(textStart, textEnd, scr(key));
-      extracted.push({ key, text, context: 'script' });
-    }
-  }
+      
+      const quoteChar = match[2] || match[1];
+      const innerStr = quoteChar + text + quoteChar;
+      const relPos = match.index + match[0].lastIndexOf(innerStr);
 
-  // Pattern C: ref('string') / ref("string")  →  match[1]=quote, match[2]=text
-  const refPattern = /\bref\s*\(\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g;
-  {
-    let match;
-    while ((match = refPattern.exec(scriptContent)) !== null) {
-      const text = match[2];
-      if (!isTranslatable(text) || text.length <= 1) continue;
-      const quoteChar = match[1];
-      const innerStr  = quoteChar + text + quoteChar;
-      const relPos    = match.index + match[0].indexOf(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-ref' });
-    }
-  }
 
-  // Pattern D: computed(() => 'string')  →  match[1]=quote, match[2]=text
-  const computedPattern = /\bcomputed\s*\(\s*\(\s*\)\s*=>\s*(['"`])((?:(?!\1)[^\\]|\\.)+)\1\s*\)/g;
-  {
-    let match;
-    while ((match = computedPattern.exec(scriptContent)) !== null) {
-      const text = match[2];
-      if (!isTranslatable(text) || text.length <= 1) continue;
-      const quoteChar = match[1];
-      const innerStr  = quoteChar + text + quoteChar;
-      const relPos    = match.index + match[0].indexOf(innerStr);
-      if (isAlreadyWrappedScript(scriptContent, relPos)) continue;
-      const key      = contextKey(text, filePath);
+      const key = contextKey(text, filePath);
       const textStart = baseOffset + relPos;
-      const textEnd   = textStart + innerStr.length;
+      const textEnd = textStart + innerStr.length;
+
       s.overwrite(textStart, textEnd, scr(key));
-      extracted.push({ key, text, context: 'script-computed' });
+      extracted.push({ key, text, context: 'script-regex' });
     }
   }
 }
@@ -222,12 +238,14 @@ function isAlreadyWrappedScript(scriptContent, 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()