@ai-matrx/design-system 0.21.14 → 0.25.0

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

@@ -0,0 +1,85 @@
+import { CellAddress } from './grid-selection.cjs';
+
+/**
+ * Clipboard model for the user-data-table grid.
+ * @ai-matrx/design-system/data-table/grid-clipboard
+ *
+ * This moved here from the app so every table in the product shares one
+ * range-selection model.
+ *
+ * WHAT A SPREADSHEET PUTS ON THE CLIPBOARD. Excel, Google Sheets and Numbers
+ * all copy a range as TAB-separated rows, one line per row, and quote any cell
+ * whose text contains a tab, a line break or a double quote (doubling the
+ * quotes inside). That is also what they ACCEPT on paste. Speaking exactly
+ * that dialect is what makes "copy three columns in Sheets, click a cell here,
+ * Cmd-V" land as a block instead of as one cell holding a wall of text — and
+ * what makes the reverse trip (copy here, paste into Sheets) split into cells.
+ *
+ * WHY THE PLAN IS A PURE FUNCTION. Pasting a block is a write to many cells at
+ * once, and "which cells" is the part that goes wrong: off by one column, the
+ * anchor row filtered out, a block wider than the grid. Computing the landing
+ * cells here, with no React and no DOM, is what lets that mapping be tested
+ * cell by cell — and lets the caller decide separately what to do with the
+ * rows that did not fit.
+ *
+ * Addresses are (rowId, fieldName), like the rest of the grid — never indices.
+ */
+
+/** One cell as text for the clipboard. Objects go out as JSON. */
+declare function cellClipboardText(value: unknown): string;
+/** A rectangular block of cells as spreadsheet TSV. */
+declare function gridToTsv(block: readonly (readonly unknown[])[]): string;
+/**
+ * Parse clipboard text as a spreadsheet block.
+ *
+ * Handles the Excel quoting dialect (a quoted cell may span lines and carries
+ * `""` for a literal quote), both `\n` and `\r\n` line endings, and the single
+ * trailing line break Excel and Sheets append to every copy — without that
+ * strip, every paste would be one empty row taller than what was copied.
+ *
+ * Plain text with no tabs and no quotes still parses: one column, one row per
+ * line, which is exactly what Sheets does with the same text. A single value
+ * with no line break is a 1×1 block.
+ */
+declare function parseClipboardGrid(text: string): string[][];
+/** One landing cell of a paste, with the raw text that goes into it. */
+type PasteCell = CellAddress & {
+    raw: string;
+};
+type PastePlan = {
+    /** Cells inside the grid, in reading order (row by row). */
+    cells: PasteCell[];
+    /**
+     * Block rows below the last grid row, trimmed to the columns that fit from
+     * the anchor column rightward. The caller decides whether these become new
+     * rows — the plan only reports them so nothing is dropped silently.
+     */
+    overflowRows: string[][];
+    /** How many block columns fell off the right edge (per row, at most). */
+    clippedColumns: number;
+    /** The columns (field names) the block spans, anchor first. */
+    fieldNames: string[];
+};
+/**
+ * Where does `block` land when pasted with its top-left cell at `anchor`?
+ *
+ * Rows extend downward from the anchor row and columns rightward from the
+ * anchor column, in the GRID's current order (so a hidden or re-ordered column
+ * is honoured — you paste into what you see). A block wider than the remaining
+ * columns is clipped on the right; a block taller than the remaining rows is
+ * reported as `overflowRows` rather than lost.
+ *
+ * Returns null when the anchor is not on the grid — the row was filtered out
+ * or the column hidden since the selection was made. Writing "somewhere near"
+ * is worse than refusing.
+ */
+declare function planPaste(anchor: CellAddress, block: readonly (readonly string[])[], rowIds: readonly string[], fieldNames: readonly string[]): PastePlan | null;
+/** True when the parsed block is a single value — the common Cmd-V case. */
+declare function isSingleCell(block: readonly (readonly string[])[]): boolean;
+/**
+ * Would writing `next` over `prior` change what is stored? Objects compare by
+ * their JSON, the same test the inline editor uses to skip a no-op write.
+ */
+declare function storedValuesEqual(a: unknown, b: unknown): boolean;
+
+export { type PasteCell, type PastePlan, cellClipboardText, gridToTsv, isSingleCell, parseClipboardGrid, planPaste, storedValuesEqual };

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

@@ -0,0 +1,85 @@
+import { CellAddress } from './grid-selection.js';
+
+/**
+ * Clipboard model for the user-data-table grid.
+ * @ai-matrx/design-system/data-table/grid-clipboard
+ *
+ * This moved here from the app so every table in the product shares one
+ * range-selection model.
+ *
+ * WHAT A SPREADSHEET PUTS ON THE CLIPBOARD. Excel, Google Sheets and Numbers
+ * all copy a range as TAB-separated rows, one line per row, and quote any cell
+ * whose text contains a tab, a line break or a double quote (doubling the
+ * quotes inside). That is also what they ACCEPT on paste. Speaking exactly
+ * that dialect is what makes "copy three columns in Sheets, click a cell here,
+ * Cmd-V" land as a block instead of as one cell holding a wall of text — and
+ * what makes the reverse trip (copy here, paste into Sheets) split into cells.
+ *
+ * WHY THE PLAN IS A PURE FUNCTION. Pasting a block is a write to many cells at
+ * once, and "which cells" is the part that goes wrong: off by one column, the
+ * anchor row filtered out, a block wider than the grid. Computing the landing
+ * cells here, with no React and no DOM, is what lets that mapping be tested
+ * cell by cell — and lets the caller decide separately what to do with the
+ * rows that did not fit.
+ *
+ * Addresses are (rowId, fieldName), like the rest of the grid — never indices.
+ */
+
+/** One cell as text for the clipboard. Objects go out as JSON. */
+declare function cellClipboardText(value: unknown): string;
+/** A rectangular block of cells as spreadsheet TSV. */
+declare function gridToTsv(block: readonly (readonly unknown[])[]): string;
+/**
+ * Parse clipboard text as a spreadsheet block.
+ *
+ * Handles the Excel quoting dialect (a quoted cell may span lines and carries
+ * `""` for a literal quote), both `\n` and `\r\n` line endings, and the single
+ * trailing line break Excel and Sheets append to every copy — without that
+ * strip, every paste would be one empty row taller than what was copied.
+ *
+ * Plain text with no tabs and no quotes still parses: one column, one row per
+ * line, which is exactly what Sheets does with the same text. A single value
+ * with no line break is a 1×1 block.
+ */
+declare function parseClipboardGrid(text: string): string[][];
+/** One landing cell of a paste, with the raw text that goes into it. */
+type PasteCell = CellAddress & {
+    raw: string;
+};
+type PastePlan = {
+    /** Cells inside the grid, in reading order (row by row). */
+    cells: PasteCell[];
+    /**
+     * Block rows below the last grid row, trimmed to the columns that fit from
+     * the anchor column rightward. The caller decides whether these become new
+     * rows — the plan only reports them so nothing is dropped silently.
+     */
+    overflowRows: string[][];
+    /** How many block columns fell off the right edge (per row, at most). */
+    clippedColumns: number;
+    /** The columns (field names) the block spans, anchor first. */
+    fieldNames: string[];
+};
+/**
+ * Where does `block` land when pasted with its top-left cell at `anchor`?
+ *
+ * Rows extend downward from the anchor row and columns rightward from the
+ * anchor column, in the GRID's current order (so a hidden or re-ordered column
+ * is honoured — you paste into what you see). A block wider than the remaining
+ * columns is clipped on the right; a block taller than the remaining rows is
+ * reported as `overflowRows` rather than lost.
+ *
+ * Returns null when the anchor is not on the grid — the row was filtered out
+ * or the column hidden since the selection was made. Writing "somewhere near"
+ * is worse than refusing.
+ */
+declare function planPaste(anchor: CellAddress, block: readonly (readonly string[])[], rowIds: readonly string[], fieldNames: readonly string[]): PastePlan | null;
+/** True when the parsed block is a single value — the common Cmd-V case. */
+declare function isSingleCell(block: readonly (readonly string[])[]): boolean;
+/**
+ * Would writing `next` over `prior` change what is stored? Objects compare by
+ * their JSON, the same test the inline editor uses to skip a no-op write.
+ */
+declare function storedValuesEqual(a: unknown, b: unknown): boolean;
+
+export { type PasteCell, type PastePlan, cellClipboardText, gridToTsv, isSingleCell, parseClipboardGrid, planPaste, storedValuesEqual };

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

@@ -0,0 +1,145 @@
+
+// src/data-table/grid-clipboard.ts
+function cellClipboardText(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function tsvCell(text) {
+  return /[\t\r\n"]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function gridToTsv(block) {
+  return block.map((row) => row.map((cell) => tsvCell(cellClipboardText(cell))).join("	")).join("\n");
+}
+function parseClipboardGrid(text) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const ch = text[i];
+    if (cell === "" && ch === '"') {
+      let j = i + 1;
+      let out = "";
+      let closed = false;
+      while (j < n) {
+        const c = text[j];
+        if (c === '"') {
+          if (text[j + 1] === '"') {
+            out += '"';
+            j += 2;
+            continue;
+          }
+          closed = true;
+          j += 1;
+          break;
+        }
+        out += c;
+        j += 1;
+      }
+      if (closed && (j >= n || text[j] === "	" || text[j] === "\n" || text[j] === "\r")) {
+        cell = out;
+        i = j;
+        if (i >= n) break;
+        const d = text[i];
+        if (d === "	") {
+          row.push(cell);
+          cell = "";
+          i += 1;
+          continue;
+        }
+        row.push(cell);
+        rows.push(row);
+        row = [];
+        cell = "";
+        i += d === "\r" && text[i + 1] === "\n" ? 2 : 1;
+        continue;
+      }
+      cell += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "	") {
+      row.push(cell);
+      cell = "";
+      i += 1;
+      continue;
+    }
+    if (ch === "\n" || ch === "\r") {
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+      i += ch === "\r" && text[i + 1] === "\n" ? 2 : 1;
+      continue;
+    }
+    cell += ch;
+    i += 1;
+  }
+  const endedOnBreak = n > 0 && (text[n - 1] === "\n" || text[n - 1] === "\r");
+  if (!endedOnBreak) {
+    row.push(cell);
+    rows.push(row);
+  } else if (row.length > 0) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows.length === 0 ? [[""]] : rows;
+}
+function planPaste(anchor, block, rowIds, fieldNames) {
+  const r0 = rowIds.indexOf(anchor.rowId);
+  const c0 = fieldNames.indexOf(anchor.fieldName);
+  if (r0 === -1 || c0 === -1) return null;
+  const width = block.reduce((w, row) => Math.max(w, row.length), 0);
+  const colsAvailable = fieldNames.length - c0;
+  const colsUsed = Math.min(width, colsAvailable);
+  const targetFields = fieldNames.slice(c0, c0 + colsUsed);
+  const cells = [];
+  const overflowRows = [];
+  block.forEach((blockRow, dr) => {
+    const rowId = rowIds[r0 + dr];
+    if (rowId === void 0) {
+      overflowRows.push(targetFields.map((_, dc) => blockRow[dc] ?? ""));
+      return;
+    }
+    targetFields.forEach((fieldName, dc) => {
+      if (dc >= blockRow.length) return;
+      const raw = blockRow[dc];
+      if (raw === void 0) return;
+      cells.push({ rowId, fieldName, raw });
+    });
+  });
+  return {
+    cells,
+    overflowRows,
+    clippedColumns: Math.max(0, width - colsAvailable),
+    fieldNames: targetFields
+  };
+}
+function isSingleCell(block) {
+  return block.length === 1 && block[0]?.length === 1;
+}
+function storedValuesEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || a === void 0 || b === void 0) {
+    return (a ?? null) === (b ?? null);
+  }
+  if (typeof a === "object" || typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+export {
+  cellClipboardText,
+  gridToTsv,
+  isSingleCell,
+  parseClipboardGrid,
+  planPaste,
+  storedValuesEqual
+};
+//# sourceMappingURL=grid-clipboard.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/data-table/grid-clipboard.ts"],"sourcesContent":["/**\n * Clipboard model for the user-data-table grid.\n * @ai-matrx/design-system/data-table/grid-clipboard\n *\n * This moved here from the app so every table in the product shares one\n * range-selection model.\n *\n * WHAT A SPREADSHEET PUTS ON THE CLIPBOARD. Excel, Google Sheets and Numbers\n * all copy a range as TAB-separated rows, one line per row, and quote any cell\n * whose text contains a tab, a line break or a double quote (doubling the\n * quotes inside). That is also what they ACCEPT on paste. Speaking exactly\n * that dialect is what makes \"copy three columns in Sheets, click a cell here,\n * Cmd-V\" land as a block instead of as one cell holding a wall of text — and\n * what makes the reverse trip (copy here, paste into Sheets) split into cells.\n *\n * WHY THE PLAN IS A PURE FUNCTION. Pasting a block is a write to many cells at\n * once, and \"which cells\" is the part that goes wrong: off by one column, the\n * anchor row filtered out, a block wider than the grid. Computing the landing\n * cells here, with no React and no DOM, is what lets that mapping be tested\n * cell by cell — and lets the caller decide separately what to do with the\n * rows that did not fit.\n *\n * Addresses are (rowId, fieldName), like the rest of the grid — never indices.\n */\n\nimport type { CellAddress } from \"./grid-selection\";\n\n/** One cell as text for the clipboard. Objects go out as JSON. */\nexport function cellClipboardText(value: unknown): string {\n  if (value === null || value === undefined) return \"\";\n  if (typeof value === \"object\") return JSON.stringify(value);\n  return String(value);\n}\n\n/** Quote a cell the way Excel does, only when it has to be. */\nfunction tsvCell(text: string): string {\n  return /[\\t\\r\\n\"]/.test(text) ? `\"${text.replace(/\"/g, '\"\"')}\"` : text;\n}\n\n/** A rectangular block of cells as spreadsheet TSV. */\nexport function gridToTsv(block: readonly (readonly unknown[])[]): string {\n  return block\n    .map((row) => row.map((cell) => tsvCell(cellClipboardText(cell))).join(\"\\t\"))\n    .join(\"\\n\");\n}\n\n/**\n * Parse clipboard text as a spreadsheet block.\n *\n * Handles the Excel quoting dialect (a quoted cell may span lines and carries\n * `\"\"` for a literal quote), both `\\n` and `\\r\\n` line endings, and the single\n * trailing line break Excel and Sheets append to every copy — without that\n * strip, every paste would be one empty row taller than what was copied.\n *\n * Plain text with no tabs and no quotes still parses: one column, one row per\n * line, which is exactly what Sheets does with the same text. A single value\n * with no line break is a 1×1 block.\n */\nexport function parseClipboardGrid(text: string): string[][] {\n  const rows: string[][] = [];\n  let row: string[] = [];\n  let cell = \"\";\n  let i = 0;\n  const n = text.length;\n\n  while (i < n) {\n    const ch = text[i];\n\n    // A quote opens a quoted cell only at the START of a cell.\n    if (cell === \"\" && ch === '\"') {\n      // Quoted cell: read to the closing quote, honouring doubled quotes.\n      let j = i + 1;\n      let out = \"\";\n      let closed = false;\n      while (j < n) {\n        const c = text[j];\n        if (c === '\"') {\n          if (text[j + 1] === '\"') {\n            out += '\"';\n            j += 2;\n            continue;\n          }\n          closed = true;\n          j += 1;\n          break;\n        }\n        out += c;\n        j += 1;\n      }\n      if (closed && (j >= n || text[j] === \"\\t\" || text[j] === \"\\n\" || text[j] === \"\\r\")) {\n        cell = out;\n        i = j;\n        // Fall through to the delimiter handling below with `cell` complete.\n        if (i >= n) break;\n        const d = text[i];\n        if (d === \"\\t\") {\n          row.push(cell);\n          cell = \"\";\n          i += 1;\n          continue;\n        }\n        // line break\n        row.push(cell);\n        rows.push(row);\n        row = [];\n        cell = \"\";\n        i += d === \"\\r\" && text[i + 1] === \"\\n\" ? 2 : 1;\n        continue;\n      }\n      // Not a well-formed quoted cell (a value that merely starts with a\n      // quote). Treat the quote literally and keep going.\n      cell += ch;\n      i += 1;\n      continue;\n    }\n\n    if (ch === \"\\t\") {\n      row.push(cell);\n      cell = \"\";\n      i += 1;\n      continue;\n    }\n    if (ch === \"\\n\" || ch === \"\\r\") {\n      row.push(cell);\n      rows.push(row);\n      row = [];\n      cell = \"\";\n      i += ch === \"\\r\" && text[i + 1] === \"\\n\" ? 2 : 1;\n      continue;\n    }\n    cell += ch;\n    i += 1;\n  }\n\n  // Flush the last cell — unless the text ended on a line break, in which\n  // case that break was the trailing one every spreadsheet appends.\n  const endedOnBreak = n > 0 && (text[n - 1] === \"\\n\" || text[n - 1] === \"\\r\");\n  if (!endedOnBreak) {\n    row.push(cell);\n    rows.push(row);\n  } else if (row.length > 0) {\n    row.push(cell);\n    rows.push(row);\n  }\n\n  return rows.length === 0 ? [[\"\"]] : rows;\n}\n\n/** One landing cell of a paste, with the raw text that goes into it. */\nexport type PasteCell = CellAddress & { raw: string };\n\nexport type PastePlan = {\n  /** Cells inside the grid, in reading order (row by row). */\n  cells: PasteCell[];\n  /**\n   * Block rows below the last grid row, trimmed to the columns that fit from\n   * the anchor column rightward. The caller decides whether these become new\n   * rows — the plan only reports them so nothing is dropped silently.\n   */\n  overflowRows: string[][];\n  /** How many block columns fell off the right edge (per row, at most). */\n  clippedColumns: number;\n  /** The columns (field names) the block spans, anchor first. */\n  fieldNames: string[];\n};\n\n/**\n * Where does `block` land when pasted with its top-left cell at `anchor`?\n *\n * Rows extend downward from the anchor row and columns rightward from the\n * anchor column, in the GRID's current order (so a hidden or re-ordered column\n * is honoured — you paste into what you see). A block wider than the remaining\n * columns is clipped on the right; a block taller than the remaining rows is\n * reported as `overflowRows` rather than lost.\n *\n * Returns null when the anchor is not on the grid — the row was filtered out\n * or the column hidden since the selection was made. Writing \"somewhere near\"\n * is worse than refusing.\n */\nexport function planPaste(\n  anchor: CellAddress,\n  block: readonly (readonly string[])[],\n  rowIds: readonly string[],\n  fieldNames: readonly string[],\n): PastePlan | null {\n  const r0 = rowIds.indexOf(anchor.rowId);\n  const c0 = fieldNames.indexOf(anchor.fieldName);\n  if (r0 === -1 || c0 === -1) return null;\n\n  const width = block.reduce((w, row) => Math.max(w, row.length), 0);\n  const colsAvailable = fieldNames.length - c0;\n  const colsUsed = Math.min(width, colsAvailable);\n  const targetFields = fieldNames.slice(c0, c0 + colsUsed);\n\n  const cells: PasteCell[] = [];\n  const overflowRows: string[][] = [];\n\n  block.forEach((blockRow, dr) => {\n    const rowId = rowIds[r0 + dr];\n    if (rowId === undefined) {\n      overflowRows.push(targetFields.map((_, dc) => blockRow[dc] ?? \"\"));\n      return;\n    }\n    targetFields.forEach((fieldName, dc) => {\n      // A ragged block (some rows shorter) leaves the cells it does not\n      // reach alone rather than blanking them — matches Sheets.\n      if (dc >= blockRow.length) return;\n      const raw = blockRow[dc];\n      // The bound check above puts this index inside the row; a hole would be\n      // \"not reached\" too, and is left alone the same way.\n      if (raw === undefined) return;\n      cells.push({ rowId, fieldName, raw });\n    });\n  });\n\n  return {\n    cells,\n    overflowRows,\n    clippedColumns: Math.max(0, width - colsAvailable),\n    fieldNames: targetFields,\n  };\n}\n\n/** True when the parsed block is a single value — the common Cmd-V case. */\nexport function isSingleCell(block: readonly (readonly string[])[]): boolean {\n  // A one-row block always has that row; `?.` keeps the read total.\n  return block.length === 1 && block[0]?.length === 1;\n}\n\n/**\n * Would writing `next` over `prior` change what is stored? Objects compare by\n * their JSON, the same test the inline editor uses to skip a no-op write.\n */\nexport function storedValuesEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (a === null || b === null || a === undefined || b === undefined) {\n    return (a ?? null) === (b ?? null);\n  }\n  if (typeof a === \"object\" || typeof b === \"object\") {\n    try {\n      return JSON.stringify(a) === JSON.stringify(b);\n    } catch {\n      return false;\n    }\n  }\n  return false;\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,258 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data-table/grid-selection.ts
+var grid_selection_exports = {};
+__export(grid_selection_exports, {
+  allRange: () => allRange,
+  boundsContain: () => boundsContain,
+  cellDomKey: () => cellDomKey,
+  cellsInRange: () => cellsInRange,
+  classifyGridKey: () => classifyGridKey,
+  columnRange: () => columnRange,
+  directClickKinds: () => directClickKinds,
+  isDirectClickEditor: () => isDirectClickEditor,
+  isSingleCellRange: () => isSingleCellRange,
+  isTypingKey: () => isTypingKey,
+  moveSelection: () => moveSelection,
+  rangeBounds: () => rangeBounds,
+  rangeRows: () => rangeRows,
+  rangeSize: () => rangeSize,
+  rowRange: () => rowRange,
+  sameCell: () => sameCell
+});
+module.exports = __toCommonJS(grid_selection_exports);
+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}`;
+}
+//# sourceMappingURL=grid-selection.cjs.map

package/dist/data-table/grid-selection.cjs.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":[]}