bctranslate 1.0.5 → 1.0.9

package/bin/bctranslate.js

@@ -92,9 +92,9 @@ async function resolveFiles(pathArg, cwd, project) {
 }
 
 // ── Translation runner — uses global batching (Python spawned once) ───────────
-async function runTranslation({ pathArg, from, to, localesDir, dryRun, outdir, verbose, jsonMode, setup, cwd }) {
-  const project = detectProject(cwd);
-  console.log(chalk.green(`  ✓ Project type: ${chalk.bold(project.type)}`));
+async function runTranslation({ pathArg, from, to, localesDir, dryRun, outdir, verbose, jsonMode, profile, setup, autoImport, cwd }) {
+  const project = detectProject(cwd);
+  console.log(chalk.green(`  ✓ Project type: ${chalk.bold(project.type)}`));
 
   const files = await resolveFiles(pathArg, cwd, project);
   if (files.length === 0) {
@@ -104,23 +104,24 @@ async function runTranslation({ pathArg, from, to, localesDir, dryRun, outdir, v
 
   console.log(chalk.cyan(`  → ${files.length} file(s) [${from} → ${to}]...\n`));
 
-  if (setup !== false) {
-    const resolvedLocalesDir = localesDir ? resolve(cwd, localesDir) : undefined;
-    await ensureI18nSetup(cwd, project, from, to, resolvedLocalesDir);
-  }
+  if (setup !== false) {
+    const resolvedLocalesDir = localesDir ? resolve(cwd, localesDir) : undefined;
+    await ensureI18nSetup(cwd, project, from, to, resolvedLocalesDir, { autoImport });
+  }
 
   // Global batch: all files parsed first, ONE Python call, then all writes
-  const results = await translateAllFiles(files, {
-    from,
-    to,
-    dryRun,
-    outdir,
-    project,
-    cwd,
-    verbose,
-    jsonMode,
-    localesDir: localesDir ? resolve(cwd, localesDir) : undefined,
-  });
+  const results = await translateAllFiles(files, {
+    from,
+    to,
+    dryRun,
+    outdir,
+    project,
+    cwd,
+    verbose,
+    jsonMode,
+    profile: !!profile,
+    localesDir: localesDir ? resolve(cwd, localesDir) : undefined,
+  });
 
   let totalStrings = 0;
   let totalFiles   = 0;
@@ -277,17 +278,20 @@ program
   .argument('[lang]', 'Target language code (e.g. fr)')
   .option('-t, --to <lang>', 'Target language(s), comma-separated (e.g. fr or fr,es)')
   .option('-d, --dry-run', 'Preview changes without writing files', false)
-  .option('-o, --outdir <dir>', 'Output directory for translated files')
-  .option('--no-setup', 'Skip i18n setup file generation')
-  .option('--json-mode <mode>', 'JSON translation mode: values or full', 'values')
-  .option('-v, --verbose', 'Show per-file diffs and skipped files', false)
+  .option('-o, --outdir <dir>', 'Output directory for translated files')
+  .option('--no-setup', 'Skip i18n setup file generation')
+  .option('--no-import', 'Do not auto-inject i18n imports/script tags')
+  .option('--json-mode <mode>', 'JSON translation mode: values or full', 'values')
+  .option('--profile', 'Print timing breakdown', false)
+  .option('-v, --verbose', 'Show per-file diffs and skipped files', false)
   .action(async (pathArg, fromArg, keyword, langArg, opts) => {
     console.log(chalk.cyan.bold('\n  ⚡ bctranslate\n'));
 
-    const invokedCwd = process.cwd();
-    const config     = loadConfig(invokedCwd);
-
-    let cwd = invokedCwd;
+    const invokedCwd = process.cwd();
+    const config     = loadConfig(invokedCwd);
+    const autoImport = opts.import !== false && (config?.autoImport !== false);
+
+    let cwd = invokedCwd;
     if (!config && pathArg) {
       const resolvedTarget = resolve(invokedCwd, pathArg);
       if (existsSync(resolvedTarget)) {
@@ -338,18 +342,20 @@ program
     for (const to of targets) {
       if (targets.length > 1) console.log(chalk.cyan.bold(`\n  ── Translating to ${to} ──`));
 
-      const { totalStrings, totalFiles } = await runTranslation({
-        pathArg,
-        from,
-        to,
-        localesDir: config?.localesDir,
-        dryRun:     opts.dryRun,
-        outdir:     opts.outdir,
-        verbose:    opts.verbose,
-        jsonMode:   opts.jsonMode,
-        setup:      opts.setup,
-        cwd,
-      });
+      const { totalStrings, totalFiles } = await runTranslation({
+        pathArg,
+        from,
+        to,
+        localesDir: config?.localesDir,
+        dryRun:     opts.dryRun,
+        outdir:     opts.outdir,
+        verbose:    opts.verbose,
+        jsonMode:   opts.jsonMode,
+        profile:    opts.profile,
+        setup:      opts.setup,
+        autoImport,
+        cwd,
+      });
 
       grandTotal += totalStrings;
       grandFiles += totalFiles;

package/package.json

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

package/src/generators/setup.js

@@ -13,9 +13,10 @@ import { getLocaleDir } from './locales.js';
  * @param {string} to - Target language code
  * @param {string} [customLocaleDir] - Optional override for locale directory
  */
-export async function ensureI18nSetup(cwd, project, from, to, customLocaleDir) {
-  const localeDir = customLocaleDir || getLocaleDir(cwd, project);
-  mkdirSync(localeDir, { recursive: true });
+export async function ensureI18nSetup(cwd, project, from, to, customLocaleDir, options = {}) {
+  const { autoImport = true } = options;
+  const localeDir = customLocaleDir || getLocaleDir(cwd, project);
+  mkdirSync(localeDir, { recursive: true });
 
   // Ensure locale JSON files exist
   for (const lang of [from, to]) {
@@ -24,18 +25,18 @@ export async function ensureI18nSetup(cwd, project, from, to, customLocaleDir) {
       writeFileSync(localePath, '{}\n', 'utf-8');
       console.log(chalk.green(`  ✓ Created ${localePath}`));
     }
-  }
-
-  if (project.type === 'vue') {
-    await ensureVueI18n(cwd, project, from, to, localeDir);
-  } else if (project.type === 'react') {
-    await ensureReactI18n(cwd, project, from, to, localeDir);
-  } else {
-    await ensureVanillaI18n(cwd, from, to, localeDir);
-  }
-}
+  }
+
+  if (project.type === 'vue') {
+    await ensureVueI18n(cwd, project, from, to, localeDir, { autoImport });
+  } else if (project.type === 'react') {
+    await ensureReactI18n(cwd, project, from, to, localeDir, { autoImport });
+  } else {
+    await ensureVanillaI18n(cwd, from, to, localeDir, { autoImport });
+  }
+}
 
-async function ensureVueI18n(cwd, project, from, to, localeDir) {
+async function ensureVueI18n(cwd, project, from, to, localeDir, { autoImport }) {
   const i18nFile = join(cwd, 'src', 'i18n.js');
 
   if (existsSync(i18nFile)) {
@@ -48,51 +49,105 @@ async function ensureVueI18n(cwd, project, from, to, localeDir) {
 
   let content;
   if (isVue3) {
-    content = `import { createI18n } from 'vue-i18n';
-import ${from} from '${relLocale}/${from}.json';
-import ${to} from '${relLocale}/${to}.json';
-
-const i18n = createI18n({
-  legacy: false,
-  locale: '${from}',
-  fallbackLocale: '${from}',
-  messages: {
-    ${from},
-    ${to},
-  },
-});
+    content = `import { createI18n } from 'vue-i18n';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+function nestMessages(input) {
+  if (!input || typeof input !== 'object') return {};
+  const out = Array.isArray(input) ? [] : {};
+  for (const [rawKey, value] of Object.entries(input)) {
+    if (!rawKey.includes('.')) {
+      out[rawKey] = value;
+      continue;
+    }
+    const parts = rawKey.split('.').filter(Boolean);
+    let cur = out;
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (i === parts.length - 1) {
+        cur[p] = value;
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur = cur[p];
+      }
+    }
+  }
+  return out;
+}
+
+const i18n = createI18n({
+  legacy: false,
+  locale: '${from}',
+  fallbackLocale: '${from}',
+  messages: {
+    ${from}: nestMessages(${from}),
+    ${to}: nestMessages(${to}),
+  },
+});
 
 export default i18n;
 `;
   } else {
-    content = `import Vue from 'vue';
-import VueI18n from 'vue-i18n';
-import ${from} from '${relLocale}/${from}.json';
-import ${to} from '${relLocale}/${to}.json';
-
-Vue.use(VueI18n);
-
-const i18n = new VueI18n({
-  locale: '${from}',
-  fallbackLocale: '${from}',
-  messages: {
-    ${from},
-    ${to},
-  },
-});
+    content = `import Vue from 'vue';
+import VueI18n from 'vue-i18n';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+Vue.use(VueI18n);
+
+function nestMessages(input) {
+  if (!input || typeof input !== 'object') return {};
+  const out = Array.isArray(input) ? [] : {};
+  for (const [rawKey, value] of Object.entries(input)) {
+    if (!rawKey.includes('.')) {
+      out[rawKey] = value;
+      continue;
+    }
+    const parts = rawKey.split('.').filter(Boolean);
+    let cur = out;
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (i === parts.length - 1) {
+        cur[p] = value;
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur = cur[p];
+      }
+    }
+  }
+  return out;
+}
+
+const i18n = new VueI18n({
+  locale: '${from}',
+  fallbackLocale: '${from}',
+  messages: {
+    ${from}: nestMessages(${from}),
+    ${to}: nestMessages(${to}),
+  },
+});
 
 export default i18n;
 `;
   }
 
-  mkdirSync(join(cwd, 'src'), { recursive: true });
-  writeFileSync(i18nFile, content, 'utf-8');
-  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
-  console.log(chalk.yellow(`  ⚠ Don't forget to install vue-i18n: npm install vue-i18n`));
-  console.log(chalk.yellow(`  ⚠ Import and use i18n in your main.js/main.ts`));
-}
+  mkdirSync(join(cwd, 'src'), { recursive: true });
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Don't forget to install vue-i18n: npm install vue-i18n`));
+
+  if (autoImport) {
+    const injected = injectVueEntrypoint(cwd, isVue3);
+    if (!injected) {
+      console.log(chalk.yellow(`  ⚠ Import and use i18n in your main.js/main.ts`));
+    }
+  } else {
+    console.log(chalk.yellow(`  ⚠ Import and use i18n in your main.js/main.ts`));
+  }
+}
 
-async function ensureReactI18n(cwd, project, from, to, localeDir) {
+async function ensureReactI18n(cwd, project, from, to, localeDir, { autoImport }) {
   const i18nFile = join(cwd, 'src', 'i18n.js');
 
   if (existsSync(i18nFile)) {
@@ -102,16 +157,39 @@ async function ensureReactI18n(cwd, project, from, to, localeDir) {
 
   const relLocale = localeDir.replace(cwd, '.').replace(/\\/g, '/');
 
-  const content = `import i18n from 'i18next';
-import { initReactI18next } from 'react-i18next';
-import ${from} from '${relLocale}/${from}.json';
-import ${to} from '${relLocale}/${to}.json';
-
-i18n.use(initReactI18next).init({
-  resources: {
-    ${from}: { translation: ${from} },
-    ${to}: { translation: ${to} },
-  },
+  const content = `import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+function nestMessages(input) {
+  if (!input || typeof input !== 'object') return {};
+  const out = Array.isArray(input) ? [] : {};
+  for (const [rawKey, value] of Object.entries(input)) {
+    if (!rawKey.includes('.')) {
+      out[rawKey] = value;
+      continue;
+    }
+    const parts = rawKey.split('.').filter(Boolean);
+    let cur = out;
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (i === parts.length - 1) {
+        cur[p] = value;
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur = cur[p];
+      }
+    }
+  }
+  return out;
+}
+
+i18n.use(initReactI18next).init({
+  resources: {
+    ${from}: { translation: nestMessages(${from}) },
+    ${to}: { translation: nestMessages(${to}) },
+  },
   lng: '${from}',
   fallbackLng: '${from}',
   interpolation: {
@@ -122,14 +200,22 @@ i18n.use(initReactI18next).init({
 export default i18n;
 `;
 
-  mkdirSync(join(cwd, 'src'), { recursive: true });
-  writeFileSync(i18nFile, content, 'utf-8');
-  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
-  console.log(chalk.yellow(`  ⚠ Don't forget to install: npm install i18next react-i18next`));
-  console.log(chalk.yellow(`  ⚠ Import './i18n' in your index.js/App.js`));
-}
+  mkdirSync(join(cwd, 'src'), { recursive: true });
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Don't forget to install: npm install i18next react-i18next`));
+
+  if (autoImport) {
+    const injected = injectReactEntrypoint(cwd);
+    if (!injected) {
+      console.log(chalk.yellow(`  ⚠ Import './i18n' in your index.js/App.js`));
+    }
+  } else {
+    console.log(chalk.yellow(`  ⚠ Import './i18n' in your index.js/App.js`));
+  }
+}
 
-async function ensureVanillaI18n(cwd, from, to, localeDir) {
+async function ensureVanillaI18n(cwd, from, to, localeDir, { autoImport }) {
   const i18nFile = join(cwd, 'i18n.js');
 
   if (existsSync(i18nFile)) {
@@ -140,9 +226,10 @@ async function ensureVanillaI18n(cwd, from, to, localeDir) {
   const content = `/**
  * Simple i18n for vanilla JS — generated by bctranslate
  */
-(function () {
-  const locales = {};
-  let currentLocale = '${from}';
+(function () {
+  const locales = {};
+  let currentLocale = '${from}';
+  const fallbackLocale = '${from}';
 
   async function loadLocale(lang) {
     if (locales[lang]) return;
@@ -153,11 +240,16 @@ async function ensureVanillaI18n(cwd, from, to, localeDir) {
   function t(key, params) {
     // Support both flat keys ("home.submit") and nested objects ({ home: { submit: ... } })
     const dict = locales[currentLocale] || {};
-    const direct = Object.prototype.hasOwnProperty.call(dict, key) ? dict[key] : null;
-    const msg =
-      direct !== null && direct !== undefined
+    const dictFallback = locales[fallbackLocale] || {};
+
+    const lookup = (d) => {
+      const direct = Object.prototype.hasOwnProperty.call(d, key) ? d[key] : null;
+      return direct !== null && direct !== undefined
         ? direct
-        : key.split('.').reduce((obj, i) => (obj ? obj[i] : null), dict) || key;
+        : key.split('.').reduce((obj, i) => (obj ? obj[i] : null), d);
+    };
+
+    const msg = lookup(dict) ?? lookup(dictFallback) ?? key;
 
     if (!params) return msg;
     return String(msg).replace(/\\{(\\w+)\\}/g, (match, k) =>
@@ -194,21 +286,123 @@ async function ensureVanillaI18n(cwd, from, to, localeDir) {
 
   // Auto-init
   loadLocale('${from}');
-  setLocale('${to}');
-
-  window.i18n = { t: t, setLocale: setLocale, loadLocale: loadLocale };
-})();
-`;
+
+  const api = { t: t, setLocale: setLocale, loadLocale: loadLocale, ready: null };
+  window.i18n = api;
+  api.ready = setLocale('${to}');
+})();
+`;
 
   writeFileSync(i18nFile, content, 'utf-8');
   console.log(chalk.green(`  ✓ Created ${i18nFile}`));
 
-  const injected = injectVanillaI18nEntrypoint(cwd);
-  if (!injected) {
+  if (autoImport) {
+    const injected = injectVanillaI18nEntrypoint(cwd);
+    if (!injected) {
+      console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
+    }
+  } else {
     console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
   }
 }
 
+function injectVueEntrypoint(cwd, isVue3) {
+  const candidates = [
+    join(cwd, 'src', 'main.ts'),
+    join(cwd, 'src', 'main.js'),
+    join(cwd, 'src', 'main.tsx'),
+    join(cwd, 'src', 'main.jsx'),
+  ];
+
+  const mainFile = candidates.find((p) => existsSync(p));
+  if (!mainFile) return false;
+
+  let code = readFileSync(mainFile, 'utf-8');
+
+  const hasI18nImport =
+    code.includes("from './i18n'") ||
+    code.includes('from "./i18n"') ||
+    code.includes("from './i18n.js'") ||
+    code.includes('from "./i18n.js"') ||
+    code.includes("import './i18n'") ||
+    code.includes('import "./i18n"');
+
+  if (!hasI18nImport) {
+    const importRe = /^import\s.+?;\s*$/gm;
+    let lastImportEnd = 0;
+    let m;
+    while ((m = importRe.exec(code)) !== null) lastImportEnd = m.index + m[0].length;
+    code =
+      code.slice(0, lastImportEnd) +
+      `\nimport i18n from './i18n';\n` +
+      code.slice(lastImportEnd);
+  }
+
+  if (isVue3) {
+    if (!code.includes('.use(i18n)') && !code.includes('use(i18n)')) {
+      const chained = /createApp\(([^)]*)\)\s*\.mount\(/;
+      if (chained.test(code)) {
+        code = code.replace(chained, 'createApp($1).use(i18n).mount(');
+      } else {
+        const hasAppVar =
+          /\bconst\s+app\s*=\s*createApp\(/.test(code) ||
+          /\blet\s+app\s*=\s*createApp\(/.test(code);
+        const mountIdx = code.indexOf('app.mount(');
+        if (hasAppVar && mountIdx !== -1 && !code.includes('app.use(i18n')) {
+          code = code.slice(0, mountIdx) + `app.use(i18n);\n` + code.slice(mountIdx);
+        } else {
+          return false;
+        }
+      }
+    }
+  } else {
+    if (!/\bi18n\s*[:,]/.test(code)) {
+      const newVue = /new\s+Vue\s*\(\s*\{/;
+      if (newVue.test(code)) {
+        code = code.replace(newVue, (m) => m + '\n  i18n,');
+      } else {
+        return false;
+      }
+    }
+  }
+
+  writeFileSync(mainFile, code, 'utf-8');
+  console.log(chalk.green(`  ✓ Updated ${mainFile} (wired i18n)`));
+  return true;
+}
+
+function injectReactEntrypoint(cwd) {
+  const candidates = [
+    join(cwd, 'src', 'index.tsx'),
+    join(cwd, 'src', 'index.js'),
+    join(cwd, 'src', 'main.tsx'),
+    join(cwd, 'src', 'main.jsx'),
+  ];
+
+  const entryFile = candidates.find((p) => existsSync(p));
+  if (!entryFile) return false;
+
+  let code = readFileSync(entryFile, 'utf-8');
+  if (
+    code.includes("from './i18n'") ||
+    code.includes('from "./i18n"') ||
+    code.includes("import './i18n'") ||
+    code.includes('import "./i18n"')
+  ) {
+    return true;
+  }
+
+  const importRe = /^import\s.+?;\s*$/gm;
+  let lastImportEnd = 0;
+  let m;
+  while ((m = importRe.exec(code)) !== null) lastImportEnd = m.index + m[0].length;
+  code = code.slice(0, lastImportEnd) + `\nimport './i18n';\n` + code.slice(lastImportEnd);
+
+  writeFileSync(entryFile, code, 'utf-8');
+  console.log(chalk.green(`  ✓ Updated ${entryFile} (imported i18n)`));
+  return true;
+}
+
 function injectVanillaI18nEntrypoint(cwd) {
   // Prefer HTML entrypoint if present
   const htmlPath = join(cwd, 'index.html');

package/src/index.js

@@ -125,24 +125,27 @@ export async function writeFileResult(parseResult, translations, opts) {
  *  Phase 3: translateBatch() once → Python starts, model loads, all strings translated
  *  Phase 4: Write each file
  */
-export async function translateAllFiles(files, opts) {
-  const { from, to, cwd, project, verbose, localesDir } = opts;
-
-  const resolvedLocaleDir = opts.outdir ? join(opts.outdir, 'locales') : (localesDir || getLocaleDir(cwd, project));
-  const existingTarget    = loadLocale(resolvedLocaleDir, to);
-
-  // Phase 1 — parse
-  const parsed = [];
-  for (const file of files) {
-    try {
-      const result = parseFileOnly(file, opts);
-      if (result.extracted.length > 0) parsed.push(result);
-    } catch (err) {
-      if (verbose) console.error(`  Parse error ${file}: ${err.message}`);
-    }
-  }
-
-  if (parsed.length === 0) return [];
+export async function translateAllFiles(files, opts) {
+  const { from, to, cwd, project, verbose, localesDir } = opts;
+  const prof0 = opts.profile ? Date.now() : 0;
+
+  const resolvedLocaleDir = opts.outdir ? join(opts.outdir, 'locales') : (localesDir || getLocaleDir(cwd, project));
+  const existingTarget    = loadLocale(resolvedLocaleDir, to);
+
+  // Phase 1 — parse
+  const profParse0 = opts.profile ? Date.now() : 0;
+  const parsed = [];
+  for (const file of files) {
+    try {
+      const result = parseFileOnly(file, opts);
+      if (result.extracted.length > 0) parsed.push(result);
+    } catch (err) {
+      if (verbose) console.error(`  Parse error ${file}: ${err.message}`);
+    }
+  }
+  const profParse1 = opts.profile ? Date.now() : 0;
+
+  if (parsed.length === 0) return [];
 
   // Phase 2 — deduplicate across all files, skip already-translated keys
   const seenKeys = new Set(Object.keys(existingTarget));
@@ -156,19 +159,22 @@ export async function translateAllFiles(files, opts) {
     }
   }
 
-  // Phase 3 — translate once (Python spawned exactly once, model loads once)
-  let newTranslations = {};
-  if (needed.length > 0) {
-    newTranslations = await translateBatch(needed, from, to);
-  }
-
-  const allTranslations = { ...existingTarget, ...newTranslations };
-
-  // Phase 4 — write files
-  if (!opts.dryRun) {
-    console.log(`  → Locale dir: ${resolvedLocaleDir}`);
-  }
-  const results = [];
+  // Phase 3 — translate once (Python spawned exactly once, model loads once)
+  const profTrans0 = opts.profile ? Date.now() : 0;
+  let newTranslations = {};
+  if (needed.length > 0) {
+    newTranslations = await translateBatch(needed, from, to);
+  }
+  const profTrans1 = opts.profile ? Date.now() : 0;
+
+  const allTranslations = { ...existingTarget, ...newTranslations };
+
+  // Phase 4 — write files
+  const profWrite0 = opts.profile ? Date.now() : 0;
+  if (!opts.dryRun) {
+    console.log(`  → Locale dir: ${resolvedLocaleDir}`);
+  }
+  const results = [];
   for (const parseResult of parsed) {
     try {
       const r = await writeFileResult(parseResult, allTranslations, {
@@ -180,10 +186,18 @@ export async function translateAllFiles(files, opts) {
       console.error(`  ✗ Write error ${relative(cwd, parseResult.filePath)}: ${err.message}`);
       results.push({ count: 0, skipped: 0, relativePath: relative(cwd, parseResult.filePath) });
     }
-  }
-
-  return results;
-}
+  }
+  const profWrite1 = opts.profile ? Date.now() : 0;
+
+  if (opts.profile) {
+    const total = Date.now() - prof0;
+    console.log(
+      `  Timing: parse ${profParse1 - profParse0}ms | translate ${profTrans1 - profTrans0}ms | write ${profWrite1 - profWrite0}ms | total ${total}ms`
+    );
+  }
+
+  return results;
+}
 
 /**
  * Single-file convenience wrapper (for backward compatibility).

package/src/parsers/html.js

@@ -37,6 +37,26 @@ function stripTags(html) {
   return html.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
 }
 
+function maybeWrapInlineScriptForI18nReady(script) {
+  if (!/\bi18n\.t\s*\(/.test(script)) return script;
+  if (/\bi18n\.ready\b/.test(script)) return script;
+  if (!/\bcreateApp\b|\bapp\.mount\b|document\./.test(script)) return script;
+
+  const trimmed = script.trim();
+  const indent = (script.match(/^\s*/) || [''])[0];
+  const body = trimmed
+    .split('\n')
+    .map((l) => (l.length ? indent + '  ' + l : l))
+    .join('\n');
+
+  return (
+    `${indent}(async () => {\n` +
+    `${indent}  if (i18n.ready) await i18n.ready;\n` +
+    `${body}\n` +
+    `${indent}})();`
+  );
+}
+
 /**
  * Parse an HTML file and extract translatable strings.
  * For vanilla HTML, we use data-i18n attributes instead of $t() calls.
@@ -85,7 +105,8 @@ export function parseHtml(source, filePath, project) {
         const scriptJs = source.slice(openTagEnd + 1, closeTagStart);
         const jsResult = parseJs(scriptJs, filePath, project);
         if (jsResult.modified) {
-          s.overwrite(openTagEnd + 1, closeTagStart, jsResult.source);
+          const wrapped = maybeWrapInlineScriptForI18nReady(jsResult.source);
+          s.overwrite(openTagEnd + 1, closeTagStart, wrapped);
           extracted.push(...jsResult.extracted);
         }
       }

package/src/parsers/js.js

@@ -20,13 +20,6 @@ export function parseJs(source, filePath, project) {
     return `t('${key}')`;
   };
 
-  const translatableVarNames = new Set([
-    'title', 'pageTitle', 'heading', 'subheading', 'header', 'subtitle',
-    'label', 'placeholder', 'message', 'text', 'description', 'tooltip', 'hint', 'caption',
-    'error', 'errorMessage', 'success', 'successMessage',
-    'buttonText', 'linkText',
-  ]);
-
   const translatableAttrNames = new Set([
     'title',
     'placeholder',
@@ -58,26 +51,6 @@ export function parseJs(source, filePath, project) {
 
   // Track which string literals to translate
   traverse(ast, {
-    VariableDeclarator(path) {
-      const { id, init } = path.node;
-      if (!init) return;
-      if (id.type !== 'Identifier') return;
-      if (!translatableVarNames.has(id.name)) return;
-
-      let value = null;
-      if (init.type === 'StringLiteral') value = init.value;
-      else if (init.type === 'TemplateLiteral' && init.expressions.length === 0) {
-        value = init.quasis[0]?.value?.cooked ?? '';
-      }
-
-      if (typeof value !== 'string' || !isTranslatable(value)) return;
-
-      const key = contextKey(value, filePath);
-      const tFunc = tFuncFor(key);
-      s.overwrite(init.start, init.end, tFunc);
-      extracted.push({ key, text: value, context: `js-var-${id.name}` });
-    },
-
     // Object property values with translatable keys
     ObjectProperty(path) {
       const keyNode = path.node.key;

package/src/parsers/vue.js

@@ -41,9 +41,17 @@ export function parseVue(source, filePath) {
   const extracted = [];
   const s = new MagicString(source);
 
-  // Always use t() for consistency, as promised in the README.
-  const tpl = (key) => `t('${key}')`;
-  const scr = (key) => `t('${key}')`;
+  const scriptSetupMatch = source.match(/(<script\b[^>]*\bsetup\b[^>]*>)([\s\S]*?)<\/script>/i);
+  const hasScriptSetup = !!scriptSetupMatch;
+
+  // Prefer what the file already uses in templates: `$t()` vs `t()`.
+  const templateBlockMatch = source.match(/<template\b[^>]*>([\s\S]*?)<\/template>/);
+  const templateBlock = templateBlockMatch ? templateBlockMatch[1] : '';
+  const templatePrefersDollarT = /\$t\s*\(/.test(templateBlock);
+  const templatePrefersT = !templatePrefersDollarT && /\bt\s*\(/.test(templateBlock);
+
+  const tpl = (key) => (templatePrefersT ? `t('${key}')` : `$t('${key}')`);
+  const scr = (key) => (hasScriptSetup ? `t('${key}')` : `this.$t('${key}')`);
 
   // ── Template ────────────────────────────────────────────────────────────────
   const templateMatch = source.match(/<template\b[^>]*>([\s\S]*?)<\/template>/);
@@ -60,27 +68,33 @@ export function parseVue(source, filePath) {
     }
   }
 
-  // ── Script ──────────────────────────────────────────────────────────────────
-  const scriptMatch = source.match(/<script\b[^>]*>([\s\S]*?)<\/script>/);
-  if (scriptMatch) {
-    const scriptContent = scriptMatch[1];
-    const scriptOffset =
-      source.indexOf(scriptMatch[0]) + scriptMatch[0].indexOf(scriptContent);
-    extractScriptStrings(scriptContent, s, scriptOffset, extracted, filePath, scr);
-  }
+  // ── Script (prefer <script setup>, else first non-setup <script>) ────────────
+  if (scriptSetupMatch) {
+    const scriptContent = scriptSetupMatch[2];
+    const scriptOffset =
+      source.indexOf(scriptSetupMatch[0]) + scriptSetupMatch[0].indexOf(scriptContent);
+    extractScriptStrings(scriptContent, s, scriptOffset, extracted, filePath, scr);
+  } else {
+    const scriptMatch = source.match(/<script\b(?![^>]*\bsetup\b)[^>]*>([\s\S]*?)<\/script>/i);
+    if (scriptMatch) {
+      const scriptContent = scriptMatch[1];
+      const scriptOffset =
+        source.indexOf(scriptMatch[0]) + scriptMatch[0].indexOf(scriptContent);
+      extractScriptStrings(scriptContent, s, scriptOffset, extracted, filePath, scr);
+    }
+  }
 
   // ── Inject `const { t } = useI18n()` if not yet declared ────────
-  if (extracted.length > 0) {
-    const scriptSetupMatch = source.match(/(<script\b[^>]*\bsetup\b[^>]*>)([\s\S]*?)<\/script>/i);
-    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`);
-    }
-  }
+  if (extracted.length > 0 && hasScriptSetup) {
+    const hasT = /const\s*\{[^}]*\bt\b[^}]*\}\s*=/.test(source);
+
+    if (!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`);
+    }
+  }
 
   return {
     source: extracted.length > 0 ? s.toString() : source,
@@ -244,8 +258,7 @@ function isAlreadyWrappedScript(scriptContent, pos) {
 function isAlreadyWrapped(source, start, end) {
   // Look back 25 chars for an open t( call — node is inside an interpolation
   const before = source.slice(Math.max(0, start - 25), start);
-  // Note: We only check for `t` now, not `$t`.
-  return /t\s*\(\s*['"]/.test(before);
+  return /\$?t\s*\(\s*['"]/.test(before);
 }
 
 function extractTemplateRegex(source, s, extracted, filePath, tpl) {