glotfile 0.4.6 → 0.5.0

package/dist/server/server.js

@@ -202,9 +202,6 @@ function validate(raw) {
     if (lint.ignore !== void 0 && (!Array.isArray(lint.ignore) || !lint.ignore.every((g) => typeof g === "string"))) {
       fail("config.lint.ignore must be an array of strings");
     }
-    if (lint.dictionary !== void 0 && (!Array.isArray(lint.dictionary) || !lint.dictionary.every((w) => typeof w === "string"))) {
-      fail("config.lint.dictionary must be an array of strings");
-    }
     if (lint.spelling !== void 0) {
       if (!isObject(lint.spelling)) fail("config.lint.spelling must be an object");
       if (lint.spelling.locales !== void 0 && (!isObject(lint.spelling.locales) || !Object.values(lint.spelling.locales).every((v) => typeof v === "string"))) {
@@ -269,6 +266,20 @@ function validate(raw) {
         lv.value = lv.value.trim();
       }
     }
+    if (entry.suppressions !== void 0) {
+      if (!Array.isArray(entry.suppressions)) fail(`key "${key}" suppressions must be an array`);
+      for (const s of entry.suppressions) {
+        if (!isObject(s) || typeof s.locale !== "string" || typeof s.source !== "string") {
+          fail(`key "${key}" has an invalid suppression (needs string rule, locale, source)`);
+        }
+        if (!RULE_IDS.includes(s.rule)) {
+          fail(`key "${key}" suppression has unknown rule id "${String(s.rule)}"`);
+        }
+        if (s.at !== void 0 && typeof s.at !== "string") {
+          fail(`key "${key}" suppression "at" must be a string`);
+        }
+      }
+    }
     if (entry.notes !== void 0) {
       if (!Array.isArray(entry.notes)) fail(`key "${key}" notes must be an array`);
       for (const n of entry.notes) {
@@ -512,6 +523,30 @@ function normalizeSource(value) {
   return value.trim().replace(/\s+/g, " ").toLowerCase();
 }
 
+// src/server/lint/suppress.ts
+import { createHash } from "crypto";
+function sourceSignature(entry, sourceLocale) {
+  const lv = entry.values[sourceLocale];
+  if (entry.plural) {
+    return Object.entries(lv?.forms ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([cat, body]) => `${cat}:${normalizeSource(body ?? "")}`).join("|");
+  }
+  return normalizeSource(lv?.value ?? "");
+}
+function sourceHash(entry, sourceLocale) {
+  return createHash("sha256").update(sourceSignature(entry, sourceLocale)).digest("hex").slice(0, 12);
+}
+function findSuppression(entry, sourceLocale, ruleId, locale) {
+  if (!entry.suppressions?.length) return void 0;
+  const current = sourceHash(entry, sourceLocale);
+  return entry.suppressions.find((s) => s.rule === ruleId && s.locale === locale && s.source === current);
+}
+function pruneStaleSuppressions(entry, sourceLocale) {
+  if (!entry.suppressions?.length) return;
+  const current = sourceHash(entry, sourceLocale);
+  entry.suppressions = entry.suppressions.filter((s) => s.source === current);
+  if (!entry.suppressions.length) delete entry.suppressions;
+}
+
 // src/server/state.ts
 var systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
 function canonLocale(locale) {
@@ -532,6 +567,7 @@ function normalizeState(state) {
     const remapped = {};
     for (const [loc, lv] of Object.entries(entry.values)) remapped[canonLocale(loc)] = lv;
     entry.values = remapped;
+    for (const s of entry.suppressions ?? []) s.locale = canonLocale(s.locale);
   }
   for (const output of state.config.outputs) {
     if (!output.localeMap) continue;
@@ -623,6 +659,7 @@ function setSourceValue(state, key, value) {
         lv.state = "needs-review";
       }
     }
+    pruneStaleSuppressions(entry, state.config.sourceLocale);
   }
 }
 function setTargetValue(state, key, locale, value, clock = systemClock) {
@@ -646,6 +683,7 @@ function setSourcePluralForms(state, key, forms) {
         lv.state = "needs-review";
       }
     }
+    pruneStaleSuppressions(entry, state.config.sourceLocale);
   }
 }
 function setPluralForms(state, key, locale, forms, clock = systemClock) {
@@ -719,6 +757,19 @@ function deleteNote(state, key, id) {
   if (!entry.notes) return;
   entry.notes = entry.notes.filter((n) => n.id !== id);
 }
+function addSuppression(state, key, rule, locale, clock = systemClock) {
+  const entry = requireKey(state, key);
+  if (!RULE_IDS.includes(rule)) throw new GlotfileError(`Unknown lint rule: ${rule}`);
+  const list = (entry.suppressions ?? []).filter((s) => !(s.rule === rule && s.locale === locale));
+  list.push({ rule, locale, source: sourceHash(entry, state.config.sourceLocale), at: clock() });
+  entry.suppressions = list;
+}
+function removeSuppression(state, key, rule, locale) {
+  const entry = requireKey(state, key);
+  if (!entry.suppressions) return;
+  entry.suppressions = entry.suppressions.filter((s) => !(s.rule === rule && s.locale === locale));
+  if (!entry.suppressions.length) delete entry.suppressions;
+}
 function upsertGlossaryEntry(state, entry) {
   const i = state.glossary.findIndex((e) => e.term === entry.term);
   if (i === -1) state.glossary.push(entry);
@@ -755,6 +806,23 @@ function applyMachineTranslationForms(state, key, locale, forms, clock = systemC
   return true;
 }
 
+// src/server/lint/accept.ts
+function acceptFindings(state, findings, opts = {}, clock = systemClock) {
+  const byRule = {};
+  let accepted = 0;
+  for (const f of findings) {
+    if (f.locale === "" || f.suppressed) continue;
+    if (f.severity === "error" && !opts.includeErrors) continue;
+    if (opts.rules && !opts.rules.includes(f.ruleId)) continue;
+    if (opts.locales && !opts.locales.includes(f.locale)) continue;
+    if (!state.keys[f.key]) continue;
+    addSuppression(state, f.key, f.ruleId, f.locale, clock);
+    byRule[f.ruleId] = (byRule[f.ruleId] ?? 0) + 1;
+    accepted++;
+  }
+  return { accepted, byRule };
+}
+
 // src/server/scan.ts
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve2 } from "path";
@@ -1653,11 +1721,19 @@ function spellValue(locale, value, ignore) {
 
 // src/server/checks.ts
 var CHECK_IDS = ["untranslated", "placeholder", "spelling", "length", "glossary"];
+var CHECK_RULE = {
+  untranslated: "empty-translation",
+  placeholder: "placeholder-mismatch",
+  spelling: "spelling",
+  length: "max-length",
+  glossary: "glossary-violation"
+};
 function contains(haystack, needle, caseSensitive) {
   return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
 }
 function runChecks(state, opts = {}) {
-  const on = (id) => !opts.only || opts.only.includes(id);
+  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;
@@ -1785,7 +1861,11 @@ function runChecks(state, opts = {}) {
       }
     }
   }
-  return { issues, spellPending };
+  const visible = issues.filter((i) => {
+    const entry = state.keys[i.key];
+    return !entry || !findSuppression(entry, sourceLocale, CHECK_RULE[i.check], i.locale);
+  });
+  return { issues: visible, spellPending };
 }
 
 // src/server/lint/spelling.ts
@@ -2027,7 +2107,10 @@ function sortFindings(findings) {
 }
 function countSeverities(findings) {
   let error = 0, warn = 0;
-  for (const f of findings) f.severity === "error" ? error++ : warn++;
+  for (const f of findings) {
+    if (f.suppressed) continue;
+    f.severity === "error" ? error++ : warn++;
+  }
   return { error, warn };
 }
 async function loadSpellers(locales, config, load, warn) {
@@ -2053,7 +2136,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, config.dictionary) : /* @__PURE__ */ new Set();
+  const allowWords = spellingOn ? buildAllowWords(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
   const ctx = {
     config,
     sourceLocale: state.config.sourceLocale,
@@ -2065,16 +2148,23 @@ async function runLint(state, options = {}) {
   const ignoreRes = (config.ignore ?? []).map(globToRegExp2);
   const localeFilter = options.locales ? new Set(options.locales) : null;
   const findings = [];
+  let suppressed = 0;
   for (const rule of active) {
     const severity = resolveSeverity(rule.id, config);
     for (const raw of rule.run(state, ctx)) {
       if (ignoreRes.some((re) => re.test(raw.key))) continue;
       if (localeFilter && raw.locale !== "" && !localeFilter.has(raw.locale)) continue;
+      const entry = state.keys[raw.key];
+      if (raw.locale !== "" && entry && findSuppression(entry, state.config.sourceLocale, rule.id, raw.locale)) {
+        suppressed++;
+        if (options.includeSuppressed) findings.push({ ...raw, severity, suppressed: true });
+        continue;
+      }
       findings.push({ ...raw, severity });
     }
   }
   const sorted = sortFindings(findings);
-  const counts = countSeverities(sorted);
+  const counts = { ...countSeverities(sorted), suppressed };
   return { findings: sorted, counts, ok: counts.error === 0 };
 }
 
@@ -4108,6 +4198,7 @@ import { homedir } from "os";
 import { join as join8 } from "path";
 var THEMES = ["system", "light", "dark"];
 var isThemeMode = (v) => THEMES.includes(v);
+var isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
 var defaultUiPrefsPath = () => join8(homedir(), ".glotfile", "ui.json");
 var DEFAULTS = { theme: "system" };
 function readJson(path) {
@@ -4120,7 +4211,10 @@ function readJson(path) {
 }
 function loadUiPrefs(path) {
   const raw = readJson(path);
-  return { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+  const prefs = { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+  if (isPanelWidth(raw.keyColumnWidth)) prefs.keyColumnWidth = Math.round(raw.keyColumnWidth);
+  if (isPanelWidth(raw.detailPanelWidth)) prefs.detailPanelWidth = Math.round(raw.detailPanelWidth);
+  return prefs;
 }
 function saveUiPrefs(path, prefs) {
   const merged = { ...readJson(path), ...prefs };
@@ -4256,9 +4350,20 @@ function createApi(deps) {
   app.get("/state", (c) => c.json(load()));
   app.get("/ui-prefs", (c) => c.json(loadUiPrefs(uiPrefsPath)));
   app.put("/ui-prefs", async (c) => {
-    const { theme } = await c.req.json();
-    if (!isThemeMode(theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
-    saveUiPrefs(uiPrefsPath, { theme });
+    const body = await c.req.json();
+    const patch = {};
+    if ("theme" in body) {
+      if (!isThemeMode(body.theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
+      patch.theme = body.theme;
+    }
+    for (const field of ["keyColumnWidth", "detailPanelWidth"]) {
+      if (field in body) {
+        if (!isPanelWidth(body[field])) return c.json({ error: `${field} must be a number between 120 and 1200` }, 400);
+        patch[field] = Math.round(body[field]);
+      }
+    }
+    if (Object.keys(patch).length === 0) return c.json({ error: "no recognized preferences in body" }, 400);
+    saveUiPrefs(uiPrefsPath, patch);
     return c.json({ ok: true });
   });
   app.get("/local-settings", (c) => c.json(loadLocalSettings(projectRoot)));
@@ -4732,12 +4837,47 @@ function createApi(deps) {
   };
   app.get("/lint", async (c) => {
     const state = load();
+    const includeSuppressed = c.req.query("includeSuppressed") === "1";
     const lint = await runLint(state, { loadSpeller: cachedLoader, warn: () => {
-    } });
+    }, includeSuppressed });
     const findings = sortFindings([...lint.findings, ...checkOutputs(state, projectRoot)]);
-    const counts = countSeverities(findings);
+    const counts = { ...countSeverities(findings), suppressed: lint.counts.suppressed };
     return c.json({ findings, counts, ok: counts.error === 0 });
   });
+  app.post("/keys/:key/suppressions", async (c) => {
+    const key = c.req.param("key");
+    const { rule, locale } = await c.req.json();
+    if (typeof rule !== "string" || !rule) return c.json({ error: "rule is required" }, 400);
+    if (typeof locale !== "string" || !locale) return c.json({ error: "locale is required" }, 400);
+    const s = load();
+    addSuppression(s, key, rule, locale);
+    persist(s);
+    logChange({ kind: "suppression", summary: `Suppressed ${rule} for ${key} [${locale}]`, key, locale, after: rule });
+    return c.json({ ok: true });
+  });
+  app.delete("/keys/:key/suppressions", (c) => {
+    const key = c.req.param("key");
+    const rule = c.req.query("rule") ?? "";
+    const locale = c.req.query("locale") ?? "";
+    if (!rule || !locale) return c.json({ error: "rule and locale are required" }, 400);
+    const s = load();
+    removeSuppression(s, key, rule, locale);
+    persist(s);
+    logChange({ kind: "suppression", summary: `Unsuppressed ${rule} for ${key} [${locale}]`, key, locale, before: rule });
+    return c.json({ ok: true });
+  });
+  app.post("/lint/accept", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const lint = await runLint(s, { loadSpeller: cachedLoader, warn: () => {
+    } });
+    const result = acceptFindings(s, lint.findings, { rules: body.rules, locales: body.locales });
+    if (result.accepted > 0) {
+      persist(s);
+      logChange({ kind: "suppression", summary: `Suppressed ${result.accepted} finding(s)`, after: result.byRule });
+    }
+    return c.json({ ok: true, ...result });
+  });
   app.get("/checks", (c) => {
     const param = c.req.query("checks");
     const only = param ? param.split(",").map((s) => s.trim()).filter((s) => CHECK_IDS.includes(s)) : void 0;