@oxide/design-system 6.6.1 → 6.7.0-canary.e63e89e

package/README.md

@@ -20,10 +20,19 @@ Releases are managed via GitHub Actions workflows triggered from the Actions tab
   tag. Install it with `npm install @oxide/design-system@canary` to test changes before
   merging.
 
-## Syncing with Figma
+## Figma Plugins
+
+Figma plugins live in `plugins/`. Each is a standalone npm project with its own
+`package.json` and `node_modules` — `cd plugins/<name> && npm install && npm run build`
+(or use the `dual-grid:*` / `token-sync:*` scripts at the root). Load a built plugin in
+Figma via **Plugins → Development → Import plugin from manifest…**.
 
-The Token Sync Figma plugin reads the CSS files in `styles/` directly and compares them
-against Figma variables. Changes can be applied from the plugin UI.
+- `plugins/token-sync` — reads the CSS files in `styles/` and compares them against
+  Figma variables; changes can be applied from the plugin UI.
+- `plugins/dual-grid` — generates a synchronised column + cell grid, ASCII grid, and
+  type specimens on a frame.
+
+## Syncing with Figma
 
 To regenerate colour palettes, run `npm run color-gen:apply`. This updates the `--color-*`
 variables in `styles/main.css` and writes the accent override files.
@@ -72,7 +81,7 @@ This is type-checked, and will throw an error if the corresponding icon doesn't
 
 ## Usage
 
-This package provides two main entry points:
+This package provides three main entry points:
 
 ### UI Components (`@oxide/design-system/ui`)
 
@@ -117,3 +126,43 @@ content: [
   'node_modules/@oxide/design-system/components/**/*.{ts,tsx,jsx,js}',
 ],
 ```
+
+### Grid math (`@oxide/design-system/grid`)
+
+The maths behind the dual-grid Figma plugin: computes an ASCII cell grid aligned with a
+column grid, where margin, column and gutter widths are all whole multiples of the cell
+size. Pure TypeScript with no dependencies. See `plugins/dual-grid/README.md` for the
+derivation.
+
+`computeGrid` takes the layout column count, the frame size, and either pixel targets
+(`mode: 'auto'` — a solver finds the closest whole-cell fit) or explicit cell counts
+(`mode: 'manual'`):
+
+```ts
+import { computeGrid, gridLineSegments } from '@oxide/design-system/grid'
+
+const grid = computeGrid({
+  mode: 'auto', // or 'manual' with marginCells / gutterCells
+  columns: 12, // layout columns
+  width: 1920, // frame size, px
+  height: 1080,
+  targetMarginPx: 50, // the solver aims at these…
+  targetGutterPx: 20,
+  targetCellColumns: 89, // …and at this ASCII column count
+  // optional: cellAspect, snapRows, pixelSnap, snapTolerancePx, aspectTolerancePct
+})
+
+grid.N // ASCII grid columns
+grid.rows // ASCII grid rows
+grid.u // cell width, px
+grid.cellH // cell height, px
+grid.solvedM // margin in cells
+grid.solvedG // gutter in cells
+grid.margin // margin in px (effectiveMargin includes the pixel-snap remainder)
+grid.gutterWidth // gutter in px
+grid.columnWidth // column width in px
+
+// The cell grid as drawable [x1, y1, x2, y2] line segments, with lines near
+// the frame edge culled.
+const segments = gridLineSegments(grid, 1920, 1080, { edgeCull: true })
+```

package/dist/asciidoc.css

@@ -419,7 +419,6 @@
       border: 1px solid var(--stroke-secondary);
       border-radius: var(--radius-md);
       padding: 1rem 1.25rem;
-      position: relative;
 
       @media (min-width: 800px) {
         padding: 1.5rem 1.75rem;
@@ -440,9 +439,19 @@
         content: attr(data-lang);
         position: absolute;
         top: 0.5rem;
-        right: 0.5rem;
+        right: 0.75rem;
         display: block;
         color: var(--content-secondary);
+        z-index: 1;
+        padding: 0 0.25rem;
+        background-color: var(--surface-default);
+        border-radius: var(--radius-sm);
+      }
+
+      /* Optional role that caps the height for extra long snippets */
+      &.scrollable pre {
+        max-height: 32rem;
+        overflow: auto;
       }
     }
 

package/dist/components/src/grid/index.d.ts

@@ -0,0 +1,98 @@
+type GridSpec = {
+    columns: number;
+    width: number;
+    height: number;
+    targetCellColumns?: number;
+    cellAspect?: number;
+    snapRows?: boolean;
+    pixelSnap?: boolean;
+    snapTolerancePx?: number;
+    aspectTolerancePct?: number;
+} & ({
+    mode: 'manual';
+    marginCells: number;
+    gutterCells: number;
+} | {
+    mode: 'auto';
+    targetMarginPx: number;
+    targetGutterPx: number;
+});
+interface GridResult {
+    N: number;
+    u: number;
+    solvedM: number;
+    solvedK: number;
+    solvedG: number;
+    solved: boolean;
+    offsetX: number;
+    cellsPerGutter: number;
+    columnWidth: number;
+    columnCells: number;
+    gutterWidth: number;
+    margin: number;
+    effectiveMargin: number;
+    contentWidth: number;
+    rows: number;
+    cellH: number;
+    rowOffset: number;
+    hRemainder: number;
+    vRemainder: number;
+    actualAspect: number;
+    deltaPct: number;
+    warn: boolean;
+    cellLadder: number[];
+    cellColumnsTaken: number;
+}
+interface Solution {
+    m: number;
+    k: number;
+    g: number;
+    marginPx: number;
+    gutterPx: number;
+    u: number;
+    N: number;
+    err: number;
+}
+interface CellOption {
+    u: number;
+    k: number;
+    N: number;
+    bleed: number;
+}
+interface GridExtent {
+    startX: number;
+    startY: number;
+    cols: number;
+    rows: number;
+    width: number;
+    height: number;
+}
+type Segment = [number, number, number, number];
+declare const DEFAULT_TARGET_CELL_COLUMNS = 89;
+declare const DEFAULT_CELL_ASPECT = 2;
+declare const DEFAULT_SNAP_TOLERANCE_PX = 0.5;
+declare const DEFAULT_ASPECT_TOL_PCT = 5;
+declare const DEFAULT_EDGE_CULL_PCT = 20;
+declare const SOLVE_MAX_GUTTER = 8;
+declare const SOLVE_MAX_MARGIN = 24;
+declare const SOLVE_MAX_COLUMN = 48;
+declare const GUTTER_WEIGHT = 8;
+declare const COLUMNS_WEIGHT = 16;
+declare const LADDER_MIN_CELL = 2;
+declare const EDGE_CULL_EPSILON = 0.01;
+declare function snapUnit(value: number, pixelSnap: boolean, tolPx: number): number;
+declare function betterFit(a: Solution, b: Solution): boolean;
+declare function solveMultiples(W: number, c: number, targetMargin: number, targetGutter: number, targetN: number, pixelSnap: boolean, snapTolPx: number): Solution;
+declare function round2(n: number): number;
+declare function cellLadder(W: number, c: number, m: number, g: number, pixelSnap: boolean, snapTolPx: number): CellOption[];
+declare function pickCellOption(ladder: CellOption[], targetN: number): CellOption | null;
+declare function computeGrid(spec: GridSpec): GridResult;
+declare function gridExtent(g: GridResult): GridExtent;
+declare function gridLineSegments(g: GridResult, width: number, height: number, opts?: {
+    density?: number;
+    edgeCull?: boolean;
+    edgeCullPct?: number;
+}): Segment[];
+declare function parseAspect(ratio: string): number;
+
+export { COLUMNS_WEIGHT, type CellOption, DEFAULT_ASPECT_TOL_PCT, DEFAULT_CELL_ASPECT, DEFAULT_EDGE_CULL_PCT, DEFAULT_SNAP_TOLERANCE_PX, DEFAULT_TARGET_CELL_COLUMNS, EDGE_CULL_EPSILON, GUTTER_WEIGHT, type GridExtent, type GridResult, type GridSpec, LADDER_MIN_CELL, SOLVE_MAX_COLUMN, SOLVE_MAX_GUTTER, SOLVE_MAX_MARGIN, type Segment, type Solution, betterFit, cellLadder, computeGrid, gridExtent, gridLineSegments, parseAspect, pickCellOption, round2, snapUnit, solveMultiples };

package/dist/components/src/grid/index.js

@@ -0,0 +1,267 @@
+// components/src/grid/index.ts
+var DEFAULT_TARGET_CELL_COLUMNS = 89;
+var DEFAULT_CELL_ASPECT = 2;
+var DEFAULT_SNAP_TOLERANCE_PX = 0.5;
+var DEFAULT_ASPECT_TOL_PCT = 5;
+var DEFAULT_EDGE_CULL_PCT = 20;
+var SOLVE_MAX_GUTTER = 8;
+var SOLVE_MAX_MARGIN = 24;
+var SOLVE_MAX_COLUMN = 48;
+var GUTTER_WEIGHT = 8;
+var COLUMNS_WEIGHT = 16;
+var LADDER_MIN_CELL = 2;
+var EDGE_CULL_EPSILON = 0.01;
+function snapUnit(value, pixelSnap, tolPx) {
+  if (!pixelSnap) return value;
+  const snapped = Math.max(1, Math.round(value));
+  return Math.abs(value - snapped) <= tolPx + 1e-9 ? snapped : value;
+}
+function betterFit(a, b) {
+  if (a.err < b.err - 1e-6) return true;
+  if (a.err > b.err + 1e-6) return false;
+  return a.N < b.N;
+}
+function solveMultiples(W, c, targetMargin, targetGutter, targetN, pixelSnap, snapTolPx) {
+  const relErr = (got, want) => Math.abs(got - want) / Math.max(1, want);
+  let best = null;
+  for (let g = 1; g <= SOLVE_MAX_GUTTER; g++) {
+    for (let m = 0; m <= SOLVE_MAX_MARGIN; m++) {
+      for (let k = 1; k <= SOLVE_MAX_COLUMN; k++) {
+        const N = 2 * m + c * k + (c - 1) * g;
+        const u = snapUnit(W / N, pixelSnap, snapTolPx);
+        const gutterPx = g * u;
+        const marginPx = m * u + (W - N * u) / 2;
+        const err = GUTTER_WEIGHT * relErr(gutterPx, targetGutter) + COLUMNS_WEIGHT * relErr(N, targetN) + relErr(marginPx, targetMargin);
+        const candidate = { m, k, g, marginPx, gutterPx, u, N, err };
+        if (!best || betterFit(candidate, best)) best = candidate;
+      }
+    }
+  }
+  return best || {
+    m: 3,
+    k: 6,
+    g: 1,
+    marginPx: 0,
+    gutterPx: 0,
+    u: 0,
+    N: 0,
+    err: Infinity
+  };
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function cellLadder(W, c, m, g, pixelSnap, snapTolPx) {
+  const byCell = /* @__PURE__ */ new Map();
+  for (let k = 1; k <= SOLVE_MAX_COLUMN; k++) {
+    const N = 2 * m + c * k + (c - 1) * g;
+    const u = snapUnit(W / N, pixelSnap, snapTolPx);
+    if (u < LADDER_MIN_CELL) continue;
+    const bleed = Math.abs(W - N * u);
+    const key = round2(u);
+    const prev = byCell.get(key);
+    if (!prev || bleed < prev.bleed) byCell.set(key, { u, k, N, bleed });
+  }
+  const out = [];
+  byCell.forEach((v) => out.push(v));
+  return out.sort((a, b) => a.u - b.u);
+}
+function pickCellOption(ladder, targetN) {
+  let best = null;
+  let bestErr = Infinity;
+  for (const opt of ladder) {
+    const err = Math.abs(opt.N - targetN);
+    if (err < bestErr - 1e-9 || best && err < bestErr + 1e-9 && opt.N < best.N) {
+      bestErr = err;
+      best = opt;
+    }
+  }
+  return best;
+}
+function computeGrid(spec) {
+  const W = spec.width;
+  const H = spec.height;
+  const c = Math.max(1, Math.round(spec.columns));
+  const a = spec.cellAspect !== void 0 ? spec.cellAspect : DEFAULT_CELL_ASPECT;
+  const snapRows = spec.snapRows !== void 0 ? spec.snapRows : true;
+  const pixelSnap = spec.pixelSnap === true;
+  const snapTol = spec.snapTolerancePx !== void 0 ? spec.snapTolerancePx : DEFAULT_SNAP_TOLERANCE_PX;
+  const aspectTolPct = spec.aspectTolerancePct !== void 0 ? spec.aspectTolerancePct : DEFAULT_ASPECT_TOL_PCT;
+  const targetN = Math.max(
+    1,
+    Math.round(
+      spec.targetCellColumns !== void 0 ? spec.targetCellColumns : DEFAULT_TARGET_CELL_COLUMNS
+    )
+  );
+  let solved = null;
+  let gm;
+  let m;
+  if (spec.mode === "auto") {
+    solved = solveMultiples(
+      W,
+      c,
+      Math.max(0, spec.targetMarginPx),
+      Math.max(1, spec.targetGutterPx),
+      targetN,
+      pixelSnap,
+      snapTol
+    );
+    gm = solved.g;
+    m = solved.m;
+  } else {
+    gm = Math.max(1, Math.round(spec.gutterCells));
+    m = Math.max(0, Math.round(spec.marginCells));
+  }
+  const ladder = solved ? [] : cellLadder(W, c, m, gm, pixelSnap, snapTol);
+  const chosen = solved ? null : pickCellOption(ladder, targetN);
+  const k = solved ? solved.k : chosen ? chosen.k : 1;
+  const N = 2 * m + c * k + (c - 1) * gm;
+  const uExact = W / N;
+  const u = snapUnit(uExact, pixelSnap, snapTol);
+  const columnWidth = k * u;
+  const gutterWidth = gm * u;
+  const margin = m * u;
+  const columnCells = k;
+  const contentWidth = c * columnWidth + (c - 1) * gutterWidth;
+  const hRemainder = W - N * u;
+  const effectiveMargin = margin + hRemainder / 2;
+  const offsetX = 0;
+  let rows;
+  let cellH;
+  if (snapRows) {
+    rows = Math.max(1, Math.round(H / (a * uExact)));
+    const band = pixelSnap ? Math.min(50, aspectTolPct) / 100 : 0;
+    if (band > 0) {
+      const lo = Math.max(1, Math.ceil(H / (a * u * (1 + band))));
+      const hi = Math.max(lo, Math.floor(H / (a * u * (1 - band))));
+      let bestR = 0;
+      let bestErr = Infinity;
+      for (let r = lo; r <= hi; r++) {
+        const snapped = Math.max(1, Math.round(H / r));
+        if (Math.abs(H / r - snapped) > snapTol + 1e-9) continue;
+        const err = Math.abs(snapped / u / a - 1);
+        if (err > band + 1e-9) continue;
+        if (err < bestErr - 1e-12 || err < bestErr + 1e-12 && Math.abs(r - rows) < Math.abs(bestR - rows)) {
+          bestErr = err;
+          bestR = r;
+        }
+      }
+      if (bestR) rows = bestR;
+    }
+    cellH = snapUnit(H / rows, pixelSnap, snapTol);
+  } else {
+    cellH = snapUnit(a * u, pixelSnap, snapTol);
+    rows = Math.max(1, Math.ceil(H / cellH - 1e-9));
+  }
+  const vRemainder = H - rows * cellH;
+  const rowOffset = vRemainder / 2;
+  const actualAspect = cellH / u;
+  const deltaPct = (actualAspect / a - 1) * 100;
+  return {
+    N,
+    u,
+    solvedM: m,
+    solvedK: k,
+    solvedG: gm,
+    solved: !!solved,
+    offsetX,
+    cellsPerGutter: gm,
+    columnWidth,
+    columnCells,
+    gutterWidth,
+    margin,
+    effectiveMargin,
+    contentWidth,
+    rows,
+    cellH,
+    rowOffset,
+    hRemainder,
+    vRemainder,
+    actualAspect,
+    deltaPct,
+    warn: Math.abs(deltaPct) > 1,
+    // Ascending in N, which is *descending* in cell size — the ladder is built
+    // u-ascending, so this reverses it.
+    cellLadder: ladder.map((o) => o.N).sort((x, y) => x - y),
+    // The count actually taken: the nearest ladder rung in manual mode, the
+    // solver's N in auto.
+    cellColumnsTaken: solved ? N : chosen ? chosen.N : targetN
+  };
+}
+function gridExtent(g) {
+  const extraCols = g.hRemainder > 0 ? Math.ceil(g.hRemainder / 2 / g.u) : 0;
+  const extraRows = g.vRemainder > 0 ? Math.ceil(g.vRemainder / 2 / g.cellH) : 0;
+  const startX = g.hRemainder / 2 - extraCols * g.u;
+  const startY = g.vRemainder / 2 - extraRows * g.cellH;
+  const cols = g.N + 2 * extraCols;
+  const rows = g.rows + 2 * extraRows;
+  return {
+    startX,
+    startY,
+    cols,
+    rows,
+    width: cols * g.u,
+    height: rows * g.cellH
+  };
+}
+function gridLineSegments(g, width, height, opts) {
+  const o = opts || {};
+  const d = o.density !== void 0 ? o.density : 1;
+  const cullOn = o.edgeCull !== void 0 ? o.edgeCull : true;
+  const cullPct = o.edgeCullPct !== void 0 ? o.edgeCullPct : DEFAULT_EDGE_CULL_PCT;
+  const cull = Math.min(50, cullPct) / 100;
+  const ext = gridExtent(g);
+  const right = ext.startX + ext.width;
+  const bottom = ext.startY + ext.height;
+  const stepX = g.u / d;
+  const stepY = g.cellH / d;
+  const tolX = stepX * cull;
+  const tolY = stepY * cull;
+  const lastCol = Math.floor(ext.cols * d + 1e-9);
+  const lastRow = Math.floor(ext.rows * d + 1e-9);
+  const segments = [];
+  for (let i = 0; i <= lastCol; i++) {
+    const x = ext.startX + i * stepX;
+    if (x < EDGE_CULL_EPSILON || x > width - EDGE_CULL_EPSILON) continue;
+    if (cullOn && (x < tolX || width - x < tolX)) continue;
+    segments.push([x, ext.startY, x, bottom]);
+  }
+  for (let j = 0; j <= lastRow; j++) {
+    const y = ext.startY + j * stepY;
+    if (y < EDGE_CULL_EPSILON || y > height - EDGE_CULL_EPSILON) continue;
+    if (cullOn && (y < tolY || height - y < tolY)) continue;
+    segments.push([ext.startX, y, right, y]);
+  }
+  return segments;
+}
+function parseAspect(ratio) {
+  const parts = ratio.split(":");
+  const w = Number(parts[0]);
+  const h = Number(parts[1]);
+  return w > 0 && h > 0 ? w / h : 16 / 9;
+}
+export {
+  COLUMNS_WEIGHT,
+  DEFAULT_ASPECT_TOL_PCT,
+  DEFAULT_CELL_ASPECT,
+  DEFAULT_EDGE_CULL_PCT,
+  DEFAULT_SNAP_TOLERANCE_PX,
+  DEFAULT_TARGET_CELL_COLUMNS,
+  EDGE_CULL_EPSILON,
+  GUTTER_WEIGHT,
+  LADDER_MIN_CELL,
+  SOLVE_MAX_COLUMN,
+  SOLVE_MAX_GUTTER,
+  SOLVE_MAX_MARGIN,
+  betterFit,
+  cellLadder,
+  computeGrid,
+  gridExtent,
+  gridLineSegments,
+  parseAspect,
+  pickCellOption,
+  round2,
+  snapUnit,
+  solveMultiples
+};
+//# sourceMappingURL=index.js.map

package/dist/components/src/grid/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../components/src/grid/index.ts"],"sourcesContent":["/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, you can obtain one at https://mozilla.org/MPL/2.0/.\n *\n * Copyright Oxide Computer Company\n */\n\n// Dual-grid math: overlays an aligned column grid and ASCII cell grid on a\n// frame. Margin, column and gutter widths are whole multiples of the cell\n// width `u`, so every edge lands on a cell line:\n//\n//   N = 2m + c·k + (c−1)·g      (cells across the frame)\n//   u = W / N                    (cell size = base unit)\n//   margin = m·u   column = k·u   gutter = g·u\n//\n// See plugins/dual-grid/README.md for the derivation, solver weight\n// comparisons and measured error tables.\n//\n// This module is consumed both as `@oxide/design-system/grid` and bundled\n// directly into the dual-grid Figma plugin. Keep it dependency-free, with no\n// Figma types and no syntax newer than ES2018 (the plugin engine's ceiling).\n\nexport type GridSpec = {\n  columns: number // c — layout column count\n  width: number // frame width, px\n  height: number // frame height, px\n  // Rough target for the number of ASCII cell columns N. Only certain counts\n  // are reachable (N steps by c with m and g fixed), so the nearest is taken.\n  targetCellColumns?: number\n  cellAspect?: number // a — cell height as a multiple of cell width\n  // Snap the row count so rows fill the height exactly; off, the cell aspect\n  // is kept exact and the last row runs off the bottom edge instead.\n  snapRows?: boolean\n  // Round the cell size to whole pixels when within snapTolerancePx. The\n  // leftover (W − N·u) is split between the margins. Off, the cell divides\n  // the frame exactly and there is no bleed.\n  pixelSnap?: boolean\n  // Maximum rounding distance per cell in pixels. Total horizontal bleed is\n  // bounded by N times this tolerance. 0 disables snapping; 0.5 always snaps.\n  snapTolerancePx?: number\n  // With snapRows and pixelSnap on, allow this percentage of aspect deviation\n  // to find an integer row height. 0 keeps the original row count.\n  aspectTolerancePct?: number\n} & (\n  | {\n      // Margin and gutter are given directly as cell counts; column width is\n      // derived from targetCellColumns via the ladder.\n      mode: 'manual'\n      marginCells: number // m — margin width in cells\n      gutterCells: number // g — cells per gutter\n    }\n  | {\n      // The solver finds the whole-cell multiples (m, k, g) whose margin,\n      // gutter and column count come closest to the pixel targets.\n      mode: 'auto'\n      targetMarginPx: number\n      targetGutterPx: number\n    }\n)\n\nexport interface GridResult {\n  N: number // whole cells that fit across the frame\n  u: number // cell size = base unit\n  solvedM: number // multiples actually used (from the spec or the solver)\n  solvedK: number\n  solvedG: number\n  solved: boolean // whether the solver chose them\n  offsetX: number // phase of the cell grid, so x = margin lands on a boundary\n  cellsPerGutter: number\n  columnWidth: number\n  columnCells: number // columnWidth in whole cells (= k)\n  gutterWidth: number\n  margin: number\n  effectiveMargin: number\n  contentWidth: number\n  rows: number\n  cellH: number\n  rowOffset: number\n  hRemainder: number // leftover width from snapping u, split between the margins\n  vRemainder: number // leftover height — split top/bottom (snapRows) or a partial row at the bottom\n  actualAspect: number\n  deltaPct: number\n  warn: boolean\n  cellLadder: number[] // reachable cell-column counts, ascending (manual only)\n  cellColumnsTaken: number // the rung actually taken (manual), or N (auto)\n}\n\nexport interface Solution {\n  m: number\n  k: number\n  g: number\n  marginPx: number\n  gutterPx: number\n  u: number\n  N: number\n  err: number\n}\n\nexport interface CellOption {\n  u: number // exact cell size\n  k: number // cells per column that produces it\n  N: number\n  bleed: number // px left over after rounding u — padding that lands in the margins\n}\n\n// The full-bleed extent of the cell grid: the N × rows grid plus enough whole\n// cells on every side to cover the snap's remainder margins, so the grid\n// fills the frame edge to edge. Whole units keep everything aligned; the\n// overhang is clipped by the frame.\nexport interface GridExtent {\n  startX: number\n  startY: number\n  cols: number\n  rows: number\n  width: number\n  height: number\n}\n\nexport type Segment = [number, number, number, number] // x1, y1, x2, y2\n\n// 89 = 2(3) + 12(6) + 11(1), i.e. k=6 — an exact rung for the default margin,\n// gutter and column count at 1920 wide, giving a 21.57px cell, 25 rows and a\n// 129px column.\nexport const DEFAULT_TARGET_CELL_COLUMNS = 89\nexport const DEFAULT_CELL_ASPECT = 2\n// Half a pixel accepts any rounding distance. Lower tolerances preserve more\n// fractional sizes and limit bleed; 0.1 caps it at N/10 pixels.\nexport const DEFAULT_SNAP_TOLERANCE_PX = 0.5\n// Allow 5% aspect deviation when searching for an integer row height.\n// For example, 24 rows of 45px fill a 1080px frame exactly.\nexport const DEFAULT_ASPECT_TOL_PCT = 5\n// 20% of a step: wide enough to catch the few-px inset the pixel snap leaves\n// (3px on a 22px cell is 13.6%), narrow enough that a real interior line — a\n// full step from the edge — can never be caught.\nexport const DEFAULT_EDGE_CULL_PCT = 20\n\n// Search all ~10k combinations on each edit to find the best match within these bounds.\nexport const SOLVE_MAX_GUTTER = 8\nexport const SOLVE_MAX_MARGIN = 24\nexport const SOLVE_MAX_COLUMN = 48\n// Prioritise column count to preserve cell density. Gutter width is g*W/N with\n// integer g, so the two targets may conflict. Report gutter mismatches rather\n// than substantially changing N. Margin has weight 1 and is quantised in\n// cell-width increments.\nexport const GUTTER_WEIGHT = 8\nexport const COLUMNS_WEIGHT = 16\n\n// Cell sizes below this are not a usable design grid, and enumerating them only\n// crowds the options.\nexport const LADDER_MIN_CELL = 2\n\n// Lines on or beyond the frame boundary (to within this epsilon) are always\n// culled as doubled frame edges, whatever the edge-cull options say.\nexport const EDGE_CULL_EPSILON = 0.01\n\n// Round to whole pixels only within tolerance. computeGrid, the solver and the\n// ladder must all use this function so previews and generated grids agree.\nexport function snapUnit(value: number, pixelSnap: boolean, tolPx: number): number {\n  if (!pixelSnap) return value\n  const snapped = Math.max(1, Math.round(value))\n  // The epsilon keeps an exactly-on-tolerance value (and a tolerance of 0.5,\n  // where |value − round(value)| can equal 0.5 up to float error) snapping.\n  return Math.abs(value - snapped) <= tolPx + 1e-9 ? snapped : value\n}\n\n// Treat errors within 1e-6 as ties and prefer the coarser grid.\nexport function betterFit(a: Solution, b: Solution): boolean {\n  if (a.err < b.err - 1e-6) return true\n  if (a.err > b.err + 1e-6) return false\n  return a.N < b.N\n}\n\n// Finds the whole-cell multiples (m, k, g) whose margin, gutter and column count\n// come closest to the three requested values.\n//\n// Whole-cell multiples preserve alignment. Inputs are weighted targets, not\n// hard constraints, so a grid is returned even when no exact match exists.\nexport function solveMultiples(\n  W: number,\n  c: number,\n  targetMargin: number,\n  targetGutter: number,\n  targetN: number,\n  pixelSnap: boolean,\n  snapTolPx: number,\n): Solution {\n  const relErr = (got: number, want: number) => Math.abs(got - want) / Math.max(1, want)\n\n  let best: Solution | null = null\n\n  for (let g = 1; g <= SOLVE_MAX_GUTTER; g++) {\n    for (let m = 0; m <= SOLVE_MAX_MARGIN; m++) {\n      for (let k = 1; k <= SOLVE_MAX_COLUMN; k++) {\n        const N = 2 * m + c * k + (c - 1) * g\n        // Must snap exactly as computeGrid will, or the solved fit drifts once\n        // the pixel snap rounds the cell size.\n        const u = snapUnit(W / N, pixelSnap, snapTolPx)\n\n        // Include half the rounding remainder in the margin to account for centring.\n        const gutterPx = g * u\n        const marginPx = m * u + (W - N * u) / 2\n\n        const err =\n          GUTTER_WEIGHT * relErr(gutterPx, targetGutter) +\n          COLUMNS_WEIGHT * relErr(N, targetN) +\n          relErr(marginPx, targetMargin)\n        const candidate: Solution = { m, k, g, marginPx, gutterPx, u, N, err }\n\n        // Prefer the closest fit, then the coarsest grid on a tie.\n        if (!best || betterFit(candidate, best)) best = candidate\n      }\n    }\n  }\n\n  return (\n    best || {\n      m: 3,\n      k: 6,\n      g: 1,\n      marginPx: 0,\n      gutterPx: 0,\n      u: 0,\n      N: 0,\n      err: Infinity,\n    }\n  )\n}\n\n// Two decimals is the resolution at which ladder rungs are considered distinct\n// (it is also the resolution the plugin panel displays).\nexport function round2(n: number): number {\n  return Math.round(n * 100) / 100\n}\n\n// The manual-mode cell ladder. With c, m and g fixed, k is the only free\n// variable in N = 2m + ck + (c−1)g. Possible counts step by c, giving a\n// discrete set of cell sizes u = W/N. Aspect deviation is reported, not used\n// to reject sizes.\nexport function cellLadder(\n  W: number,\n  c: number,\n  m: number,\n  g: number,\n  pixelSnap: boolean,\n  snapTolPx: number,\n): CellOption[] {\n  const byCell = new Map<number, CellOption>()\n  for (let k = 1; k <= SOLVE_MAX_COLUMN; k++) {\n    const N = 2 * m + c * k + (c - 1) * g\n    const u = snapUnit(W / N, pixelSnap, snapTolPx)\n    if (u < LADDER_MIN_CELL) continue\n\n    const bleed = Math.abs(W - N * u)\n    // Rounding u to whole pixels collapses several adjacent k onto the same cell\n    // size; keep whichever leaves the least bleed, since that is the one that\n    // fills the frame most cleanly.\n    const key = round2(u)\n    const prev = byCell.get(key)\n    if (!prev || bleed < prev.bleed) byCell.set(key, { u, k, N, bleed })\n  }\n  const out: CellOption[] = []\n  byCell.forEach((v) => out.push(v))\n  return out.sort((a, b) => a.u - b.u)\n}\n\n// Nearest available column count. Ties prefer fewer columns, matching the solver.\nexport function pickCellOption(ladder: CellOption[], targetN: number): CellOption | null {\n  let best: CellOption | null = null\n  let bestErr = Infinity\n  for (const opt of ladder) {\n    const err = Math.abs(opt.N - targetN)\n    if (err < bestErr - 1e-9 || (best && err < bestErr + 1e-9 && opt.N < best.N)) {\n      bestErr = err\n      best = opt\n    }\n  }\n  return best\n}\n\n// The mathematical core. Dimensions are measured in cells; cell size is\n// derived from the frame width. All pixel sizes are reported back in the\n// result.\nexport function computeGrid(spec: GridSpec): GridResult {\n  const W = spec.width\n  const H = spec.height\n  const c = Math.max(1, Math.round(spec.columns))\n  const a = spec.cellAspect !== undefined ? spec.cellAspect : DEFAULT_CELL_ASPECT\n  const snapRows = spec.snapRows !== undefined ? spec.snapRows : true\n  const pixelSnap = spec.pixelSnap === true\n  const snapTol =\n    spec.snapTolerancePx !== undefined ? spec.snapTolerancePx : DEFAULT_SNAP_TOLERANCE_PX\n  // The aspect band as a share, capped at 50%. 0 disables the row-count search.\n  const aspectTolPct =\n    spec.aspectTolerancePct !== undefined ? spec.aspectTolerancePct : DEFAULT_ASPECT_TOL_PCT\n  const targetN = Math.max(\n    1,\n    Math.round(\n      spec.targetCellColumns !== undefined\n        ? spec.targetCellColumns\n        : DEFAULT_TARGET_CELL_COLUMNS,\n    ),\n  )\n\n  // In auto mode the multiples come from the solver rather than the spec.\n  // Manual: the gutter sets the scale, the margin is measured against it, and the\n  // column width is derived. Rounding keeps every part a whole number of cells,\n  // which is what holds the two grids in phase.\n  let solved: Solution | null = null\n  let gm: number\n  let m: number\n  if (spec.mode === 'auto') {\n    solved = solveMultiples(\n      W,\n      c,\n      Math.max(0, spec.targetMarginPx),\n      Math.max(1, spec.targetGutterPx),\n      targetN,\n      pixelSnap,\n      snapTol,\n    )\n    gm = solved.g\n    m = solved.m\n  } else {\n    gm = Math.max(1, Math.round(spec.gutterCells))\n    m = Math.max(0, Math.round(spec.marginCells))\n  }\n  // Manual: the column count is picked straight off the ladder. The ladder depends\n  // on c, m, g, the pixel snap and its tolerance, so it is rebuilt whenever any of\n  // those move and the request is re-snapped by *count* — 197 cells stays ≈197\n  // across a margin change rather than sliding to whatever sits at the same\n  // ladder index.\n  const ladder = solved ? [] : cellLadder(W, c, m, gm, pixelSnap, snapTol)\n  const chosen = solved ? null : pickCellOption(ladder, targetN)\n  const k = solved ? solved.k : chosen ? chosen.k : 1\n\n  const N = 2 * m + c * k + (c - 1) * gm\n  const uExact = W / N\n  const u = snapUnit(uExact, pixelSnap, snapTol)\n\n  const columnWidth = k * u\n  const gutterWidth = gm * u\n  const margin = m * u\n  const columnCells = k\n  const contentWidth = c * columnWidth + (c - 1) * gutterWidth\n\n  // Rounding u leaves a remainder; split evenly it shifts both grids by the same\n  // amount, so they stay in phase.\n  const hRemainder = W - N * u\n  const effectiveMargin = margin + hRemainder / 2\n  const offsetX = 0 // centring handles the phase; no offset needed\n\n  let rows: number\n  let cellH: number\n  if (snapRows) {\n    // Counted off the exact cell, not the snapped one, so snapping u to a whole\n    // pixel cannot flip the row count the fractional grid chose (at the borderline\n    // it otherwise does: u 22.07 → 24 rows, u 22 → 25).\n    rows = Math.max(1, Math.round(H / (a * uExact)))\n    // Search row counts within the aspect tolerance for a height that snaps.\n    // Prefer the closest aspect ratio; a divisor of H gives an exact vertical fit.\n    const band = pixelSnap ? Math.min(50, aspectTolPct) / 100 : 0\n    if (band > 0) {\n      const lo = Math.max(1, Math.ceil(H / (a * u * (1 + band))))\n      const hi = Math.max(lo, Math.floor(H / (a * u * (1 - band))))\n      let bestR = 0\n      let bestErr = Infinity\n      for (let r = lo; r <= hi; r++) {\n        const snapped = Math.max(1, Math.round(H / r))\n        if (Math.abs(H / r - snapped) > snapTol + 1e-9) continue\n        const err = Math.abs(snapped / u / a - 1)\n        if (err > band + 1e-9) continue\n        // Closest to the aspect ask wins; ties go to the natural row count.\n        if (\n          err < bestErr - 1e-12 ||\n          (err < bestErr + 1e-12 && Math.abs(r - rows) < Math.abs(bestR - rows))\n        ) {\n          bestErr = err\n          bestR = r\n        }\n      }\n      if (bestR) rows = bestR\n    }\n    // H/rows divides H exactly; the whole-pixel snap trades that for a small\n    // remainder, split top and bottom like the horizontal one.\n    cellH = snapUnit(H / rows, pixelSnap, snapTol)\n  } else {\n    // Keep the aspect exact and let the last row run off the bottom edge rather\n    // than stopping the grid short — the overhang is clipped by the frame, the\n    // same way the side edges already bleed. Snapping is the opposite trade:\n    // exact fit, approximate aspect.\n    cellH = snapUnit(a * u, pixelSnap, snapTol)\n    rows = Math.max(1, Math.ceil(H / cellH - 1e-9))\n  }\n  const vRemainder = H - rows * cellH\n  // Same trick vertically: centre the leftover so the rows stay in phase.\n  const rowOffset = vRemainder / 2\n\n  const actualAspect = cellH / u\n  const deltaPct = (actualAspect / a - 1) * 100\n\n  return {\n    N,\n    u,\n    solvedM: m,\n    solvedK: k,\n    solvedG: gm,\n    solved: !!solved,\n    offsetX,\n    cellsPerGutter: gm,\n    columnWidth,\n    columnCells,\n    gutterWidth,\n    margin,\n    effectiveMargin,\n    contentWidth,\n    rows,\n    cellH,\n    rowOffset,\n    hRemainder,\n    vRemainder,\n    actualAspect,\n    deltaPct,\n    warn: Math.abs(deltaPct) > 1,\n    // Ascending in N, which is *descending* in cell size — the ladder is built\n    // u-ascending, so this reverses it.\n    cellLadder: ladder.map((o) => o.N).sort((x, y) => x - y),\n    // The count actually taken: the nearest ladder rung in manual mode, the\n    // solver's N in auto.\n    cellColumnsTaken: solved ? N : chosen ? chosen.N : targetN,\n  }\n}\n\n// Extends the grid by whole cells past its own bounds so the rounding remainder\n// at the frame edges is covered too; the frame clips the overhang.\nexport function gridExtent(g: GridResult): GridExtent {\n  const extraCols = g.hRemainder > 0 ? Math.ceil(g.hRemainder / 2 / g.u) : 0\n  const extraRows = g.vRemainder > 0 ? Math.ceil(g.vRemainder / 2 / g.cellH) : 0\n  const startX = g.hRemainder / 2 - extraCols * g.u\n  const startY = g.vRemainder / 2 - extraRows * g.cellH\n  const cols = g.N + 2 * extraCols\n  const rows = g.rows + 2 * extraRows\n  return {\n    startX,\n    startY,\n    cols,\n    rows,\n    width: cols * g.u,\n    height: rows * g.cellH,\n  }\n}\n\n// The cell grid as drawable line segments over the full-bleed extent. Density\n// subdivides (2, 3) or coarsens (0.5, 0.25) the cell. Lines on or beyond the\n// frame boundary are always omitted; edge cull additionally removes interior\n// lines within edgeCullPct of a step from the boundary, to avoid darkening the\n// frame edge. The percentage is capped at half a step so it can never reach\n// two adjacent lines.\nexport function gridLineSegments(\n  g: GridResult,\n  width: number,\n  height: number,\n  opts?: { density?: number; edgeCull?: boolean; edgeCullPct?: number },\n): Segment[] {\n  const o = opts || {}\n  const d = o.density !== undefined ? o.density : 1\n  const cullOn = o.edgeCull !== undefined ? o.edgeCull : true\n  const cullPct = o.edgeCullPct !== undefined ? o.edgeCullPct : DEFAULT_EDGE_CULL_PCT\n  const cull = Math.min(50, cullPct) / 100\n\n  const ext = gridExtent(g)\n  const right = ext.startX + ext.width\n  const bottom = ext.startY + ext.height\n\n  const stepX = g.u / d\n  const stepY = g.cellH / d\n\n  const tolX = stepX * cull\n  const tolY = stepY * cull\n\n  // Coarse densities can leave a fractional line count; the loop floor just\n  // stops at the last coarse line inside the extent.\n  const lastCol = Math.floor(ext.cols * d + 1e-9)\n  const lastRow = Math.floor(ext.rows * d + 1e-9)\n\n  const segments: Segment[] = []\n  for (let i = 0; i <= lastCol; i++) {\n    const x = ext.startX + i * stepX\n    if (x < EDGE_CULL_EPSILON || x > width - EDGE_CULL_EPSILON) continue\n    if (cullOn && (x < tolX || width - x < tolX)) continue\n    segments.push([x, ext.startY, x, bottom])\n  }\n  for (let j = 0; j <= lastRow; j++) {\n    const y = ext.startY + j * stepY\n    if (y < EDGE_CULL_EPSILON || y > height - EDGE_CULL_EPSILON) continue\n    if (cullOn && (y < tolY || height - y < tolY)) continue\n    segments.push([ext.startX, y, right, y])\n  }\n  return segments\n}\n\nexport function parseAspect(ratio: string): number {\n  const parts = ratio.split(':')\n  const w = Number(parts[0])\n  const h = Number(parts[1])\n  return w > 0 && h > 0 ? w / h : 16 / 9\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxide/design-system",
-  "version": "6.6.1",
+  "version": "6.7.0-canary.e63e89e",
   "description": "Home of reusable design assets and token for oxide internal sites",
   "type": "module",
   "sideEffects": false,
@@ -8,6 +8,7 @@
     "./styles/*": "./styles/*",
     "./components/*.css": "./dist/*.css",
     "./asciidoc": "./dist/components/src/asciidoc/index.js",
+    "./grid": "./dist/components/src/grid/index.js",
     "./syntax": "./dist/components/src/syntax/index.js",
     "./ui": "./dist/components/src/ui/index.js",
     "./icons": "./dist/icons/index.js",
@@ -25,6 +26,10 @@
     "color-gen:dev": "vite --config color-gen/vite.config.ts color-gen",
     "color-gen:apply": "tsx color-gen/apply-colors.ts",
     "preview:dev": "vite --config preview/vite.config.ts",
+    "dual-grid:build": "npm --prefix plugins/dual-grid run build",
+    "dual-grid:test": "npm --prefix plugins/dual-grid run test",
+    "token-sync:dev": "npm --prefix plugins/token-sync run dev",
+    "token-sync:build": "npm --prefix plugins/token-sync run build",
     "design-md": "node scripts/design-md.mjs",
     "design-md:check": "node scripts/design-md.mjs --check"
   },