@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,567 +0,0 @@
-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);
-    }
-  }
-}