@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,206 +0,0 @@
-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

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