@ai-matrx/design-system 0.22.0 → 0.26.0

package/dist/data-table/grid-selection.d.cts

@@ -0,0 +1,166 @@
+/**
+ * Grid selection model for user data tables.
+ * @ai-matrx/design-system/data-table/grid-selection
+ *
+ * This moved here from the app so every table in the product shares one
+ * range-selection model.
+ *
+ * THE THREE STATES. A spreadsheet grid has three, not two, and collapsing them
+ * to two is what made this grid feel like a web page instead of a tool:
+ *
+ *   1. NOTHING SELECTED  — the grid at rest.
+ *   2. SELECTED          — one cell is current. Nothing has changed. You can
+ *                          look, copy, and move with the keyboard.
+ *   3. EDITING           — a value is being changed.
+ *
+ * State 2 is the one that was missing, and its absence is why every edit needed
+ * a double-click and why arrow keys, Tab, copy and fill-down were all
+ * impossible: none of them mean anything without a notion of "the current cell".
+ *
+ * 🚨 THE CLICK LAW — a single click may SELECT a cell, TOGGLE a two-state
+ * value, or OPEN a chooser. It may NEVER drop the user into a free-text buffer.
+ * Opening a menu is not a mutation and toggling a checkbox is instantly
+ * reversible, but landing in a text buffer turns every attempt to select-and-
+ * copy into an accidental edit. `directClickKinds()` below is the whole list of
+ * what a single click may act on; adding a free-text editor to it is a defect.
+ *
+ * A CHOOSER OPENS ON THE SECOND CLICK. A choice cell's first click SELECTS it
+ * (so Cmd-C, Cmd-X, the arrow keys and the right-click menu all have a current
+ * cell); a click on the cell that is ALREADY selected opens the option list —
+ * the Airtable gesture. Opening the chooser on the very first click moved
+ * focus into its search box, and every keyboard shortcut then went to that box
+ * instead of the grid: a choice column could not be copied at all (2026-09-14).
+ * Checkboxes and ratings stay one-click: a mis-click on those is instantly
+ * undone in place and steals no focus.
+ *
+ * CLIPBOARD KEYS. Cmd-C / Cmd-X / Cmd-V on a selected cell act on THAT CELL —
+ * copy its value, cut it (copy + clear), paste over it. A paste carrying a
+ * spreadsheet block (tabs / line breaks) lands as a block from the selected
+ * cell downward and rightward (`grid-clipboard.ts`). None of these need an
+ * editor open, which is the whole point: a normal table copies what you point
+ * at, not only what you are typing into.
+ *
+ * Addresses are (rowId, fieldName), never (rowIndex, colIndex): the grid
+ * reloads after every write, and realtime reorders rows underneath the user. An
+ * index-based selection silently jumps to a DIFFERENT cell when that happens —
+ * and the next keystroke then edits the wrong row.
+ *
+ * Pure module: no React, no DOM. Everything here is a function of the current
+ * address and the row/field lists, which is what makes the navigation testable
+ * without mounting a grid.
+ */
+type CellAddress = {
+    rowId: string;
+    fieldName: string;
+};
+type GridMove = "up" | "down" | "left" | "right" | "nextCell" | "prevCell" | "rowStart" | "rowEnd" | "gridStart" | "gridEnd";
+/** What a keystroke means when a cell is selected but NOT being edited. */
+type GridKeyAction = {
+    kind: "move";
+    move: GridMove;
+}
+/** Shift+arrow: grow the range toward `move`, anchor fixed. */
+ | {
+    kind: "extend";
+    move: GridMove;
+} | {
+    kind: "selectAll";
+} | {
+    kind: "selectRow";
+} | {
+    kind: "selectColumn";
+} | {
+    kind: "fillDown";
+} | {
+    kind: "edit";
+} | {
+    kind: "editSeeded";
+    seed: string;
+} | {
+    kind: "clearCell";
+} | {
+    kind: "copy";
+} | {
+    kind: "cut";
+} | {
+    kind: "paste";
+} | {
+    kind: "escape";
+} | null;
+type CellRange = {
+    anchor: CellAddress;
+    focus: CellAddress;
+};
+/** The rectangle a range spans, as inclusive indexes into the grid's order. */
+type RangeBounds = {
+    r0: number;
+    r1: number;
+    c0: number;
+    c1: number;
+};
+declare function rangeBounds(range: CellRange, rowIds: readonly string[], fieldNames: readonly string[]): RangeBounds | null;
+declare function rangeSize(bounds: RangeBounds): {
+    rows: number;
+    cols: number;
+    cells: number;
+};
+declare function boundsContain(bounds: RangeBounds, rowIndex: number, colIndex: number): boolean;
+/** Every cell of the range in reading order (row by row, left to right). */
+declare function cellsInRange(range: CellRange, rowIds: readonly string[], fieldNames: readonly string[]): CellAddress[];
+/** The range as a 2-D grid of addresses — what a block copy serialises. */
+declare function rangeRows(range: CellRange, rowIds: readonly string[], fieldNames: readonly string[]): CellAddress[][];
+declare function isSingleCellRange(range: CellRange): boolean;
+/** The whole row, first column to last — what clicking a row's edge selects. */
+declare function rowRange(rowId: string, fieldNames: readonly string[]): CellRange | null;
+/** The whole column across the page — what clicking a header's edge selects. */
+declare function columnRange(fieldName: string, rowIds: readonly string[]): CellRange | null;
+/** Every cell on the page. */
+declare function allRange(rowIds: readonly string[], fieldNames: readonly string[]): CellRange | null;
+declare function sameCell(a: CellAddress | null, b: CellAddress | null): boolean;
+/**
+ * Where does `move` land from `current`?
+ *
+ * Returns null when the move is impossible (no selection, empty grid). Vertical
+ * moves CLAMP at the edges — running into the top of the grid should park you
+ * on the first row, not clear the selection, because a selection that vanishes
+ * when you overshoot loses your place. Horizontal Tab moves WRAP to the next or
+ * previous row, which is what makes Tab a usable data-entry gesture.
+ */
+declare function moveSelection(current: CellAddress | null, move: GridMove, rowIds: readonly string[], fieldNames: readonly string[]): CellAddress | null;
+/**
+ * A single printable character typed on a selected cell starts an edit seeded
+ * with it — the spreadsheet reflex of "just start typing to replace".
+ *
+ * Modifier combinations are excluded so Cmd-C / Ctrl-R never get mistaken for
+ * typing, and only genuinely printable single characters qualify: `key` is the
+ * character itself for those, and a multi-character name ("ArrowUp", "F3") for
+ * everything else.
+ */
+declare function isTypingKey(e: {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}): boolean;
+/**
+ * Translate a keystroke into a grid action. Called ONLY when a cell is selected
+ * and not being edited — an editor owns its own keys while it is open.
+ */
+declare function classifyGridKey(e: {
+    key: string;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}): GridKeyAction;
+/**
+ * Editor kinds a SINGLE click may operate directly, without first entering edit
+ * mode. See THE CLICK LAW at the top of this file — this list is closed sets
+ * and two-state values only, where a mis-click is obvious and instantly undone.
+ */
+declare function directClickKinds(): readonly string[];
+declare function isDirectClickEditor(editorKind: string | undefined): boolean;
+/** Stable DOM key for a cell, so selection can scroll itself into view. */
+declare function cellDomKey(address: CellAddress): string;
+
+export { type CellAddress, type CellRange, type GridKeyAction, type GridMove, type RangeBounds, allRange, boundsContain, cellDomKey, cellsInRange, classifyGridKey, columnRange, directClickKinds, isDirectClickEditor, isSingleCellRange, isTypingKey, moveSelection, rangeBounds, rangeRows, rangeSize, rowRange, sameCell };

package/dist/data-table/grid-selection.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Grid selection model for user data tables.
+ * @ai-matrx/design-system/data-table/grid-selection
+ *
+ * This moved here from the app so every table in the product shares one
+ * range-selection model.
+ *
+ * THE THREE STATES. A spreadsheet grid has three, not two, and collapsing them
+ * to two is what made this grid feel like a web page instead of a tool:
+ *
+ *   1. NOTHING SELECTED  — the grid at rest.
+ *   2. SELECTED          — one cell is current. Nothing has changed. You can
+ *                          look, copy, and move with the keyboard.
+ *   3. EDITING           — a value is being changed.
+ *
+ * State 2 is the one that was missing, and its absence is why every edit needed
+ * a double-click and why arrow keys, Tab, copy and fill-down were all
+ * impossible: none of them mean anything without a notion of "the current cell".
+ *
+ * 🚨 THE CLICK LAW — a single click may SELECT a cell, TOGGLE a two-state
+ * value, or OPEN a chooser. It may NEVER drop the user into a free-text buffer.
+ * Opening a menu is not a mutation and toggling a checkbox is instantly
+ * reversible, but landing in a text buffer turns every attempt to select-and-
+ * copy into an accidental edit. `directClickKinds()` below is the whole list of
+ * what a single click may act on; adding a free-text editor to it is a defect.
+ *
+ * A CHOOSER OPENS ON THE SECOND CLICK. A choice cell's first click SELECTS it
+ * (so Cmd-C, Cmd-X, the arrow keys and the right-click menu all have a current
+ * cell); a click on the cell that is ALREADY selected opens the option list —
+ * the Airtable gesture. Opening the chooser on the very first click moved
+ * focus into its search box, and every keyboard shortcut then went to that box
+ * instead of the grid: a choice column could not be copied at all (2026-09-14).
+ * Checkboxes and ratings stay one-click: a mis-click on those is instantly
+ * undone in place and steals no focus.
+ *
+ * CLIPBOARD KEYS. Cmd-C / Cmd-X / Cmd-V on a selected cell act on THAT CELL —
+ * copy its value, cut it (copy + clear), paste over it. A paste carrying a
+ * spreadsheet block (tabs / line breaks) lands as a block from the selected
+ * cell downward and rightward (`grid-clipboard.ts`). None of these need an
+ * editor open, which is the whole point: a normal table copies what you point
+ * at, not only what you are typing into.
+ *
+ * Addresses are (rowId, fieldName), never (rowIndex, colIndex): the grid
+ * reloads after every write, and realtime reorders rows underneath the user. An
+ * index-based selection silently jumps to a DIFFERENT cell when that happens —
+ * and the next keystroke then edits the wrong row.
+ *
+ * Pure module: no React, no DOM. Everything here is a function of the current
+ * address and the row/field lists, which is what makes the navigation testable
+ * without mounting a grid.
+ */
+type CellAddress = {
+    rowId: string;
+    fieldName: string;
+};
+type GridMove = "up" | "down" | "left" | "right" | "nextCell" | "prevCell" | "rowStart" | "rowEnd" | "gridStart" | "gridEnd";
+/** What a keystroke means when a cell is selected but NOT being edited. */
+type GridKeyAction = {
+    kind: "move";
+    move: GridMove;
+}
+/** Shift+arrow: grow the range toward `move`, anchor fixed. */
+ | {
+    kind: "extend";
+    move: GridMove;
+} | {
+    kind: "selectAll";
+} | {
+    kind: "selectRow";
+} | {
+    kind: "selectColumn";
+} | {
+    kind: "fillDown";
+} | {
+    kind: "edit";
+} | {
+    kind: "editSeeded";
+    seed: string;
+} | {
+    kind: "clearCell";
+} | {
+    kind: "copy";
+} | {
+    kind: "cut";
+} | {
+    kind: "paste";
+} | {
+    kind: "escape";
+} | null;
+type CellRange = {
+    anchor: CellAddress;
+    focus: CellAddress;
+};
+/** The rectangle a range spans, as inclusive indexes into the grid's order. */
+type RangeBounds = {
+    r0: number;
+    r1: number;
+    c0: number;
+    c1: number;
+};
+declare function rangeBounds(range: CellRange, rowIds: readonly string[], fieldNames: readonly string[]): RangeBounds | null;
+declare function rangeSize(bounds: RangeBounds): {
+    rows: number;
+    cols: number;
+    cells: number;
+};
+declare function boundsContain(bounds: RangeBounds, rowIndex: number, colIndex: number): boolean;
+/** Every cell of the range in reading order (row by row, left to right). */
+declare function cellsInRange(range: CellRange, rowIds: readonly string[], fieldNames: readonly string[]): CellAddress[];
+/** The range as a 2-D grid of addresses — what a block copy serialises. */
+declare function rangeRows(range: CellRange, rowIds: readonly string[], fieldNames: readonly string[]): CellAddress[][];
+declare function isSingleCellRange(range: CellRange): boolean;
+/** The whole row, first column to last — what clicking a row's edge selects. */
+declare function rowRange(rowId: string, fieldNames: readonly string[]): CellRange | null;
+/** The whole column across the page — what clicking a header's edge selects. */
+declare function columnRange(fieldName: string, rowIds: readonly string[]): CellRange | null;
+/** Every cell on the page. */
+declare function allRange(rowIds: readonly string[], fieldNames: readonly string[]): CellRange | null;
+declare function sameCell(a: CellAddress | null, b: CellAddress | null): boolean;
+/**
+ * Where does `move` land from `current`?
+ *
+ * Returns null when the move is impossible (no selection, empty grid). Vertical
+ * moves CLAMP at the edges — running into the top of the grid should park you
+ * on the first row, not clear the selection, because a selection that vanishes
+ * when you overshoot loses your place. Horizontal Tab moves WRAP to the next or
+ * previous row, which is what makes Tab a usable data-entry gesture.
+ */
+declare function moveSelection(current: CellAddress | null, move: GridMove, rowIds: readonly string[], fieldNames: readonly string[]): CellAddress | null;
+/**
+ * A single printable character typed on a selected cell starts an edit seeded
+ * with it — the spreadsheet reflex of "just start typing to replace".
+ *
+ * Modifier combinations are excluded so Cmd-C / Ctrl-R never get mistaken for
+ * typing, and only genuinely printable single characters qualify: `key` is the
+ * character itself for those, and a multi-character name ("ArrowUp", "F3") for
+ * everything else.
+ */
+declare function isTypingKey(e: {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}): boolean;
+/**
+ * Translate a keystroke into a grid action. Called ONLY when a cell is selected
+ * and not being edited — an editor owns its own keys while it is open.
+ */
+declare function classifyGridKey(e: {
+    key: string;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}): GridKeyAction;
+/**
+ * Editor kinds a SINGLE click may operate directly, without first entering edit
+ * mode. See THE CLICK LAW at the top of this file — this list is closed sets
+ * and two-state values only, where a mis-click is obvious and instantly undone.
+ */
+declare function directClickKinds(): readonly string[];
+declare function isDirectClickEditor(editorKind: string | undefined): boolean;
+/** Stable DOM key for a cell, so selection can scroll itself into view. */
+declare function cellDomKey(address: CellAddress): string;
+
+export { type CellAddress, type CellRange, type GridKeyAction, type GridMove, type RangeBounds, allRange, boundsContain, cellDomKey, cellsInRange, classifyGridKey, columnRange, directClickKinds, isDirectClickEditor, isSingleCellRange, isTypingKey, moveSelection, rangeBounds, rangeRows, rangeSize, rowRange, sameCell };

package/dist/data-table/grid-selection.js

@@ -0,0 +1,238 @@
+
+// src/data-table/grid-selection.ts
+function rangeBounds(range, rowIds, fieldNames) {
+  const ra = rowIds.indexOf(range.anchor.rowId);
+  const rf = rowIds.indexOf(range.focus.rowId);
+  const ca = fieldNames.indexOf(range.anchor.fieldName);
+  const cf = fieldNames.indexOf(range.focus.fieldName);
+  if (ra === -1 || rf === -1 || ca === -1 || cf === -1) return null;
+  return {
+    r0: Math.min(ra, rf),
+    r1: Math.max(ra, rf),
+    c0: Math.min(ca, cf),
+    c1: Math.max(ca, cf)
+  };
+}
+function rangeSize(bounds) {
+  const rows = bounds.r1 - bounds.r0 + 1;
+  const cols = bounds.c1 - bounds.c0 + 1;
+  return { rows, cols, cells: rows * cols };
+}
+function boundsContain(bounds, rowIndex, colIndex) {
+  return rowIndex >= bounds.r0 && rowIndex <= bounds.r1 && colIndex >= bounds.c0 && colIndex <= bounds.c1;
+}
+function cellsInRange(range, rowIds, fieldNames) {
+  const b = rangeBounds(range, rowIds, fieldNames);
+  if (!b) return [];
+  const out = [];
+  for (let r = b.r0; r <= b.r1; r += 1) {
+    const rowId = rowIds[r];
+    if (rowId === void 0) continue;
+    for (let c = b.c0; c <= b.c1; c += 1) {
+      const fieldName = fieldNames[c];
+      if (fieldName === void 0) continue;
+      out.push({ rowId, fieldName });
+    }
+  }
+  return out;
+}
+function rangeRows(range, rowIds, fieldNames) {
+  const b = rangeBounds(range, rowIds, fieldNames);
+  if (!b) return [];
+  const rows = [];
+  for (let r = b.r0; r <= b.r1; r += 1) {
+    const rowId = rowIds[r];
+    if (rowId === void 0) continue;
+    const row = [];
+    for (let c = b.c0; c <= b.c1; c += 1) {
+      const fieldName = fieldNames[c];
+      if (fieldName === void 0) continue;
+      row.push({ rowId, fieldName });
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function isSingleCellRange(range) {
+  return sameCell(range.anchor, range.focus);
+}
+function rowRange(rowId, fieldNames) {
+  const firstField = fieldNames[0];
+  const lastField = fieldNames[fieldNames.length - 1];
+  if (firstField === void 0 || lastField === void 0) return null;
+  return {
+    anchor: { rowId, fieldName: firstField },
+    focus: { rowId, fieldName: lastField }
+  };
+}
+function columnRange(fieldName, rowIds) {
+  const firstRow = rowIds[0];
+  const lastRow = rowIds[rowIds.length - 1];
+  if (firstRow === void 0 || lastRow === void 0) return null;
+  return {
+    anchor: { rowId: firstRow, fieldName },
+    focus: { rowId: lastRow, fieldName }
+  };
+}
+function allRange(rowIds, fieldNames) {
+  const firstRow = rowIds[0];
+  const lastRow = rowIds[rowIds.length - 1];
+  const firstField = fieldNames[0];
+  const lastField = fieldNames[fieldNames.length - 1];
+  if (firstRow === void 0 || lastRow === void 0 || firstField === void 0 || lastField === void 0) {
+    return null;
+  }
+  return {
+    anchor: { rowId: firstRow, fieldName: firstField },
+    focus: { rowId: lastRow, fieldName: lastField }
+  };
+}
+function sameCell(a, b) {
+  if (!a || !b) return a === b;
+  return a.rowId === b.rowId && a.fieldName === b.fieldName;
+}
+function moveSelection(current, move, rowIds, fieldNames) {
+  if (rowIds.length === 0 || fieldNames.length === 0) return null;
+  const firstRowId = rowIds[0];
+  const firstFieldName = fieldNames[0];
+  if (firstRowId === void 0 || firstFieldName === void 0) return null;
+  const first = { rowId: firstRowId, fieldName: firstFieldName };
+  if (!current) return first;
+  let r = rowIds.indexOf(current.rowId);
+  let c = fieldNames.indexOf(current.fieldName);
+  if (r === -1 || c === -1) return first;
+  const lastRow = rowIds.length - 1;
+  const lastCol = fieldNames.length - 1;
+  const clamp = (n, max) => Math.min(Math.max(n, 0), max);
+  switch (move) {
+    case "up":
+      r = clamp(r - 1, lastRow);
+      break;
+    case "down":
+      r = clamp(r + 1, lastRow);
+      break;
+    case "left":
+      c = clamp(c - 1, lastCol);
+      break;
+    case "right":
+      c = clamp(c + 1, lastCol);
+      break;
+    case "rowStart":
+      c = 0;
+      break;
+    case "rowEnd":
+      c = lastCol;
+      break;
+    case "gridStart":
+      r = 0;
+      c = 0;
+      break;
+    case "gridEnd":
+      r = lastRow;
+      c = lastCol;
+      break;
+    case "nextCell":
+      if (c < lastCol) c += 1;
+      else if (r < lastRow) {
+        r += 1;
+        c = 0;
+      }
+      break;
+    case "prevCell":
+      if (c > 0) c -= 1;
+      else if (r > 0) {
+        r -= 1;
+        c = lastCol;
+      }
+      break;
+  }
+  const rowId = rowIds[r];
+  const fieldName = fieldNames[c];
+  if (rowId === void 0 || fieldName === void 0) return first;
+  return { rowId, fieldName };
+}
+function isTypingKey(e) {
+  if (e.ctrlKey || e.metaKey || e.altKey) return false;
+  return e.key.length === 1 && e.key !== " ";
+}
+function classifyGridKey(e) {
+  const mod = e.ctrlKey || e.metaKey;
+  const arrowMove = {
+    ArrowUp: mod ? "gridStart" : "up",
+    ArrowDown: mod ? "gridEnd" : "down",
+    ArrowLeft: mod ? "rowStart" : "left",
+    ArrowRight: mod ? "rowEnd" : "right",
+    Home: mod ? "gridStart" : "rowStart",
+    End: mod ? "gridEnd" : "rowEnd"
+  };
+  const arrow = arrowMove[e.key];
+  if (arrow !== void 0) {
+    return { kind: e.shiftKey ? "extend" : "move", move: arrow };
+  }
+  switch (e.key) {
+    case "Tab":
+      return { kind: "move", move: e.shiftKey ? "prevCell" : "nextCell" };
+    case "Enter":
+    case "F2":
+      return { kind: "edit" };
+    case " ":
+      if (e.shiftKey) return { kind: "selectRow" };
+      if (mod) return { kind: "selectColumn" };
+      return { kind: "edit" };
+    case "a":
+    case "A":
+      if (mod) return { kind: "selectAll" };
+      break;
+    case "d":
+    case "D":
+      if (mod) return { kind: "fillDown" };
+      break;
+    case "Escape":
+      return { kind: "escape" };
+    case "Delete":
+    case "Backspace":
+      return { kind: "clearCell" };
+    case "c":
+    case "C":
+      if (mod) return { kind: "copy" };
+      break;
+    case "x":
+    case "X":
+      if (mod) return { kind: "cut" };
+      break;
+    case "v":
+    case "V":
+      if (mod) return { kind: "paste" };
+      break;
+  }
+  if (isTypingKey(e)) return { kind: "editSeeded", seed: e.key };
+  return null;
+}
+function directClickKinds() {
+  return ["checkbox", "rating", "select", "multiselect"];
+}
+function isDirectClickEditor(editorKind) {
+  return editorKind !== void 0 && directClickKinds().includes(editorKind);
+}
+function cellDomKey(address) {
+  return `${address.rowId}::${address.fieldName}`;
+}
+export {
+  allRange,
+  boundsContain,
+  cellDomKey,
+  cellsInRange,
+  classifyGridKey,
+  columnRange,
+  directClickKinds,
+  isDirectClickEditor,
+  isSingleCellRange,
+  isTypingKey,
+  moveSelection,
+  rangeBounds,
+  rangeRows,
+  rangeSize,
+  rowRange,
+  sameCell
+};
+//# sourceMappingURL=grid-selection.js.map

package/dist/data-table/grid-selection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/data-table/grid-selection.ts"],"sourcesContent":["/**\n * Grid selection model for user data tables.\n * @ai-matrx/design-system/data-table/grid-selection\n *\n * This moved here from the app so every table in the product shares one\n * range-selection model.\n *\n * THE THREE STATES. A spreadsheet grid has three, not two, and collapsing them\n * to two is what made this grid feel like a web page instead of a tool:\n *\n *   1. NOTHING SELECTED  — the grid at rest.\n *   2. SELECTED          — one cell is current. Nothing has changed. You can\n *                          look, copy, and move with the keyboard.\n *   3. EDITING           — a value is being changed.\n *\n * State 2 is the one that was missing, and its absence is why every edit needed\n * a double-click and why arrow keys, Tab, copy and fill-down were all\n * impossible: none of them mean anything without a notion of \"the current cell\".\n *\n * 🚨 THE CLICK LAW — a single click may SELECT a cell, TOGGLE a two-state\n * value, or OPEN a chooser. It may NEVER drop the user into a free-text buffer.\n * Opening a menu is not a mutation and toggling a checkbox is instantly\n * reversible, but landing in a text buffer turns every attempt to select-and-\n * copy into an accidental edit. `directClickKinds()` below is the whole list of\n * what a single click may act on; adding a free-text editor to it is a defect.\n *\n * A CHOOSER OPENS ON THE SECOND CLICK. A choice cell's first click SELECTS it\n * (so Cmd-C, Cmd-X, the arrow keys and the right-click menu all have a current\n * cell); a click on the cell that is ALREADY selected opens the option list —\n * the Airtable gesture. Opening the chooser on the very first click moved\n * focus into its search box, and every keyboard shortcut then went to that box\n * instead of the grid: a choice column could not be copied at all (2026-09-14).\n * Checkboxes and ratings stay one-click: a mis-click on those is instantly\n * undone in place and steals no focus.\n *\n * CLIPBOARD KEYS. Cmd-C / Cmd-X / Cmd-V on a selected cell act on THAT CELL —\n * copy its value, cut it (copy + clear), paste over it. A paste carrying a\n * spreadsheet block (tabs / line breaks) lands as a block from the selected\n * cell downward and rightward (`grid-clipboard.ts`). None of these need an\n * editor open, which is the whole point: a normal table copies what you point\n * at, not only what you are typing into.\n *\n * Addresses are (rowId, fieldName), never (rowIndex, colIndex): the grid\n * reloads after every write, and realtime reorders rows underneath the user. An\n * index-based selection silently jumps to a DIFFERENT cell when that happens —\n * and the next keystroke then edits the wrong row.\n *\n * Pure module: no React, no DOM. Everything here is a function of the current\n * address and the row/field lists, which is what makes the navigation testable\n * without mounting a grid.\n */\n\nexport type CellAddress = { rowId: string; fieldName: string };\n\nexport type GridMove =\n  | \"up\"\n  | \"down\"\n  | \"left\"\n  | \"right\"\n  | \"nextCell\"\n  | \"prevCell\"\n  | \"rowStart\"\n  | \"rowEnd\"\n  | \"gridStart\"\n  | \"gridEnd\";\n\n/** What a keystroke means when a cell is selected but NOT being edited. */\nexport type GridKeyAction =\n  | { kind: \"move\"; move: GridMove }\n  /** Shift+arrow: grow the range toward `move`, anchor fixed. */\n  | { kind: \"extend\"; move: GridMove }\n  | { kind: \"selectAll\" }\n  | { kind: \"selectRow\" }\n  | { kind: \"selectColumn\" }\n  | { kind: \"fillDown\" }\n  | { kind: \"edit\" }\n  | { kind: \"editSeeded\"; seed: string }\n  | { kind: \"clearCell\" }\n  | { kind: \"copy\" }\n  | { kind: \"cut\" }\n  | { kind: \"paste\" }\n  | { kind: \"escape\" }\n  | null;\n\n// ─── Ranges ─────────────────────────────────────────────────────────────────\n//\n// A RANGE is an anchor (where the selection started — the cell with the ring)\n// and a focus (where it was extended to), both by ADDRESS. The rectangle they\n// span is resolved against the grid's current row and column order at the\n// moment it is needed, so a range survives a re-sort or a hidden column the\n// same way a single selection does: by naming cells, not positions.\n\nexport type CellRange = { anchor: CellAddress; focus: CellAddress };\n\n/** The rectangle a range spans, as inclusive indexes into the grid's order. */\nexport type RangeBounds = { r0: number; r1: number; c0: number; c1: number };\n\nexport function rangeBounds(\n  range: CellRange,\n  rowIds: readonly string[],\n  fieldNames: readonly string[],\n): RangeBounds | null {\n  const ra = rowIds.indexOf(range.anchor.rowId);\n  const rf = rowIds.indexOf(range.focus.rowId);\n  const ca = fieldNames.indexOf(range.anchor.fieldName);\n  const cf = fieldNames.indexOf(range.focus.fieldName);\n  if (ra === -1 || rf === -1 || ca === -1 || cf === -1) return null;\n  return {\n    r0: Math.min(ra, rf),\n    r1: Math.max(ra, rf),\n    c0: Math.min(ca, cf),\n    c1: Math.max(ca, cf),\n  };\n}\n\nexport function rangeSize(bounds: RangeBounds): {\n  rows: number;\n  cols: number;\n  cells: number;\n} {\n  const rows = bounds.r1 - bounds.r0 + 1;\n  const cols = bounds.c1 - bounds.c0 + 1;\n  return { rows, cols, cells: rows * cols };\n}\n\nexport function boundsContain(\n  bounds: RangeBounds,\n  rowIndex: number,\n  colIndex: number,\n): boolean {\n  return (\n    rowIndex >= bounds.r0 &&\n    rowIndex <= bounds.r1 &&\n    colIndex >= bounds.c0 &&\n    colIndex <= bounds.c1\n  );\n}\n\n/** Every cell of the range in reading order (row by row, left to right). */\nexport function cellsInRange(\n  range: CellRange,\n  rowIds: readonly string[],\n  fieldNames: readonly string[],\n): CellAddress[] {\n  const b = rangeBounds(range, rowIds, fieldNames);\n  if (!b) return [];\n  const out: CellAddress[] = [];\n  // `rangeBounds` derives every index from `indexOf`, so both lookups below are\n  // in range; the guards make that explicit instead of asserting it.\n  for (let r = b.r0; r <= b.r1; r += 1) {\n    const rowId = rowIds[r];\n    if (rowId === undefined) continue;\n    for (let c = b.c0; c <= b.c1; c += 1) {\n      const fieldName = fieldNames[c];\n      if (fieldName === undefined) continue;\n      out.push({ rowId, fieldName });\n    }\n  }\n  return out;\n}\n\n/** The range as a 2-D grid of addresses — what a block copy serialises. */\nexport function rangeRows(\n  range: CellRange,\n  rowIds: readonly string[],\n  fieldNames: readonly string[],\n): CellAddress[][] {\n  const b = rangeBounds(range, rowIds, fieldNames);\n  if (!b) return [];\n  const rows: CellAddress[][] = [];\n  // Same in-range guarantee as `cellsInRange`.\n  for (let r = b.r0; r <= b.r1; r += 1) {\n    const rowId = rowIds[r];\n    if (rowId === undefined) continue;\n    const row: CellAddress[] = [];\n    for (let c = b.c0; c <= b.c1; c += 1) {\n      const fieldName = fieldNames[c];\n      if (fieldName === undefined) continue;\n      row.push({ rowId, fieldName });\n    }\n    rows.push(row);\n  }\n  return rows;\n}\n\nexport function isSingleCellRange(range: CellRange): boolean {\n  return sameCell(range.anchor, range.focus);\n}\n\n/** The whole row, first column to last — what clicking a row's edge selects. */\nexport function rowRange(\n  rowId: string,\n  fieldNames: readonly string[],\n): CellRange | null {\n  const firstField = fieldNames[0];\n  const lastField = fieldNames[fieldNames.length - 1];\n  // A non-empty list always has both ends; the null here is the same \"no range\n  // to make\" answer the empty-list case gives.\n  if (firstField === undefined || lastField === undefined) return null;\n  return {\n    anchor: { rowId, fieldName: firstField },\n    focus: { rowId, fieldName: lastField },\n  };\n}\n\n/** The whole column across the page — what clicking a header's edge selects. */\nexport function columnRange(\n  fieldName: string,\n  rowIds: readonly string[],\n): CellRange | null {\n  const firstRow = rowIds[0];\n  const lastRow = rowIds[rowIds.length - 1];\n  if (firstRow === undefined || lastRow === undefined) return null;\n  return {\n    anchor: { rowId: firstRow, fieldName },\n    focus: { rowId: lastRow, fieldName },\n  };\n}\n\n/** Every cell on the page. */\nexport function allRange(\n  rowIds: readonly string[],\n  fieldNames: readonly string[],\n): CellRange | null {\n  const firstRow = rowIds[0];\n  const lastRow = rowIds[rowIds.length - 1];\n  const firstField = fieldNames[0];\n  const lastField = fieldNames[fieldNames.length - 1];\n  if (\n    firstRow === undefined ||\n    lastRow === undefined ||\n    firstField === undefined ||\n    lastField === undefined\n  ) {\n    return null;\n  }\n  return {\n    anchor: { rowId: firstRow, fieldName: firstField },\n    focus: { rowId: lastRow, fieldName: lastField },\n  };\n}\n\nexport function sameCell(\n  a: CellAddress | null,\n  b: CellAddress | null,\n): boolean {\n  if (!a || !b) return a === b;\n  return a.rowId === b.rowId && a.fieldName === b.fieldName;\n}\n\n/**\n * Where does `move` land from `current`?\n *\n * Returns null when the move is impossible (no selection, empty grid). Vertical\n * moves CLAMP at the edges — running into the top of the grid should park you\n * on the first row, not clear the selection, because a selection that vanishes\n * when you overshoot loses your place. Horizontal Tab moves WRAP to the next or\n * previous row, which is what makes Tab a usable data-entry gesture.\n */\nexport function moveSelection(\n  current: CellAddress | null,\n  move: GridMove,\n  rowIds: readonly string[],\n  fieldNames: readonly string[],\n): CellAddress | null {\n  if (rowIds.length === 0 || fieldNames.length === 0) return null;\n\n  const firstRowId = rowIds[0];\n  const firstFieldName = fieldNames[0];\n  // Both lists are non-empty by the check above; `null` here is the same \"no\n  // move is possible\" answer the empty-grid case gives.\n  if (firstRowId === undefined || firstFieldName === undefined) return null;\n  const first: CellAddress = { rowId: firstRowId, fieldName: firstFieldName };\n  if (!current) return first;\n\n  let r = rowIds.indexOf(current.rowId);\n  let c = fieldNames.indexOf(current.fieldName);\n  // The selected row or column disappeared (deleted, filtered out, re-sorted\n  // off the page). Fall back to the start rather than computing from -1, which\n  // would quietly resolve to the last element.\n  if (r === -1 || c === -1) return first;\n\n  const lastRow = rowIds.length - 1;\n  const lastCol = fieldNames.length - 1;\n  const clamp = (n: number, max: number) => Math.min(Math.max(n, 0), max);\n\n  switch (move) {\n    case \"up\":\n      r = clamp(r - 1, lastRow);\n      break;\n    case \"down\":\n      r = clamp(r + 1, lastRow);\n      break;\n    case \"left\":\n      c = clamp(c - 1, lastCol);\n      break;\n    case \"right\":\n      c = clamp(c + 1, lastCol);\n      break;\n    case \"rowStart\":\n      c = 0;\n      break;\n    case \"rowEnd\":\n      c = lastCol;\n      break;\n    case \"gridStart\":\n      r = 0;\n      c = 0;\n      break;\n    case \"gridEnd\":\n      r = lastRow;\n      c = lastCol;\n      break;\n    case \"nextCell\":\n      if (c < lastCol) c += 1;\n      else if (r < lastRow) {\n        r += 1;\n        c = 0;\n      }\n      break;\n    case \"prevCell\":\n      if (c > 0) c -= 1;\n      else if (r > 0) {\n        r -= 1;\n        c = lastCol;\n      }\n      break;\n  }\n\n  // Every branch above clamps into range or leaves r/c at their `indexOf`\n  // values, so both reads land; falling back to `first` matches what this\n  // function already does when an index cannot be resolved.\n  const rowId = rowIds[r];\n  const fieldName = fieldNames[c];\n  if (rowId === undefined || fieldName === undefined) return first;\n  return { rowId, fieldName };\n}\n\n/**\n * A single printable character typed on a selected cell starts an edit seeded\n * with it — the spreadsheet reflex of \"just start typing to replace\".\n *\n * Modifier combinations are excluded so Cmd-C / Ctrl-R never get mistaken for\n * typing, and only genuinely printable single characters qualify: `key` is the\n * character itself for those, and a multi-character name (\"ArrowUp\", \"F3\") for\n * everything else.\n */\nexport function isTypingKey(e: {\n  key: string;\n  ctrlKey: boolean;\n  metaKey: boolean;\n  altKey: boolean;\n}): boolean {\n  if (e.ctrlKey || e.metaKey || e.altKey) return false;\n  return e.key.length === 1 && e.key !== \" \";\n}\n\n/**\n * Translate a keystroke into a grid action. Called ONLY when a cell is selected\n * and not being edited — an editor owns its own keys while it is open.\n */\nexport function classifyGridKey(e: {\n  key: string;\n  shiftKey: boolean;\n  ctrlKey: boolean;\n  metaKey: boolean;\n  altKey: boolean;\n}): GridKeyAction {\n  const mod = e.ctrlKey || e.metaKey;\n\n  // Shift+arrow GROWS the selection instead of moving it — the spreadsheet\n  // gesture for \"these cells\". Shift+Tab stays a move (previous cell).\n  const arrowMove: Record<string, GridMove> = {\n    ArrowUp: mod ? \"gridStart\" : \"up\",\n    ArrowDown: mod ? \"gridEnd\" : \"down\",\n    ArrowLeft: mod ? \"rowStart\" : \"left\",\n    ArrowRight: mod ? \"rowEnd\" : \"right\",\n    Home: mod ? \"gridStart\" : \"rowStart\",\n    End: mod ? \"gridEnd\" : \"rowEnd\",\n  };\n  // Read the entry rather than testing `in`: `in` also answers true for\n  // inherited Object.prototype names (\"constructor\", \"toString\"), which used to\n  // produce a move action carrying an undefined move.\n  const arrow = arrowMove[e.key];\n  if (arrow !== undefined) {\n    return { kind: e.shiftKey ? \"extend\" : \"move\", move: arrow };\n  }\n\n  switch (e.key) {\n    case \"Tab\":\n      return { kind: \"move\", move: e.shiftKey ? \"prevCell\" : \"nextCell\" };\n    case \"Enter\":\n    case \"F2\":\n      return { kind: \"edit\" };\n    case \" \":\n      // Shift+Space selects the row and Ctrl/Cmd+Space the column (Excel);\n      // plain Space opens the editor without seeding it, so a boolean or\n      // choice cell can be operated entirely from the keyboard.\n      if (e.shiftKey) return { kind: \"selectRow\" };\n      if (mod) return { kind: \"selectColumn\" };\n      return { kind: \"edit\" };\n    case \"a\":\n    case \"A\":\n      if (mod) return { kind: \"selectAll\" };\n      break;\n    case \"d\":\n    case \"D\":\n      if (mod) return { kind: \"fillDown\" };\n      break;\n    case \"Escape\":\n      return { kind: \"escape\" };\n    case \"Delete\":\n    case \"Backspace\":\n      return { kind: \"clearCell\" };\n    case \"c\":\n    case \"C\":\n      if (mod) return { kind: \"copy\" };\n      break;\n    case \"x\":\n    case \"X\":\n      if (mod) return { kind: \"cut\" };\n      break;\n    case \"v\":\n    case \"V\":\n      if (mod) return { kind: \"paste\" };\n      break;\n  }\n\n  if (isTypingKey(e)) return { kind: \"editSeeded\", seed: e.key };\n  return null;\n}\n\n/**\n * Editor kinds a SINGLE click may operate directly, without first entering edit\n * mode. See THE CLICK LAW at the top of this file — this list is closed sets\n * and two-state values only, where a mis-click is obvious and instantly undone.\n */\nexport function directClickKinds(): readonly string[] {\n  return [\"checkbox\", \"rating\", \"select\", \"multiselect\"] as const;\n}\n\nexport function isDirectClickEditor(editorKind: string | undefined): boolean {\n  return editorKind !== undefined && directClickKinds().includes(editorKind);\n}\n\n/** Stable DOM key for a cell, so selection can scroll itself into view. */\nexport function cellDomKey(address: CellAddress): string {\n  return `${address.rowId}::${address.fieldName}`;\n}\n"],"mappings":"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","names":[]}