@spotlab/hand-matrix 0.3.0 → 0.5.0

package/README.md

@@ -5,13 +5,13 @@ and [`@spotlab/range`](../range) — no Tailwind, no bundler-plugin
 requirement.
 
 ```tsx
-import { RangeGrid } from "@spotlab/hand-matrix";
+import { RangeMatrix, rangeToMatrix } from "@spotlab/hand-matrix";
 import "@spotlab/hand-matrix/style.css";
 import { initRange } from "@spotlab/range";
 
 await initRange(); // once, at startup
 
-<RangeGrid range="AKs:0.5,QQ" />;
+<RangeMatrix {...rangeToMatrix("AKs:0.5,QQ")} />;
 ```
 
 ## Exports
@@ -20,31 +20,33 @@ Everything below is exported from the package root.
 
 ### Display
 
-- `HandMatrix` — the bare 13x13 grid primitive. Takes no range data; styling
-  is entirely the caller's job via `comboStyle`, keyed by combo string (e.g.
-  `"AKs"`). Each cell carries a `data-combo` attribute. Props:
-  - `comboStyle?: (combo) => CSSProperties` — per-cell style.
-  - `onPointerDown?`, `onPointerEnter?: CellPointerHandler` — the
-    `(combo, event)` handlers to use for dragging across cells, with a mouse
-    or a finger. `onPointerDown` releases the implicit pointer capture a
-    touch takes on its first cell. `onPointerEnter` fires once each time the
-    pointer moves onto a new cell, found by hit-testing each `pointermove`
-    (`elementFromPoint`), so it also fires during a touch drag, where
-    enter events never reach the other cells. Passing `onPointerDown` sets
-    `touch-action: none` and `user-select: none` on the grid, so a drag
-    neither scrolls the page nor selects the combo text it crosses.
-  - `className?: string` — merged onto the `.spotlab-hm-root` wrapper.
-- `RangeGrid` — a read-only display component. Accepts the expanded
-  `HandFrequency[]` form or a range string directly (parsed via
-  `@spotlab/range`), and fills each cell to its combo's mean weight. Props:
-  `range: HandFrequency[] | string`, `fill?: string` (a CSS color, defaulting
-  to `var(--spotlab-hm-fill)`), `className?: string`.
-- `cellFillGradient(stops: string[]): string` / `CELL_FILL_DIRECTION` — the
-  canonical left-to-right gradient helper used to render a cell's fill.
-  Returns `"transparent"` for no stops.
-
-`RangeGrid`'s combo collapse (`toComboWeights`) is a wasm call, so
-`initRange()` must have resolved before rendering it — see
+- `RangeMatrix` — the read-only grid, for one range or several actions at
+  once, drawn exactly as `RangeMatrixEditor` draws it but without painting.
+  Each cell stacks its actions' weights as colored bands, dead cells
+  (`avail` 0) are hatched, and capped cells (`avail` below 1) show a cap
+  line with the rest hatched. Each cell carries a `data-combo` attribute.
+  Props (`RangeMatrixProps`):
+  - `cells: EditorCell[]` — one per combo, in `@spotlab/range`'s `COMBOS`
+    order (see [Editing](#editing)).
+  - `actions: EditorActionSpec[]` — index-aligned with each cell's
+    `weights`.
+  - `order: number[]` — indices into `actions`, in the order bands stack.
+    An action left out isn't drawn, so its share of a cell stays
+    transparent; include it to give it a color.
+  - `className?: string`.
+- `rangeToMatrix(range, { color?, labels? }): RangeMatrixProps` (without
+  `className`) — `RangeMatrix`'s props for drawing one range:
+  `<RangeMatrix {...rangeToMatrix(range)} />`. Takes a range string (parsed
+  via `@spotlab/range`) or the expanded `HandFrequency[]` form, and fills
+  each cell to its combo's mean weight in `color` (default
+  `var(--spotlab-hm-fill)`), leaving the rest blank. The returned `actions`
+  are `in` and `out`, labeled by `labels.in` (default `"In range"`) and
+  `labels.out` (default `"Out of range"`), for building your own legend.
+  Memoize the result (e.g. `useMemo`) rather than calling it on every
+  render.
+
+`rangeToMatrix`'s parse and combo collapse (`toComboWeights`) are wasm
+calls, so `initRange()` must have resolved before calling it — see
 [`@spotlab/range`](../range)'s own README for why that call is explicit
 rather than automatic.
 
@@ -55,9 +57,8 @@ raise). Its state is an array of 169 `EditorCell`s, one per combo in
 `@spotlab/range`'s `COMBOS` order. Every component is fully controlled: state
 goes in as props and changes come out through `on*Change` callbacks.
 
-- `RangeMatrixEditor` — the paintable grid. Draws each cell's action bands,
-  hatches dead cells (`avail` 0), marks capped cells (`avail` below 1), and
-  wires brush/eyedropper painting onto `HandMatrix` for mouse and touch.
+- `RangeMatrixEditor` — the paintable grid: `RangeMatrix`'s cells with
+  brush/eyedropper painting wired on for mouse and touch.
   Props (`RangeMatrixEditorProps`):
   - `cells: EditorCell[]` and `onCellsChange(cells)`.
   - `actions: EditorActionSpec[]` — index-aligned with each cell's
@@ -85,9 +86,9 @@ goes in as props and changes come out through `on*Change` callbacks.
 - `useRangePainting(opts)` — the brush/eyedropper state machine behind
   `RangeMatrixEditor`, for building your own grid. `opts` takes the editor's
   `cells`, `brush`, `tool` and their three `on*Change` callbacks. Returns
-  `{ onCellDown(combo), onCellEnter(combo) }`; wire them to `HandMatrix`'s
-  `onPointerDown`/`onPointerEnter`. A stroke ends on any window `pointerup`
-  or `pointercancel`.
+  `{ onCellDown(combo), onCellEnter(combo) }`: call `onCellDown` when a
+  pointer goes down on a cell and `onCellEnter` each time it moves onto
+  another one. A stroke ends on any window `pointerup` or `pointercancel`.
 - `seedCells(avail, actionWeights, passive): EditorCell[]` — build the
   initial grid from a parent range's per-combo availability (`null` for
   unconstrained) and each action's absolute per-combo weights (the
@@ -95,13 +96,16 @@ goes in as props and changes come out through `on*Change` callbacks.
   produces).
 - `cellsToComboWeights(cells, actionIndex): Map<string, number>` — collapse
   one action back to absolute per-combo weights, ready to save as a range.
-- `cellsToRanges(original, seed, cells): HandFrequency[][]` — turn the
-  edited grid back into one hand-keyed range per action. `original` holds
-  each action's range (or `null`) in editor action order, `seed` the cells
-  the editor opened with, and `cells` the cells after editing. Combos whose
-  cell still matches its seed keep each action's original hands verbatim;
-  changed combos, and every combo of a `null` action, are rebuilt from the
-  cells.
+- `cellsToRanges(original, seed, cells, avail?): HandFrequency[][]` — turn
+  the edited grid back into one hand-keyed range per action. `original`
+  holds each action's range (or `null`) in editor action order, `seed` the
+  cells the editor opened with, and `cells` the cells after editing.
+  `avail` is the parent range per hand (`null` for unconstrained); leave it
+  out when the parent gives every hand of a combo the same weight. Combos
+  whose cell still matches its seed keep each action's original hands
+  verbatim, and a `null` action takes what's left of each hand there.
+  Changed combos are rebuilt from the cells. Either way, each hand's
+  actions sum to its parent weight.
 - `comboWeightsToCells(cells, actionWeights, passive): EditorCell[]` — the
   inverse: re-derive the cells' conditional weights from absolute
   per-action ranges, keeping each cell's `avail`.
@@ -112,7 +116,7 @@ goes in as props and changes come out through `on*Change` callbacks.
   is the combo's cap in the parent range and `weights` are each action's
   share of it, summing to 100), `EditorActionSpec`
   (`{ id: string; label: string; color: string }`), `PaintTool`,
-  `CellPointerHandler`, `RangeMatrixEditorProps`, `ActionWeightSlidersProps`,
+  `RangeMatrixEditorProps`, `ActionWeightSlidersProps`,
   `WeightInputProps`.
 
 **The editor works at combo level.** A cell is one of the 169 combos (`AKs`,
@@ -130,7 +134,7 @@ custom property has a default declared on `.spotlab-hm-root`, so the
 component renders correctly with zero theming.
 
 Because the `className` you pass to a component lands on that same root, a
-class that sets variables works there too (`<RangeGrid className="my-theme" />`
+class that sets variables works there too (`<RangeMatrix className="my-theme" … />`
 with `.my-theme { --spotlab-hm-border: … }`), in addition to the
 `.spotlab-hm-root` selector form below.
 
@@ -192,9 +196,10 @@ Available variables: `--spotlab-hm-border`, `--spotlab-hm-border-width`,
 `--spotlab-hm-muted-bg`, `--spotlab-hm-muted-fg`, `--spotlab-hm-track-bg`,
 `--spotlab-hm-row-passive-bg`, `--spotlab-hm-dead-hatch`.
 
-Action/fill colors (`RangeGrid`'s `fill` prop) are **not** theme variables —
-they are data, passed as props. `--spotlab-hm-fill` is only the default used
-when `fill` is omitted.
+Action colors (each `EditorActionSpec`'s `color`, or `rangeToMatrix`'s
+`color` option) are **not** theme variables — they are data, passed as props.
+`--spotlab-hm-fill` is only the default `rangeToMatrix` uses when `color` is
+omitted.
 
 ## License
 

package/dist/editor/cells.d.ts

@@ -31,17 +31,23 @@ export declare function comboWeightsToCells(cells: EditorCell[], actionWeights:
  * Turn an edited grid back into one hand-keyed range per action, keeping each
  * action's original hands wherever the editor didn't touch them. `original`
  * holds each action's range in editor action order, `seed` the cells the
- * editor opened with, and `cells` the cells after editing.
+ * editor opened with, and `cells` the cells after editing. `avail` is the
+ * parent range per hand, as passed (collapsed) to `seedCells`: `null` means
+ * unconstrained, and leaving it out takes each hand's weight from its cell's
+ * `avail`, which is exact whenever the parent gives every hand of a combo the
+ * same weight.
  *
  * A combo whose cell still equals its seed cell (same `avail`, same weights)
  * keeps every action's original hands verbatim, so input the whole-percent grid
  * can't represent — a single suit (`AhKh:0.7`) or a fractional weight
- * (`QQ:0.333`) — survives a save. A changed combo is rebuilt from the cells as
- * `cellsToComboWeights` does. An action whose original is `null` (e.g. an
- * implicit fold) is always rebuilt from the cells in full.
+ * (`QQ:0.333`) — survives a save. An action whose original is `null` (e.g. an
+ * implicit fold) takes what's left of each hand there: its parent weight minus
+ * the preserved originals, never below 0, split across `null` actions by their
+ * cell weights. A changed combo is rebuilt from its cell for every action, each
+ * hand getting the action's share of its own parent weight.
  *
  * Each rebuilt combo takes its first original hand's place, and combos the
  * original didn't have follow in matrix order, so an unedited range formats
  * back to the string it came from.
  */
-export declare function cellsToRanges(original: (HandFrequency[] | null)[], seed: EditorCell[], cells: EditorCell[]): HandFrequency[][];
+export declare function cellsToRanges(original: (HandFrequency[] | null)[], seed: EditorCell[], cells: EditorCell[], avail?: HandFrequency[] | null): HandFrequency[][];

package/dist/editor/matrix-editor.d.ts

@@ -1,24 +1,17 @@
 import { FC } from 'react';
+import { MatrixDisplayProps } from '../hand-matrix';
 import { PaintTool } from './use-range-painting';
 import { EditorCell } from './cells';
-import { EditorActionSpec } from './weights';
-export type RangeMatrixEditorProps = {
-    /** The 169-cell grid, in `@spotlab/range`'s `COMBOS` order. */
-    cells: EditorCell[];
-    /** Index-aligned with each cell's `weights` array. */
-    actions: EditorActionSpec[];
-    /** Indices into `actions`/`weights`, in the order bands should stack — a display concern the consumer owns (e.g. biggest raise first). */
-    order: number[];
+export type RangeMatrixEditorProps = MatrixDisplayProps & {
     brush: number[];
     tool: PaintTool;
     onCellsChange: (cells: EditorCell[]) => void;
     onBrushChange: (brush: number[]) => void;
     onToolChange: (tool: PaintTool) => void;
-    className?: string;
 };
 /**
- * The paintable 13x13 range grid: per-cell action bands, the dead-cell hatch,
- * the capped-cell cap marker, and the brush/eyedropper painting wired onto
- * `HandMatrix`. Fully controlled; `useRangePainting` drives the state changes.
+ * The paintable 13x13 range grid: `RangeMatrix`'s cells with brush/eyedropper
+ * painting wired onto them. Fully controlled; `useRangePainting` drives the
+ * state changes.
  */
 export declare const RangeMatrixEditor: FC<RangeMatrixEditorProps>;

package/dist/hand-matrix.d.ts

@@ -1,10 +1,7 @@
 import { CSSProperties, FC, PointerEvent as ReactPointerEvent } from 'react';
-export declare const CELL_FILL_DIRECTION = "to right";
-export declare const cellFillGradient: (stops: string[]) => string;
-export type CellPointerHandler = (combo: string, event: ReactPointerEvent<HTMLDivElement>) => void;
-type ComboStyleProp = {
-    comboStyle?: (combo: string) => CSSProperties;
-};
+import { EditorCell } from './editor/cells';
+import { EditorActionSpec } from './editor/weights';
+type CellPointerHandler = (combo: string, event: ReactPointerEvent<HTMLDivElement>) => void;
 type GridPointerHandlers = {
     /**
      * A pointer (mouse, pen or touch) went down on `combo`'s cell. The grid
@@ -22,12 +19,29 @@ type GridPointerHandlers = {
      */
     onPointerEnter?: CellPointerHandler;
 };
+/** The cell data both `RangeMatrix` and `RangeMatrixEditor` draw from. */
+export type MatrixDisplayProps = {
+    /** The 169-cell grid, in `@spotlab/range`'s `COMBOS` order. */
+    cells: EditorCell[];
+    /** Index-aligned with each cell's `weights` array. */
+    actions: EditorActionSpec[];
+    /**
+     * Indices into `actions`/`weights`, in the order bands should stack. An
+     * action left out isn't drawn, so its share of a cell stays transparent.
+     */
+    order: number[];
+    className?: string;
+};
 /**
- * The bare 13x13 grid. Each cell carries a `data-combo` attribute. Passing
- * `onPointerDown` marks the grid as a drag surface (`dragSurfaceStyle`): a
- * drag reaches the handlers instead of scrolling the page or selecting text.
+ * The 13x13 grid that `RangeMatrix` and `RangeMatrixEditor` both render, so
+ * the two draw cells identically: each cell stacks its actions' weights as
+ * bands in `order`, with dead and capped cells marked. Each cell carries a
+ * `data-combo` attribute. The editor adds a per-cell cursor and the painting
+ * handlers; passing `onPointerDown` also makes the grid a drag surface
+ * (`dragSurfaceStyle`), so a drag reaches the handlers instead of scrolling
+ * the page or selecting text. Internal: not exported from the package root.
  */
-export declare const HandMatrix: FC<{
-    className?: string;
-} & ComboStyleProp & GridPointerHandlers>;
+export declare const HandMatrix: FC<MatrixDisplayProps & GridPointerHandlers & {
+    cursorOf?: (cell: EditorCell) => CSSProperties["cursor"];
+}>;
 export {};

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { HandMatrix, cellFillGradient, CELL_FILL_DIRECTION, type CellPointerHandler, } from './hand-matrix';
-export { RangeGrid } from './range-grid';
+export { RangeMatrix, type RangeMatrixProps } from './range-matrix';
+export { rangeToMatrix } from './range-to-matrix';
 export { RangeMatrixEditor, type RangeMatrixEditorProps, } from './editor/matrix-editor';
 export { ActionWeightSliders, type ActionWeightSlidersProps, type WeightInputProps, } from './editor/action-sliders';
 export { useRangePainting, type PaintTool } from './editor/use-range-painting';

package/dist/index.js

@@ -1,356 +1,368 @@
-import { useCallback as g, useEffect as N, useLayoutEffect as S, useMemo as I, useRef as b } from "react";
-import { COMBOS as v, comboOf as A, expandComboWeights as M, parseRange as P, toComboWeights as W } from "@spotlab/range";
-import { jsx as p, jsxs as w } from "react/jsx-runtime";
-var D = (t, e) => Array.from({ length: Math.ceil(t.length / e) }, (n, r) => t.slice(r * e, r * e + e)), T = "to right", R = (t) => t.length === 0 ? "transparent" : `linear-gradient(${T}, ${t.join(", ")})`, O = (t) => {
-  const e = t.target;
-  e.hasPointerCapture(t.pointerId) && e.releasePointerCapture(t.pointerId);
-}, $ = (t, e, n) => {
-  const r = t.ownerDocument.elementFromPoint(e, n)?.closest("[data-combo]");
-  return !r || !t.contains(r) ? null : r.getAttribute("data-combo");
-}, B = ({ combo: t, onPointerDown: e, comboStyle: n }) => /* @__PURE__ */ p("div", {
-  className: "spotlab-hm-cell",
-  "data-combo": t,
-  style: n?.(t),
-  onPointerDown: e && ((r) => {
-    O(r), e(t, r);
-  }),
-  children: /* @__PURE__ */ p("div", {
-    className: "spotlab-hm-cell-inner",
-    children: /* @__PURE__ */ p("div", {
-      "data-combo": t,
-      children: t
-    })
-  })
-}), F = ({ row: t, ...e }) => /* @__PURE__ */ p("div", {
-  className: "spotlab-hm-row",
-  children: t.map((n, r) => /* @__PURE__ */ p(B, {
-    combo: n,
-    ...e
-  }, r))
-}), X = {
-  touchAction: "none",
-  userSelect: "none",
-  WebkitUserSelect: "none",
-  WebkitTouchCallout: "none"
-}, x = ({ className: t, onPointerDown: e, onPointerEnter: n, ...r }) => {
-  const a = b(null), o = (s) => {
-    const l = $(s.currentTarget, s.clientX, s.clientY);
-    l !== a.current && (a.current = l, l && n?.(l, s));
-  };
-  return /* @__PURE__ */ p("div", {
-    className: ["spotlab-hm-root", t].filter(Boolean).join(" "),
-    style: e ? X : void 0,
-    onPointerDown: n && ((s) => {
-      a.current = $(s.currentTarget, s.clientX, s.clientY);
-    }),
-    onPointerMove: n && o,
-    onPointerLeave: n && (() => a.current = null),
-    children: D(v, 13).map((s, l) => /* @__PURE__ */ p(F, {
-      row: s,
-      onPointerDown: e,
-      ...r
-    }, l))
-  });
-}, _ = (t, e) => ({ background: R([`${t} 0 ${e * 100}%`, `transparent ${e * 100}% 100%`]) }), rt = ({ range: t, fill: e = "var(--spotlab-hm-fill)", className: n }) => {
-  const r = I(() => {
-    const a = typeof t == "string" ? P(t) : t;
-    return W(a);
-  }, [t]);
-  return /* @__PURE__ */ p(x, {
-    className: n,
-    comboStyle: (a) => {
-      const o = r.get(a);
-      return o ? _(e, o) : {};
-    }
-  });
-}, j = (t) => Math.max(0, Math.min(100, Math.round(t))), q = (t, e) => {
+import { useCallback as M, useEffect as R, useLayoutEffect as L, useRef as y } from "react";
+import { COMBOS as C, comboOf as P, handsOfCombo as T, parseRange as W, toComboWeights as D } from "@spotlab/range";
+import { jsx as v, jsxs as E } from "react/jsx-runtime";
+var B = (t) => Math.max(0, Math.min(100, Math.round(t))), F = (t, r) => {
   const n = t.map(Math.round);
-  let r = 100 - n.reduce((a, o) => a + o, 0);
-  if (r !== 0) {
-    for (let a = 0; a < n.length; a++) if (a !== e && n[a] + r >= 0) {
-      n[a] += r, r = 0;
+  let e = 100 - n.reduce((a, o) => a + o, 0);
+  if (e !== 0) {
+    for (let a = 0; a < n.length; a++) if (a !== r && n[a] + e >= 0) {
+      n[a] += e, e = 0;
       break;
     }
-    if (r !== 0) {
-      for (let a = 0; a < n.length; a++) if (a !== e && n[a] > 0) {
-        const o = Math.min(n[a], -r);
-        if (n[a] -= o, r += o, r === 0) break;
+    if (e !== 0) {
+      for (let a = 0; a < n.length; a++) if (a !== r && n[a] > 0) {
+        const o = Math.min(n[a], -e);
+        if (n[a] -= o, e += o, e === 0) break;
       }
-      n[e] = Math.max(0, n[e] + r);
+      n[r] = Math.max(0, n[r] + e);
     }
   }
   return n;
-}, G = (t, e, n, r) => {
-  const a = j(n), o = t.slice();
-  o[e] = a;
-  const s = 100 - a, l = [];
-  for (let i = 0; i < t.length; i++) i !== e && l.push(i);
-  const c = l.reduce((i, d) => i + t[d], 0);
-  if (c <= 0) {
-    l.forEach((d) => o[d] = 0);
-    const i = e === r ? l[0] : r;
-    i != null && (o[i] = s);
-  } else l.forEach((i) => o[i] = Math.round(t[i] / c * s));
-  return q(o, e);
-}, E = (t, e) => t.reduce((n, r, a) => a === e ? n : n + r, 0), C = new Map(v.map((t, e) => [t, e])), U = (t, e, n) => {
-  const r = t.slice();
-  return r[C.get(e)] = n, r;
-}, L = (t, e) => {
+}, X = (t, r, n, e) => {
+  const a = B(n), o = t.slice();
+  o[r] = a;
+  const c = 100 - a, i = [];
+  for (let l = 0; l < t.length; l++) l !== r && i.push(l);
+  const u = i.reduce((l, f) => l + t[f], 0);
+  if (u <= 0) {
+    i.forEach((f) => o[f] = 0);
+    const l = r === e ? i[0] : e;
+    l != null && (o[l] = c);
+  } else i.forEach((l) => o[l] = Math.round(t[l] / u * c));
+  return F(o, r);
+}, N = (t, r) => t.reduce((n, e, a) => a === r ? n : n + e, 0), k = new Map(C.map((t, r) => [t, r])), j = (t, r, n) => {
+  const e = t.slice();
+  return e[k.get(r)] = n, e;
+}, I = (t, r) => {
   const n = t.slice();
-  let r = E(n, e);
-  if (r > 100) {
-    const a = 100 / r;
-    for (let o = 0; o < n.length; o++) o !== e && (n[o] = Math.round(n[o] * a));
-    r = E(n, e);
+  let e = N(n, r);
+  if (e > 100) {
+    const a = 100 / e;
+    for (let o = 0; o < n.length; o++) o !== r && (n[o] = Math.round(n[o] * a));
+    e = N(n, r);
   }
-  return n[e] = Math.max(0, 100 - r), n;
+  return n[r] = Math.max(0, 100 - e), n;
 };
-function nt(t, e, n) {
-  return v.map((r) => {
-    const a = t ? t.get(r) ?? 0 : 1, o = e.map(() => 0);
+function et(t, r, n) {
+  return C.map((e) => {
+    const a = t ? t.get(e) ?? 0 : 1, o = r.map(() => 0);
     return a <= 0 ? (o[n] = 100, {
       avail: 0,
       weights: o
-    }) : (e.forEach((s, l) => {
-      const c = s?.get(r) ?? 0;
-      o[l] = Math.round(c / a * 100);
+    }) : (r.forEach((c, i) => {
+      const u = c?.get(e) ?? 0;
+      o[i] = Math.round(u / a * 100);
     }), {
       avail: a,
-      weights: L(o, n)
+      weights: I(o, n)
     });
   });
 }
-var Y = 8;
-function H(t, e) {
+var S = 8;
+function rt(t, r) {
   const n = /* @__PURE__ */ new Map();
-  return t.forEach((r, a) => {
-    if (r.avail <= 0) return;
-    const o = r.weights.reduce((l, c) => l + c, 0);
+  return t.forEach((e, a) => {
+    if (e.avail <= 0) return;
+    const o = e.weights.reduce((i, u) => i + u, 0);
     if (!o) return;
-    const s = Number((r.weights[e] / o * r.avail).toFixed(Y));
-    s && n.set(v[a], s);
+    const c = Number((e.weights[r] / o * e.avail).toFixed(S));
+    c && n.set(C[a], c);
   }), n;
 }
-function at(t, e, n) {
-  return t.map((r, a) => {
-    const o = e.map(() => 0);
-    if (r.avail <= 0)
+function nt(t, r, n) {
+  return t.map((e, a) => {
+    const o = r.map(() => 0);
+    if (e.avail <= 0)
       return o[n] = 100, {
-        avail: r.avail,
+        avail: e.avail,
         weights: o
       };
-    const s = v[a];
-    return e.forEach((l, c) => {
-      const i = l?.get(s) ?? 0;
-      o[c] = Math.round(i / r.avail * 100);
+    const c = C[a];
+    return r.forEach((i, u) => {
+      const l = i?.get(c) ?? 0;
+      o[u] = Math.round(l / e.avail * 100);
     }), {
-      avail: r.avail,
-      weights: L(o, n)
+      avail: e.avail,
+      weights: I(o, n)
     };
   });
 }
-var Q = (t, e) => t.avail !== e.avail || t.weights.length !== e.weights.length || t.weights.some((n, r) => n !== e.weights[r]);
-function ot(t, e, n) {
-  const r = new Set(v.filter((a, o) => Q(e[o], n[o])));
-  return t.map((a, o) => {
-    const s = H(n, o);
-    if (a === null) return M(s);
-    const l = (d) => {
-      const h = s.get(d);
-      return h ? M(/* @__PURE__ */ new Map([[d, h]])) : [];
-    }, c = [], i = /* @__PURE__ */ new Set();
-    for (const d of a) {
-      const h = A(d.hand);
-      r.has(h) ? i.has(h) || (i.add(h), c.push(...l(h))) : c.push(d);
+var q = (t, r) => t.avail !== r.avail || t.weights.length !== r.weights.length || t.weights.some((n, e) => n !== r.weights[e]);
+function at(t, r, n, e) {
+  const a = e && new Map(e.map(({ hand: s, frequency: h }) => [s, h])), o = (s, h) => e === void 0 ? h.avail : a ? a.get(s) ?? 0 : 1, c = t.map((s) => s && new Map(s.map(({ hand: h, frequency: g }) => [h, g]))), i = (s) => c.reduce((h, g) => h + (g?.get(s) ?? 0), 0), u = t.flatMap((s, h) => s ? [] : [h]), l = (s, h) => T(s).flatMap((g) => {
+    const b = Number(h(g).toFixed(S));
+    return b > 0 ? [{
+      hand: g,
+      frequency: b
+    }] : [];
+  }), f = (s, h) => {
+    const g = n[k.get(s)], b = g.weights.reduce((m, w) => m + w, 0);
+    return g.avail <= 0 || !b ? [] : l(s, (m) => g.weights[h] / b * o(m, g));
+  }, p = (s, h) => {
+    const g = n[k.get(s)], b = u.reduce((w, O) => w + g.weights[O], 0), m = b ? g.weights[h] / b : 1 / u.length;
+    return l(s, (w) => Math.max(0, o(w, g) - i(w)) * m);
+  }, d = new Set(C.filter((s, h) => q(r[h], n[h])));
+  return t.map((s, h) => {
+    if (s === null) return C.flatMap((m) => d.has(m) ? f(m, h) : p(m, h));
+    const g = [], b = /* @__PURE__ */ new Set();
+    for (const m of s) {
+      const w = P(m.hand);
+      d.has(w) ? b.has(w) || (b.add(w), g.push(...f(w, h))) : g.push(m);
     }
-    for (const d of r) i.has(d) || c.push(...l(d));
-    return c;
+    for (const m of d) b.has(m) || g.push(...f(m, h));
+    return g;
+  });
+}
+var _ = (t, r) => Array.from({ length: Math.ceil(t.length / r) }, (n, e) => t.slice(e * r, e * r + r)), U = (t) => `linear-gradient(to right, ${t.join(", ")})`, $ = (t, r, n) => {
+  const e = [];
+  let a = 0;
+  return n.forEach((o) => {
+    const c = (t.weights[o] || 0) / 100;
+    if (c <= 0) return;
+    const i = r[o].color;
+    e.push(`${i} ${a * 100}%`), e.push(`${i} ${(a + c) * 100}%`), a += c;
+  }), e.length > 0 && a < 1 - 1e-9 && e.push(`transparent ${a * 100}% 100%`), e.length > 0 ? U(e) : "none";
+}, Y = (t, r, n) => {
+  if (t.avail <= 0) return {
+    backgroundImage: "var(--spotlab-hm-dead-hatch)",
+    backgroundColor: "var(--spotlab-hm-muted-bg)",
+    color: "var(--spotlab-hm-muted-fg)"
+  };
+  if (t.avail < 1) {
+    const e = `${t.avail * 100}%`;
+    return {
+      backgroundImage: `repeating-linear-gradient(180deg, var(--spotlab-hm-muted-fg) 0 4px, transparent 4px 8px), var(--spotlab-hm-dead-hatch), ${$(t, r, n)}`,
+      backgroundSize: `1px 100%, ${(1 - t.avail) * 100}% 100%, ${t.avail * 100}% 100%`,
+      backgroundPosition: `${e} center, right center, left center`,
+      backgroundRepeat: "no-repeat, no-repeat, no-repeat"
+    };
+  }
+  return { backgroundImage: $(t, r, n) };
+}, G = (t) => {
+  const r = t.target;
+  r.hasPointerCapture(t.pointerId) && r.releasePointerCapture(t.pointerId);
+}, x = (t, r, n) => {
+  const e = t.ownerDocument.elementFromPoint(r, n)?.closest("[data-combo]");
+  return !e || !t.contains(e) ? null : e.getAttribute("data-combo");
+}, H = {
+  touchAction: "none",
+  userSelect: "none",
+  WebkitUserSelect: "none",
+  WebkitTouchCallout: "none"
+}, A = ({ cells: t, actions: r, order: n, className: e, cursorOf: a, onPointerDown: o, onPointerEnter: c }) => {
+  const i = y(null), u = (l) => {
+    const f = x(l.currentTarget, l.clientX, l.clientY);
+    f !== i.current && (i.current = f, f && c?.(f, l));
+  };
+  return /* @__PURE__ */ v("div", {
+    className: ["spotlab-hm-root", e].filter(Boolean).join(" "),
+    style: o ? H : void 0,
+    onPointerDown: c && ((l) => {
+      i.current = x(l.currentTarget, l.clientX, l.clientY);
+    }),
+    onPointerMove: c && u,
+    onPointerLeave: c && (() => i.current = null),
+    children: _(C, 13).map((l, f) => /* @__PURE__ */ v("div", {
+      className: "spotlab-hm-row",
+      children: l.map((p) => {
+        const d = t[k.get(p)];
+        return /* @__PURE__ */ v("div", {
+          className: "spotlab-hm-cell",
+          "data-combo": p,
+          style: {
+            ...Y(d, r, n),
+            cursor: a?.(d)
+          },
+          onPointerDown: o && ((s) => {
+            G(s), o(p, s);
+          }),
+          children: /* @__PURE__ */ v("div", {
+            className: "spotlab-hm-cell-inner",
+            children: /* @__PURE__ */ v("div", {
+              "data-combo": p,
+              children: p
+            })
+          })
+        }, p);
+      })
+    }, f))
   });
+}, ot = A;
+function lt(t, { color: r = "var(--spotlab-hm-fill)", labels: n = {} } = {}) {
+  const e = D(typeof t == "string" ? W(t) : t);
+  return {
+    cells: C.map((a) => {
+      const o = (e.get(a) ?? 0) * 100;
+      return {
+        avail: 1,
+        weights: [o, 100 - o]
+      };
+    }),
+    actions: [{
+      id: "in",
+      label: n.in ?? "In range",
+      color: r
+    }, {
+      id: "out",
+      label: n.out ?? "Out of range",
+      color: "transparent"
+    }],
+    order: [0]
+  };
 }
-function J(t) {
-  const { cells: e, brush: n, tool: r, onCellsChange: a, onBrushChange: o, onToolChange: s } = t, l = b(null), c = g(() => {
-    l.current?.abort(), l.current = null;
+function Q(t) {
+  const { cells: r, brush: n, tool: e, onCellsChange: a, onBrushChange: o, onToolChange: c } = t, i = y(null), u = M(() => {
+    i.current?.abort(), i.current = null;
   }, []);
-  N(() => c, [c]);
-  const i = b(e);
-  S(() => {
-    i.current = e;
-  }, [e]);
-  const d = g((u) => {
-    const f = i.current, { avail: m } = f[C.get(u)];
-    if (m <= 0) return;
-    const k = U(f, u, {
-      avail: m,
+  R(() => u, [u]);
+  const l = y(r);
+  L(() => {
+    l.current = r;
+  }, [r]);
+  const f = M((d) => {
+    const s = l.current, { avail: h } = s[k.get(d)];
+    if (h <= 0) return;
+    const g = j(s, d, {
+      avail: h,
       weights: [...n]
     });
-    i.current = k, a(k);
-  }, [n, a]), h = g((u) => {
-    const f = C.get(u);
-    e[f].avail <= 0 || (o([...e[f].weights]), s("brush"));
+    l.current = g, a(g);
+  }, [n, a]), p = M((d) => {
+    const s = k.get(d);
+    r[s].avail <= 0 || (o([...r[s].weights]), c("brush"));
   }, [
-    e,
+    r,
     o,
-    s
+    c
   ]);
   return {
-    onCellDown: g((u) => {
-      if (r === "eyedropper") {
-        h(u);
+    onCellDown: M((d) => {
+      if (e === "eyedropper") {
+        p(d);
         return;
       }
-      c();
-      const f = new AbortController();
-      l.current = f, window.addEventListener("pointerup", c, { signal: f.signal }), window.addEventListener("pointercancel", c, { signal: f.signal }), d(u);
+      u();
+      const s = new AbortController();
+      i.current = s, window.addEventListener("pointerup", u, { signal: s.signal }), window.addEventListener("pointercancel", u, { signal: s.signal }), f(d);
     }, [
-      r,
-      h,
-      d,
-      c
+      e,
+      p,
+      f,
+      u
     ]),
-    onCellEnter: g((u) => {
-      l.current && r === "brush" && d(u);
-    }, [r, d])
+    onCellEnter: M((d) => {
+      i.current && e === "brush" && f(d);
+    }, [e, f])
   };
 }
-var y = (t, e, n) => {
-  const r = [];
-  let a = 0;
-  return n.forEach((o) => {
-    const s = (t.weights[o] || 0) / 100;
-    if (s <= 0) return;
-    const l = e[o].color;
-    r.push(`${l} ${a * 100}%`), r.push(`${l} ${(a + s) * 100}%`), a += s;
-  }), r.length > 0 && a < 1 - 1e-9 && r.push(`transparent ${a * 100}% 100%`), R(r);
-}, lt = ({ cells: t, actions: e, order: n, brush: r, tool: a, onCellsChange: o, onBrushChange: s, onToolChange: l, className: c }) => {
-  const { onCellDown: i, onCellEnter: d } = J({
+var st = ({ cells: t, actions: r, order: n, brush: e, tool: a, onCellsChange: o, onBrushChange: c, onToolChange: i, className: u }) => {
+  const { onCellDown: l, onCellEnter: f } = Q({
     cells: t,
-    brush: r,
+    brush: e,
     tool: a,
     onCellsChange: o,
-    onBrushChange: s,
-    onToolChange: l
+    onBrushChange: c,
+    onToolChange: i
   });
-  return /* @__PURE__ */ p(x, {
-    className: c,
-    comboStyle: (h) => {
-      const u = t[C.get(h)];
-      if (u.avail <= 0) return {
-        background: "var(--spotlab-hm-dead-hatch)",
-        backgroundColor: "var(--spotlab-hm-muted-bg)",
-        cursor: "not-allowed",
-        color: "var(--spotlab-hm-muted-fg)"
-      };
-      const f = a === "eyedropper" ? "copy" : "pointer";
-      if (u.avail < 1) {
-        const m = `${u.avail * 100}%`;
-        return {
-          background: `repeating-linear-gradient(180deg, var(--spotlab-hm-muted-fg) 0 4px, transparent 4px 8px), var(--spotlab-hm-dead-hatch), ${y(u, e, n)}`,
-          backgroundSize: `1px 100%, ${(1 - u.avail) * 100}% 100%, ${u.avail * 100}% 100%`,
-          backgroundPosition: `${m} center, right center, left center`,
-          backgroundRepeat: "no-repeat, no-repeat, no-repeat",
-          cursor: f
-        };
-      }
-      return {
-        background: y(u, e, n),
-        cursor: f
-      };
-    },
-    onPointerDown: i,
-    onPointerEnter: d
+  return /* @__PURE__ */ v(A, {
+    cells: t,
+    actions: r,
+    order: n,
+    className: u,
+    cursorOf: (p) => p.avail <= 0 ? "not-allowed" : a === "eyedropper" ? "copy" : "pointer",
+    onPointerDown: l,
+    onPointerEnter: f
   });
-}, K = (t) => /* @__PURE__ */ p("input", {
+}, J = (t) => /* @__PURE__ */ v("input", {
   type: "number",
   className: "spotlab-hm-weight-input",
   ...t
-}), V = ({ value: t, color: e, passive: n, onChange: r }) => {
-  const a = b(null), o = b(!1), s = g((l) => {
-    const c = a.current;
-    if (!c) return;
-    const i = c.getBoundingClientRect();
-    r((l - i.left) / i.width * 100);
-  }, [r]);
-  return N(() => {
-    const l = (i) => {
-      o.current && s(i.clientX);
-    }, c = () => o.current = !1;
-    return window.addEventListener("pointermove", l), window.addEventListener("pointerup", c), () => {
-      window.removeEventListener("pointermove", l), window.removeEventListener("pointerup", c);
+}), K = ({ value: t, color: r, passive: n, onChange: e }) => {
+  const a = y(null), o = y(!1), c = M((i) => {
+    const u = a.current;
+    if (!u) return;
+    const l = u.getBoundingClientRect();
+    e((i - l.left) / l.width * 100);
+  }, [e]);
+  return R(() => {
+    const i = (l) => {
+      o.current && c(l.clientX);
+    }, u = () => o.current = !1;
+    return window.addEventListener("pointermove", i), window.addEventListener("pointerup", u), () => {
+      window.removeEventListener("pointermove", i), window.removeEventListener("pointerup", u);
     };
-  }, [s]), /* @__PURE__ */ p("div", {
+  }, [c]), /* @__PURE__ */ v("div", {
     ref: a,
     role: "slider",
     "aria-valuenow": t,
     "aria-valuemin": 0,
     "aria-valuemax": 100,
     className: "spotlab-hm-slider-track",
-    style: { background: `linear-gradient(to right, ${e} 0 ${t}%, var(--spotlab-hm-track-bg) ${t}% 100%)` },
-    onPointerDown: (l) => {
-      o.current = !0, s(l.clientX);
+    style: { background: `linear-gradient(to right, ${r} 0 ${t}%, var(--spotlab-hm-track-bg) ${t}% 100%)` },
+    onPointerDown: (i) => {
+      o.current = !0, c(i.clientX);
     },
-    children: /* @__PURE__ */ p("div", {
+    children: /* @__PURE__ */ v("div", {
       className: "spotlab-hm-slider-thumb",
       style: {
         left: `${t}%`,
-        border: `2px solid ${n ? "var(--spotlab-hm-muted-fg)" : e}`
+        border: `2px solid ${n ? "var(--spotlab-hm-muted-fg)" : r}`
       }
     })
   });
-}, Z = (t, e) => /* @__PURE__ */ w("span", {
+}, V = (t, r) => /* @__PURE__ */ E("span", {
   className: "spotlab-hm-slider-label",
-  children: [t.label, e && /* @__PURE__ */ p("span", {
+  children: [t.label, r && /* @__PURE__ */ v("span", {
     className: "spotlab-hm-slider-remainder",
     children: " · remainder"
   })]
-}), st = ({ actions: t, order: e, weights: n, passive: r, onWeightsChange: a, renderActionLabel: o, renderActionExtra: s, components: l, className: c }) => {
-  const i = l?.WeightInput ?? K, d = (h, u) => {
-    a(G(n, h, u, r));
+}), it = ({ actions: t, order: r, weights: n, passive: e, onWeightsChange: a, renderActionLabel: o, renderActionExtra: c, components: i, className: u }) => {
+  const l = i?.WeightInput ?? J, f = (p, d) => {
+    a(X(n, p, d, e));
   };
-  return /* @__PURE__ */ p("div", {
-    className: ["spotlab-hm-root spotlab-hm-sliders", c].filter(Boolean).join(" "),
-    children: e.map((h) => {
-      const u = t[h], f = h === r;
-      return /* @__PURE__ */ w("div", {
+  return /* @__PURE__ */ v("div", {
+    className: ["spotlab-hm-root spotlab-hm-sliders", u].filter(Boolean).join(" "),
+    children: r.map((p) => {
+      const d = t[p], s = p === e;
+      return /* @__PURE__ */ E("div", {
         className: "spotlab-hm-slider-row",
-        "data-passive": f,
-        children: [/* @__PURE__ */ w("div", {
+        "data-passive": s,
+        children: [/* @__PURE__ */ E("div", {
           className: "spotlab-hm-slider-header",
           children: [
-            /* @__PURE__ */ p("span", {
+            /* @__PURE__ */ v("span", {
               className: "spotlab-hm-slider-swatch",
-              style: { background: u.color }
+              style: { background: d.color }
             }),
-            o?.(u, h, f) ?? Z(u, f),
-            s?.(u, h)
+            o?.(d, p, s) ?? V(d, s),
+            c?.(d, p)
           ]
-        }), /* @__PURE__ */ w("div", {
+        }), /* @__PURE__ */ E("div", {
           className: "spotlab-hm-slider-track-row",
-          children: [/* @__PURE__ */ p(V, {
-            value: n[h],
-            color: u.color,
-            passive: f,
-            onChange: (m) => d(h, m)
-          }), /* @__PURE__ */ p(i, {
-            value: n[h],
-            "aria-label": `${u.label} weight`,
-            onChange: (m) => d(h, parseInt(m.target.value || "0", 10))
+          children: [/* @__PURE__ */ v(K, {
+            value: n[p],
+            color: d.color,
+            passive: s,
+            onChange: (h) => f(p, h)
+          }), /* @__PURE__ */ v(l, {
+            value: n[p],
+            "aria-label": `${d.label} weight`,
+            onChange: (h) => f(p, parseInt(h.target.value || "0", 10))
           })]
         })]
-      }, u.id);
+      }, d.id);
     })
   });
 };
 export {
-  st as ActionWeightSliders,
-  T as CELL_FILL_DIRECTION,
-  x as HandMatrix,
-  rt as RangeGrid,
-  lt as RangeMatrixEditor,
-  R as cellFillGradient,
-  H as cellsToComboWeights,
-  ot as cellsToRanges,
-  at as comboWeightsToCells,
-  G as rebalance,
-  nt as seedCells,
-  J as useRangePainting
+  it as ActionWeightSliders,
+  ot as RangeMatrix,
+  st as RangeMatrixEditor,
+  rt as cellsToComboWeights,
+  at as cellsToRanges,
+  nt as comboWeightsToCells,
+  lt as rangeToMatrix,
+  X as rebalance,
+  et as seedCells,
+  Q as useRangePainting
 };

package/dist/range-matrix.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { MatrixDisplayProps } from './hand-matrix';
+export type RangeMatrixProps = MatrixDisplayProps;
+/**
+ * A read-only 13x13 grid of several actions at once: each cell stacks its
+ * actions' weights as colored bands in `order`, hatches dead cells (`avail`
+ * 0), and marks capped cells (`avail` below 1) with a cap line and hatched
+ * remainder. Draws exactly what `RangeMatrixEditor` does, without painting.
+ */
+export declare const RangeMatrix: FC<RangeMatrixProps>;

package/dist/range-to-matrix.d.ts

@@ -0,0 +1,19 @@
+import { HandFrequency } from '@spotlab/range';
+import { RangeMatrixProps } from './range-matrix';
+/**
+ * `RangeMatrix`'s props for drawing one range: every cell is fully available
+ * and filled to its combo's mean weight in `color` (default
+ * `var(--spotlab-hm-fill)`), with the rest left blank. The two actions are
+ * `in` and `out`, labeled `labels.in` (default "In range") and `labels.out`
+ * (default "Out of range") for a legend of your own. Takes a range string or
+ * its expanded hand-keyed form; a string is parsed via `@spotlab/range`, so
+ * `initRange()` must have resolved. Parsing and collapsing are wasm calls, so
+ * memoize the result rather than calling this on every render.
+ */
+export declare function rangeToMatrix(range: HandFrequency[] | string, { color, labels, }?: {
+    color?: string;
+    labels?: {
+        in?: string;
+        out?: string;
+    };
+}): Omit<RangeMatrixProps, "className">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spotlab/hand-matrix",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A 13x13 poker hand-matrix React component: the read-only grid primitive and a range-string-aware display component, themed through CSS custom properties.",
   "type": "module",
   "license": "MIT",

package/dist/range-grid.d.ts

@@ -1,13 +0,0 @@
-import { FC } from 'react';
-import { HandFrequency } from '@spotlab/range';
-/**
- * A read-only 13x13 range grid: each cell fills to its combo's mean weight.
- * Accepts the expanded hand-keyed form or a range string directly — a range
- * string is parsed via `@spotlab/range`, so the caller never needs to touch
- * the parser itself to render one.
- */
-export declare const RangeGrid: FC<{
-    range: HandFrequency[] | string;
-    fill?: string;
-    className?: string;
-}>;