@matteoaliano/forest-ui 1.2.0 → 1.2.2

package/bin/dense.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// Dense mode for skill reference docs.
+//
+// ONE transform, lossless: strip the repeated "Import" column from every
+// GFM table. The import path `@matteoaliano/forest-ui` is invariant and
+// stated once at the top of the file, so `import { X } from "..."` on every
+// row is pure redundancy. Names that AREN'T derivable from the component
+// name (family members like TableHead/TableBody, type exports like
+// AppShellNavItem) are folded into the Component cell so nothing is lost.
+//
+// Files with no Import column pass through byte-identical (never inflated).
+//
+// Used as a library by sync.mjs (densifies the shipped plugin/dogfood copies)
+// and as a CLI for inspection:
+//   node bin/dense.mjs <file.md>            # print dense version to stdout
+//   node bin/dense.mjs <file.md> --write    # write references/dense/<file>.md
+//   node bin/dense.mjs <file.md> --stats    # print savings to stderr
+//   node bin/dense.mjs <file.md> --check    # assert nothing was lost
+
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Split a GFM table row on unescaped pipes (unions use `\|` as a literal pipe).
+const cells = (line) =>
+  line
+    .trim()
+    .replace(/^\||\|$/g, "")
+    .split(/(?<!\\)\|/)
+    .map((c) => c.trim());
+
+const bareNames = (str) =>
+  [...str.matchAll(/`([^`]+)`/g)].map((m) => m[1].replace(/^type\s+/, ""));
+
+export function densify(src) {
+  let didStrip = false;
+
+  const transformTable = (block) => {
+    const rows = block.map(cells);
+    const importCol = rows[0].findIndex((h) => h === "Import");
+    if (importCol === -1) return block; // no Import column → untouched
+    didStrip = true;
+
+    const nameCol = 0; // Component/Hook name is always the first column
+    const out = rows.map((cols, i) => {
+      if (i > 1) {
+        const importNames = (cols[importCol].match(/import\s*\{([^}]*)\}/)?.[1] ?? "")
+          .split(",")
+          .map((n) => n.trim())
+          .filter(Boolean);
+        const shown = new Set(bareNames(cols[nameCol]));
+        const extras = importNames.filter((n) => !shown.has(n.replace(/^type\s+/, "")));
+        if (extras.length) cols[nameCol] += ` — also: ${extras.join(", ")}`;
+      }
+      return cols.filter((_, c) => c !== importCol);
+    });
+    return out.map((cols) => `| ${cols.join(" | ")} |`);
+  };
+
+  // Walk the file, transforming each contiguous table block in place.
+  const result = [];
+  let table = [];
+  const flush = () => {
+    if (table.length) result.push(...transformTable(table));
+    table = [];
+  };
+  for (const line of src.split("\n")) {
+    if (line.trim().startsWith("|")) table.push(line);
+    else {
+      flush();
+      result.push(line);
+    }
+  }
+  flush();
+
+  // Insert the invariant note once, right after the H1 — only when we stripped
+  // something, so files with no Import column stay byte-identical.
+  const h1 = result.findIndex((l) => l.startsWith("# "));
+  if (didStrip && h1 !== -1) {
+    result.splice(
+      h1 + 1,
+      0,
+      "",
+      "> **Dense.** Import column dropped — every name imports from `@matteoaliano/forest-ui`. `— also:` lists extra names/types that import alongside.",
+    );
+  }
+
+  return result.join("\n");
+}
+
+// ── CLI ──
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const [file, ...flags] = process.argv.slice(2);
+  if (!file) {
+    console.error("usage: node bin/dense.mjs <file.md> [--write|--stats|--check]");
+    process.exit(1);
+  }
+  const src = readFileSync(file, "utf8");
+  const dense = densify(src);
+
+  if (flags.includes("--check")) {
+    const imported = [...src.matchAll(/import\s*\{([^}]*)\}/g)]
+      .flatMap((m) => m[1].split(","))
+      .map((n) => n.trim().replace(/^type\s+/, ""))
+      .filter(Boolean);
+    const lost = imported.filter((n) => !dense.includes(n));
+    if (lost.length) {
+      console.error(`FAIL: names lost in dense output: ${lost.join(", ")}`);
+      process.exit(1);
+    }
+    console.error(`ok: all ${imported.length} imported names preserved`);
+  } else if (flags.includes("--stats")) {
+    const est = (s) => Math.round(s.length / 4);
+    const pct = (1 - dense.length / src.length) * 100;
+    console.error(
+      `${basename(file)}: ${src.length} → ${dense.length} chars ` +
+        `(~${est(src)} → ~${est(dense)} tokens, -${pct.toFixed(0)}%)`,
+    );
+  } else if (flags.includes("--write")) {
+    const dir = join(dirname(file), "dense");
+    mkdirSync(dir, { recursive: true });
+    const dest = join(dir, basename(file));
+    writeFileSync(dest, dense);
+    console.error(`wrote ${dest}`);
+  } else {
+    process.stdout.write(dense);
+  }
+}

package/bin/sync.mjs

@@ -14,6 +14,7 @@
 import { mkdirSync, readdirSync, cpSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { densify } from "./dense.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const skillsDir = resolve(__dirname, "..", "skills");
@@ -47,13 +48,26 @@ const skillFolders = readdirSync(skillsDir, { withFileTypes: true })
   .filter((d) => d.isDirectory())
   .map((d) => d.name);
 
+// Densify every .md in the shipped copies. Sources under skills/ stay full
+// and human-readable; consumers transparently get the token-efficient form
+// (same filenames, so SKILL.md links are unchanged). No-op on files without
+// an Import column, so it never inflates anything.
+const densifyTree = (dir) => {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = resolve(dir, entry.name);
+    if (entry.isDirectory()) densifyTree(p);
+    else if (entry.name.endsWith(".md")) writeFileSync(p, densify(readFileSync(p, "utf-8")));
+  }
+};
+
 let synced = 0;
 for (const target of targets) {
   for (const folder of skillFolders) {
     const dest = resolve(target, folder);
     mkdirSync(dest, { recursive: true });
     cpSync(resolve(skillsDir, folder), dest, { recursive: true });
-    console.log(`   ✅ ${dest.replace(repoRoot + "/", "")}/`);
+    densifyTree(dest);
+    console.log(`   ✅ ${dest.replace(repoRoot + "/", "")}/ (dense)`);
     synced++;
   }
 }

package/dist/{chunk-VIQ5IYUZ.mjs → chunk-4PNVZETQ.mjs}

@@ -447,6 +447,20 @@ function buildComponents(tokens2) {
                 borderTopRightRadius: radius4.md,
                 opacity: 0.75
               },
+              // Unified disabled treatment across the button family (Button,
+              // IconButton, Fab, ButtonGroup, ToggleButton): transparent face,
+              // disabled border, disabled text — matching the outlined
+              // IconButton reference. Contained's fill is dropped and the bevel
+              // geometry re-asserted (MUI's outlined disabled `border: 1px`
+              // shorthand would otherwise flatten it).
+              "&.Mui-disabled": {
+                backgroundColor: "transparent",
+                borderColor: border4.disabled,
+                borderTopWidth: 1,
+                borderRightWidth: 1,
+                borderLeftWidth: 1,
+                borderBottomWidth: 4
+              },
               "@media (prefers-reduced-motion: reduce)": {
                 transition: "none",
                 "&::before": { display: "none" }
@@ -488,6 +502,13 @@ function buildComponents(tokens2) {
           "&.MuiButtonGroup-contained .MuiButtonGroup-grouped:not(.Mui-disabled)": {
             borderColor: fg4.tertiary
           },
+          // Disabled grouped children: MUI's per-position grouped-contained
+          // border wins over the child Button's own .Mui-disabled rule on the
+          // first/middle buttons — pin the unified disabled border here so the
+          // whole group matches the standalone disabled Button.
+          "&.MuiButtonGroup-contained .MuiButtonGroup-grouped.Mui-disabled": {
+            borderColor: border4.disabled
+          },
           // outlined group → the outlined-Button look (outlinedFill), including
           // its lightened hover sweep (the forced-contained children would
           // otherwise sweep at full currentColor strength).
@@ -552,6 +573,13 @@ function buildComponents(tokens2) {
           },
           "&.ForestIconButton": {
             ...bevel3D,
+            // Square 32×32 with border-box so the faux-3D bevel (1px top + 4px
+            // bottom, 1px left/right) is absorbed rather than added on top —
+            // otherwise it rendered a 37×34 control instead of matching the
+            // standalone Button's 32px height.
+            height: 32,
+            width: 32,
+            boxSizing: "border-box",
             boxShadow: tokenShadows.xs,
             "&:focus-visible": {
               boxShadow: focusRings4.brandShadowXs
@@ -589,15 +617,13 @@ function buildComponents(tokens2) {
               filter: "brightness(0.97)"
             }
           },
-          // Disabled parity with the Button variants: MUI IconButton's own
-          // .Mui-disabled (transparent bg + action.disabled icon) ties with the
-          // variant faces at (0,2,0) and loses on insertion order — pin the
-          // disabled treatment one class higher.
-          "&.ForestIconButton-contained.Mui-disabled": {
-            backgroundColor: (theme.vars || theme).palette.action.disabledBackground,
-            color: (theme.vars || theme).palette.action.disabled
-          },
-          "&.ForestIconButton-outlined.Mui-disabled": {
+          // Unified disabled treatment for both variants: transparent face,
+          // disabled border, disabled icon — bevel geometry retained. This is
+          // the reference the rest of the button family matches. The two-class
+          // selector out-specifies the single-class variant faces so contained's
+          // fill is dropped.
+          "&.ForestIconButton.Mui-disabled": {
+            backgroundColor: "transparent",
             color: (theme.vars || theme).palette.action.disabled,
             borderColor: border4.disabled
           }
@@ -664,6 +690,13 @@ function buildComponents(tokens2) {
           "&:focus-visible": {
             boxShadow: focusRings4.brandShadowSm
           },
+          // Same unified disabled treatment as Button/IconButton: drop the
+          // contained fill for a transparent, disabled-bordered face.
+          "&.Mui-disabled": {
+            backgroundColor: "transparent",
+            borderColor: border4.disabled,
+            color: (theme.vars || theme).palette.action.disabled
+          },
           "@media (prefers-reduced-motion: reduce)": {
             transition: "none",
             "&::before": { display: "none" }
@@ -1059,16 +1092,16 @@ function buildComponents(tokens2) {
               borderTopRightRadius: radius4.md
             }
           },
-          // Disabled parity with the disabled contained Button: greyed face +
-          // disabled fg, bevel geometry retained. MUI's own .Mui-disabled rule
-          // only swaps color and border-shorthands the bevel away — and ties
-          // with .Mui-selected at (0,2,0) — so this block sits AFTER selected
-          // to win both.
+          // Disabled parity with the rest of the button family: transparent
+          // face, disabled border + fg, bevel geometry retained. MUI's own
+          // .Mui-disabled rule only swaps color and border-shorthands the bevel
+          // away — and ties with .Mui-selected at (0,2,0) — so this block sits
+          // AFTER selected to win both.
           "&.Mui-disabled": {
-            backgroundColor: (theme.vars || theme).palette.action.disabledBackground,
+            backgroundColor: "transparent",
             color: (theme.vars || theme).palette.action.disabled,
             borderStyle: "solid",
-            borderColor: fg4.tertiary,
+            borderColor: border4.disabled,
             borderTopWidth: 1,
             borderRightWidth: 1,
             borderLeftWidth: 1,
@@ -3988,4 +4021,4 @@ export {
   forestTheme,
   forestThemeOptions
 };
-//# sourceMappingURL=chunk-VIQ5IYUZ.mjs.map
+//# sourceMappingURL=chunk-4PNVZETQ.mjs.map