glotfile 0.7.5 → 0.8.1

package/dist/server/server.js

@@ -4788,6 +4788,23 @@ function parseAttrs(s) {
   for (const m of s.matchAll(/([\w-]+)="([^"]*)"/g)) out[m[1]] = decodeEntities(m[2]);
   return out;
 }
+function decodeLocations(body) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const g of body.matchAll(/<context-group\b[^>]*\bpurpose="location"[^>]*>([\s\S]*?)<\/context-group>/g)) {
+    const inner = g[1];
+    const file = inner.match(/<context\b[^>]*context-type="sourcefile"[^>]*>([\s\S]*?)<\/context>/)?.[1];
+    if (file === void 0) continue;
+    const lineRaw = inner.match(/<context\b[^>]*context-type="linenumber"[^>]*>([\s\S]*?)<\/context>/)?.[1];
+    const decodedFile = decodeEntities(file.trim());
+    const line = lineRaw ? parseInt(lineRaw.trim(), 10) || 1 : 1;
+    const dedup = `${decodedFile}:${line}`;
+    if (seen.has(dedup)) continue;
+    seen.add(dedup);
+    out.push({ file: decodedFile, line });
+  }
+  return out;
+}
 function decodeInline(raw, addMeta) {
   let out = "";
   let last = 0;
@@ -4859,6 +4876,10 @@ var angularXliff2 = {
           entry.values[targetLocale] = decodeInline(tgt[2], addMeta);
           seen(targetLocale);
         }
+        if (entry.locations === void 0) {
+          const locs = decodeLocations(body);
+          if (locs.length) entry.locations = locs;
+        }
       }
     }
     return { locales, keys, warnings };
@@ -5605,6 +5626,96 @@ function assemble2(parsed, opts) {
   };
 }
 
+// src/server/import/merge.ts
+function hasContent(lv) {
+  if (!lv) return false;
+  return !!(lv.forms ? lv.forms.other?.trim() : lv.value?.trim());
+}
+function formsEqual(a, b) {
+  const ak = Object.keys(a ?? {}).sort();
+  const bk = Object.keys(b ?? {}).sort();
+  if (ak.length !== bk.length || ak.some((k, i) => k !== bk[i])) return false;
+  return ak.every((k) => a[k] === b[k]);
+}
+function sameSource(cur, inc, src) {
+  if (!!cur.plural !== !!inc.plural) return false;
+  const c = cur.values[src];
+  const i = inc.values[src];
+  return cur.plural ? formsEqual(c?.forms, i?.forms) : (c?.value ?? "") === (i?.value ?? "");
+}
+function applyIncomingSource(cur, inc, src, shapeChanged) {
+  const incSrc = inc.values[src];
+  if (shapeChanged) {
+    if (inc.plural) cur.plural = { arg: inc.plural.arg };
+    else delete cur.plural;
+    cur.values = { [src]: { ...incSrc, state: "source" } };
+    return;
+  }
+  const existing = cur.values[src];
+  if (cur.plural) cur.values[src] = { ...existing, forms: incSrc?.forms, state: "source" };
+  else cur.values[src] = { ...existing, value: incSrc?.value, state: "source" };
+}
+function cloneForAdd(inc, allowed) {
+  const entry = structuredClone(inc);
+  for (const loc of Object.keys(entry.values)) {
+    if (!allowed.has(loc)) delete entry.values[loc];
+  }
+  return entry;
+}
+function mergeStates(existing, incoming, opts = {}) {
+  const state = structuredClone(existing);
+  const src = state.config.sourceLocale;
+  const targets = state.config.locales.filter((l) => l !== src);
+  const allowed = new Set(state.config.locales);
+  const live = opts.liveKeys ?? new Set(Object.keys(incoming.keys));
+  const plan = { added: [], sourceChanged: [], adopted: [], removed: [], unchanged: 0 };
+  for (const [key, inc] of Object.entries(incoming.keys)) {
+    if (!live.has(key)) continue;
+    const cur = state.keys[key];
+    if (!cur) {
+      const entry = cloneForAdd(inc, allowed);
+      if (!entry.createdAt) entry.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      state.keys[key] = entry;
+      plan.added.push(key);
+      continue;
+    }
+    const shapeChanged = !!cur.plural !== !!inc.plural;
+    const srcChanged = !sameSource(cur, inc, src);
+    if (srcChanged) {
+      applyIncomingSource(cur, inc, src, shapeChanged);
+      plan.sourceChanged.push(key);
+      for (const loc of targets) {
+        const lv = cur.values[loc];
+        if (lv && hasContent(lv)) lv.state = "needs-review";
+      }
+    }
+    if (inc.placeholders) cur.placeholders = inc.placeholders;
+    else delete cur.placeholders;
+    if (!cur.description && inc.description) cur.description = inc.description;
+    let adoptedHere = false;
+    for (const loc of targets) {
+      const incLv = inc.values[loc];
+      if (!hasContent(incLv)) continue;
+      if (hasContent(cur.values[loc])) continue;
+      cur.values[loc] = { ...structuredClone(incLv), state: "reviewed" };
+      plan.adopted.push({ key, locale: loc });
+      adoptedHere = true;
+    }
+    if (!srcChanged && !adoptedHere) plan.unchanged++;
+  }
+  for (const key of Object.keys(state.keys)) {
+    if (!live.has(key)) {
+      plan.removed.push(key);
+      if (opts.prune) delete state.keys[key];
+    }
+  }
+  plan.added.sort();
+  plan.sourceChanged.sort();
+  plan.removed.sort();
+  plan.adopted.sort((a, b) => a.key.localeCompare(b.key) || a.locale.localeCompare(b.locale));
+  return { state, plan };
+}
+
 // src/server/import/run.ts
 function previewImport(projectRoot, format) {
   const det = detect(projectRoot, format);
@@ -5628,6 +5739,29 @@ function previewImport(projectRoot, format) {
     sampleKeys
   };
 }
+function runSync(opts) {
+  const det = detect(opts.projectRoot, opts.format);
+  if (!det) throw new Error(`No recognized locale files found in ${opts.projectRoot}`);
+  const parser = getParser(det.format);
+  const sourceLocale = opts.sourceLocale ?? det.sourceLocale;
+  const parsed = parser.parse(
+    det.localeRoot,
+    opts.locales ? { locales: opts.locales } : void 0
+  );
+  const sourceParse = parser.parse(det.localeRoot, { locales: [sourceLocale] });
+  const liveKeys = new Set(Object.keys(sourceParse.keys));
+  const assembled = assemble2(parsed, {
+    sourceLocale,
+    format: det.format,
+    cldr: opts.cldr,
+    localeRootRel: relative3(opts.projectRoot, det.localeRoot)
+  });
+  const { warnings, ...rest } = assembled;
+  const incoming = validate(rest);
+  const existing = loadState(opts.statePath);
+  const { state, plan } = mergeStates(existing, incoming, { prune: opts.prune, liveKeys });
+  return { state, plan, warnings, keyCount: Object.keys(state.keys).length };
+}
 function runImport(opts) {
   const det = detect(opts.projectRoot, opts.format);
   if (!det) throw new Error(`No recognized locale files found in ${opts.projectRoot}`);
@@ -5652,6 +5786,36 @@ function runImport(opts) {
   };
 }
 
+// src/server/import/usage.ts
+var LOCATION_SCANNED_ADAPTERS = /* @__PURE__ */ new Set(["angular-xliff"]);
+function isLocationScannedState(state) {
+  return state.config.outputs.some((o) => LOCATION_SCANNED_ADAPTERS.has(o.adapter));
+}
+function buildLocationUsageCache(parsed) {
+  const files = {};
+  for (const [key, pk] of Object.entries(parsed.keys)) {
+    for (const loc of pk.locations ?? []) {
+      const file = files[loc.file] ??= { mtime: 0, size: 0, refs: [], prefixes: [] };
+      file.refs.push({ key, line: loc.line, col: 1, scanner: "angular-xliff" });
+    }
+  }
+  return { version: CACHE_VERSION, scannedAt: (/* @__PURE__ */ new Date()).toISOString(), files };
+}
+function usageCounts(cache2) {
+  return {
+    files: Object.keys(cache2.files).length,
+    refs: Object.values(cache2.files).reduce((n, f) => n + f.refs.length, 0)
+  };
+}
+function refreshLocationUsage(projectRoot, format) {
+  const det = detect(projectRoot, format);
+  if (!det) return null;
+  const parsed = getParser(det.format).parse(det.localeRoot, { locales: [det.sourceLocale] });
+  const cache2 = buildLocationUsageCache(parsed);
+  saveUsageCache(projectRoot, cache2);
+  return cache2;
+}
+
 // src/server/export-run.ts
 import { existsSync as existsSync12, readFileSync as readFileSync20, readdirSync as readdirSync13, rmdirSync, statSync as statSync7, unlinkSync } from "fs";
 import { dirname as dirname2, resolve as resolve7, sep } from "path";
@@ -6503,6 +6667,39 @@ function createApi(deps) {
     console.log(`[import] ${result.keyCount} key(s) across ${result.localeCount} locale(s)${result.warnings.length ? `, ${result.warnings.length} warning(s)` : ""}`);
     return c.json({ keyCount: result.keyCount, localeCount: result.localeCount, warnings: result.warnings });
   });
+  app.post("/sync", async (c) => {
+    if (Object.keys(load().keys).length === 0) {
+      return c.json({ error: "nothing to sync into; import first" }, 400);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    let result;
+    try {
+      result = runSync({
+        projectRoot,
+        statePath: deps.statePath,
+        format: body.format,
+        sourceLocale: body.sourceLocale,
+        locales: body.locales,
+        cldr: body.cldr,
+        prune: body.prune
+      });
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    if (body.apply !== true) {
+      return c.json({ plan: result.plan, warnings: result.warnings });
+    }
+    persist(result.state);
+    const usageCache = isLocationScannedState(result.state) ? refreshLocationUsage(projectRoot, body.format) : null;
+    const usageRefs = usageCache ? usageCounts(usageCache).refs : void 0;
+    const p = result.plan;
+    logChange({
+      kind: "import",
+      summary: `Synced: +${p.added.length} added, ~${p.sourceChanged.length} changed, -${p.removed.length} removed${body.prune ? " (pruned)" : ""}`
+    });
+    console.log(`[sync] +${p.added.length} ~${p.sourceChanged.length} -${p.removed.length}${body.prune ? " pruned" : ""}`);
+    return c.json({ applied: true, plan: result.plan, warnings: result.warnings, usageRefs });
+  });
   app.post("/export", (c) => {
     const root = dirname3(resolve9(deps.statePath));
     const { written, skipped, deleted, warnings } = exportToDisk(load(), root);
@@ -6766,12 +6963,11 @@ function createApi(deps) {
   app.get("/log", (c) => c.json(readLog(projectRoot, 100)));
   app.post("/scan", async (c) => {
     const s = load();
-    const existing = loadUsageCache(projectRoot);
-    const result = runScan(projectRoot, s.config.scan ?? {}, existing);
-    const fileCount2 = Object.keys(result.files).length;
-    const refCount = Object.values(result.files).reduce((n, f) => n + f.refs.length, 0);
-    console.log(`[scan] ${fileCount2} file(s), ${refCount} reference(s)`);
-    return c.json({ files: fileCount2, refs: refCount, scannedAt: result.scannedAt });
+    const result = isLocationScannedState(s) ? refreshLocationUsage(projectRoot) : runScan(projectRoot, s.config.scan ?? {}, loadUsageCache(projectRoot));
+    if (!result) return c.json({ files: 0, refs: 0, scannedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    const { files, refs } = usageCounts(result);
+    console.log(`[scan] ${files} file(s), ${refs} reference(s)`);
+    return c.json({ files, refs, scannedAt: result.scannedAt });
   });
   app.get("/scan", (c) => {
     const cache2 = loadUsageCache(projectRoot);
@@ -7118,11 +7314,16 @@ function backgroundScan(statePath) {
   const projectRoot = dirname4(resolve10(statePath));
   Promise.resolve().then(() => {
     const state = loadState(statePath);
+    if (isLocationScannedState(state)) {
+      const cache2 = refreshLocationUsage(projectRoot);
+      const { files: files2, refs: refs2 } = cache2 ? usageCounts(cache2) : { files: 0, refs: 0 };
+      console.log(`[scan] ${files2} file(s), ${refs2} reference(s) (from catalog locations)`);
+      return;
+    }
     const existing = loadUsageCache(projectRoot);
     const result = runScan(projectRoot, state.config.scan ?? {}, existing);
-    const fileCount2 = Object.keys(result.files).length;
-    const refCount = Object.values(result.files).reduce((n, f) => n + f.refs.length, 0);
-    console.log(`[scan] ${fileCount2} file(s), ${refCount} reference(s)`);
+    const { files, refs } = usageCounts(result);
+    console.log(`[scan] ${files} file(s), ${refs} reference(s)`);
   }).catch((err) => {
     console.warn("[scan] failed:", err instanceof Error ? err.message : String(err));
   });