@ai-matrx/design-system 0.22.0 → 0.25.0

package/dist/data-table/spreadsheet.cjs

@@ -0,0 +1,1014 @@
+"use client";
+"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/useSpreadsheetGrid.ts
+var useSpreadsheetGrid_exports = {};
+__export(useSpreadsheetGrid_exports, {
+  NO_PATCHES: () => NOTHING,
+  useSpreadsheetGrid: () => useSpreadsheetGrid
+});
+module.exports = __toCommonJS(useSpreadsheetGrid_exports);
+var import_react = require("react");
+
+// 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 boundsContain(bounds, rowIndex, colIndex) {
+  return rowIndex >= bounds.r0 && rowIndex <= bounds.r1 && colIndex >= bounds.c0 && colIndex <= bounds.c1;
+}
+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 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;
+}
+
+// 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;
+}
+
+// src/data-table/fill.ts
+var NO_SERIES = { kind: "none", step: 0 };
+var MS_PER_DAY = 864e5;
+function plural(count, one, many) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+function isValidRect(rect) {
+  return Number.isInteger(rect.top) && Number.isInteger(rect.left) && Number.isInteger(rect.bottom) && Number.isInteger(rect.right) && rect.top <= rect.bottom && rect.left <= rect.right;
+}
+function asBounds(rect) {
+  return { r0: rect.top, r1: rect.bottom, c0: rect.left, c1: rect.right };
+}
+function directionOf(source, target) {
+  if (!isValidRect(source) || !isValidRect(target)) return null;
+  if (target.top === source.bottom + 1) return "down";
+  if (target.bottom === source.top - 1) return "up";
+  if (target.left === source.right + 1) return "right";
+  if (target.right === source.left - 1) return "left";
+  return null;
+}
+function tileIndex(i, a, b) {
+  const n = b - a + 1;
+  if (n <= 0) return a;
+  if (i >= a && i <= b) return i;
+  if (i > b) return a + (i - a) % n;
+  return b - (a - 1 - i) % n;
+}
+function isFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+var DATE_ISH = /^\d{4}-\d{2}-\d{2}([T ]|$)/;
+function dateMs(v) {
+  if (v instanceof Date) {
+    const t = v.getTime();
+    return Number.isFinite(t) ? t : null;
+  }
+  if (typeof v === "string" && DATE_ISH.test(v)) {
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+function detectSeries(values) {
+  if (!Array.isArray(values) || values.length < 2) return NO_SERIES;
+  if (values.every(isFiniteNumber)) {
+    const nums = values;
+    const first = nums[0];
+    const second = nums[1];
+    if (first === void 0 || second === void 0) return NO_SERIES;
+    const step = second - first;
+    for (let i = 1; i < nums.length; i += 1) {
+      const prev = nums[i - 1];
+      const cur = nums[i];
+      if (prev === void 0 || cur === void 0) return NO_SERIES;
+      if (cur - prev !== step) return NO_SERIES;
+    }
+    return { kind: "number", step };
+  }
+  const stamps = values.map(dateMs);
+  if (stamps.every((t) => t !== null)) {
+    const first = stamps[0];
+    const second = stamps[1];
+    if (first === void 0 || second === void 0) return NO_SERIES;
+    const deltaMs = second - first;
+    if (deltaMs % MS_PER_DAY !== 0) return NO_SERIES;
+    for (let i = 1; i < stamps.length; i += 1) {
+      const prev = stamps[i - 1];
+      const cur = stamps[i];
+      if (prev === void 0 || cur === void 0) return NO_SERIES;
+      if (cur - prev !== deltaMs) return NO_SERIES;
+    }
+    return { kind: "date", step: deltaMs / MS_PER_DAY };
+  }
+  return NO_SERIES;
+}
+function formatDateLike(ms, sample) {
+  const iso = new Date(ms).toISOString();
+  if (typeof sample === "string" && DATE_ONLY.test(sample)) return iso.slice(0, 10);
+  return iso;
+}
+function extrapolate(line, series, k) {
+  const last = line[line.length - 1];
+  if (series.kind === "number" && isFiniteNumber(last)) {
+    return last + k * series.step;
+  }
+  if (series.kind === "date") {
+    const base = dateMs(last);
+    if (base === null) return jsonable(last);
+    return formatDateLike(base + k * series.step * MS_PER_DAY, last);
+  }
+  return jsonable(last);
+}
+function jsonable(value) {
+  if (value instanceof Date) {
+    const t = value.getTime();
+    return Number.isFinite(t) ? value.toISOString() : null;
+  }
+  if (value === void 0) return null;
+  return value;
+}
+function emptyResult(summary) {
+  return { patches: [], skipped: [], summary };
+}
+function fillRange(request) {
+  const { source, target, columnIds, rowIds } = request;
+  const mode = request.mode ?? "series";
+  const isWritable = request.isColumnWritable ?? (() => true);
+  const direction = directionOf(source, target);
+  if (!direction) {
+    return emptyResult(
+      "Filled 0 cells because the fill area does not touch the selection."
+    );
+  }
+  if (rowIds.length === 0 || columnIds.length === 0) {
+    return emptyResult("Filled 0 cells because the table is empty.");
+  }
+  const read = (r, c) => {
+    try {
+      return { ok: true, value: request.valueAt(r, c) };
+    } catch {
+      return { ok: false, value: void 0 };
+    }
+  };
+  const vertical = direction === "down" || direction === "up";
+  const forward = direction === "down" || direction === "right";
+  const fillStart = vertical ? source.top : source.left;
+  const fillEnd = vertical ? source.bottom : source.right;
+  const crossStart = vertical ? source.left : source.top;
+  const crossEnd = vertical ? source.right : source.bottom;
+  const maxFill = (vertical ? rowIds.length : columnIds.length) - 1;
+  const maxCross = (vertical ? columnIds.length : rowIds.length) - 1;
+  const rawFillFrom = vertical ? target.top : target.left;
+  const rawFillTo = vertical ? target.bottom : target.right;
+  const rawCrossFrom = vertical ? target.left : target.top;
+  const rawCrossTo = vertical ? target.right : target.bottom;
+  const fillFrom = Math.max(rawFillFrom, 0);
+  const fillTo = Math.min(rawFillTo, maxFill);
+  const crossFrom = Math.max(rawCrossFrom, 0);
+  const crossTo = Math.min(rawCrossTo, maxCross);
+  const requested = Math.max(rawFillTo - rawFillFrom + 1, 0) * Math.max(rawCrossTo - rawCrossFrom + 1, 0);
+  const inside = Math.max(fillTo - fillFrom + 1, 0) * Math.max(crossTo - crossFrom + 1, 0);
+  const outside = Math.max(requested - inside, 0);
+  const sourceBounds = asBounds(source);
+  const patches = [];
+  const skipped = [];
+  const touchedColumns = /* @__PURE__ */ new Set();
+  const lines = /* @__PURE__ */ new Map();
+  const lineFor = (crossIndex) => {
+    const srcCross = tileIndex(crossIndex, crossStart, crossEnd);
+    const cached = lines.get(srcCross);
+    if (cached) return cached;
+    const values = [];
+    const reads = [];
+    for (let f = fillStart; f <= fillEnd; f += 1) {
+      const r = vertical ? f : srcCross;
+      const c = vertical ? srcCross : f;
+      const got = read(r, c);
+      values.push(got.value);
+      reads.push(got.ok);
+    }
+    const series = mode === "series" ? detectSeries(values) : NO_SERIES;
+    const line = { values, reads, series };
+    lines.set(srcCross, line);
+    return line;
+  };
+  for (let f = fillFrom; f <= fillTo; f += 1) {
+    for (let x = crossFrom; x <= crossTo; x += 1) {
+      const rowIndex = vertical ? f : x;
+      const colIndex = vertical ? x : f;
+      const rowId = rowIds[rowIndex];
+      const columnId = columnIds[colIndex];
+      if (rowId === void 0 || columnId === void 0) continue;
+      if (boundsContain(sourceBounds, rowIndex, colIndex)) continue;
+      if (!isWritable(columnId)) {
+        skipped.push({
+          rowId,
+          columnId,
+          reason: `${columnId} cannot be filled because that column is read-only.`
+        });
+        continue;
+      }
+      const line = lineFor(x);
+      if (line.series.kind !== "none") {
+        const k = forward ? f - fillEnd : fillStart - f;
+        patches.push({ rowId, columnId, value: jsonable(extrapolate(line.values, line.series, k)) });
+        touchedColumns.add(columnId);
+        continue;
+      }
+      const srcFill = tileIndex(f, fillStart, fillEnd);
+      const patternIndex = srcFill - fillStart;
+      if (line.reads[patternIndex] !== true) {
+        skipped.push({
+          rowId,
+          columnId,
+          reason: `The value to copy into ${columnId} could not be read, so that cell was left alone.`
+        });
+        continue;
+      }
+      patches.push({ rowId, columnId, value: jsonable(line.values[patternIndex]) });
+      touchedColumns.add(columnId);
+    }
+  }
+  return { patches, skipped, summary: summarize(direction, patches, skipped, touchedColumns, outside) };
+}
+function summarize(direction, patches, skipped, touchedColumns, outside) {
+  const parts = [];
+  if (patches.length === 0) {
+    parts.push("Filled 0 cells because there was nothing to fill.");
+  } else if (direction === "down" || direction === "up") {
+    const word = direction === "down" ? "down" : "up";
+    parts.push(
+      `Filled ${plural(patches.length, "cell", "cells")} ${word} ${plural(touchedColumns.size, "column", "columns")}.`
+    );
+  } else {
+    const word = direction === "right" ? "right" : "left";
+    parts.push(
+      `Filled ${plural(patches.length, "cell", "cells")} ${word} across ${plural(touchedColumns.size, "column", "columns")}.`
+    );
+  }
+  if (skipped.length > 0) {
+    parts.push(`Skipped ${plural(skipped.length, "cell", "cells")} that could not be filled.`);
+  }
+  if (outside > 0) {
+    parts.push(`Ignored ${plural(outside, "cell", "cells")} outside the table.`);
+  }
+  return parts.join(" ");
+}
+function fillDown(request) {
+  const { range, ...rest } = request;
+  if (!isValidRect(range)) {
+    return emptyResult("Filled 0 cells because the selection is not a rectangle.");
+  }
+  if (range.top === range.bottom) {
+    return emptyResult("Filled 0 cells because the selection is a single row.");
+  }
+  return fillRange({
+    ...rest,
+    source: { top: range.top, left: range.left, bottom: range.top, right: range.right },
+    target: { top: range.top + 1, left: range.left, bottom: range.bottom, right: range.right }
+  });
+}
+function fillTargetFor(source, toRow, toColumn) {
+  if (!isValidRect(source)) return null;
+  if (!Number.isInteger(toRow) || !Number.isInteger(toColumn)) return null;
+  const below = toRow - source.bottom;
+  const above = source.top - toRow;
+  const rightOf = toColumn - source.right;
+  const leftOf = source.left - toColumn;
+  const vertical = Math.max(below, above, 0);
+  const horizontal = Math.max(rightOf, leftOf, 0);
+  if (vertical === 0 && horizontal === 0) return null;
+  if (vertical >= horizontal) {
+    if (below > 0) {
+      return { top: source.bottom + 1, bottom: toRow, left: source.left, right: source.right };
+    }
+    return { top: toRow, bottom: source.top - 1, left: source.left, right: source.right };
+  }
+  if (rightOf > 0) {
+    return { top: source.top, bottom: source.bottom, left: source.right + 1, right: toColumn };
+  }
+  return { top: source.top, bottom: source.bottom, left: toColumn, right: source.left - 1 };
+}
+
+// src/data-table/cell-undo.ts
+var DEFAULT_UNDO_DEPTH = 100;
+function createUndoStack(depth = DEFAULT_UNDO_DEPTH) {
+  const bounded = Number.isFinite(depth) && depth > 0 ? Math.floor(depth) : 0;
+  return { past: [], future: [], depth: bounded };
+}
+function pushUndo(stack, entry) {
+  if (stack.depth <= 0) {
+    return { past: [], future: [], depth: stack.depth };
+  }
+  const past = [...stack.past, entry];
+  while (past.length > stack.depth) past.shift();
+  return { past, future: [], depth: stack.depth };
+}
+function popUndo(stack) {
+  const entry = stack.past[stack.past.length - 1];
+  if (entry === void 0) return { stack, entry: null };
+  return {
+    stack: {
+      past: stack.past.slice(0, -1),
+      future: [...stack.future, entry],
+      depth: stack.depth
+    },
+    entry
+  };
+}
+function popRedo(stack) {
+  const entry = stack.future[stack.future.length - 1];
+  if (entry === void 0) return { stack, entry: null };
+  const past = [...stack.past, entry];
+  while (past.length > stack.depth) past.shift();
+  return {
+    stack: { past, future: stack.future.slice(0, -1), depth: stack.depth },
+    entry
+  };
+}
+function keyOf(patch) {
+  return JSON.stringify([patch.rowId, patch.columnId]);
+}
+function undoEntryFor(before, after, label) {
+  const priors = /* @__PURE__ */ new Map();
+  for (const patch of before) priors.set(keyOf(patch), patch);
+  const undo = after.map((patch) => {
+    const prior = priors.get(keyOf(patch));
+    return {
+      rowId: patch.rowId,
+      columnId: patch.columnId,
+      value: prior ? prior.value : null
+    };
+  });
+  return {
+    label,
+    undo,
+    redo: after.map((patch) => ({
+      rowId: patch.rowId,
+      columnId: patch.columnId,
+      value: patch.value
+    }))
+  };
+}
+
+// src/data-table/useSpreadsheetGrid.ts
+function targetsAnEditor(target) {
+  const element = target instanceof Element ? target : null;
+  if (!element) return false;
+  return element.closest("input, textarea, select, [contenteditable='true']") !== null;
+}
+var NOTHING = [];
+function useSpreadsheetGrid(options) {
+  const [range, setRange] = (0, import_react.useState)(null);
+  const [fillTarget, setFillTarget] = (0, import_react.useState)(null);
+  const [stack, setStack] = (0, import_react.useState)(() => createUndoStack(options?.undoDepth ?? 100));
+  const draggingRef = (0, import_react.useRef)(null);
+  const optionsRef = (0, import_react.useRef)(options);
+  optionsRef.current = options;
+  const rowIds = options?.rowIds ?? [];
+  const columnIds = (0, import_react.useMemo)(
+    () => options ? options.columnIds.filter((id) => id !== "") : [],
+    [options]
+  );
+  (0, import_react.useEffect)(() => {
+    if (!range) return;
+    const rowSet = new Set(rowIds);
+    const colSet = new Set(columnIds);
+    const alive = rowSet.has(range.anchor.rowId) && rowSet.has(range.focus.rowId) && colSet.has(range.anchor.fieldName) && colSet.has(range.focus.fieldName);
+    if (!alive) setRange(null);
+  }, [range, rowIds, columnIds]);
+  const bounds = (0, import_react.useMemo)(
+    () => range ? rangeBounds(range, rowIds, columnIds) : null,
+    [range, rowIds, columnIds]
+  );
+  const rowIndexById = (0, import_react.useMemo)(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < rowIds.length; i += 1) map.set(rowIds[i], i);
+    return map;
+  }, [rowIds]);
+  const columnIndexById = (0, import_react.useMemo)(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < columnIds.length; i += 1) map.set(columnIds[i], i);
+    return map;
+  }, [columnIds]);
+  const applyPatches = (0, import_react.useCallback)(
+    async (patches, intent, label) => {
+      const current = optionsRef.current;
+      if (!current || patches.length === 0) return;
+      const depth = current.undoDepth ?? 100;
+      if (depth > 0 && intent !== "undo" && intent !== "redo") {
+        const before = patches.map((patch) => ({
+          rowId: patch.rowId,
+          columnId: patch.columnId,
+          value: current.valueAt(patch.rowId, patch.columnId) ?? null
+        }));
+        setStack((previous) => pushUndo(previous, undoEntryFor(before, patches, label)));
+      }
+      await current.onPatch(patches, intent);
+    },
+    []
+  );
+  const readValueAt = (0, import_react.useCallback)((rowIndex, columnIndex) => {
+    const current = optionsRef.current;
+    const rowId = current?.rowIds[rowIndex];
+    const columnId = current?.columnIds[columnIndex];
+    if (!current || rowId === void 0 || columnId === void 0) return null;
+    return current.valueAt(rowId, columnId);
+  }, []);
+  const fillRequestBase = (0, import_react.useCallback)(() => {
+    const current = optionsRef.current;
+    if (!current) return null;
+    return {
+      valueAt: readValueAt,
+      columnIds: [...current.columnIds],
+      rowIds: [...current.rowIds],
+      isColumnWritable: current.isColumnWritable
+    };
+  }, [readValueAt]);
+  const announceSkips = (0, import_react.useCallback)(
+    (skipped, summary) => {
+      const current = optionsRef.current;
+      if (!current?.notify) return;
+      if (skipped.length === 0) {
+        current.notify(summary);
+        return;
+      }
+      const first = skipped[0];
+      const reason = current.columnRefusal?.(first.columnId) ?? first.reason;
+      const rest = skipped.length > 1 ? ` ${skipped.length - 1} more were left alone.` : "";
+      current.notify(`${summary} ${reason}${rest}`);
+    },
+    []
+  );
+  const doFillDown = (0, import_react.useCallback)(async () => {
+    const base = fillRequestBase();
+    if (!base || !bounds) return;
+    const result = fillDown({
+      ...base,
+      range: { top: bounds.r0, left: bounds.c0, bottom: bounds.r1, right: bounds.c1 }
+    });
+    await applyPatches(result.patches, "fill-down", "Filled down");
+    announceSkips(result.skipped, result.summary);
+  }, [fillRequestBase, bounds, applyPatches, announceSkips]);
+  const doClear = (0, import_react.useCallback)(async () => {
+    const current = optionsRef.current;
+    if (!current || !bounds) return;
+    const patches = [];
+    const skipped = [];
+    for (let r = bounds.r0; r <= bounds.r1; r += 1) {
+      for (let c = bounds.c0; c <= bounds.c1; c += 1) {
+        const rowId = current.rowIds[r];
+        const columnId = current.columnIds[c];
+        if (rowId === void 0 || columnId === void 0) continue;
+        if (!current.isColumnWritable(columnId)) {
+          skipped.push({
+            columnId,
+            reason: current.columnRefusal?.(columnId) ?? `${columnId} cannot be cleared.`
+          });
+          continue;
+        }
+        patches.push({ rowId, columnId, value: null });
+      }
+    }
+    await applyPatches(patches, "clear", "Cleared");
+    announceSkips(skipped, `Cleared ${patches.length} cells.`);
+  }, [bounds, applyPatches, announceSkips]);
+  const doUndo = (0, import_react.useCallback)(async () => {
+    const taken = popUndo(stack);
+    if (!taken.entry) return;
+    setStack(taken.stack);
+    await applyPatches(taken.entry.undo, "undo", taken.entry.label);
+    optionsRef.current?.notify?.(taken.entry.label);
+  }, [stack, applyPatches]);
+  const doRedo = (0, import_react.useCallback)(async () => {
+    const taken = popRedo(stack);
+    if (!taken.entry) return;
+    setStack(taken.stack);
+    await applyPatches(taken.entry.redo, "redo", taken.entry.label);
+  }, [stack, applyPatches]);
+  const move = (0, import_react.useCallback)(
+    (direction, extend) => {
+      setRange((previous) => {
+        const from = previous ? previous.focus : null;
+        const next = moveSelection(from, direction, rowIds, columnIds);
+        if (!next) return previous;
+        if (extend && previous) return { anchor: previous.anchor, focus: next };
+        return { anchor: next, focus: next };
+      });
+    },
+    [rowIds, columnIds]
+  );
+  const onKeyDown = (0, import_react.useCallback)(
+    (event) => {
+      const current = optionsRef.current;
+      if (!current) return;
+      if (targetsAnEditor(event.target)) return;
+      const accel = event.metaKey || event.ctrlKey;
+      if (accel && (event.key === "z" || event.key === "Z")) {
+        event.preventDefault();
+        if (event.shiftKey) void doRedo();
+        else void doUndo();
+        return;
+      }
+      if (accel && (event.key === "y" || event.key === "Y")) {
+        event.preventDefault();
+        void doRedo();
+        return;
+      }
+      const action = classifyGridKey(event);
+      if (!action) return;
+      switch (action.kind) {
+        case "move":
+          event.preventDefault();
+          move(action.move, false);
+          return;
+        case "extend":
+          event.preventDefault();
+          move(action.move, true);
+          return;
+        case "selectAll": {
+          event.preventDefault();
+          const all = allRange(rowIds, columnIds);
+          if (all) setRange(all);
+          return;
+        }
+        case "selectRow": {
+          event.preventDefault();
+          const focused = range?.focus;
+          const next = focused ? rowRange(focused.rowId, columnIds) : null;
+          if (next) setRange(next);
+          return;
+        }
+        case "selectColumn": {
+          event.preventDefault();
+          const focused = range?.focus;
+          const next = focused ? columnRange(focused.fieldName, rowIds) : null;
+          if (next) setRange(next);
+          return;
+        }
+        case "clearCell":
+          event.preventDefault();
+          void doClear();
+          return;
+        case "fillDown":
+          event.preventDefault();
+          void doFillDown();
+          return;
+        case "escape":
+          setRange(null);
+          return;
+        default:
+          return;
+      }
+    },
+    [move, range, rowIds, columnIds, doClear, doFillDown, doUndo, doRedo]
+  );
+  const selectionAsTsv = (0, import_react.useCallback)(() => {
+    const current = optionsRef.current;
+    if (!current || !range) return "";
+    const grid = rangeRows(range, rowIds, columnIds).map(
+      (row) => row.map((address) => current.valueAt(address.rowId, address.fieldName))
+    );
+    return gridToTsv(grid);
+  }, [range, rowIds, columnIds]);
+  const onCopy = (0, import_react.useCallback)(
+    (event) => {
+      if (!optionsRef.current || !range || targetsAnEditor(event.target)) return;
+      const text = selectionAsTsv();
+      if (!text) return;
+      event.preventDefault();
+      event.clipboardData?.setData("text/plain", text);
+    },
+    [range, selectionAsTsv]
+  );
+  const onCut = (0, import_react.useCallback)(
+    (event) => {
+      if (!optionsRef.current || !range || targetsAnEditor(event.target)) return;
+      const text = selectionAsTsv();
+      if (!text) return;
+      event.preventDefault();
+      event.clipboardData?.setData("text/plain", text);
+      void doClear();
+    },
+    [range, selectionAsTsv, doClear]
+  );
+  const onPaste = (0, import_react.useCallback)(
+    (event) => {
+      const current = optionsRef.current;
+      if (!current || current.paste === false || !range || targetsAnEditor(event.target)) return;
+      const text = event.clipboardData?.getData("text/plain") ?? "";
+      if (!text) return;
+      event.preventDefault();
+      const block = parseClipboardGrid(text);
+      const start = range.focus;
+      const startRow = rowIds.indexOf(start.rowId);
+      const startCol = columnIds.indexOf(start.fieldName);
+      if (startRow === -1 || startCol === -1) return;
+      const patches = [];
+      const skipped = [];
+      let outside = 0;
+      for (let r = 0; r < block.length; r += 1) {
+        const line = block[r] ?? [];
+        for (let c = 0; c < line.length; c += 1) {
+          const rowId = rowIds[startRow + r];
+          const columnId = columnIds[startCol + c];
+          if (rowId === void 0 || columnId === void 0) {
+            outside += 1;
+            continue;
+          }
+          if (!current.isColumnWritable(columnId)) {
+            skipped.push({
+              columnId,
+              reason: current.columnRefusal?.(columnId) ?? `${columnId} cannot take a pasted value.`
+            });
+            continue;
+          }
+          patches.push({ rowId, columnId, value: line[c] ?? null });
+        }
+      }
+      void applyPatches(patches, "paste", "Pasted");
+      const tail = outside > 0 ? ` ${outside} landed past the edge of the table and were ignored.` : "";
+      announceSkips(skipped, `Pasted ${patches.length} cells.${tail}`);
+    },
+    [range, rowIds, columnIds, applyPatches, announceSkips]
+  );
+  const cellProps = (0, import_react.useCallback)(
+    (rowId, columnId) => {
+      const address = { rowId, fieldName: columnId };
+      const rowIndex = rowIndexById.get(rowId) ?? -1;
+      const colIndex = columnIndexById.get(columnId) ?? -1;
+      const selected = bounds !== null && rowIndex >= bounds.r0 && rowIndex <= bounds.r1 && colIndex >= bounds.c0 && colIndex <= bounds.c1;
+      const active = range !== null && sameCell(range.focus, address);
+      const inFillPreview = fillTarget !== null && rowIndex >= fillTarget.top && rowIndex <= fillTarget.bottom && colIndex >= fillTarget.left && colIndex <= fillTarget.right;
+      return {
+        "data-matrx-cell-row": rowId,
+        "data-matrx-cell-col": columnId,
+        ...selected ? { "data-matrx-cell-selected": "true" } : {},
+        ...active ? { "data-matrx-cell-active": "true" } : {},
+        ...inFillPreview ? { "data-matrx-cell-fill-preview": "true" } : {},
+        onMouseDown: (event) => {
+          if (event.button !== 0) return;
+          event.preventDefault();
+          setRange(
+            (previous) => event.shiftKey && previous ? { anchor: previous.anchor, focus: address } : { anchor: address, focus: address }
+          );
+          draggingRef.current = "select";
+        },
+        onMouseEnter: () => {
+          if (draggingRef.current === "select") {
+            setRange((previous) => previous ? { anchor: previous.anchor, focus: address } : previous);
+            return;
+          }
+          if (draggingRef.current === "fill" && bounds) {
+            setFillTarget(
+              fillTargetFor(
+                { top: bounds.r0, left: bounds.c0, bottom: bounds.r1, right: bounds.c1 },
+                rowIndex,
+                colIndex
+              )
+            );
+          }
+        }
+      };
+    },
+    [rowIndexById, columnIndexById, bounds, range, fillTarget]
+  );
+  const isFillHandleCell = (0, import_react.useCallback)(
+    (rowId, columnId) => {
+      const current = optionsRef.current;
+      if (!current || current.fillHandle === false || !bounds) return false;
+      return rowIds[bounds.r1] === rowId && columnIds[bounds.c1] === columnId;
+    },
+    [bounds, rowIds, columnIds]
+  );
+  const startFillDrag = (0, import_react.useCallback)(
+    (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      draggingRef.current = "fill";
+    },
+    []
+  );
+  const fillTargetRef = (0, import_react.useRef)(null);
+  fillTargetRef.current = fillTarget;
+  const boundsRef = (0, import_react.useRef)(null);
+  boundsRef.current = bounds;
+  (0, import_react.useEffect)(() => {
+    if (!options) return;
+    const commit = () => {
+      const wasDragging = draggingRef.current;
+      draggingRef.current = null;
+      if (wasDragging !== "fill") return;
+      const target = fillTargetRef.current;
+      const source = boundsRef.current;
+      setFillTarget(null);
+      if (!target || !source) return;
+      const base = fillRequestBase();
+      if (!base) return;
+      const result = fillRange({
+        ...base,
+        source: { top: source.r0, left: source.c0, bottom: source.r1, right: source.c1 },
+        target
+      });
+      void applyPatches(result.patches, "fill", "Filled");
+      announceSkips(result.skipped, result.summary);
+    };
+    window.addEventListener("mouseup", commit);
+    return () => window.removeEventListener("mouseup", commit);
+  }, [options, fillRequestBase, applyPatches, announceSkips]);
+  return {
+    range,
+    bounds,
+    enabled: options !== null,
+    containerProps: {
+      tabIndex: options ? 0 : -1,
+      onKeyDown,
+      onCopy,
+      onCut,
+      onPaste
+    },
+    cellProps,
+    isFillHandleCell,
+    startFillDrag,
+    canUndo: stack.past.length > 0,
+    canRedo: stack.future.length > 0
+  };
+}
+//# sourceMappingURL=spreadsheet.cjs.map