bin/capsomer.mjs

Functions

Imports

It imports bin/states.mjs. No module of this repo imports it.

Source

1#!/usr/bin/env node
2// Capsomer's command line. In the capsomer repo it prepares the site's data and reports
3// the package's sizes; in an app that installed Capsomer it writes the adoption report and
4// checks the app's CSS against the tokens.
5//
6//   capsomer report [--out capsomer-report.json] [--a11y <playwright json>] [--app <name>]
7//   capsomer token-check [paths...]        warns, always exits 0 (rulings.md, rule 1)
8//   capsomer size [--dist <dir>]           reports and warns, always exits 0 (decision 12)
9//   capsomer states                        writes components/<name>/states.html from examples.html (capsomer repo only)
10//   capsomer site-data                     the site's data files (capsomer repo only)
11import { execFileSync } from "node:child_process";
12import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
13import { basename, dirname, extname, join, relative, resolve } from "node:path";
14import { fileURLToPath, pathToFileURL } from "node:url";
15import { gzipSync } from "node:zlib";
16import { generateStates } from "./states.mjs";
17
18const PKG = resolve(dirname(fileURLToPath(import.meta.url)), "..");
19const args = process.argv.slice(2);
20const cmd = args[0];
21const flag = (name, fallback) => {
22  const i = args.indexOf(`--${name}`);
23  return i >= 0 && args[i + 1] && !args[i + 1].startsWith("--") ? args[i + 1] : fallback;
24};
25const KB = 1024;
26const kb = (n) => `${(n / KB).toFixed(1)} KB`;
27const gz = (buf) => gzipSync(buf, { level: 9 }).length;
28const readJson = (p) => JSON.parse(readFileSync(p, "utf8").replace(/^\uFEFF/, ""));
29
30// ---- shared ------------------------------------------------------------------------------
31
32const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "site-dist", "test-results", "playwright-report", ".wrangler", ".react-router", "coverage"]);
33
34function walk(dir, exts, out = []) {
35  let entries = [];
36  try {
37    entries = readdirSync(dir, { withFileTypes: true });
38  } catch {
39    return out;
40  }
41  for (const e of entries) {
42    if (e.name.startsWith(".") && e.name !== ".") continue;
43    const p = join(dir, e.name);
44    if (e.isDirectory()) {
45      if (!SKIP_DIRS.has(e.name)) walk(p, exts, out);
46    } else if (exts.includes(extname(e.name))) out.push(p);
47  }
48  return out;
49}
50
51// The doc pages' frontmatter: name, parts, tool, states, added, replaces.
52function frontmatter(src) {
53  const m = src.replace(/\r\n/g, "\n").match(/^---\n([\s\S]*?)\n---/);
54  const data = {};
55  if (!m) return data;
56  let key = "";
57  for (const raw of m[1].split("\n")) {
58    const item = raw.match(/^\s+-\s+(.*)$/);
59    if (item && key) {
60      (data[key] = Array.isArray(data[key]) ? data[key] : []).push(item[1].replace(/^(['"])(.*)\1$/, "$2"));
61      continue;
62    }
63    const kv = raw.match(/^([\w-]+):\s*(.*)$/);
64    if (!kv) continue;
65    key = kv[1];
66    const v = kv[2].trim();
67    data[key] = v.startsWith("[") ? v.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean) : v === "" ? [] : v.replace(/^(['"])(.*)\1$/, "$2");
68  }
69  return data;
70}
71
72function components(root) {
73  const dir = join(root, "components");
74  if (!existsSync(dir)) return [];
75  return readdirSync(dir, { withFileTypes: true })
76    .filter((d) => d.isDirectory() && existsSync(join(dir, d.name, `${d.name}.md`)))
77    .map((d) => {
78      const css = join(dir, d.name, `${d.name}.css`);
79      // The component's root class is the first cap- class its CSS styles.
80      const rootClass = existsSync(css) ? (readFileSync(css, "utf8").match(/\.(cap-[\w-]+)/)?.[1] ?? null) : null;
81      return { name: d.name, dir: join(dir, d.name), rootClass, ...frontmatter(readFileSync(join(dir, d.name, `${d.name}.md`), "utf8")) };
82    });
83}
84
85function git(argsList, cwd) {
86  try {
87    return execFileSync("git", argsList, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
88  } catch {
89    return null;
90  }
91}
92
93// ---- token-check -------------------------------------------------------------------------
94
95function lightTokens() {
96  const css = readFileSync(join(PKG, "tokens", "colour.css"), "utf8");
97  const root = css.slice(css.indexOf(":root {"), css.indexOf("}"));
98  return [...root.matchAll(/--([\w-]+):\s*(#[0-9a-f]{6})/gi)].map((m) => ({ name: m[1], hex: m[2].toLowerCase() }));
99}
100
101const SPACES = [2, 4, 8, 12, 16, 24, 32, 48, 64];
102const hexRgb = (h) => {
103  const s = h.length === 4 ? h.replace(/^#(.)(.)(.)$/, "#$1$1$2$2$3$3") : h;
104  return [1, 3, 5].map((i) => parseInt(s.slice(i, i + 2), 16));
105};
106const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
107
108// Raw colours and off-scale spacing in an app's CSS, each with the nearest token. Generated
109// files and Capsomer's own token files are skipped.
110export function tokenCheck(root, paths) {
111  const tokens = lightTokens();
112  const files = (paths.length ? paths.flatMap((p) => (statSync(p).isDirectory() ? walk(p, [".css"]) : [p])) : walk(root, [".css"])).filter(
113    (f) => !/[\\/](tokens|site-dist)[\\/]/.test(f) && !/capsomer[\\/]tokens/.test(f),
114  );
115  const items = [];
116  for (const file of files) {
117    const lines = readFileSync(file, "utf8").split(/\r?\n/);
118    lines.forEach((line, i) => {
119      const code = line.replace(/\/\*.*?\*\//g, "");
120      if (/^\s*--[\w-]+\s*:/.test(code)) return; // defining a token is the fix, not the fault
121      for (const m of code.matchAll(/#[0-9a-f]{6}\b|#[0-9a-f]{3}\b/gi)) {
122        const rgb = hexRgb(m[0].toLowerCase());
123        const near = tokens.reduce((a, t) => (dist(hexRgb(t.hex), rgb) < dist(hexRgb(a.hex), rgb) ? t : a));
124        items.push({ file: relative(root, file).replace(/\\/g, "/"), line: i + 1, text: m[0], kind: "colour", suggestion: `var(--${near.name})` });
125      }
126      for (const m of code.matchAll(/\b(?:margin|padding|gap|row-gap|column-gap|inset|top|left|right|bottom)[\w-]*\s*:\s*([^;]+)/g)) {
127        for (const px of m[1].matchAll(/(?<![\w.-])(\d+(?:\.\d+)?)px\b/g)) {
128          const n = Number(px[1]);
129          if (n === 0 || n === 1 || SPACES.includes(n)) continue;
130          const near = SPACES.reduce((a, s) => (Math.abs(s - n) < Math.abs(a - n) ? s : a));
131          items.push({ file: relative(root, file).replace(/\\/g, "/"), line: i + 1, text: `${n}px`, kind: "space", suggestion: `var(--space-${SPACES.indexOf(near) + 1}) (${near}px)` });
132        }
133      }
134    });
135  }
136  return { count: items.length, items };
137}
138
139// ---- report --------------------------------------------------------------------------------
140
141function installedVersion(root) {
142  const lock = join(root, "package-lock.json");
143  if (existsSync(lock)) {
144    const pkgs = readJson(lock).packages ?? {};
145    const entry = pkgs["node_modules/capsomer"];
146    if (entry) return { version: entry.version ?? null, resolved: entry.resolved ?? null };
147  }
148  const pnpm = join(root, "pnpm-lock.yaml");
149  if (existsSync(pnpm)) {
150    const m = readFileSync(pnpm, "utf8").match(/capsomer@[^\s:]*?#?(v?\d+\.\d+\.\d+)/);
151    if (m) return { version: m[1].replace(/^v/, ""), resolved: "pnpm-lock.yaml" };
152  }
153  const pj = join(root, "node_modules", "capsomer", "package.json");
154  if (existsSync(pj)) return { version: readJson(pj).version, resolved: null };
155  return { version: null, resolved: null };
156}
157
158function a11yFrom(reportPath) {
159  if (!reportPath || !existsSync(reportPath)) return { passed: null, failed: null, source: null, note: "No Playwright report given (--a11y <path>)." };
160  const r = readJson(reportPath);
161  let passed = 0;
162  let failed = 0;
163  const visit = (s) => {
164    for (const spec of s.specs ?? []) {
165      if (!/accessib|axe|contrast/i.test(spec.title)) continue;
166      for (const t of spec.tests ?? []) (t.status === "expected" || t.status === "flaky" ? passed++ : t.status === "skipped" ? 0 : failed++);
167    }
168    for (const c of s.suites ?? []) visit(c);
169  };
170  for (const s of r.suites ?? []) visit(s);
171  return { passed, failed, source: relative(process.cwd(), reportPath).replace(/\\/g, "/") };
172}
173
174export function report(root) {
175  const lib = existsSync(join(root, "node_modules", "capsomer")) ? join(root, "node_modules", "capsomer") : PKG;
176  const catalogue = components(lib);
177  const files = walk(root, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".css", ".html", ".astro"]).filter((f) => !f.includes(`${join("node_modules", "capsomer")}`));
178  const used = new Set();
179  const own = [];
180  let keep = [];
181  try {
182    keep = JSON.parse(readFileSync(join(root, "capsomer.keep.json"), "utf8"));
183  } catch {
184    keep = [];
185  }
186  const kept = (component, file) => keep.find((k) => k.component === component && (k.file === file || (k.file.endsWith("/") && file.startsWith(k.file))));
187  const keptHits = [];
188  for (const file of files) {
189    const rel = relative(root, file).replace(/\\/g, "/");
190    const text = readFileSync(file, "utf8");
191    for (const m of text.matchAll(/capsomer\/(?:react\/|behaviour\/)?([\w-]+)(?:\.css)?/g)) if (catalogue.some((c) => c.name === m[1])) used.add(m[1]);
192    for (const c of catalogue) {
193      if (c.rootClass && new RegExp(`\\b${c.rootClass}\\b`).test(text)) used.add(c.name);
194      for (const signal of [].concat(c.replaces ?? [])) {
195        let re;
196        try {
197          re = new RegExp(signal);
198        } catch {
199          continue;
200        }
201        const lines = text.split(/\r?\n/);
202        const at = lines.findIndex((l) => re.test(l));
203        if (at < 0) continue;
204        const k = kept(c.name, rel);
205        if (k) keptHits.push({ component: c.name, file: rel, reason: k.reason });
206        else own.push({ component: c.name, file: rel, line: at + 1 });
207        break;
208      }
209    }
210  }
211  const tc = tokenCheck(root, []);
212  const name = flag("app", (() => {
213    try {
214      return JSON.parse(readFileSync(join(root, "package.json"), "utf8")).name;
215    } catch {
216      return basename(root);
217    }
218  })());
219  return {
220    schema: 1,
221    app: name,
222    commit: git(["rev-parse", "HEAD"], root),
223    generated: new Date().toISOString(),
224    capsomer: installedVersion(root),
225    components: { count: used.size, names: [...used].sort() },
226    ownCopies: { count: own.length, items: own },
227    kept: keptHits,
228    tokenWarnings: { count: tc.count, items: tc.items.slice(0, 500) },
229    accessibility: a11yFrom(flag("a11y")),
230  };
231}
232
233// ---- size ----------------------------------------------------------------------------------
234
235const BUDGET = { base: 3 * KB, css: 15 * KB, behaviour: 10 * KB };
236
237async function size() {
238  const rows = [];
239  const warn = [];
240  const distDir = flag("dist");
241  if (distDir) {
242    // In an app: the CSS the build ships that carries Capsomer's classes or layers.
243    const css = walk(resolve(distDir), [".css"]);
244    let total = 0;
245    for (const f of css) {
246      const buf = readFileSync(f);
247      if (!/cap-|@layer cap/.test(buf.toString("utf8"))) continue;
248      total += gz(buf);
249      rows.push(["app css", relative(distDir, f), gz(buf)]);
250    }
251    rows.push(["app css", "TOTAL with Capsomer", total]);
252    if (total > BUDGET.css * 2) warn.push(`CSS carrying Capsomer is ${kb(total)} gzip; Capsomer's own share should stay near ${kb(BUDGET.css)}.`);
253  } else {
254    const read = (...p) => readFileSync(join(PKG, ...p));
255    const base = gz(Buffer.concat([read("css", "layers.css"), read("tokens", "colour.css"), read("tokens", "scale.css"), read("css", "base.css")]));
256    rows.push(["base", "layers, tokens, base", base]);
257    if (base > BUDGET.base) warn.push(`Tokens, layers and base are ${kb(base)} gzip, over ${kb(BUDGET.base)}.`);
258    let all = base;
259    for (const c of components(PKG)) {
260      const f = join(c.dir, `${c.name}.css`);
261      if (!existsSync(f)) continue;
262      const n = gz(readFileSync(f));
263      all += n;
264      rows.push(["css", c.name, n]);
265    }
266    rows.push(["css", "TOTAL, every component", all]);
267    if (all > BUDGET.css) warn.push(`All Capsomer CSS is ${kb(all)} gzip, over ${kb(BUDGET.css)}.`);
268    let js = 0;
269    for (const c of components(PKG)) {
270      const f = join(PKG, "dist", "components", c.name, `${c.name}.js`);
271      if (!existsSync(f)) continue;
272      const n = gz(readFileSync(f));
273      js += n;
274      rows.push(["behaviour", c.name, n]);
275    }
276    rows.push(["behaviour", existsSync(join(PKG, "dist")) ? "TOTAL, every module" : "TOTAL (run npm run build first)", js]);
277    if (js > BUDGET.behaviour) warn.push(`Every behaviour module together is ${kb(js)} gzip, over ${kb(BUDGET.behaviour)}; a page loads only the ones it uses.`);
278    for (const [name, n] of await baseUiSizes()) rows.push(["base ui", name, n]);
279  }
280  const w = Math.max(...rows.map((r) => r[1].length), 10);
281  console.log(`${"kind".padEnd(10)}  ${"part".padEnd(w)}  ${"gzip".padStart(9)}`);
282  for (const r of rows) console.log(`${r[0].padEnd(10)}  ${r[1].padEnd(w)}  ${kb(r[2]).padStart(9)}`);
283  for (const m of warn) console.warn(`size: warning: ${m}`);
284  console.log(warn.length ? `size: ${warn.length} warning(s); size never fails a build` : "size: within every budget");
285  if (flag("json")) writeFileSync(flag("json"), JSON.stringify({ rows: rows.map(([kind, part, gzip]) => ({ kind, part, gzip })), warnings: warn }, null, 2));
286  if (!distDir) writeComponentSizes();
287}
288
289// Each component's gzipped CSS and JS in test-results/size.json. Information only: it never
290// warns and never fails. JS is the built module in dist when there is one, else the source.
291function writeComponentSizes() {
292  const out = {};
293  for (const c of components(PKG)) {
294    const css = join(c.dir, `${c.name}.css`);
295    const built = join(PKG, "dist", "components", c.name, `${c.name}.js`);
296    const src = join(c.dir, `${c.name}.ts`);
297    const js = existsSync(built) ? built : existsSync(src) ? src : null;
298    const entry = { css: existsSync(css) ? gz(readFileSync(css)) : 0, js: js ? gz(readFileSync(js)) : 0, jsFrom: js ? (js === built ? "dist" : "source") : null };
299    out[c.name] = { ...entry, total: entry.css + entry.js };
300  }
301  mkdirSync(join(PKG, "test-results"), { recursive: true });
302  writeFileSync(join(PKG, "test-results", "size.json"), JSON.stringify({ unit: "bytes, gzip level 9", components: out }, null, 2));
303  console.log("size: wrote test-results/size.json (per component, information only)");
304}
305
306// Each Base UI-backed wrapper bundled on its own with React left out, as an app would ship
307// it: the honest per-component cost Base UI does not publish.
308async function baseUiSizes() {
309  const wrappers = components(PKG).filter((c) => /base ui/i.test(String(c.tool ?? "")) && existsSync(join(c.dir, `${c.name}.react.tsx`)));
310  if (!wrappers.length) return [];
311  let build;
312  try {
313    ({ build } = await import("vite"));
314  } catch {
315    return [["(vite not installed)", 0]];
316  }
317  const out = [];
318  for (const c of wrappers) {
319    const outDir = join(PKG, "test-results", "size", c.name);
320    await build({
321      logLevel: "silent",
322      configFile: false,
323      build: {
324        outDir,
325        emptyOutDir: true,
326        lib: { entry: join(c.dir, `${c.name}.react.tsx`), formats: ["es"], fileName: "bundle" },
327        rollupOptions: { external: ["react", "react-dom", "react/jsx-runtime", "react-dom/client"] },
328        minify: true,
329      },
330    });
331    const f = walk(outDir, [".js"])[0];
332    out.push([`${c.name} (Base UI parts, React excluded)`, f ? gz(readFileSync(f)) : 0]);
333  }
334  return out;
335}
336
337// ---- site-data -----------------------------------------------------------------------------
338
339async function siteData() {
340  const dataDir = join(PKG, "site", "data");
341  mkdirSync(dataDir, { recursive: true });
342  const pal = await import(pathToFileURL(join(PKG, "tokens", "palette.mjs")).href);
343  // The committed colours (the purple family), and every family's pairs for the contrast report.
344  writeFileSync(join(dataDir, "palette.json"), JSON.stringify(pal.themes(pal.FAMILIES.purple), null, 2));
345  const scales = Object.fromEntries(Object.entries(pal.FAMILIES).map(([n, f]) => [n, { light: pal.scale(f.seed, f.anchor, "light"), dark: pal.scale(f.seed, f.anchor, "dark") }]));
346  writeFileSync(join(dataDir, "families.json"), JSON.stringify({ families: pal.FAMILIES, pairs: pal.report(), scales }, null, 2));
347  const pj = JSON.parse(readFileSync(join(PKG, "package.json"), "utf8"));
348  const runUrl = process.env.GITHUB_RUN_ID ? `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}` : null;
349  writeFileSync(join(dataDir, "meta.json"), JSON.stringify({ version: pj.version, commit: git(["rev-parse", "--short", "HEAD"], PKG), branch: git(["branch", "--show-current"], PKG), built: new Date().toISOString(), runUrl }, null, 2));
350
351  const src = join(PKG, "test-results", "results.json");
352  const results = { available: false, ran: null, components: {}, totals: { passed: 0, failed: 0, skipped: 0 } };
353  if (existsSync(src)) {
354    const r = readJson(src);
355    results.available = true;
356    results.ran = r.stats?.startTime ?? null;
357    const visit = (suite, file, theme) => {
358      const f = suite.file ?? file;
359      const th = /^(light|dark) theme$/.exec(suite.title ?? "")?.[1] ?? theme;
360      for (const spec of suite.specs ?? []) {
361        const m = /^components\/([\w-]+)\//.exec((f ?? "").replace(/\\/g, "/")) ?? /^site\//.exec((f ?? "").replace(/\\/g, "/"));
362        const comp = m?.[1] ?? "site";
363        const kind = /^(keyboard|accessibility|behaviour):/.exec(spec.title)?.[1] ?? "behaviour";
364        for (const t of spec.tests ?? []) {
365          const status = t.status === "expected" || t.status === "flaky" ? "passed" : t.status === "skipped" ? "skipped" : "failed";
366          const err = t.results?.at(-1)?.error?.message?.replace(/\u001b\[[0-9;]*m/g, "").split("\n").slice(0, 6).join("\n") ?? null;
367          const entry = (results.components[comp] ??= { keyboard: { passed: 0, failed: 0 }, accessibility: { passed: 0, failed: 0 }, behaviour: { passed: 0, failed: 0 }, tests: [] });
368          if (status !== "skipped") entry[kind][status]++;
369          results.totals[status]++;
370          entry.tests.push({ title: spec.title, theme: th ?? null, kind, status, error: status === "failed" ? err : null });
371        }
372      }
373      for (const s of suite.suites ?? []) visit(s, f, th);
374    };
375    for (const s of r.suites ?? []) visit(s, s.file, null);
376  }
377  writeFileSync(join(dataDir, "results.json"), JSON.stringify(results, null, 2));
378  const resultsOut = flag("results-out");
379  if (resultsOut) writeFileSync(resultsOut, JSON.stringify({ ...results, commit: git(["rev-parse", "--short", "HEAD"], PKG), runUrl }, null, 2));
380  console.log(`site-data: wrote site/data (palette, meta, results${results.available ? `: ${results.totals.passed} passed, ${results.totals.failed} failed` : ": no test run found"})`);
381}
382
383// ---- weight and loc (the no-bloat baseline) ------------------------------------------------
384
385// JavaScript and CSS weight per route: for every .html page in a built site, the gzip size of
386// the scripts and stylesheets it loads (script src, stylesheet link, modulepreload). Fonts and
387// images are counted apart, raw. Reports only; it never fails a build.
388function weight(root) {
389  const dist = resolve(root, flag("dist", "site-dist"));
390  if (!existsSync(dist)) {
391    console.error(`weight: no ${relative(root, dist)}; run npm run site first`);
392    return { routes: [], error: "no build" };
393  }
394  const pages = walk(dist, [".html"]);
395  const routes = [];
396  for (const page of pages) {
397    const html = readFileSync(page, "utf8");
398    const refs = new Set();
399    for (const m of html.matchAll(/<(?:script|link)\b[^>]*?(?:src|href)="([^"]+)"[^>]*>/g)) {
400      const tag = m[0];
401      if (/<script/.test(tag) || /rel="(?:stylesheet|modulepreload)"/.test(tag)) refs.add(m[1]);
402    }
403    let js = 0;
404    let css = 0;
405    const files = [];
406    for (const ref of refs) {
407      if (/^https?:/.test(ref)) continue;
408      const file = resolve(dist, ref.replace(/^\//, ""));
409      if (!existsSync(file)) continue;
410      const n = gz(readFileSync(file));
411      if (/\.css$/.test(file)) css += n;
412      else if (/\.m?js$/.test(file)) js += n;
413      else continue;
414      files.push(relative(dist, file).replace(/\\/g, "/"));
415    }
416    routes.push({ route: "/" + relative(dist, page).replace(/\\/g, "/"), js, css, total: js + css, files: files.length });
417  }
418  routes.sort((a, b) => b.total - a.total);
419  const fonts = walk(dist, [".woff2", ".woff"]).reduce((n, f) => n + statSync(f).size, 0);
420  return { routes, fontsRaw: fonts };
421}
422
423// Lines of code by language, over tracked files (so generated and vendored files are out).
424function loc(root) {
425  const files = (git(["ls-files"], root) ?? "").split("\n").filter(Boolean);
426  const lang = { ".ts": "TypeScript", ".tsx": "TypeScript (React)", ".mjs": "JavaScript", ".js": "JavaScript", ".css": "CSS", ".html": "HTML", ".md": "Markdown", ".json": "JSON", ".yml": "YAML", ".jsonc": "JSON" };
427  const out = {};
428  for (const f of files) {
429    if (/(^|\/)(package-lock\.json|tokens\/(colour|scale|themes)\.css|tokens\/tokens\.json)$/.test(f)) continue;
430    const l = lang[extname(f)];
431    if (!l) continue;
432    const text = readFileSync(join(root, f), "utf8");
433    const row = (out[l] ??= { files: 0, lines: 0 });
434    row.files++;
435    row.lines += text.split("\n").length;
436  }
437  return out;
438}
439
440function deps(root) {
441  const p = readJson(join(root, "package.json"));
442  const lock = existsSync(join(root, "package-lock.json")) ? readJson(join(root, "package-lock.json")) : null;
443  return {
444    dependencies: Object.keys(p.dependencies ?? {}).length,
445    devDependencies: Object.keys(p.devDependencies ?? {}).length,
446    peerDependencies: Object.keys(p.peerDependencies ?? {}).length,
447    installedPackages: lock ? Object.keys(lock.packages ?? {}).filter((k) => k.startsWith("node_modules/")).length : null,
448  };
449}
450// The no-bloat summary for a pull request: Knip's findings, jscpd's duplication and the page
451// weight, each against the baseline in no-bloat/baseline.json. Markdown on stdout, for the job
452// summary. Warn-only: it reports and always exits 0 (defaults, not laws).
453function bloat(root) {
454  const base = existsSync(resolve(root, "no-bloat/baseline.json")) ? readJson(resolve(root, "no-bloat/baseline.json")) : null;
455  const out = ["## No-bloat report (warn only)", ""];
456  const delta = (now, then, unit = "") => (then == null ? `${now}${unit}` : `${now}${unit} (baseline ${then}${unit}, ${now - then >= 0 ? "+" : ""}${Math.round((now - then) * 100) / 100}${unit})`);
457  const knipFile = flag("knip");
458  if (knipFile && existsSync(knipFile)) {
459    const j = readJson(knipFile);
460    const c = {};
461    for (const i of j.issues ?? []) for (const [k, v] of Object.entries(i)) if (Array.isArray(v) && v.length) c[k] = (c[k] ?? 0) + v.length;
462    const total = Object.values(c).reduce((n, x) => n + x, 0);
463    out.push(`**Knip** (public API as entry points): ${delta(total, base?.knip?.total)} findings`, `- ${Object.entries(c).map(([k, v]) => `${k} ${v}`).join(", ") || "none"}`, "");
464  } else out.push("**Knip:** no report found.", "");
465  const jf = flag("jscpd");
466  if (jf && existsSync(jf)) {
467    const t = readJson(jf).statistics.total;
468    out.push(`**jscpd:** ${delta(Math.round(t.percentage * 100) / 100, base?.jscpd?.percentage, "%")} duplicated lines, ${delta(t.clones, base?.jscpd?.clones)} clones over ${t.sources} files`, "");
469  } else out.push("**jscpd:** no report found.", "");
470  const w = weight(root);
471  if (w.routes?.length) {
472    const top = w.routes.slice(0, 5);
473    const bw = base?.weight?.largestRouteTotal;
474    out.push(`**Page weight (gzip JS + CSS):** largest route ${top[0].route} ${(top[0].total / KB).toFixed(1)} KB${bw ? ` (baseline ${(bw / KB).toFixed(1)} KB)` : ""}`, "", "| route | js | css | total |", "| --- | ---: | ---: | ---: |", ...top.map((r) => `| ${r.route} | ${(r.js / KB).toFixed(1)} KB | ${(r.css / KB).toFixed(1)} KB | ${(r.total / KB).toFixed(1)} KB |`), "");
475  }
476  const l = loc(root);
477  out.push(`**Lines:** ${delta(Object.values(l).reduce((n, r) => n + r.lines, 0), base?.loc?.total)} across ${Object.keys(l).length} languages`, "");
478  console.log(out.join("\n"));
479}
480// ---- main ----------------------------------------------------------------------------------
481
482if (cmd === "report") {
483  const out = flag("out", "capsomer-report.json");
484  const r = report(process.cwd());
485  writeFileSync(out, JSON.stringify(r, null, 2) + "\n");
486  console.log(`report: ${r.app} uses Capsomer ${r.capsomer.version ?? "(not installed)"}: ${r.components.count} components, ${r.ownCopies.count} own copies left, ${r.tokenWarnings.count} token warnings. Wrote ${out}.`);
487} else if (cmd === "token-check") {
488  const r = tokenCheck(process.cwd(), args.slice(1).filter((a) => !a.startsWith("--")));
489  for (const it of r.items.slice(0, 200)) console.warn(`${it.file}:${it.line}: ${it.kind} ${it.text}; nearest token ${it.suggestion}`);
490  console.log(r.count ? `token-check: ${r.count} warning(s). Warnings never fail a build; adding a token is the normal fix.` : "token-check: no raw colours or off-scale spacing found");
491} else if (cmd === "size") {
492  await size();
493} else if (cmd === "weight") {
494  const w = weight(process.cwd());
495  const k = (n) => `${(n / KB).toFixed(1)} KB`;
496  console.log(`${"route".padEnd(44)} ${"js".padStart(10)} ${"css".padStart(10)} ${"total".padStart(10)}`);
497  for (const r of w.routes) console.log(`${r.route.padEnd(44)} ${k(r.js).padStart(10)} ${k(r.css).padStart(10)} ${k(r.total).padStart(10)}`);
498  if (w.fontsRaw !== undefined) console.log(`fonts (raw, not budgeted): ${k(w.fontsRaw)}`);
499  if (flag("json")) writeFileSync(flag("json"), JSON.stringify(w, null, 2));
500  console.log("weight: reported, never a failure");
501} else if (cmd === "loc") {
502  const l = loc(process.cwd());
503  const total = Object.values(l).reduce((n, r) => n + r.lines, 0);
504  for (const [name, r] of Object.entries(l).sort((a, b) => b[1].lines - a[1].lines)) console.log(`${name.padEnd(22)} ${String(r.files).padStart(5)} files ${String(r.lines).padStart(8)} lines`);
505  console.log(`${"Total".padEnd(22)} ${"".padStart(11)} ${String(total).padStart(8)} lines`);
506  const d = deps(process.cwd());
507  console.log(`dependencies ${d.dependencies}, dev ${d.devDependencies}, peer ${d.peerDependencies}, installed packages in the lockfile ${d.installedPackages}`);
508  if (flag("json")) writeFileSync(flag("json"), JSON.stringify({ loc: l, total, deps: d }, null, 2));
509} else if (cmd === "bloat") {
510  bloat(process.cwd());
511} else if (cmd === "states") {
512  const written = generateStates(PKG);
513  console.log(`states: wrote ${written.length} states pages (components/<name>/states.html, generated, gitignored)`);
514} else if (cmd === "site-data") {
515  await siteData();
516} else {
517  console.log("usage: capsomer report | token-check [paths] | size [--dist dir] [--json out] | weight [--dist dir] [--json out] | loc [--json out] | bloat --knip f --jscpd f | states | site-data");
518  process.exit(cmd ? 1 : 0);
519}