solid-translate 1.4.1 → 1.4.3

package/dist/vite.js

@@ -14617,9 +14617,40 @@ function hashContent(content) {
 
 // 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);
@@ -14646,26 +14677,48 @@ async function translateBatch(model, entries, targetLocale, sourceLocale, system
       ].join("\n");
     }
   }
-  const generateObject = await loadGenerateObject();
-  const { object } = await generateObject({
-    model,
-    schema: z.object({
-      translations: z.record(z.string(), z.string())
-    }),
-    system: systemPrompt || defaultSystem,
-    prompt: [
-      `Translate each value in this JSON object from "${sourceLocale}" to "${targetLocale}".`,
-      `Return a JSON object with the exact same keys and the translated values.`,
-      contextSection,
-      JSON.stringify(entries, null, 2)
-    ].join("\n")
-  });
-  return object.translations;
+  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;
 }
 
 // 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) => {
@@ -14687,26 +14740,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") {
@@ -15040,7 +15225,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",
@@ -15049,7 +15243,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);
@@ -15062,27 +15256,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) {
@@ -15152,7 +15362,8 @@ function solidTranslate(config) {
     batchSize = 50,
     translate = true,
     autoExtract = false,
-    include = ["src/**/*.tsx", "src/**/*.ts", "src/**/*.jsx"]
+    include = ["src/**/*.tsx", "src/**/*.ts", "src/**/*.jsx"],
+    extractImportSources
   } = config;
   let root;
   let resolvedLocalesDir;
@@ -15180,7 +15391,11 @@ function solidTranslate(config) {
       );
       let contexts = {};
       if (autoExtract) {
-        const extracted = await autoExtractStrings(root, include);
+        const extracted = await autoExtractStrings(
+          root,
+          include,
+          extractImportSources
+        );
         contexts = extracted.contexts;
         let existingSource = {};
         if (existsSync2(sourceFilePath)) {
@@ -15343,7 +15558,7 @@ function solidTranslate(config) {
   };
 }
 var vite_default = solidTranslate;
-async function autoExtractStrings(root, patterns) {
+async function autoExtractStrings(root, patterns, importSources) {
   const strings = {};
   const contexts = {};
   const warnings = [];
@@ -15356,7 +15571,8 @@ async function autoExtractStrings(root, patterns) {
         const extracted = extractStringsFromSource(
           code,
           relative(root, file),
-          warnings
+          warnings,
+          { importSources }
         );
         for (const entry of extracted) {
           strings[entry.key] = entry.source;