bctranslate 1.0.0-beta.2 → 1.0.0-beta.4

package/README.md

@@ -1,6 +1,6 @@
 # bctranslate ⚡
 
-# Notice: This app is in Beta mode, work in progress; currently works for html files, contribution is welcome at: [BCtranslate github repo](https://github.com/mrkinix/bctranslate)
+# Notice: This app is in Beta mode, work in progress; the tool works but necessitates user intervention to fix some bugs and alter directories and imports, contribution is welcome at: [BCtranslate github repo](https://github.com/mrkinix/bctranslate)
 
 `bctranslate` is a command-line tool to automatically transform source code into an i18n-ready format. It extracts hardcoded strings from your files, replaces them with calls to a translation function, and generates locale files with translations powered by [Argos Translate](https://www.argosopentech.com/).
 

package/package.json

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

package/src/generators/setup.js

@@ -78,6 +78,7 @@ function nestMessages(input) {
 
 const i18n = createI18n({
   legacy: false,
+  globalInjection: true,
   locale: '${from}',
   fallbackLocale: '${from}',
   messages: {

package/src/parsers/js.js

@@ -20,6 +20,10 @@ export function parseJs(source, filePath, project) {
     return `t('${key}')`;
   };
 
+  const arrayKeys = new Set([
+    'options', 'items', 'labels', 'actions', 'tabs', 'menu', 'choices', 'buttons', 'breadcrumbs',
+  ]);
+
   const translatableAttrNames = new Set([
     'title',
     'placeholder',
@@ -77,6 +81,35 @@ export function parseJs(source, filePath, project) {
       s.overwrite(valueNode.start, valueNode.end, tFunc);
       extracted.push({ key, text: valueNode.value, context: `js-prop-${keyName}` });
     },
+
+    ArrayExpression(path) {
+      const parent = path.parent;
+      if (!parent) return;
+
+      // Translate arrays of strings only when clearly UI-ish, e.g. { options: ['A','B'] }
+      if (parent.type === 'ObjectProperty' && parent.value === path.node) {
+        const keyNode = parent.key;
+        const keyName = keyNode.name || keyNode.value || '';
+        if (!arrayKeys.has(keyName) && !translatableKeys.has(keyName)) return;
+
+        for (const el of path.node.elements) {
+          if (!el) continue;
+          if (el.type === 'StringLiteral' && isTranslatable(el.value)) {
+            const key = contextKey(el.value, filePath);
+            const tFunc = tFuncFor(key);
+            s.overwrite(el.start, el.end, tFunc);
+            extracted.push({ key, text: el.value, context: `js-array-${keyName}` });
+          } else if (el.type === 'TemplateLiteral' && el.expressions.length === 0) {
+            const value = el.quasis[0]?.value?.cooked ?? '';
+            if (!isTranslatable(value)) continue;
+            const key = contextKey(value, filePath);
+            const tFunc = tFuncFor(key);
+            s.overwrite(el.start, el.end, tFunc);
+            extracted.push({ key, text: value, context: `js-array-${keyName}` });
+          }
+        }
+      }
+    },
 
     // Function calls: alert('text'), console messages excluded
     CallExpression(path) {

package/src/parsers/vue.js

@@ -50,7 +50,12 @@ export function parseVue(source, filePath) {
   const templatePrefersDollarT = /\$t\s*\(/.test(templateBlock);
   const templatePrefersT = !templatePrefersDollarT && /\bt\s*\(/.test(templateBlock);
 
-  const tpl = (key) => (templatePrefersT ? `t('${key}')` : `$t('${key}')`);
+  // Safer default: in <script setup>, `t()` can always be injected; `$t` depends on globalInjection/legacy.
+  const tpl = (key) => {
+    if (templatePrefersDollarT) return `$t('${key}')`;
+    if (templatePrefersT) return `t('${key}')`;
+    return hasScriptSetup ? `t('${key}')` : `$t('${key}')`;
+  };
   const scr = (key) => (hasScriptSetup ? `t('${key}')` : `this.$t('${key}')`);
 
   // ── Template ────────────────────────────────────────────────────────────────
@@ -161,18 +166,142 @@ function walkTemplate(nodes, s, baseOffset, extracted, filePath, tpl) {
 
 // ── Script string extractor ───────────────────────────────────────────────────
 
-function extractScriptStrings(scriptContent, s, baseOffset, extracted, filePath, scr) {
-  try {
+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;
+    const replacements = [];
+
+    const translatableKeys = new Set([
+      'title', 'label', 'placeholder', 'message', 'text',
+      'description', 'tooltip', 'hint', 'caption', 'header',
+      'subtitle', 'errorMessage', 'successMessage', 'content',
+      'heading', 'subheading', 'buttonText', 'linkText',
+      'emptyText', 'noData', 'loadingText', 'confirmText',
+      'cancelText', 'successText', 'failText', 'warningText',
+      'helperText', 'hintText',
+    ]);
+
+    const arrayKeys = new Set([
+      'options', 'items', 'labels', 'actions', 'tabs', 'menu', 'choices', 'buttons', 'breadcrumbs',
+    ]);
+
+    const skipCallees = new Set([
+      'defineEmits',
+      'defineProps',
+      'defineExpose',
+      'withDefaults',
+      'emit',
+      '$emit',
+    ]);
+
+    const skipMemberCallees = new Set([
+      'localStorage.getItem',
+      'localStorage.setItem',
+      'localStorage.removeItem',
+      'sessionStorage.getItem',
+      'sessionStorage.setItem',
+      'sessionStorage.removeItem',
+      'document.querySelector',
+      'document.querySelectorAll',
+      'document.getElementById',
+      'document.getElementsByClassName',
+      'document.getElementsByTagName',
+    ]);
+
+    const allowCallees = new Set(['alert', 'confirm', 'prompt', 'toast', 'notify']);
+
+    const getKeyName = (keyNode) => {
+      if (!keyNode) return '';
+      if (keyNode.type === 'Identifier') return keyNode.name;
+      if (keyNode.type === 'StringLiteral') return keyNode.value;
+      return '';
+    };
+
+    const calleeName = (callee) => {
+      if (!callee) return '';
+      if (callee.type === 'Identifier') return callee.name;
+      if (callee.type === 'MemberExpression' && callee.property) {
+        const obj = callee.object?.name || '';
+        const prop = callee.property?.name || callee.property?.value || '';
+        return obj && prop ? `${obj}.${prop}` : prop;
+      }
+      return '';
+    };
+
+    const isInSkippedCall = (p) => {
+      const call = p.findParent((pp) => pp.isCallExpression());
+      if (!call) return false;
+      const name = calleeName(call.node.callee);
+      return skipCallees.has(name) || skipMemberCallees.has(name);
+    };
+
+    const isTSOnly = (p) =>
+      !!p.findParent((pp) =>
+        pp.isTSTypeAnnotation?.() ||
+        pp.isTSLiteralType?.() ||
+        pp.isTSUnionType?.() ||
+        pp.isTSInterfaceDeclaration?.() ||
+        pp.isTSTypeAliasDeclaration?.()
+      );
+
+    const shouldTranslate = (p, text) => {
+      if (!isTranslatable(text)) return false;
+      if (isTSOnly(p)) return false;
+
+      // Never touch selectors / computed property names: obj['key']
+      if (p.parent?.type === 'MemberExpression' && p.parent.computed && p.parent.property === p.node) return false;
+
+      // Skip event/prop definitions and other internal identifiers
+      if (isInSkippedCall(p)) return false;
+
+      // Skip already wrapped
+      if (p.parent?.type === 'CallExpression' && (calleeName(p.parent.callee) === 't' || calleeName(p.parent.callee) === '$t')) return false;
+
+      // UI-ish object properties
+      if (p.parent?.type === 'ObjectProperty' && p.parent.value === p.node) {
+        const key = getKeyName(p.parent.key);
+        if (translatableKeys.has(key)) return true;
+
+        // Arrays of visible labels/options
+        if (
+          (p.parent.value?.type === 'ArrayExpression' && (arrayKeys.has(key) || translatableKeys.has(key)))
+        ) {
+          return true;
+        }
+
+        return false;
+      }
+
+      // Arrays of strings (translate only when clearly UI lists)
+      if (p.parent?.type === 'ArrayExpression') {
+        const gp = p.parentPath?.parent;
+        if (gp?.type === 'ObjectProperty' && gp.value === p.parent) {
+          const key = getKeyName(gp.key);
+          if (arrayKeys.has(key) || translatableKeys.has(key)) return true;
+        }
+        if (gp?.type === 'VariableDeclarator' && gp.id?.type === 'Identifier') {
+          const name = gp.id.name;
+          if (arrayKeys.has(name) || name.endsWith('Options') || name.endsWith('Labels')) return true;
+        }
+        return false;
+      }
+
+      // Allow common UI calls (alert/toast/etc)
+      if (p.parent?.type === 'CallExpression') {
+        const name = calleeName(p.parent.callee);
+        if (allowCallees.has(name)) return true;
+      }
+
+      return false;
+    };
+
+    traverse(ast, {
+      enter(path) {
+        let text;
 
         if (path.isStringLiteral()) {
           text = path.node.value;
@@ -185,16 +314,15 @@ function extractScriptStrings(scriptContent, s, baseOffset, extracted, filePath,
           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);
+        if (!shouldTranslate(path, text)) return;
+
+        // --- Parent checks to avoid replacing the wrong strings ---
+        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 });