glotfile 0.5.2 → 0.5.4

package/dist/server/cli.js

@@ -2734,7 +2734,7 @@ var init_local_settings = __esm({
     isEditorId = (v) => EDITOR_IDS.includes(v);
     DEFAULT_AI = {
       provider: "anthropic",
-      model: "claude-haiku-4-5-20251001",
+      model: "claude-sonnet-4-6",
       endpoint: null,
       region: null,
       batchSize: 25
@@ -2744,6 +2744,46 @@ var init_local_settings = __esm({
   }
 });
 
+// src/server/glossary.ts
+function contains(haystack, needle, caseSensitive) {
+  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
+}
+function relevantGlossary(source, targetLocale, glossary) {
+  const hints = [];
+  for (const entry of glossary) {
+    if (!contains(source, entry.term, entry.caseSensitive)) continue;
+    hints.push({
+      term: entry.term,
+      doNotTranslate: entry.doNotTranslate,
+      forced: entry.translations?.[targetLocale],
+      notes: entry.notes
+    });
+  }
+  return hints;
+}
+function glossaryViolations(source, value, targetLocale, glossary) {
+  const out = [];
+  for (const entry of glossary) {
+    if (!contains(source, entry.term, entry.caseSensitive)) continue;
+    if (entry.doNotTranslate) {
+      if (!contains(value, entry.term, entry.caseSensitive)) {
+        out.push({ term: entry.term, expected: entry.term, kind: "do-not-translate" });
+      }
+      continue;
+    }
+    const forced = entry.translations?.[targetLocale];
+    if (forced && !contains(value, forced, entry.caseSensitive)) {
+      out.push({ term: entry.term, expected: forced, kind: "forced" });
+    }
+  }
+  return out;
+}
+var init_glossary = __esm({
+  "src/server/glossary.ts"() {
+    "use strict";
+  }
+});
+
 // src/server/glob.ts
 function globToRegExp(glob) {
   const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -2815,21 +2855,6 @@ function selectRequests(state, opts) {
   }
   return reqs;
 }
-function relevantGlossary(source, targetLocale, glossary) {
-  const hints = [];
-  for (const entry of glossary) {
-    const haystack = entry.caseSensitive ? source : source.toLowerCase();
-    const needle = entry.caseSensitive ? entry.term : entry.term.toLowerCase();
-    if (!haystack.includes(needle)) continue;
-    hints.push({
-      term: entry.term,
-      doNotTranslate: entry.doNotTranslate,
-      forced: entry.translations?.[targetLocale],
-      notes: entry.notes
-    });
-  }
-  return hints;
-}
 function attachScreenshots(reqs, state, projectRoot) {
   const cache2 = /* @__PURE__ */ new Map();
   for (const req of reqs) {
@@ -2936,6 +2961,7 @@ var MEDIA_TYPES, MAX_IMAGE_BYTES, DEFAULT_LOCALE_CONCURRENCY;
 var init_run = __esm({
   "src/server/ai/run.ts"() {
     "use strict";
+    init_glossary();
     init_placeholders();
     init_plurals();
     init_state();
@@ -3113,7 +3139,7 @@ function findMissing(state) {
     const entry = state.keys[key];
     if (entry.skipTranslate) continue;
     for (const locale of targets) {
-      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value;
+      const v = entry.plural ? entry.values[locale]?.forms?.other?.trim() : entry.values[locale]?.value?.trim();
       if (!v) out.push({ key, locale });
     }
   }
@@ -3581,24 +3607,83 @@ var init_context = __esm({
   }
 });
 
-// src/server/lint/spelling.ts
-function tokenize(text) {
-  return text.match(new RegExp("\\p{L}[\\p{L}'']*", "gu")) ?? [];
+// src/server/spell.ts
+function spellTokens(value) {
+  return value.replace(ICU_BLOCK, " ").replace(MASK, " ").match(WORD) ?? [];
 }
-function buildAllowWords(glossary, dictionary2 = []) {
+function ignoreWordsFor(glossary, customWords = []) {
   const set = /* @__PURE__ */ new Set();
-  const add = (s) => {
-    for (const w of tokenize(s)) set.add(w.toLowerCase());
+  const add = (text) => {
+    for (const w of text.match(WORD) ?? []) set.add(w.toLowerCase());
   };
-  for (const g of glossary) add(g.term);
-  for (const w of dictionary2) add(w);
+  for (const e of glossary) {
+    add(e.term);
+    for (const t of Object.values(e.translations ?? {})) add(t);
+  }
+  for (const w of customWords) add(w);
   return set;
 }
+async function getSpeller(dictId) {
+  const key = norm(dictId);
+  const existing = instances.get(key);
+  if (existing) return existing;
+  if (unavailable.has(key)) return null;
+  try {
+    const nspellMod = await import("nspell");
+    const nspell = nspellMod.default ?? nspellMod;
+    const dictMod = await import(`dictionary-${key}`);
+    const dictExport = dictMod.default ?? dictMod;
+    const dict = typeof dictExport === "function" ? await dictExport() : dictExport;
+    const speller = nspell(dict);
+    instances.set(key, speller);
+    return speller;
+  } catch {
+    unavailable.add(key);
+    return null;
+  } finally {
+    loading.delete(key);
+  }
+}
+function spellValue(dictId, value, ignore) {
+  const key = norm(dictId);
+  if (unavailable.has(key)) return [];
+  const spell = instances.get(key);
+  if (!spell) {
+    if (!loading.has(key)) {
+      loading.add(key);
+      void getSpeller(key);
+    }
+    return null;
+  }
+  const cacheKey = key + " " + value;
+  let allBad = cache.get(cacheKey);
+  if (!allBad) {
+    allBad = spellTokens(value).filter((w) => !spell.correct(w));
+    cache.set(cacheKey, allBad);
+  }
+  return allBad.filter((w) => !ignore.has(w.toLowerCase()));
+}
+var instances, loading, unavailable, cache, norm, ICU_BLOCK, MASK, WORD;
+var init_spell = __esm({
+  "src/server/spell.ts"() {
+    "use strict";
+    instances = /* @__PURE__ */ new Map();
+    loading = /* @__PURE__ */ new Set();
+    unavailable = /* @__PURE__ */ new Set();
+    cache = /* @__PURE__ */ new Map();
+    norm = (dictId) => dictId.toLowerCase();
+    ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
+    MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
+    WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
+  }
+});
+
+// src/server/lint/spelling.ts
 var spellingRule, defaultLoader;
 var init_spelling = __esm({
   "src/server/lint/spelling.ts"() {
     "use strict";
-    init_placeholders();
+    init_spell();
     spellingRule = {
       id: "spelling",
       run(state, ctx) {
@@ -3610,10 +3695,8 @@ var init_spelling = __esm({
             if (!speller) continue;
             const value = entry.values[locale]?.value;
             if (!value) continue;
-            const placeholders = new Set(extractPlaceholders(value).map((p) => p.toLowerCase()));
-            for (const word of tokenize(value)) {
-              const lower = word.toLowerCase();
-              if (placeholders.has(lower) || ctx.allowWords.has(lower)) continue;
+            for (const word of spellTokens(value)) {
+              if (ctx.allowWords.has(word.toLowerCase())) continue;
               if (!speller.correct(word)) {
                 out.push({ ruleId: "spelling", key, locale, message: `possible misspelling: "${word}"` });
               }
@@ -3623,18 +3706,7 @@ var init_spelling = __esm({
         return out;
       }
     };
-    defaultLoader = async (dictId) => {
-      try {
-        const nspellMod = await import("nspell");
-        const nspell2 = nspellMod.default ?? nspellMod;
-        const dictMod = await import(`dictionary-${dictId.toLowerCase()}`);
-        const dictExport = dictMod.default ?? dictMod;
-        const dict = typeof dictExport === "function" ? await dictExport() : dictExport;
-        return nspell2(dict);
-      } catch {
-        return null;
-      }
-    };
+    defaultLoader = (dictId) => getSpeller(dictId);
   }
 });
 
@@ -3645,7 +3717,7 @@ var init_rules = __esm({
     "use strict";
     init_scan();
     init_placeholders();
-    init_run();
+    init_glossary();
     init_spelling();
     emptySourceRule = {
       id: "empty-source",
@@ -3661,17 +3733,14 @@ var init_rules = __esm({
     };
     emptyTranslationRule = {
       id: "empty-translation",
-      run(state, ctx) {
+      // findMissing is the shared "untranslated" walk (also behind the editor's
+      // untranslated check and /scan/missing); a whitespace-only value counts as
+      // missing there, so no separate whitespace pass is needed.
+      run(state) {
         const out = [];
         for (const m of findMissing(state)) {
           out.push({ ruleId: "empty-translation", key: m.key, locale: m.locale, message: "translation is empty or missing" });
         }
-        for (const key of Object.keys(state.keys)) {
-          for (const locale of ctx.targetLocales) {
-            const v = state.keys[key].values[locale]?.value;
-            if (v && !v.trim()) out.push({ ruleId: "empty-translation", key, locale, message: "translation is whitespace-only" });
-          }
-        }
         return out;
       }
     };
@@ -3799,13 +3868,13 @@ var init_rules = __esm({
           for (const locale of ctx.targetLocales) {
             const v = entry.values[locale]?.value;
             if (!v) continue;
-            for (const hint of relevantGlossary(src, locale, ctx.glossary)) {
-              if (hint.doNotTranslate && !v.includes(hint.term)) {
-                out.push({ ruleId: "glossary-violation", key, locale, message: `do-not-translate term "${hint.term}" is missing or altered` });
-              }
-              if (hint.forced && !v.includes(hint.forced)) {
-                out.push({ ruleId: "glossary-violation", key, locale, message: `expected glossary translation "${hint.forced}" for "${hint.term}"` });
-              }
+            for (const viol of glossaryViolations(src, v, locale, ctx.glossary)) {
+              out.push({
+                ruleId: "glossary-violation",
+                key,
+                locale,
+                message: viol.kind === "do-not-translate" ? `do-not-translate term "${viol.term}" is missing or altered` : `expected glossary translation "${viol.expected}" for "${viol.term}"`
+              });
             }
           }
         }
@@ -3866,7 +3935,7 @@ async function runLint(state, options = {}) {
   const active = rules.filter(isActive);
   const spellingOn = active.some((r) => r.id === "spelling");
   const spellers = spellingOn ? await loadSpellers(targetLocales, config, load, warn) : /* @__PURE__ */ new Map();
-  const allowWords = spellingOn ? buildAllowWords(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
+  const allowWords = spellingOn ? ignoreWordsFor(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
   const ctx = {
     config,
     sourceLocale: state.config.sourceLocale,
@@ -3904,6 +3973,7 @@ var init_run2 = __esm({
     init_registry();
     init_rules();
     init_spelling();
+    init_spell();
     init_suppress();
   }
 });
@@ -4718,120 +4788,22 @@ var init_stats = __esm({
   }
 });
 
-// node_modules/dictionary-en/index.js
-var dictionary_en_exports = {};
-__export(dictionary_en_exports, {
-  default: () => dictionary_en_default
-});
-import fs from "fs/promises";
-var aff, dic, dictionary, dictionary_en_default;
-var init_dictionary_en = __esm({
-  async "node_modules/dictionary-en/index.js"() {
-    "use strict";
-    aff = await fs.readFile(new URL("index.aff", import.meta.url));
-    dic = await fs.readFile(new URL("index.dic", import.meta.url));
-    dictionary = { aff, dic };
-    dictionary_en_default = dictionary;
-  }
-});
-
-// src/server/spell.ts
-import nspell from "nspell";
-async function loadDictionary(locale) {
-  const key = norm(locale);
-  if (instances.has(key) || unavailable.has(key)) return;
-  const loader = LOADERS[key];
-  if (!loader) {
-    unavailable.add(key);
-    return;
-  }
-  try {
-    const { default: dict } = await loader();
-    instances.set(key, nspell(dict));
-  } catch {
-    unavailable.add(key);
-  } finally {
-    loading.delete(key);
-  }
-}
-function spellValue(locale, value, ignore) {
-  const key = norm(locale);
-  if (unavailable.has(key)) return [];
-  const spell = instances.get(key);
-  if (!spell) {
-    if (!LOADERS[key]) {
-      unavailable.add(key);
-      return [];
-    }
-    if (!loading.has(key)) {
-      loading.add(key);
-      void loadDictionary(key);
-    }
-    return null;
-  }
-  const cacheKey = key + " " + value;
-  let allBad = cache.get(cacheKey);
-  if (!allBad) {
-    const words = value.replace(ICU_BLOCK, " ").replace(MASK, " ").match(WORD) ?? [];
-    allBad = words.filter((w) => !spell.correct(w));
-    cache.set(cacheKey, allBad);
-  }
-  return allBad.filter((w) => !ignore.has(w.toLowerCase()));
-}
-var LOADERS, instances, loading, unavailable, cache, norm, ICU_BLOCK, MASK, WORD;
-var init_spell = __esm({
-  "src/server/spell.ts"() {
-    "use strict";
-    LOADERS = {
-      en: () => init_dictionary_en().then(() => dictionary_en_exports),
-      es: () => import("dictionary-es"),
-      fr: () => import("dictionary-fr")
-    };
-    instances = /* @__PURE__ */ new Map();
-    loading = /* @__PURE__ */ new Set();
-    unavailable = /* @__PURE__ */ new Set();
-    cache = /* @__PURE__ */ new Map();
-    norm = (locale) => locale.toLowerCase();
-    ICU_BLOCK = /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g;
-    MASK = /\{[^}]*\}|<[^>]*>|:\w+|%[sd]/g;
-    WORD = new RegExp("\\p{L}[\\p{L}''\u2019-]*", "gu");
-  }
-});
-
 // src/server/checks.ts
-function contains(haystack, needle, caseSensitive) {
-  return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
-}
 function runChecks(state, opts = {}) {
   const ruleOff = (id) => state.config.lint?.rules?.[CHECK_RULE[id]] === "off";
   const on = (id) => (!opts.only || opts.only.includes(id)) && !ruleOff(id);
   const issues = [];
   let spellPending = false;
   const { sourceLocale } = state.config;
-  const byTerm = new Map(state.glossary.map((e) => [e.term, e]));
-  const ignore = /* @__PURE__ */ new Set();
-  for (const e of state.glossary) {
-    for (const w of e.term.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
-    for (const t of Object.values(e.translations ?? {})) {
-      for (const w of t.toLowerCase().split(/\s+/)) if (w) ignore.add(w);
+  const ignore = ignoreWordsFor(state.glossary, state.config.spelling?.customWords);
+  if (on("untranslated")) {
+    for (const m of findMissing(state)) {
+      issues.push({ key: m.key, locale: m.locale, check: "untranslated", message: "Not translated yet" });
     }
   }
-  for (const word of state.config.spelling?.customWords ?? []) {
-    const w = word.trim().toLowerCase();
-    if (w) ignore.add(w);
-  }
-  const targetLocales = state.config.locales.filter((l) => l !== sourceLocale);
   for (const key of Object.keys(state.keys).sort()) {
     const entry = state.keys[key];
     const source = entry.values[sourceLocale]?.value ?? "";
-    if (on("untranslated") && !entry.skipTranslate) {
-      for (const locale of targetLocales) {
-        const translated = entry.plural ? (entry.values[locale]?.forms?.other ?? "").trim() !== "" : (entry.values[locale]?.value ?? "").trim() !== "";
-        if (!translated) {
-          issues.push({ key, locale, check: "untranslated", message: "Not translated yet" });
-        }
-      }
-    }
     if (entry.plural) {
       if (on("placeholder")) {
         const sourceForm = entry.values[sourceLocale]?.forms?.other ?? "";
@@ -4875,7 +4847,8 @@ function runChecks(state, opts = {}) {
         });
       }
       if (on("spelling") && !blank) {
-        const bad = spellValue(locale, value, ignore);
+        const dictId = state.config.lint?.spelling?.locales?.[locale] ?? locale;
+        const bad = spellValue(dictId, value, ignore);
         if (bad === null) spellPending = true;
         else if (bad.length) {
           issues.push({
@@ -4905,29 +4878,14 @@ function runChecks(state, opts = {}) {
         });
       }
       if (on("glossary") && source) {
-        for (const hint of relevantGlossary(source, locale, state.glossary)) {
-          const cs = byTerm.get(hint.term)?.caseSensitive;
-          if (hint.doNotTranslate) {
-            if (!contains(value, hint.term, cs)) {
-              issues.push({
-                key,
-                locale,
-                check: "glossary",
-                message: `Do-not-translate term "${hint.term}" is missing from the translation`,
-                detail: [hint.term]
-              });
-            }
-          } else if (hint.forced) {
-            if (!contains(value, hint.forced, cs)) {
-              issues.push({
-                key,
-                locale,
-                check: "glossary",
-                message: `Should use "${hint.forced}" for "${hint.term}"`,
-                detail: [hint.forced]
-              });
-            }
-          }
+        for (const viol of glossaryViolations(source, value, locale, state.glossary)) {
+          issues.push({
+            key,
+            locale,
+            check: "glossary",
+            message: viol.kind === "do-not-translate" ? `Do-not-translate term "${viol.term}" is missing from the translation` : `Should use "${viol.expected}" for "${viol.term}"`,
+            detail: [viol.expected]
+          });
         }
       }
     }
@@ -4943,7 +4901,8 @@ var init_checks = __esm({
   "src/server/checks.ts"() {
     "use strict";
     init_placeholders();
-    init_run();
+    init_glossary();
+    init_scan();
     init_spell();
     init_suppress();
     CHECK_IDS = ["untranslated", "placeholder", "spelling", "length", "glossary"];