@beyondwork/docx-react-component 1.0.29 → 1.0.30

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

@@ -0,0 +1,206 @@
+import { addSheet, getSheetByName, moveSheet, removeSheet, renameSheet, type CanonicalWorkbook } from "../model/workbook.ts";
+import {
+  cloneWorkbook,
+  createEmptyWorkbookMapping,
+  createWorkbookSelection,
+  createWorkbookTransaction,
+  getDefaultSelection,
+  normalizeWorkbookSelection,
+  remapFormulasForMutation,
+  type WorkbookSelection,
+  type WorkbookTransaction,
+} from "./workbook-transaction.ts";
+
+export type WorkbookSheetCommand =
+  | {
+      type: "sheet.add";
+      sheetId?: string;
+      name: string;
+      atIndex?: number;
+      activate?: boolean;
+    }
+  | {
+      type: "sheet.remove";
+      sheetId: string;
+    }
+  | {
+      type: "sheet.rename";
+      sheetId: string;
+      name: string;
+    }
+  | {
+      type: "sheet.reorder";
+      sheetId: string;
+      toIndex: number;
+    };
+
+export function applySheetCommand(
+  workbook: CanonicalWorkbook,
+  selection: WorkbookSelection,
+  command: WorkbookSheetCommand,
+  options?: {
+    createSheetId?: () => string;
+  },
+): WorkbookTransaction {
+  const nextWorkbook = cloneWorkbook(workbook);
+  const mapping = createEmptyWorkbookMapping();
+
+  switch (command.type) {
+    case "sheet.add": {
+      assertUniqueSheetName(nextWorkbook, command.name);
+      const sheetId = command.sheetId ?? createSheetId(nextWorkbook, options?.createSheetId);
+      const insertIndex = command.atIndex ?? nextWorkbook.sheetOrder.length;
+      addSheet(nextWorkbook, sheetId, command.name, command.atIndex);
+      mapping.operations.push({
+        type: "sheet-add",
+        sheetId,
+        index: clampIndex(insertIndex, nextWorkbook.sheetOrder.length - 1),
+        name: command.name,
+      });
+      const nextSelection = command.activate || workbook.sheetOrder.length === 0
+        ? createWorkbookSelection(sheetId)
+        : selection;
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(nextWorkbook, nextSelection),
+        mapping,
+        "sheet.add",
+      );
+    }
+    case "sheet.remove": {
+      const currentIndex = nextWorkbook.sheetOrder.indexOf(command.sheetId);
+      if (currentIndex === -1) {
+        throw new Error(`Sheet not found: ${command.sheetId}`);
+      }
+      const removedSheet = nextWorkbook.sheets.get(command.sheetId);
+      if (!removedSheet) {
+        throw new Error(`Sheet not found: ${command.sheetId}`);
+      }
+      const fallbackSheetId = resolveFallbackSheetId(nextWorkbook, command.sheetId);
+      remapFormulasForMutation(
+        nextWorkbook,
+        command.sheetId,
+        { kind: "remove-sheet", removedName: removedSheet.name },
+        mapping,
+      );
+      nextWorkbook.namedItems = nextWorkbook.namedItems.filter((item) => item.localSheetId !== command.sheetId);
+      removeSheet(nextWorkbook, command.sheetId);
+      mapping.operations.push({
+        type: "sheet-remove",
+        sheetId: command.sheetId,
+        index: currentIndex,
+        name: removedSheet.name,
+        fallbackSheetId,
+      });
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(nextWorkbook, selection.sheetId === command.sheetId
+          ? (fallbackSheetId ? createWorkbookSelection(fallbackSheetId) : { mode: "sheet" })
+          : selection),
+        mapping,
+        "sheet.remove",
+      );
+    }
+    case "sheet.rename": {
+      const sheet = nextWorkbook.sheets.get(command.sheetId);
+      if (!sheet) {
+        throw new Error(`Sheet not found: ${command.sheetId}`);
+      }
+      if (sheet.name !== command.name) {
+        assertUniqueSheetName(nextWorkbook, command.name, command.sheetId);
+      }
+      const beforeName = sheet.name;
+      renameSheet(nextWorkbook, command.sheetId, command.name);
+      mapping.operations.push({
+        type: "sheet-rename",
+        sheetId: command.sheetId,
+        beforeName,
+        afterName: command.name,
+      });
+      remapFormulasForMutation(
+        nextWorkbook,
+        command.sheetId,
+        { kind: "rename-sheet", beforeName, afterName: command.name },
+        mapping,
+      );
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(nextWorkbook, selection),
+        mapping,
+        "sheet.rename",
+      );
+    }
+    case "sheet.reorder": {
+      const fromIndex = nextWorkbook.sheetOrder.indexOf(command.sheetId);
+      if (fromIndex === -1) {
+        throw new Error(`Sheet not found: ${command.sheetId}`);
+      }
+      const toIndex = clampIndex(command.toIndex, nextWorkbook.sheetOrder.length - 1);
+      moveSheet(nextWorkbook, command.sheetId, command.toIndex);
+      mapping.operations.push({
+        type: "sheet-reorder",
+        sheetId: command.sheetId,
+        fromIndex,
+        toIndex,
+      });
+      return createWorkbookTransaction(
+        nextWorkbook,
+        normalizeWorkbookSelection(nextWorkbook, selection),
+        mapping,
+        "sheet.reorder",
+      );
+    }
+  }
+}
+
+function resolveFallbackSheetId(
+  workbook: CanonicalWorkbook,
+  removedSheetId: string,
+): string | undefined {
+  const currentIndex = workbook.sheetOrder.indexOf(removedSheetId);
+  if (currentIndex === -1) {
+    return getDefaultSelection(workbook).sheetId;
+  }
+
+  if (workbook.sheetOrder.length === 1) {
+    return undefined;
+  }
+
+  return workbook.sheetOrder[currentIndex + 1] ?? workbook.sheetOrder[currentIndex - 1];
+}
+
+function assertUniqueSheetName(
+  workbook: CanonicalWorkbook,
+  name: string,
+  currentSheetId?: string,
+): void {
+  const existing = getSheetByName(workbook, name);
+  if (existing && existing.sheetId !== currentSheetId) {
+    throw new Error(`Sheet name already exists: ${name}`);
+  }
+}
+
+function createSheetId(
+  workbook: CanonicalWorkbook,
+  factory?: () => string,
+): string {
+  if (factory) {
+    const nextId = factory();
+    if (workbook.sheets.has(nextId)) {
+      throw new Error(`Sheet id already exists: ${nextId}`);
+    }
+    return nextId;
+  }
+
+  let counter = workbook.sheets.size + 1;
+  let sheetId = `sheet-${counter}`;
+  while (workbook.sheets.has(sheetId)) {
+    counter += 1;
+    sheetId = `sheet-${counter}`;
+  }
+  return sheetId;
+}
+
+function clampIndex(value: number, maxIndex: number): number {
+  return Math.max(0, Math.min(value, maxIndex));
+}

package/src/formats/xlsx/runtime/workbook-runtime.ts

@@ -0,0 +1,177 @@
+import type { CanonicalWorkbook } from "../model/workbook.ts";
+import { applyCellCommand, type WorkbookCellCommand } from "./cell-commands.ts";
+import { applySheetCommand, type WorkbookSheetCommand } from "./sheet-commands.ts";
+import {
+  cloneWorkbook,
+  getDefaultSelection,
+  normalizeWorkbookSelection,
+  type WorkbookSelection,
+  type WorkbookTransaction,
+} from "./workbook-transaction.ts";
+
+export type WorkbookCommand = WorkbookCellCommand | WorkbookSheetCommand;
+
+export type WorkbookRuntimeUnsubscribe = () => void;
+
+export interface WorkbookRuntimeSnapshot {
+  workbook: CanonicalWorkbook;
+  selection: WorkbookSelection;
+  commandState: {
+    canUndo: boolean;
+    canRedo: boolean;
+    activeSheetId?: string;
+  };
+}
+
+export interface WorkbookRuntime {
+  subscribe(listener: () => void): WorkbookRuntimeUnsubscribe;
+  getSnapshot(): WorkbookRuntimeSnapshot;
+  dispatch(command: WorkbookCommand): WorkbookTransaction;
+  undo(): WorkbookTransaction | null;
+  redo(): WorkbookTransaction | null;
+}
+
+export interface CreateWorkbookRuntimeOptions {
+  workbook: CanonicalWorkbook;
+  selection?: WorkbookSelection;
+  createSheetId?: () => string;
+}
+
+interface WorkbookHistoryEntry {
+  beforeWorkbook: CanonicalWorkbook;
+  beforeSelection: WorkbookSelection;
+  transaction: WorkbookTransaction;
+}
+
+export function createWorkbookRuntime(
+  options: CreateWorkbookRuntimeOptions,
+): WorkbookRuntime {
+  const listeners = new Set<() => void>();
+  const history = {
+    past: [] as WorkbookHistoryEntry[],
+    future: [] as WorkbookHistoryEntry[],
+  };
+
+  let workbook = cloneWorkbook(options.workbook);
+  let selection = normalizeWorkbookSelection(workbook, options.selection ?? getDefaultSelection(workbook));
+  let cachedSnapshot = createSnapshot(workbook, selection, history);
+
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot() {
+      return cachedSnapshot;
+    },
+    dispatch(command) {
+      const beforeWorkbook = cloneWorkbook(workbook);
+      const beforeSelection = cloneSelection(selection);
+      const transaction = isCellCommand(command)
+        ? applyCellCommand(workbook, selection, command)
+        : applySheetCommand(workbook, selection, command, {
+            createSheetId: options.createSheetId,
+          });
+
+      workbook = transaction.nextWorkbook;
+      selection = transaction.nextSelection;
+      history.past.push({
+        beforeWorkbook,
+        beforeSelection,
+        transaction,
+      });
+      history.future = [];
+      cachedSnapshot = createSnapshot(workbook, selection, history);
+      notifyListeners(listeners);
+      return transaction;
+    },
+    undo() {
+      const entry = history.past.pop();
+      if (!entry) {
+        return null;
+      }
+
+      const redoEntry: WorkbookHistoryEntry = {
+        beforeWorkbook: cloneWorkbook(workbook),
+        beforeSelection: cloneSelection(selection),
+        transaction: entry.transaction,
+      };
+      history.future.push(redoEntry);
+
+      workbook = cloneWorkbook(entry.beforeWorkbook);
+      selection = cloneSelection(entry.beforeSelection);
+      cachedSnapshot = createSnapshot(workbook, selection, history);
+      notifyListeners(listeners);
+      return {
+        ...entry.transaction,
+        nextWorkbook: cloneWorkbook(workbook),
+        nextSelection: cloneSelection(selection),
+      };
+    },
+    redo() {
+      const entry = history.future.pop();
+      if (!entry) {
+        return null;
+      }
+
+      history.past.push({
+        beforeWorkbook: cloneWorkbook(workbook),
+        beforeSelection: cloneSelection(selection),
+        transaction: entry.transaction,
+      });
+
+      workbook = cloneWorkbook(entry.transaction.nextWorkbook);
+      selection = cloneSelection(entry.transaction.nextSelection);
+      cachedSnapshot = createSnapshot(workbook, selection, history);
+      notifyListeners(listeners);
+      return {
+        ...entry.transaction,
+        nextWorkbook: cloneWorkbook(workbook),
+        nextSelection: cloneSelection(selection),
+      };
+    },
+  };
+}
+
+function createSnapshot(
+  workbook: CanonicalWorkbook,
+  selection: WorkbookSelection,
+  history: {
+    past: WorkbookHistoryEntry[];
+    future: WorkbookHistoryEntry[];
+  },
+): WorkbookRuntimeSnapshot {
+  return {
+    workbook,
+    selection,
+    commandState: {
+      canUndo: history.past.length > 0,
+      canRedo: history.future.length > 0,
+      activeSheetId: selection.sheetId,
+    },
+  };
+}
+
+function notifyListeners(listeners: Set<() => void>): void {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function isCellCommand(command: WorkbookCommand): command is WorkbookCellCommand {
+  return command.type.startsWith("cell.")
+    || command.type.startsWith("row.")
+    || command.type.startsWith("column.")
+    || command.type.startsWith("cells.");
+}
+
+function cloneSelection(selection: WorkbookSelection): WorkbookSelection {
+  return {
+    mode: selection.mode,
+    sheetId: selection.sheetId,
+    activeCell: selection.activeCell ? { ...selection.activeCell } : undefined,
+    range: selection.range ? { ...selection.range } : undefined,
+  };
+}