@oxide/design-system 6.7.0-canary.8a33f9c → 6.7.0

package/README.md

@@ -20,20 +20,11 @@ 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.
 
-## 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…**.
-
-- `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
 
+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.
+
 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.
 
@@ -81,7 +72,7 @@ This is type-checked, and will throw an error if the corresponding icon doesn't
 
 ## Usage
 
-This package provides four main entry points:
+This package provides two main entry points:
 
 ### UI Components (`@oxide/design-system/ui`)
 
@@ -126,81 +117,3 @@ 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, snapLineHeight } 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 })
-
-// A line height snapped to whole cell rows, so text set at it keeps its
-// baselines on the grid. Pick the font size as a share of the result.
-const lh = snapLineHeight(grid, 1080 * 0.12) // { cells: 3, px: 129.6 }
-const fontSize = lh.px * 0.92
-```
-
-To place text by coordinate (canvas, SVG, Figma), `baselineOffset(metrics, fontSize,
-lineHeight)` gives the distance from the top of the line box to the first baseline, so
-`y = grid.rowOffset + row * grid.cellH - baselineOffset(...)` seats it on a cell row.
-In CSS, pair with the capsize entry point below instead.
-
-### Capsize (`@oxide/design-system/capsize`)
-
-A [capsize](https://seek-oss.github.io/capsize/)-style React hook that trims the space
-above the cap height and below the baseline, so the element's box runs exactly from cap
-top to baseline. Anchor the trimmed box's bottom edge to a grid row and the text sits on
-the baseline grid — no offset arithmetic needed:
-
-```tsx
-import { computeGrid, snapLineHeight } from '@oxide/design-system/grid'
-import { useCapsize } from '@oxide/design-system/capsize'
-
-const grid = computeGrid({ ... })
-const lh = snapLineHeight(grid, height * 0.12)
-
-const { styles, className } = useCapsize({
-  fontFamily: 'suisse-intl', // or pass `metrics` for other fonts
-  fontSize: lh.px * 0.92,
-  lineHeight: lh.px,
-})
-
-// bottom-0 lands on the container edge — a grid line — and capsize makes the
-// element's bottom edge the baseline.
-<h1 className={cn('absolute bottom-0', className)} style={styles}>…</h1>
-```
-
-The pure computation is also exported as `capsize(options)` (returns `styles`,
-`className` and the `cssText` for the trim pseudo-elements) for non-React or SSR use.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxide/design-system",
-  "version": "6.7.0-canary.8a33f9c",
+  "version": "6.7.0",
   "description": "Home of reusable design assets and token for oxide internal sites",
   "type": "module",
   "sideEffects": false,
@@ -8,8 +8,6 @@
     "./styles/*": "./styles/*",
     "./components/*.css": "./dist/*.css",
     "./asciidoc": "./dist/components/src/asciidoc/index.js",
-    "./capsize": "./dist/components/src/capsize/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",
@@ -27,10 +25,6 @@
     "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"
   },

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

@@ -1,22 +0,0 @@
-import { FontMetrics } from '../grid/index.js';
-
-interface CapsizeFontMetrics extends FontMetrics {
-    capHeight: number;
-}
-declare const FONT_METRICS: Record<string, CapsizeFontMetrics>;
-interface CapsizeOptions {
-    fontFamily?: string;
-    metrics?: CapsizeFontMetrics;
-    fontSize: number | string;
-    lineHeight?: number | string;
-    rootSize?: number;
-}
-interface CapsizeResult {
-    styles: React.CSSProperties;
-    className: string;
-    cssText?: string;
-}
-declare function capsize({ fontFamily, metrics, fontSize, lineHeight, rootSize, }: CapsizeOptions): CapsizeResult;
-declare const useCapsize: (options: CapsizeOptions) => CapsizeResult;
-
-export { type CapsizeFontMetrics, type CapsizeOptions, type CapsizeResult, FONT_METRICS, capsize, useCapsize };

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

@@ -1,125 +0,0 @@
-// components/src/capsize/index.ts
-import { useEffect, useMemo } from "react";
-var FONT_METRICS = {
-  "suisse-intl": {
-    capHeight: 725,
-    ascent: 986,
-    descent: -311,
-    lineGap: 0,
-    unitsPerEm: 1e3
-  }
-};
-function isRelativeValue(value) {
-  const isPercentValue = value.endsWith("%");
-  const isUnitlessValue = /\d$/.test(value);
-  return isPercentValue || isUnitlessValue;
-}
-function getRelativeValue(value) {
-  const isPercentValue = value.endsWith("%");
-  return isPercentValue ? Number.parseInt(value.replace("%", ""), 10) / 100 : Number.parseFloat(value);
-}
-function normalizeValue(value, root, fs) {
-  if (typeof value === "number") return value;
-  if (value.endsWith("px")) return Number.parseFloat(value.replace("px", ""));
-  if (value.endsWith("rem")) return root * Number.parseFloat(value.replace("rem", ""));
-  if (isRelativeValue(value) && fs !== void 0) {
-    return fs * getRelativeValue(value);
-  }
-  return Number.parseInt(value, 10);
-}
-function round(value) {
-  return Number.parseFloat(value.toFixed(4)).toString();
-}
-function lineHeightProperties(lineHeight, rootSize = 16, fontSizePx) {
-  if (lineHeight === void 0) return {};
-  const lineHeightStr = typeof lineHeight === "number" ? `${lineHeight}px` : lineHeight;
-  const lineHeightActual = isRelativeValue(lineHeightStr) ? `calc(${getRelativeValue(lineHeightStr).toString()} * var(--font-size-px))` : normalizeValue(lineHeightStr, rootSize, fontSizePx).toString();
-  return {
-    "--line-height-offset": `calc((((var(--line-height-scale) * var(--font-size-px)) - ${lineHeightActual}) / 2) / var(--font-size-px))`
-  };
-}
-function capsize({
-  fontFamily = "sans",
-  metrics,
-  fontSize,
-  lineHeight,
-  rootSize = 16
-}) {
-  const fontMetrics = metrics || FONT_METRICS[fontFamily];
-  if (!fontMetrics) {
-    return {
-      styles: {
-        fontSize: typeof fontSize === "number" ? `${fontSize}px` : fontSize,
-        lineHeight: typeof lineHeight === "number" ? `${lineHeight}px` : lineHeight
-      },
-      className: ""
-    };
-  }
-  const { ascent, descent, lineGap, unitsPerEm, capHeight } = fontMetrics;
-  const ascentScale = ascent / unitsPerEm;
-  const descentScale = Math.abs(descent) / unitsPerEm;
-  const capHeightScale = capHeight / unitsPerEm;
-  const lineGapScale = lineGap / unitsPerEm;
-  const lineHeightScale = (ascent + lineGap + Math.abs(descent)) / unitsPerEm;
-  const fontSizeActual = normalizeValue(fontSize, rootSize);
-  const lineHeightProps = lineHeightProperties(lineHeight, rootSize, fontSizeActual);
-  const fontSizeKey = typeof fontSize === "number" ? fontSize : fontSizeActual;
-  const className = `capsize-${fontFamily}-${Math.round(fontSizeKey)}`;
-  const styles = {
-    fontSize: typeof fontSize === "number" ? `${fontSize}px` : fontSize,
-    lineHeight: typeof lineHeight === "number" ? `${lineHeight}px` : lineHeight,
-    "--font-size-px": String(fontSizeActual),
-    "--ascent-scale": round(ascentScale),
-    "--descent-scale": round(descentScale),
-    "--cap-height-scale": round(capHeightScale),
-    "--line-gap-scale": round(lineGapScale),
-    "--line-height-scale": round(lineHeightScale),
-    ...lineHeightProps
-  };
-  return {
-    styles,
-    className,
-    cssText: `
-      .${className}::before {
-        display: table;
-        content: "";
-        margin-bottom: calc(((var(--ascent-scale) - var(--cap-height-scale) + var(--line-gap-scale) / 2) - var(--line-height-offset)) * -1em);
-      }
-      .${className}::after {
-        display: table;
-        content: "";
-        margin-top: calc(((var(--descent-scale) + var(--line-gap-scale) / 2) - var(--line-height-offset)) * -1em);
-      }
-    `
-  };
-}
-var useCapsize = (options) => {
-  const { fontFamily = "sans", metrics, fontSize, lineHeight, rootSize = 16 } = options;
-  const result = useMemo(
-    () => capsize({ fontFamily, metrics, fontSize, lineHeight, rootSize }),
-    [fontFamily, metrics, fontSize, lineHeight, rootSize]
-  );
-  useEffect(() => {
-    if (!result.cssText) return;
-    const styleId = "capsize-styles";
-    let styleElement = document.getElementById(styleId);
-    if (!styleElement) {
-      styleElement = document.createElement("style");
-      styleElement.id = styleId;
-      document.head.appendChild(styleElement);
-    }
-    if (!styleElement.textContent?.includes(result.className)) {
-      styleElement.textContent += result.cssText;
-    }
-  }, [result.cssText, result.className]);
-  return {
-    styles: result.styles,
-    className: result.className
-  };
-};
-export {
-  FONT_METRICS,
-  capsize,
-  useCapsize
-};
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../components/src/capsize/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 */\nimport { useEffect, useMemo } from 'react'\n\nimport type { FontMetrics } from '../grid'\n\n// Capsize-style leading trim: ::before/::after pseudo-elements pull the space\n// above the cap height and below the baseline out of the first and last line,\n// so the element's box runs exactly from cap top to baseline. Anchoring the\n// trimmed box's bottom edge to a grid row therefore seats the baseline on the\n// grid — pair with snapLineHeight from @oxide/design-system/grid.\n\n// Grid FontMetrics plus the cap height, which the top trim needs.\n// Generate values on https://seek-oss.github.io/capsize/\nexport interface CapsizeFontMetrics extends FontMetrics {\n  capHeight: number\n}\n\nexport const FONT_METRICS: Record<string, CapsizeFontMetrics> = {\n  'suisse-intl': {\n    capHeight: 725,\n    ascent: 986,\n    descent: -311,\n    lineGap: 0,\n    unitsPerEm: 1000,\n  },\n}\n\nexport interface CapsizeOptions {\n  // Key into FONT_METRICS; ignored when metrics is given. Unknown families\n  // fall through with untrimmed font-size/line-height styles.\n  fontFamily?: string\n  metrics?: CapsizeFontMetrics\n  fontSize: number | string\n  lineHeight?: number | string\n  rootSize?: number\n}\n\nexport interface CapsizeResult {\n  styles: React.CSSProperties\n  className: string\n  // Rules for the trim pseudo-elements; useCapsize injects these, non-React\n  // consumers add them to a stylesheet themselves.\n  cssText?: string\n}\n\nfunction isRelativeValue(value: string) {\n  const isPercentValue = value.endsWith('%')\n  const isUnitlessValue = /\\d$/.test(value)\n  return isPercentValue || isUnitlessValue\n}\n\nfunction getRelativeValue(value: string) {\n  const isPercentValue = value.endsWith('%')\n  return isPercentValue\n    ? Number.parseInt(value.replace('%', ''), 10) / 100\n    : Number.parseFloat(value)\n}\n\nfunction normalizeValue(value: string | number, root: number, fs?: number): number {\n  if (typeof value === 'number') return value\n\n  if (value.endsWith('px')) return Number.parseFloat(value.replace('px', ''))\n  if (value.endsWith('rem')) return root * Number.parseFloat(value.replace('rem', ''))\n\n  if (isRelativeValue(value) && fs !== undefined) {\n    return fs * getRelativeValue(value)\n  }\n\n  return Number.parseInt(value, 10)\n}\n\nfunction round(value: number): string {\n  return Number.parseFloat(value.toFixed(4)).toString()\n}\n\n// With a fixed line height the em box is centred in the line box; this is the\n// resulting half leading in em, which both trims subtract.\nfunction lineHeightProperties(\n  lineHeight?: string | number,\n  rootSize = 16,\n  fontSizePx?: number,\n) {\n  if (lineHeight === undefined) return {}\n\n  const lineHeightStr = typeof lineHeight === 'number' ? `${lineHeight}px` : lineHeight\n\n  const lineHeightActual = isRelativeValue(lineHeightStr)\n    ? `calc(${getRelativeValue(lineHeightStr).toString()} * var(--font-size-px))`\n    : normalizeValue(lineHeightStr, rootSize, fontSizePx).toString()\n\n  return {\n    '--line-height-offset': `calc((((var(--line-height-scale) * var(--font-size-px)) - ${lineHeightActual}) / 2) / var(--font-size-px))`,\n  }\n}\n\n// The pure computation behind useCapsize.\nexport function capsize({\n  fontFamily = 'sans',\n  metrics,\n  fontSize,\n  lineHeight,\n  rootSize = 16,\n}: CapsizeOptions): CapsizeResult {\n  const fontMetrics = metrics || FONT_METRICS[fontFamily]\n\n  if (!fontMetrics) {\n    return {\n      styles: {\n        fontSize: typeof fontSize === 'number' ? `${fontSize}px` : fontSize,\n        lineHeight: typeof lineHeight === 'number' ? `${lineHeight}px` : lineHeight,\n      },\n      className: '',\n    }\n  }\n\n  const { ascent, descent, lineGap, unitsPerEm, capHeight } = fontMetrics\n\n  const ascentScale = ascent / unitsPerEm\n  const descentScale = Math.abs(descent) / unitsPerEm\n  const capHeightScale = capHeight / unitsPerEm\n  const lineGapScale = lineGap / unitsPerEm\n  const lineHeightScale = (ascent + lineGap + Math.abs(descent)) / unitsPerEm\n\n  const fontSizeActual = normalizeValue(fontSize, rootSize)\n\n  const lineHeightProps = lineHeightProperties(lineHeight, rootSize, fontSizeActual)\n\n  const fontSizeKey = typeof fontSize === 'number' ? fontSize : fontSizeActual\n  const className = `capsize-${fontFamily}-${Math.round(fontSizeKey)}`\n\n  const styles = {\n    fontSize: typeof fontSize === 'number' ? `${fontSize}px` : fontSize,\n    lineHeight: typeof lineHeight === 'number' ? `${lineHeight}px` : lineHeight,\n    '--font-size-px': String(fontSizeActual),\n    '--ascent-scale': round(ascentScale),\n    '--descent-scale': round(descentScale),\n    '--cap-height-scale': round(capHeightScale),\n    '--line-gap-scale': round(lineGapScale),\n    '--line-height-scale': round(lineHeightScale),\n    ...lineHeightProps,\n  }\n\n  return {\n    styles,\n    className,\n    cssText: `\n      .${className}::before {\n        display: table;\n        content: \"\";\n        margin-bottom: calc(((var(--ascent-scale) - var(--cap-height-scale) + var(--line-gap-scale) / 2) - var(--line-height-offset)) * -1em);\n      }\n      .${className}::after {\n        display: table;\n        content: \"\";\n        margin-top: calc(((var(--descent-scale) + var(--line-gap-scale) / 2) - var(--line-height-offset)) * -1em);\n      }\n    `,\n  }\n}\n\nexport const useCapsize = (options: CapsizeOptions): CapsizeResult => {\n  const { fontFamily = 'sans', metrics, fontSize, lineHeight, rootSize = 16 } = options\n\n  const result = useMemo(\n    () => capsize({ fontFamily, metrics, fontSize, lineHeight, rootSize }),\n    [fontFamily, metrics, fontSize, lineHeight, rootSize],\n  )\n\n  // Inject CSS for the trim pseudo-elements, one shared style tag, one rule\n  // per class.\n  useEffect(() => {\n    if (!result.cssText) return\n\n    const styleId = 'capsize-styles'\n    let styleElement = document.getElementById(styleId) as HTMLStyleElement\n\n    if (!styleElement) {\n      styleElement = document.createElement('style')\n      styleElement.id = styleId\n      document.head.appendChild(styleElement)\n    }\n\n    if (!styleElement.textContent?.includes(result.className)) {\n      styleElement.textContent += result.cssText\n    }\n  }, [result.cssText, result.className])\n\n  return {\n    styles: result.styles,\n    className: result.className,\n  }\n}\n"],"mappings":"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","names":[]}

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

@@ -1,109 +0,0 @@
-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 snapLineHeight(g: GridResult, targetPx: number): {
-    cells: number;
-    px: number;
-};
-interface FontMetrics {
-    ascent: number;
-    descent: number;
-    lineGap: number;
-    unitsPerEm: number;
-}
-declare function baselineOffset(m: FontMetrics, fontSize: number, lineHeight: number): number;
-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, type FontMetrics, GUTTER_WEIGHT, type GridExtent, type GridResult, type GridSpec, LADDER_MIN_CELL, SOLVE_MAX_COLUMN, SOLVE_MAX_GUTTER, SOLVE_MAX_MARGIN, type Segment, type Solution, baselineOffset, betterFit, cellLadder, computeGrid, gridExtent, gridLineSegments, parseAspect, pickCellOption, round2, snapLineHeight, snapUnit, solveMultiples };

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

@@ -1,278 +0,0 @@
-// 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 snapLineHeight(g, targetPx) {
-  const cells = Math.max(1, Math.round(targetPx / g.cellH));
-  return { cells, px: cells * g.cellH };
-}
-function baselineOffset(m, fontSize, lineHeight) {
-  const emBox = fontSize * (m.ascent + m.lineGap + Math.abs(m.descent)) / m.unitsPerEm;
-  const halfLeading = (lineHeight - emBox) / 2;
-  return halfLeading + fontSize * (m.ascent + m.lineGap / 2) / m.unitsPerEm;
-}
-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,
-  baselineOffset,
-  betterFit,
-  cellLadder,
-  computeGrid,
-  gridExtent,
-  gridLineSegments,
-  parseAspect,
-  pickCellOption,
-  round2,
-  snapLineHeight,
-  snapUnit,
-  solveMultiples
-};
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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// Snaps a target line height to a whole number of cell rows. Text set at the\n// returned height advances by whole cells, so with the first baseline seated\n// on a cell line every following baseline lands on the grid too. Font size is\n// the consumer's choice — typically a share of the line height.\nexport function snapLineHeight(\n  g: GridResult,\n  targetPx: number,\n): { cells: number; px: number } {\n  const cells = Math.max(1, Math.round(targetPx / g.cellH))\n  return { cells, px: cells * g.cellH }\n}\n\n// Vertical font metrics in font units, as reported by capsize or fonttools;\n// descent is negative.\nexport interface FontMetrics {\n  ascent: number\n  descent: number\n  lineGap: number\n  unitsPerEm: number\n}\n\n// Distance from the top of the line box to the first baseline. With a fixed\n// line height, renderers centre the font's em box in the line box (half\n// leading), so the baseline sits one ascent (plus half the line gap) below\n// that. To seat a text block's first baseline on cell row `r`:\n//\n//   y = g.rowOffset + r * g.cellH − baselineOffset(m, fontSize, lineHeight)\nexport function baselineOffset(\n  m: FontMetrics,\n  fontSize: number,\n  lineHeight: number,\n): number {\n  const emBox = (fontSize * (m.ascent + m.lineGap + Math.abs(m.descent))) / m.unitsPerEm\n  const halfLeading = (lineHeight - emBox) / 2\n  return halfLeading + (fontSize * (m.ascent + m.lineGap / 2)) / m.unitsPerEm\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":[]}