@beyondwork/docx-react-component 1.0.14 → 1.0.16

package/src/formats/xlsx/runtime/cell-commands.ts

@@ -0,0 +1,567 @@
+import {
+  cellKey,
+  makeFormulaCell,
+  parseCellKey,
+  type CachedFormulaValue,
+  type CellValue,
+  type StyleRef,
+} from "../model/cell.ts";
+import { setCell } from "../model/sheet.ts";
+import type { CanonicalSheet, ColProperties, MergeRange, RowProperties } from "../model/sheet.ts";
+import type { CanonicalWorkbook } from "../model/workbook.ts";
+import {
+  cloneWorkbook,
+  createEmptyWorkbookMapping,
+  createWorkbookSelection,
+  createWorkbookTransaction,
+  extractFormulaReferenceTokens,
+  getRequiredSheet,
+  mapSelectionThroughMapping,
+  mergeRangeToWorkbookRange,
+  normalizeRange,
+  normalizeWorkbookSelection,
+  rangesIntersect,
+  remapFormulasForMutation,
+  type WorkbookRange,
+  type WorkbookSelection,
+  type WorkbookTransaction,
+} from "./workbook-transaction.ts";
+
+export type WorkbookCellCommand =
+  | {
+      type: "cell.set-value";
+      sheetId: string;
+      row: number;
+      col: number;
+      value: CellValue;
+    }
+  | {
+      type: "cell.clear";
+      sheetId: string;
+      row: number;
+      col: number;
+    }
+  | {
+      type: "cell.set-formula";
+      sheetId: string;
+      row: number;
+      col: number;
+      formula: string;
+      referenceTokens?: string[];
+      cachedValue?: CachedFormulaValue;
+      styleRef?: StyleRef;
+    }
+  | {
+      type: "row.insert";
+      sheetId: string;
+      row: number;
+      count?: number;
+    }
+  | {
+      type: "row.delete";
+      sheetId: string;
+      row: number;
+      count?: number;
+    }
+  | {
+      type: "column.insert";
+      sheetId: string;
+      col: number;
+      count?: number;
+    }
+  | {
+      type: "column.delete";
+      sheetId: string;
+      col: number;
+      count?: number;
+    }
+  | {
+      type: "cells.merge";
+      sheetId: string;
+      range: WorkbookRange;
+    }
+  | {
+      type: "cells.unmerge";
+      sheetId: string;
+      range: WorkbookRange;
+    };
+
+export function applyCellCommand(
+  workbook: CanonicalWorkbook,
+  selection: WorkbookSelection,
+  command: WorkbookCellCommand,
+): WorkbookTransaction {
+  const nextWorkbook = cloneWorkbook(workbook);
+  const mapping = createEmptyWorkbookMapping();
+
+  switch (command.type) {
+    case "cell.set-value": {
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      setCell(sheet, command.row, command.col, command.value);
+      mapping.operations.push({
+        type: "cell-set",
+        sheetId: command.sheetId,
+        row: command.row,
+        col: command.col,
+      });
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          createWorkbookSelection(command.sheetId, command.row, command.col),
+        ),
+        mapping,
+        "cell.set-value",
+      );
+    }
+    case "cell.clear": {
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      setCell(sheet, command.row, command.col, undefined);
+      mapping.operations.push({
+        type: "cell-set",
+        sheetId: command.sheetId,
+        row: command.row,
+        col: command.col,
+      });
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          createWorkbookSelection(command.sheetId, command.row, command.col),
+        ),
+        mapping,
+        "cell.clear",
+      );
+    }
+    case "cell.set-formula": {
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      const referenceTokens = command.referenceTokens ?? extractFormulaReferenceTokens(command.formula);
+      setCell(
+        sheet,
+        command.row,
+        command.col,
+        makeFormulaCell(command.formula, command.cachedValue, command.styleRef, referenceTokens),
+      );
+      mapping.operations.push({
+        type: "cell-set",
+        sheetId: command.sheetId,
+        row: command.row,
+        col: command.col,
+      });
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          createWorkbookSelection(command.sheetId, command.row, command.col),
+        ),
+        mapping,
+        "cell.set-formula",
+      );
+    }
+    case "row.insert": {
+      const count = normalizeCount(command.count);
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      shiftRows(sheet, command.row, count, "insert");
+      mapping.operations.push({
+        type: "row-insert",
+        sheetId: command.sheetId,
+        index: command.row,
+        count,
+      });
+      remapFormulasForMutation(
+        nextWorkbook,
+        command.sheetId,
+        { axis: "row", kind: "insert", index: command.row, count },
+        mapping,
+      );
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          mapSelectionThroughMapping(selection, mapping),
+        ),
+        mapping,
+        "row.insert",
+      );
+    }
+    case "row.delete": {
+      const count = normalizeCount(command.count);
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      shiftRows(sheet, command.row, count, "delete");
+      mapping.operations.push({
+        type: "row-delete",
+        sheetId: command.sheetId,
+        index: command.row,
+        count,
+      });
+      remapFormulasForMutation(
+        nextWorkbook,
+        command.sheetId,
+        { axis: "row", kind: "delete", index: command.row, count },
+        mapping,
+      );
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          mapSelectionThroughMapping(selection, mapping),
+        ),
+        mapping,
+        "row.delete",
+      );
+    }
+    case "column.insert": {
+      const count = normalizeCount(command.count);
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      shiftColumns(sheet, command.col, count, "insert");
+      mapping.operations.push({
+        type: "column-insert",
+        sheetId: command.sheetId,
+        index: command.col,
+        count,
+      });
+      remapFormulasForMutation(
+        nextWorkbook,
+        command.sheetId,
+        { axis: "col", kind: "insert", index: command.col, count },
+        mapping,
+      );
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          mapSelectionThroughMapping(selection, mapping),
+        ),
+        mapping,
+        "column.insert",
+      );
+    }
+    case "column.delete": {
+      const count = normalizeCount(command.count);
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      shiftColumns(sheet, command.col, count, "delete");
+      mapping.operations.push({
+        type: "column-delete",
+        sheetId: command.sheetId,
+        index: command.col,
+        count,
+      });
+      remapFormulasForMutation(
+        nextWorkbook,
+        command.sheetId,
+        { axis: "col", kind: "delete", index: command.col, count },
+        mapping,
+      );
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(
+          nextWorkbook,
+          mapSelectionThroughMapping(selection, mapping),
+        ),
+        mapping,
+        "column.delete",
+      );
+    }
+    case "cells.merge": {
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      const range = normalizeRange(command.range);
+      assertNonIntersectingMerge(sheet, range);
+      clearMergedInteriorCells(sheet, range);
+      sheet.merges = [
+        ...sheet.merges,
+        {
+          startRow: range.startRow,
+          startCol: range.startCol,
+          endRow: range.endRow,
+          endCol: range.endCol,
+        },
+      ];
+      mapping.operations.push({
+        type: "merge-add",
+        sheetId: command.sheetId,
+        range,
+      });
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(nextWorkbook, {
+          mode: "cell",
+          sheetId: command.sheetId,
+          activeCell: { row: range.startRow, col: range.startCol },
+          range,
+        }),
+        mapping,
+        "cells.merge",
+      );
+    }
+    case "cells.unmerge": {
+      const sheet = getRequiredSheet(nextWorkbook, command.sheetId);
+      const range = normalizeRange(command.range);
+      const removed = sheet.merges.filter((merge) => rangesIntersect(range, mergeRangeToWorkbookRange(merge)));
+      sheet.merges = sheet.merges.filter((merge) => !rangesIntersect(range, mergeRangeToWorkbookRange(merge)));
+      for (const merge of removed) {
+        mapping.operations.push({
+          type: "merge-remove",
+          sheetId: command.sheetId,
+          range: mergeRangeToWorkbookRange(merge),
+        });
+      }
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(nextWorkbook, {
+          mode: "cell",
+          sheetId: command.sheetId,
+          activeCell: { row: range.startRow, col: range.startCol },
+          range,
+        }),
+        mapping,
+        "cells.unmerge",
+      );
+    }
+  }
+}
+
+function normalizeCount(value: number | undefined): number {
+  const next = Math.floor(value ?? 1);
+  return Number.isFinite(next) && next > 0 ? next : 1;
+}
+
+function shiftRows(
+  sheet: CanonicalSheet,
+  row: number,
+  count: number,
+  mode: "insert" | "delete",
+): void {
+  const nextCells = new Map<string, CellValue>();
+  for (const [key, value] of sheet.cells) {
+    const address = parseCellKey(key);
+    const nextRow = mode === "insert"
+      ? remapInsertedIndex(address.row, row, count)
+      : remapDeletedIndex(address.row, row, count);
+    if (nextRow === null) {
+      continue;
+    }
+    nextCells.set(cellKey(nextRow, address.col), value);
+  }
+  sheet.cells = nextCells;
+
+  const nextRowProps = new Map<number, RowProperties>();
+  for (const [rowIndex, props] of sheet.rowProps) {
+    const nextRow = mode === "insert"
+      ? remapInsertedIndex(rowIndex, row, count)
+      : remapDeletedIndex(rowIndex, row, count);
+    if (nextRow === null) {
+      continue;
+    }
+    nextRowProps.set(nextRow, {
+      ...props,
+      rowIndex: nextRow,
+    });
+  }
+  sheet.rowProps = nextRowProps;
+  sheet.merges = sheet.merges
+    .map((merge) => remapMergeRows(merge, row, count, mode))
+    .filter((merge): merge is MergeRange => merge !== null);
+
+  if (sheet.paneState && row <= sheet.paneState.frozenRows) {
+    sheet.paneState = {
+      ...sheet.paneState,
+      frozenRows: mode === "insert"
+        ? sheet.paneState.frozenRows + count
+        : Math.max(0, sheet.paneState.frozenRows - countWithin(sheet.paneState.frozenRows, row, count)),
+    };
+  }
+}
+
+function shiftColumns(
+  sheet: CanonicalSheet,
+  col: number,
+  count: number,
+  mode: "insert" | "delete",
+): void {
+  const nextCells = new Map<string, CellValue>();
+  for (const [key, value] of sheet.cells) {
+    const address = parseCellKey(key);
+    const nextCol = mode === "insert"
+      ? remapInsertedIndex(address.col, col, count)
+      : remapDeletedIndex(address.col, col, count);
+    if (nextCol === null) {
+      continue;
+    }
+    nextCells.set(cellKey(address.row, nextCol), value);
+  }
+  sheet.cells = nextCells;
+
+  const nextColProps = new Map<number, ColProperties>();
+  for (const [colIndex, props] of sheet.colProps) {
+    const nextCol = mode === "insert"
+      ? remapInsertedIndex(colIndex, col, count)
+      : remapDeletedIndex(colIndex, col, count);
+    if (nextCol === null) {
+      continue;
+    }
+    nextColProps.set(nextCol, {
+      ...props,
+      colIndex: nextCol,
+    });
+  }
+  sheet.colProps = nextColProps;
+  sheet.merges = sheet.merges
+    .map((merge) => remapMergeColumns(merge, col, count, mode))
+    .filter((merge): merge is MergeRange => merge !== null);
+
+  if (sheet.paneState && col <= sheet.paneState.frozenCols) {
+    sheet.paneState = {
+      ...sheet.paneState,
+      frozenCols: mode === "insert"
+        ? sheet.paneState.frozenCols + count
+        : Math.max(0, sheet.paneState.frozenCols - countWithin(sheet.paneState.frozenCols, col, count)),
+    };
+  }
+}
+
+function remapInsertedIndex(value: number, index: number, count: number): number {
+  return value >= index ? value + count : value;
+}
+
+function remapDeletedIndex(value: number, index: number, count: number): number | null {
+  const deleteEnd = index + count - 1;
+  if (value < index) {
+    return value;
+  }
+  if (value <= deleteEnd) {
+    return null;
+  }
+  return value - count;
+}
+
+function remapMergeRows(
+  merge: MergeRange,
+  row: number,
+  count: number,
+  mode: "insert" | "delete",
+): MergeRange | null {
+  if (mode === "insert") {
+    if (row <= merge.startRow) {
+      return {
+        ...merge,
+        startRow: merge.startRow + count,
+        endRow: merge.endRow + count,
+      };
+    }
+    if (row <= merge.endRow) {
+      return {
+        ...merge,
+        endRow: merge.endRow + count,
+      };
+    }
+    return merge;
+  }
+
+  const rowInterval = remapDeletedInterval(merge.startRow, merge.endRow, row, count);
+  if (!rowInterval) {
+    return null;
+  }
+  return {
+    ...merge,
+    startRow: rowInterval.start,
+    endRow: rowInterval.end,
+  };
+}
+
+function remapMergeColumns(
+  merge: MergeRange,
+  col: number,
+  count: number,
+  mode: "insert" | "delete",
+): MergeRange | null {
+  if (mode === "insert") {
+    if (col <= merge.startCol) {
+      return {
+        ...merge,
+        startCol: merge.startCol + count,
+        endCol: merge.endCol + count,
+      };
+    }
+    if (col <= merge.endCol) {
+      return {
+        ...merge,
+        endCol: merge.endCol + count,
+      };
+    }
+    return merge;
+  }
+
+  const colInterval = remapDeletedInterval(merge.startCol, merge.endCol, col, count);
+  if (!colInterval) {
+    return null;
+  }
+  return {
+    ...merge,
+    startCol: colInterval.start,
+    endCol: colInterval.end,
+  };
+}
+
+function remapDeletedInterval(
+  start: number,
+  end: number,
+  index: number,
+  count: number,
+): { start: number; end: number } | null {
+  const deleteEnd = index + count - 1;
+  const overlapStart = Math.max(start, index);
+  const overlapEnd = Math.min(end, deleteEnd);
+  if (overlapStart <= overlapEnd && overlapEnd - overlapStart + 1 >= end - start + 1) {
+    return null;
+  }
+
+  let nextStart = start;
+  let nextEnd = end;
+  if (start >= index && start <= deleteEnd) {
+    nextStart = index;
+  } else if (start > deleteEnd) {
+    nextStart = start - count;
+  }
+
+  if (end >= index && end <= deleteEnd) {
+    nextEnd = index - 1;
+  } else if (end > deleteEnd) {
+    nextEnd = end - count;
+  }
+
+  if (nextEnd < nextStart) {
+    nextEnd = nextStart;
+  }
+
+  return { start: nextStart, end: nextEnd };
+}
+
+function countWithin(value: number, index: number, count: number): number {
+  const deleteEnd = index + count - 1;
+  if (value < index) {
+    return 0;
+  }
+  if (value <= deleteEnd) {
+    return value - index + 1;
+  }
+  return count;
+}
+
+function assertNonIntersectingMerge(sheet: CanonicalSheet, range: WorkbookRange): void {
+  for (const merge of sheet.merges) {
+    if (rangesIntersect(range, mergeRangeToWorkbookRange(merge))) {
+      throw new Error("Cannot create an overlapping merge range.");
+    }
+  }
+}
+
+function clearMergedInteriorCells(sheet: CanonicalSheet, range: WorkbookRange): void {
+  for (let row = range.startRow; row <= range.endRow; row += 1) {
+    for (let col = range.startCol; col <= range.endCol; col += 1) {
+      if (row === range.startRow && col === range.startCol) {
+        continue;
+      }
+      setCell(sheet, row, col, undefined);
+    }
+  }
+}