solid-translate 1.4.1 → 1.4.3

package/README.md

@@ -350,9 +350,29 @@ solidTranslate({
   batchSize: 50,                 // Keys per API call (default: 50)
   autoExtract: true,             // Auto-extract <T> and msg() strings (default: false)
   include: ["src/**/*.tsx"],     // Files to scan for extraction
+  extractImportSources: ["@/i18n"], // Extra module specifiers whose msg/<T> imports count as markers (optional)
 })
 ```
 
+### What extraction considers a marker
+
+Extraction only honors `msg()` calls and `<T>`/`<Plural>` elements whose
+identifier actually refers to solid-translate:
+
+- Imported bindings must come from `"solid-translate"` or an accepted
+  re-export wrapper. By default any specifier whose final path segment is
+  `solid-translate` or `i18n` (e.g. `@/i18n`, `../lib/i18n`) is accepted;
+  set `extractImportSources` (plugin config) / `"extractImportSources"`
+  (CLI config) to an explicit list to override the `i18n` heuristic
+  (`"solid-translate"` itself is always accepted).
+- Aliased imports work: `import { msg as m } from "solid-translate"`
+  extracts `m("...")`.
+- Locally bound identifiers are never extracted — a callback parameter
+  named `msg`, a local `const msg = ...`, or a local component named `T`
+  will not pollute the catalog or emit warnings.
+- Identifiers with no binding at all are still treated as markers by name,
+  so snippet-style sources keep working.
+
 ## CLI
 
 For translating locale files, JSON, Markdown, and MDX outside of the Vite build.

package/dist/chunk-P6RTZPHZ.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+// src/translate.ts
+import { z } from "zod";
+async function loadGenerateObject() {
+  const { generateObject } = await import("ai");
+  return generateObject;
+}
+async function loadGenerateText() {
+  const { generateText } = await import("ai");
+  return generateText;
+}
+function extractJsonObject(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end <= start) {
+    throw new Error("model response contained no JSON object");
+  }
+  const parsed = JSON.parse(text.slice(start, end + 1));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("model response was not a JSON object");
+  }
+  return parsed;
+}
+function collectBatchTranslations(parsed, requestedKeys) {
+  let dict = parsed;
+  const inner = parsed["translations"];
+  if (typeof inner === "object" && inner !== null && !Array.isArray(inner) && // Only unwrap when the envelope key is not itself a requested key
+  !requestedKeys.includes("translations")) {
+    dict = inner;
+  }
+  const translations = {};
+  const missing = [];
+  for (const key of requestedKeys) {
+    const value = dict[key];
+    if (typeof value === "string" && value.length > 0) {
+      translations[key] = value;
+    } else {
+      missing.push(key);
+    }
+  }
+  return { translations, missing };
+}
+async function translateBatch(model, entries, targetLocale, sourceLocale, systemPrompt, contexts) {
+  const keys = Object.keys(entries);
+  if (keys.length === 0) return {};
+  const defaultSystem = [
+    `You are a professional translator specializing in software localization.`,
+    `Translate text from "${sourceLocale}" to "${targetLocale}".`,
+    `Rules:`,
+    `- Preserve the original tone and meaning`,
+    `- Keep placeholders like {{variable}}, {variable}, {0}, {1} unchanged`,
+    `- Keep HTML tags unchanged`,
+    `- Do not add or remove content`,
+    `- Return natural, idiomatic translations`
+  ].join("\n");
+  let contextSection = "";
+  if (contexts && Object.keys(contexts).length > 0) {
+    const contextLines = Object.entries(contexts).filter(([key]) => key in entries).map(([key, ctx]) => `  "${key}": ${ctx}`);
+    if (contextLines.length > 0) {
+      contextSection = [
+        ``,
+        `Context hints for disambiguation:`,
+        ...contextLines,
+        ``
+      ].join("\n");
+    }
+  }
+  const generateText = await loadGenerateText();
+  const basePrompt = [
+    `Translate each value in this JSON object from "${sourceLocale}" to "${targetLocale}".`,
+    `Respond with ONLY a JSON object \u2014 no prose, no code fences \u2014 containing the exact same keys and the translated values.`,
+    contextSection,
+    JSON.stringify(entries, null, 2)
+  ].join("\n");
+  const attempt = async (prompt) => {
+    const { text } = await generateText({
+      model,
+      system: systemPrompt || defaultSystem,
+      prompt
+    });
+    return collectBatchTranslations(extractJsonObject(text), keys);
+  };
+  let { translations, missing } = await attempt(basePrompt);
+  if (missing.length > 0) {
+    const retryEntries = {};
+    for (const key of missing) retryEntries[key] = entries[key];
+    const retry = await attempt(
+      [
+        `Translate each value in this JSON object from "${sourceLocale}" to "${targetLocale}".`,
+        `Respond with ONLY a JSON object \u2014 no prose, no code fences \u2014 containing the exact same keys and the translated values.`,
+        contextSection,
+        JSON.stringify(retryEntries, null, 2)
+      ].join("\n")
+    );
+    translations = { ...translations, ...retry.translations };
+    missing = retry.missing;
+  }
+  if (missing.length > 0) {
+    const sample = missing.slice(0, 3).join('", "');
+    throw new Error(
+      `model returned no translation for ${missing.length} of ${keys.length} keys (e.g. "${sample}")`
+    );
+  }
+  return translations;
+}
+async function translateMarkdown(model, content, targetLocale, sourceLocale, systemPrompt) {
+  const defaultSystem = [
+    `You are a professional translator specializing in documentation.`,
+    `Translate Markdown/MDX content from "${sourceLocale}" to "${targetLocale}".`,
+    `Rules:`,
+    `- Preserve all Markdown formatting (headers, lists, bold, italic, links, etc.)`,
+    `- Preserve code blocks and inline code unchanged`,
+    `- Preserve frontmatter YAML keys (only translate values)`,
+    `- Preserve MDX component syntax and JSX expressions`,
+    `- Preserve URLs and file paths unchanged`,
+    `- Return natural, idiomatic translations`
+  ].join("\n");
+  const generateObject = await loadGenerateObject();
+  const { object } = await generateObject({
+    model,
+    schema: z.object({
+      translated: z.string()
+    }),
+    system: systemPrompt || defaultSystem,
+    prompt: [
+      `Translate this Markdown/MDX content from "${sourceLocale}" to "${targetLocale}".`,
+      `Return the complete translated document.`,
+      ``,
+      content
+    ].join("\n")
+  });
+  return object.translated;
+}
+
+export {
+  extractJsonObject,
+  collectBatchTranslations,
+  translateBatch,
+  translateMarkdown
+};

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   translateBatch
-} from "./chunk-2BKJUY37.js";
+} from "./chunk-P6RTZPHZ.js";
 import {
   __commonJS,
   __toESM
@@ -14599,7 +14599,7 @@ function hashContent(content) {
 
 // src/extract.ts
 var import_parser = __toESM(require_lib(), 1);
-function extractStringsFromSource(code, filePath, warnings) {
+function extractStringsFromSource(code, filePath, warnings, options) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   const warn = (line, message) => {
@@ -14621,26 +14621,158 @@ function extractStringsFromSource(code, filePath, warnings) {
     seen.add(entry.key);
     results.push(entry);
   };
+  const bindings = collectModuleBindings(ast);
+  const shadowStack = [];
+  const resolveMarker = (localName) => {
+    for (let i = shadowStack.length - 1; i >= 0; i--) {
+      if (shadowStack[i].has(localName)) return null;
+    }
+    const imported = bindings.imports.get(localName);
+    if (imported) {
+      if (!isAcceptedImportSource(imported.source, options?.importSources)) {
+        return null;
+      }
+      return MARKER_NAMES.has(imported.imported) ? imported.imported : null;
+    }
+    if (bindings.moduleLocals.has(localName)) return null;
+    return MARKER_NAMES.has(localName) ? localName : null;
+  };
   const visit = (node) => {
+    const scopeBindings = collectScopeBindings(node);
+    if (scopeBindings) shadowStack.push(scopeBindings);
     if (node.type === "JSXElement") {
       const name = jsxName(node);
-      if (name === "T") {
+      const marker = name ? resolveMarker(name) : null;
+      if (marker === "T") {
         const entry = processT(node, filePath, warn);
         if (entry) push(entry);
-      } else if (name === "Plural") {
+      } else if (marker === "Plural") {
         for (const entry of processPlural(node, filePath, warn)) {
           push(entry);
         }
       }
-    } else if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "msg") {
+    } else if (node.type === "CallExpression" && node.callee?.type === "Identifier" && resolveMarker(node.callee.name) === "msg") {
       const entry = processMsg(node, filePath, warn);
       if (entry) push(entry);
     }
     walkChildren(node, visit);
+    if (scopeBindings) shadowStack.pop();
   };
   visit(ast);
   return results;
 }
+var MARKER_NAMES = /* @__PURE__ */ new Set([
+  "msg",
+  "T",
+  "Var",
+  "Num",
+  "Currency",
+  "DateTime",
+  "Plural"
+]);
+var DEFAULT_IMPORT_SOURCE_RE = /(^|\/)(solid-translate|i18n)(\.[cm]?[jt]sx?)?$/;
+function isAcceptedImportSource(source, importSources) {
+  if (source === "solid-translate") return true;
+  if (importSources) return importSources.includes(source);
+  return DEFAULT_IMPORT_SOURCE_RE.test(source);
+}
+function collectModuleBindings(ast) {
+  const imports = /* @__PURE__ */ new Map();
+  const moduleLocals = /* @__PURE__ */ new Set();
+  const body = ast.program?.body ?? [];
+  for (const stmt of body) {
+    if (stmt.type === "ImportDeclaration") {
+      const source = String(stmt.source?.value ?? "");
+      for (const spec of stmt.specifiers ?? []) {
+        const local = spec.local?.name;
+        if (typeof local !== "string") continue;
+        if (spec.type === "ImportSpecifier") {
+          const imported = spec.imported?.type === "Identifier" ? spec.imported.name : String(spec.imported?.value ?? "");
+          imports.set(local, { imported, source });
+        } else {
+          imports.set(local, { imported: "*", source });
+        }
+      }
+    } else {
+      collectDeclaredNames(stmt, moduleLocals);
+    }
+  }
+  return { imports, moduleLocals };
+}
+function collectDeclaredNames(stmt, into) {
+  if (stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration") {
+    if (stmt.declaration) collectDeclaredNames(stmt.declaration, into);
+    return;
+  }
+  if (stmt.type === "VariableDeclaration") {
+    for (const decl of stmt.declarations ?? []) {
+      if (decl.id) collectPatternNames(decl.id, into);
+    }
+    return;
+  }
+  if ((stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration" || stmt.type === "TSEnumDeclaration") && stmt.id?.type === "Identifier") {
+    addMarkerName(stmt.id.name, into);
+  }
+}
+function collectPatternNames(pattern, into) {
+  switch (pattern.type) {
+    case "Identifier":
+      addMarkerName(pattern.name, into);
+      break;
+    case "AssignmentPattern":
+      collectPatternNames(pattern.left, into);
+      break;
+    case "RestElement":
+      collectPatternNames(pattern.argument, into);
+      break;
+    case "ObjectPattern":
+      for (const prop of pattern.properties ?? []) {
+        if (prop.type === "ObjectProperty") {
+          collectPatternNames(prop.value, into);
+        } else if (prop.type === "RestElement") {
+          collectPatternNames(prop.argument, into);
+        }
+      }
+      break;
+    case "ArrayPattern":
+      for (const el of pattern.elements ?? []) {
+        if (el) collectPatternNames(el, into);
+      }
+      break;
+  }
+}
+function addMarkerName(name, into) {
+  if (typeof name === "string" && MARKER_NAMES.has(name)) into.add(name);
+}
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration",
+  "ObjectMethod",
+  "ClassMethod",
+  "ClassPrivateMethod"
+]);
+function collectScopeBindings(node) {
+  const bound = /* @__PURE__ */ new Set();
+  if (FUNCTION_TYPES.has(node.type)) {
+    if (node.id?.type === "Identifier") addMarkerName(node.id.name, bound);
+    for (const param of node.params ?? []) {
+      collectPatternNames(param, bound);
+    }
+  } else if (node.type === "CatchClause" && node.param) {
+    collectPatternNames(node.param, bound);
+  } else if (node.type === "BlockStatement") {
+    for (const stmt of node.body ?? []) {
+      collectDeclaredNames(stmt, bound);
+    }
+  } else if (node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement") {
+    const init = node.init ?? node.left;
+    if (init?.type === "VariableDeclaration") {
+      collectDeclaredNames(init, bound);
+    }
+  }
+  return bound.size > 0 ? bound : null;
+}
 function walkChildren(node, visit) {
   for (const key of Object.keys(node)) {
     if (key === "loc" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") {
@@ -14974,7 +15106,16 @@ async function syncLocaleFiles(options) {
     delete lock.keys[key];
   }
   const changedCount = Object.keys(changedKeys).length;
-  if (changedCount === 0 && deletedKeys.length === 0) {
+  const missingByLocale = {};
+  for (const targetLocale of targetLocales) {
+    const existing = readTargetFile(join(localesDir, `${targetLocale}.json`));
+    const missing = Object.keys(sourceDict).filter(
+      (key) => !(key in changedKeys) && !(key in existing)
+    );
+    if (missing.length > 0) missingByLocale[targetLocale] = missing;
+  }
+  const missingLocaleCount = Object.keys(missingByLocale).length;
+  if (changedCount === 0 && deletedKeys.length === 0 && missingLocaleCount === 0) {
     log("No changes detected in locale files.");
     return {
       status: "no-changes",
@@ -14983,7 +15124,7 @@ async function syncLocaleFiles(options) {
       failures: []
     };
   }
-  if (changedCount === 0) {
+  if (changedCount === 0 && missingLocaleCount === 0) {
     for (const targetLocale of targetLocales) {
       const targetFilePath = join(localesDir, `${targetLocale}.json`);
       const existing = readTargetFile(targetFilePath);
@@ -14996,27 +15137,43 @@ async function syncLocaleFiles(options) {
     );
     return { status: "synced", translatedKeys: [], deletedKeys, failures: [] };
   }
-  log(
-    `Translating ${changedCount} key${changedCount > 1 ? "s" : ""} to ${targetLocales.length} locale${targetLocales.length > 1 ? "s" : ""}...`
-  );
-  const changedContexts = {};
-  for (const key of Object.keys(changedKeys)) {
-    const ctx = pendingEntries[key]?.context;
-    if (ctx) changedContexts[key] = ctx;
+  if (changedCount > 0) {
+    log(
+      `Translating ${changedCount} key${changedCount > 1 ? "s" : ""} to ${targetLocales.length} locale${targetLocales.length > 1 ? "s" : ""}...`
+    );
   }
+  if (missingLocaleCount > 0) {
+    const healTotal = Object.values(missingByLocale).reduce(
+      (sum, keys) => sum + keys.length,
+      0
+    );
+    log(
+      `Healing ${healTotal} key${healTotal > 1 ? "s" : ""} missing from ${missingLocaleCount} locale file${missingLocaleCount > 1 ? "s" : ""}...`
+    );
+  }
+  const contextFor = (key) => pendingEntries[key]?.context ?? lock.keys[key]?.context;
   const failures = [];
   const failedKeys = /* @__PURE__ */ new Set();
   for (const targetLocale of targetLocales) {
     const targetFilePath = join(localesDir, `${targetLocale}.json`);
     const existing = readTargetFile(targetFilePath);
-    const entries = Object.entries(changedKeys);
+    const localeEntries = { ...changedKeys };
+    for (const key of missingByLocale[targetLocale] ?? []) {
+      localeEntries[key] = sourceDict[key];
+    }
+    const localeContexts = {};
+    for (const key of Object.keys(localeEntries)) {
+      const ctx = contextFor(key);
+      if (ctx) localeContexts[key] = ctx;
+    }
+    const entries = Object.entries(localeEntries);
     for (let i = 0; i < entries.length; i += batchSize) {
       const batch = Object.fromEntries(entries.slice(i, i + batchSize));
       try {
         const translated = await translate(
           batch,
           targetLocale,
-          changedContexts
+          localeContexts
         );
         Object.assign(existing, translated);
       } catch (err) {
@@ -15229,7 +15386,8 @@ async function runExtract() {
         const extracted = extractStringsFromSource(
           code,
           relative(root, file),
-          warnings
+          warnings,
+          { importSources: config.extractImportSources }
         );
         for (const entry of extracted) {
           strings[entry.key] = entry.source;
@@ -15286,7 +15444,9 @@ async function runCheck(jsonOutput) {
         const code = readFileSync2(file, "utf-8");
         const entries = extractStringsFromSource(
           code,
-          relative(root, file)
+          relative(root, file),
+          void 0,
+          { importSources: config.extractImportSources }
         );
         for (const entry of entries) {
           extracted[entry.key] = entry.source;
@@ -15410,7 +15570,7 @@ Run \`solid-translate translate\` to refresh ${sourceLocale} \u2192 targets.`
   );
 }
 async function runTranslate() {
-  const { translateBatch: translateBatch2, translateMarkdown: translateMarkdown2 } = await import("./translate-M737VQHG.js");
+  const { translateBatch: translateBatch2, translateMarkdown: translateMarkdown2 } = await import("./translate-SWLCBQ5Y.js");
   const config = await loadConfig();
   const root = process.cwd();
   const sourceLocale = config.sourceLocale || "en";

package/dist/index.d.ts

@@ -36,6 +36,13 @@ interface SolidTranslatePluginConfig {
      * Default: `["src/**\/*.tsx", "src/**\/*.ts", "src/**\/*.jsx"]`
      */
     include?: string[];
+    /**
+     * Module specifiers accepted as sources of the extraction markers
+     * (`msg`, `<T>`, `<Plural>`, ...). `"solid-translate"` is always
+     * accepted. When omitted, any specifier whose final path segment is
+     * `solid-translate` or `i18n` (e.g. `"@/i18n"`) is accepted.
+     */
+    extractImportSources?: string[];
 }
 /** A flat dictionary mapping keys to translated strings */
 type TranslationDictionary = Record<string, string>;

package/dist/{translate-M737VQHG.js → translate-SWLCBQ5Y.js}

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import {
+  collectBatchTranslations,
+  extractJsonObject,
   translateBatch,
   translateMarkdown
-} from "./chunk-2BKJUY37.js";
+} from "./chunk-P6RTZPHZ.js";
 import "./chunk-FYS2JH42.js";
 export {
+  collectBatchTranslations,
+  extractJsonObject,
   translateBatch,
   translateMarkdown
 };

package/dist/vite.d.ts

@@ -36,6 +36,13 @@ interface SolidTranslatePluginConfig {
      * Default: `["src/**\/*.tsx", "src/**\/*.ts", "src/**\/*.jsx"]`
      */
     include?: string[];
+    /**
+     * Module specifiers accepted as sources of the extraction markers
+     * (`msg`, `<T>`, `<Plural>`, ...). `"solid-translate"` is always
+     * accepted. When omitted, any specifier whose final path segment is
+     * `solid-translate` or `i18n` (e.g. `"@/i18n"`) is accepted.
+     */
+    extractImportSources?: string[];
 }
 
 /**