@ricsam/formula-engine 0.2.8 → 0.2.10

package/dist/mjs/core/engine.mjs

@@ -16,64 +16,27 @@ import { DependencyManager } from "./managers/dependency-manager.mjs";
 import { StyleManager } from "./managers/style-manager.mjs";
 import { CopyManager } from "./managers/copy-manager.mjs";
 import { ReferenceManager } from "./managers/reference-manager.mjs";
-import {
-  SchemaManager
-} from "./managers/schema-manager.mjs";
-import { buildSchemaFromDeclaration } from "./schema/schema-builder.mjs";
-import { TableOrm } from "./schema/table-orm.mjs";
-import { CellOrm } from "./schema/cell-orm.mjs";
-import { GridOrm } from "./schema/grid-orm.mjs";
 import {
   ENGINE_SNAPSHOT_VERSION
 } from "./engine-snapshot.mjs";
 import {
-  CommandExecutor
-} from "./commands/command-executor.mjs";
-import {
-  SetCellContentCommand,
-  SetSheetContentCommand,
-  ClearRangeCommand,
-  PasteCellsCommand,
-  FillAreasCommand,
-  MoveCellCommand,
-  MoveRangeCommand,
-  AutoFillCommand
-} from "./commands/content-commands.mjs";
-import {
-  AddWorkbookCommand,
-  RemoveWorkbookCommand,
-  RenameWorkbookCommand,
-  CloneWorkbookCommand,
-  AddSheetCommand,
-  RemoveSheetCommand,
-  RenameSheetCommand
-} from "./commands/structure-commands.mjs";
-import {
-  AddTableCommand,
-  RemoveTableCommand,
-  RenameTableCommand,
-  UpdateTableCommand,
-  ResetTablesCommand
-} from "./commands/table-commands.mjs";
-import {
-  AddNamedExpressionCommand,
-  RemoveNamedExpressionCommand,
-  UpdateNamedExpressionCommand,
-  RenameNamedExpressionCommand,
-  SetNamedExpressionsCommand
-} from "./commands/named-expression-commands.mjs";
+  buildFormulaTouchedCells,
+  buildSheetContentTouchedCells,
+  buildTableContextChangedCells,
+  buildTableTouchedCells,
+  buildTouchedCells,
+  captureCellContents,
+  getFiniteRangeAddresses,
+  getMutationAddressKey,
+  getNamedExpressionScopeResourceKeys,
+  mergeTouchedCells
+} from "./mutation-invalidation.mjs";
 import {
-  SetCellMetadataCommand,
-  SetSheetMetadataCommand,
-  SetWorkbookMetadataCommand
-} from "./commands/metadata-commands.mjs";
-import {
-  AddConditionalStyleCommand,
-  RemoveConditionalStyleCommand,
-  AddCellStyleCommand,
-  RemoveCellStyleCommand,
-  ClearCellStylesCommand
-} from "./commands/style-commands.mjs";
+  getNamedExpressionResourceKey,
+  getSheetResourceKey,
+  getTableResourceKey,
+  getWorkbookResourceKey
+} from "./resource-keys.mjs";
 
 class FormulaEngine {
   workbookManager;
@@ -86,10 +49,6 @@ class FormulaEngine {
   styleManager;
   copyManager;
   referenceManager;
-  schemaManager;
-  commandExecutor;
-  schema;
-  schemaDeclaration;
   _workbookManager;
   _namedExpressionManager;
   _tableManager;
@@ -98,8 +57,7 @@ class FormulaEngine {
   _autoFillManager;
   _dependencyManager;
   _styleManager;
-  constructor(schema) {
-    this.schemaDeclaration = schema?.declaration;
+  constructor() {
     this.eventManager = new EventManager;
     this.workbookManager = new WorkbookManager;
     this.namedExpressionManager = new NamedExpressionManager;
@@ -112,13 +70,6 @@ class FormulaEngine {
     this.copyManager = new CopyManager(this.workbookManager, this.evaluationManager, this.styleManager);
     this.autoFillManager = new AutoFill(this.workbookManager, this.styleManager);
     this.referenceManager = new ReferenceManager;
-    this.schemaManager = new SchemaManager(this.tableManager);
-    this.commandExecutor = new CommandExecutor(this.evaluationManager, this.eventManager, () => this.schemaManager.validateAllSchemaConstraints((cell) => this.getCellValue(cell), (cell) => this.getCellMetadata(cell), (table) => this.getTableDataCells(table)));
-    if (this.schemaDeclaration) {
-      this.schema = buildSchemaFromDeclaration(this, this.schemaDeclaration, this.schemaManager);
-    } else {
-      this.schema = {};
-    }
     this._workbookManager = this.workbookManager;
     this._namedExpressionManager = this.namedExpressionManager;
     this._tableManager = this.tableManager;
@@ -128,46 +79,63 @@ class FormulaEngine {
     this._dependencyManager = this.dependencyManager;
     this._styleManager = this.styleManager;
   }
-  static buildEmpty(schema) {
-    return new FormulaEngine(schema);
-  }
-  addTableSchema(namespace, address, headers) {
-    this.schemaManager.registerTableSchema(namespace, address.workbookName, address.tableName, headers);
-    const orm = new TableOrm(this, address.workbookName, address.tableName, headers, namespace);
-    this.schema[namespace] = orm;
-    return orm;
+  static buildEmpty() {
+    return new FormulaEngine;
   }
-  addCellSchema(namespace, cellAddress, parse, write = (value) => ({ value })) {
-    this.schemaManager.registerCellSchema(namespace, cellAddress, parse);
-    const orm = new CellOrm(this, cellAddress, parse, write, namespace);
-    this.schema[namespace] = orm;
-    return orm;
-  }
-  addGridSchema(namespace, address, range, parse, write = (value) => ({ value })) {
-    this.schemaManager.registerGridSchema(namespace, address.workbookName, address.sheetName, range, parse);
-    const orm = new GridOrm(this, address.workbookName, address.sheetName, range, parse, write, namespace);
-    this.schema[namespace] = orm;
-    return orm;
-  }
-  removeTableSchema(namespace) {
-    return this.removeSchemaOfType(namespace, "table");
+  emitMutation(footprint) {
+    this.evaluationManager.invalidateFromMutation(footprint);
+    this.eventManager.emitUpdate();
   }
-  removeCellSchema(namespace) {
-    return this.removeSchemaOfType(namespace, "cell");
+  emitUpdate() {
+    this.eventManager.emitUpdate();
   }
-  removeGridSchema(namespace) {
-    return this.removeSchemaOfType(namespace, "grid");
+  getExistingSheetContent(opts) {
+    const sheet = this.workbookManager.getSheet(opts);
+    return sheet ? new Map(sheet.content) : undefined;
   }
-  removeSchemaOfType(namespace, type) {
-    const schema = this.schemaManager.getSchema(namespace);
-    if (!schema || schema.type !== type) {
-      return false;
+  getWorkbookResourceKeys(workbookName) {
+    const resourceKeys = new Set([getWorkbookResourceKey(workbookName)]);
+    for (const sheetName of this.workbookManager.getWorkbooks().get(workbookName)?.sheets.keys() ?? []) {
+      resourceKeys.add(getSheetResourceKey({ workbookName, sheetName }));
     }
-    const removed = this.schemaManager.removeSchema(namespace);
-    if (removed) {
-      delete this.schema[namespace];
+    for (const tableName of this.tableManager.getTables(workbookName).keys()) {
+      resourceKeys.add(getTableResourceKey({ workbookName, tableName }));
+    }
+    const namedExpressions = this.namedExpressionManager.getNamedExpressions();
+    for (const name of namedExpressions.workbookExpressions.get(workbookName)?.keys() ?? []) {
+      resourceKeys.add(getNamedExpressionResourceKey({ expressionName: name, workbookName }));
+    }
+    for (const [sheetName, expressions] of namedExpressions.sheetExpressions.get(workbookName) ?? []) {
+      resourceKeys.add(getSheetResourceKey({ workbookName, sheetName }));
+      for (const name of expressions.keys()) {
+        resourceKeys.add(getNamedExpressionResourceKey({
+          expressionName: name,
+          workbookName,
+          sheetName
+        }));
+      }
     }
-    return removed;
+    return Array.from(resourceKeys);
+  }
+  getSheetResourceKeys(opts) {
+    const resourceKeys = new Set([
+      getWorkbookResourceKey(opts.workbookName),
+      getSheetResourceKey(opts)
+    ]);
+    for (const [tableName, table] of this.tableManager.getTables(opts.workbookName)) {
+      if (table.sheetName === opts.sheetName) {
+        resourceKeys.add(getTableResourceKey({ workbookName: opts.workbookName, tableName }));
+      }
+    }
+    const sheetExpressions = this.namedExpressionManager.getNamedExpressions().sheetExpressions.get(opts.workbookName)?.get(opts.sheetName);
+    for (const name of sheetExpressions?.keys() ?? []) {
+      resourceKeys.add(getNamedExpressionResourceKey({
+        expressionName: name,
+        workbookName: opts.workbookName,
+        sheetName: opts.sheetName
+      }));
+    }
+    return Array.from(resourceKeys);
   }
   getCellEvaluationResult(cellAddress) {
     return this.evaluationManager.getCellEvaluationResult(cellAddress);
@@ -180,7 +148,8 @@ class FormulaEngine {
     return this.evaluationManager.evaluationResultToSerializedValue(result, cellAddress, debug);
   }
   setCellMetadata(address, metadata) {
-    this.commandExecutor.execute(new SetCellMetadataCommand(this.workbookManager, address, metadata));
+    this.workbookManager.setCellMetadata(address, metadata);
+    this.emitUpdate();
   }
   getCellMetadata(address) {
     const metadata = this.workbookManager.getCellMetadata(address);
@@ -190,13 +159,15 @@ class FormulaEngine {
     return this.workbookManager.getSheetMetadataSerialized(opts);
   }
   setSheetMetadata(opts, metadata) {
-    this.commandExecutor.execute(new SetSheetMetadataCommand(this.workbookManager, opts, metadata));
+    this.workbookManager.setSheetMetadata(opts, metadata);
+    this.emitUpdate();
   }
   getSheetMetadata(opts) {
     return this.workbookManager.getSheetMetadata(opts);
   }
   setWorkbookMetadata(workbookName, metadata) {
-    this.commandExecutor.execute(new SetWorkbookMetadataCommand(this.workbookManager, workbookName, metadata));
+    this.workbookManager.setWorkbookMetadata(workbookName, metadata);
+    this.emitUpdate();
   }
   getWorkbookMetadata(workbookName) {
     return this.workbookManager.getWorkbookMetadata(workbookName);
@@ -223,10 +194,20 @@ class FormulaEngine {
     throw new Error("Not implemented");
   }
   addNamedExpression(opts) {
-    this.commandExecutor.execute(new AddNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    this.namedExpressionManager.addNamedExpression(opts);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [getNamedExpressionResourceKey(opts)]
+    });
   }
   removeNamedExpression(opts) {
-    this.commandExecutor.execute(new RemoveNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const removed = this.namedExpressionManager.removeNamedExpression(opts);
+    if (removed) {
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [getNamedExpressionResourceKey(opts)]
+      });
+    }
   }
   hasNamedExpression(opts) {
     const scope = opts.sheetName && opts.workbookName ? {
@@ -240,25 +221,154 @@ class FormulaEngine {
     });
   }
   updateNamedExpression(opts) {
-    this.commandExecutor.execute(new UpdateNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    this.namedExpressionManager.updateNamedExpression(opts);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [getNamedExpressionResourceKey(opts)]
+    });
   }
   renameNamedExpression(opts) {
-    this.commandExecutor.execute(new RenameNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    this.namedExpressionManager.renameNamedExpression(opts);
+    const changedCells = this.workbookManager.updateAllFormulas((formula) => renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
+    const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
+    this.emitMutation({
+      touchedCells: buildFormulaTouchedCells(changedCells),
+      resourceKeys: [
+        getNamedExpressionResourceKey({
+          expressionName: opts.expressionName,
+          workbookName: opts.workbookName,
+          sheetName: opts.sheetName
+        }),
+        getNamedExpressionResourceKey({
+          expressionName: opts.newName,
+          workbookName: opts.workbookName,
+          sheetName: opts.sheetName
+        }),
+        ...changedNamedExpressions
+      ]
+    });
   }
   setNamedExpressions(opts) {
-    this.commandExecutor.execute(new SetNamedExpressionsCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const allExpressions = this.namedExpressionManager.getNamedExpressions();
+    let previousExpressions;
+    if (opts.type === "global") {
+      previousExpressions = new Map(allExpressions.globalExpressions);
+    } else if (opts.type === "workbook") {
+      previousExpressions = new Map(allExpressions.workbookExpressions.get(opts.workbookName) || []);
+    } else {
+      const sheetExpressions = allExpressions.sheetExpressions.get(opts.workbookName)?.get(opts.sheetName);
+      previousExpressions = new Map(sheetExpressions || []);
+    }
+    this.namedExpressionManager.setNamedExpressions(opts);
+    const scope = opts.type === "global" ? {} : opts.type === "workbook" ? { workbookName: opts.workbookName } : {
+      workbookName: opts.workbookName,
+      sheetName: opts.sheetName
+    };
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [
+        ...getNamedExpressionScopeResourceKeys(previousExpressions.keys(), scope),
+        ...getNamedExpressionScopeResourceKeys(opts.expressions.keys(), scope)
+      ]
+    });
   }
   addTable(props) {
-    this.commandExecutor.execute(new AddTableCommand(this.getTableCommandDeps(), props), { validate: this.schemaManager.hasSchemas() });
+    const table = this.tableManager.addTable({
+      ...props,
+      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
+    });
+    this.emitMutation({
+      touchedCells: buildTableTouchedCells(this.workbookManager, [table]),
+      tableContextChangedCells: buildTableContextChangedCells(this.workbookManager, [table]),
+      resourceKeys: [
+        getTableResourceKey({
+          workbookName: props.workbookName,
+          tableName: props.tableName
+        })
+      ]
+    });
   }
   renameTable(workbookName, names) {
-    this.commandExecutor.execute(new RenameTableCommand(this.getTableCommandDeps(), workbookName, names.oldName, names.newName), { validate: this.schemaManager.hasSchemas() });
+    const oldTable = this.tableManager.getTable({
+      workbookName,
+      name: names.oldName
+    });
+    const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
+    this.tableManager.renameTable(workbookName, names);
+    const changedCells = this.workbookManager.updateAllFormulas((formula) => renameTableInFormula(formula, names.oldName, names.newName));
+    const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => renameTableInFormula(formula, names.oldName, names.newName));
+    const newTable = this.tableManager.getTable({
+      workbookName,
+      name: names.newName
+    });
+    this.emitMutation({
+      touchedCells: mergeTouchedCells(buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), buildTableTouchedCells(this.workbookManager, [newTable]), buildFormulaTouchedCells(changedCells)),
+      tableContextChangedCells: buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
+      resourceKeys: [
+        getTableResourceKey({
+          workbookName,
+          tableName: names.oldName
+        }),
+        getTableResourceKey({
+          workbookName,
+          tableName: names.newName
+        }),
+        ...changedNamedExpressions
+      ]
+    });
   }
   updateTable(opts) {
-    this.commandExecutor.execute(new UpdateTableCommand(this.getTableCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const oldTable = this.tableManager.getTable({
+      workbookName: opts.workbookName,
+      name: opts.tableName
+    });
+    const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
+    this.tableManager.updateTable({
+      ...opts,
+      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
+    });
+    const newTable = this.tableManager.getTable({
+      workbookName: opts.workbookName,
+      name: opts.tableName
+    });
+    this.emitMutation({
+      touchedCells: mergeTouchedCells(buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), buildTableTouchedCells(this.workbookManager, [newTable])),
+      tableContextChangedCells: buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
+      resourceKeys: [
+        getTableResourceKey({
+          workbookName: opts.workbookName,
+          tableName: opts.tableName
+        })
+      ]
+    });
   }
   removeTable(opts) {
-    this.commandExecutor.execute(new RemoveTableCommand(this.getTableCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const oldTable = this.tableManager.getTable({
+      workbookName: opts.workbookName,
+      name: opts.tableName
+    });
+    const oldTableSnapshot = oldTable ? { ...oldTable, headers: new Map(oldTable.headers) } : undefined;
+    const found = this.tableManager.removeTable(opts);
+    if (found) {
+      this.emitMutation({
+        touchedCells: buildTableTouchedCells(this.workbookManager, [
+          oldTableSnapshot
+        ]),
+        tableContextChangedCells: buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot]),
+        resourceKeys: [
+          getTableResourceKey({
+            workbookName: opts.workbookName,
+            tableName: opts.tableName
+          })
+        ]
+      });
+    }
+  }
+  getAllTables() {
+    return Array.from(this.tableManager.tables.values()).flatMap((tables) => Array.from(tables.values()).map((table) => ({
+      ...table,
+      headers: new Map(table.headers)
+    })));
   }
   hasTable(opts) {
     return !!this.tableManager.getTable({
@@ -273,7 +383,21 @@ class FormulaEngine {
     });
   }
   resetTables(tables) {
-    this.commandExecutor.execute(new ResetTablesCommand(this.getTableCommandDeps(), tables), { validate: this.schemaManager.hasSchemas() });
+    const oldTables = this.getAllTables();
+    const newTables = Array.from(tables.values()).flatMap((workbookTables) => Array.from(workbookTables.values()));
+    const resourceKeys = new Set;
+    for (const table of [...oldTables, ...newTables]) {
+      resourceKeys.add(getTableResourceKey({
+        workbookName: table.workbookName,
+        tableName: table.name
+      }));
+    }
+    this.tableManager.resetTables(tables);
+    this.emitMutation({
+      touchedCells: mergeTouchedCells(buildTableTouchedCells(this.workbookManager, oldTables), buildTableTouchedCells(this.workbookManager, newTables)),
+      tableContextChangedCells: buildTableContextChangedCells(this.workbookManager, [...oldTables, ...newTables]),
+      resourceKeys: Array.from(resourceKeys)
+    });
   }
   getTables(workbookName) {
     return this.tableManager.getTables(workbookName);
@@ -281,28 +405,15 @@ class FormulaEngine {
   isCellInTable(cellAddress) {
     return this.tableManager.isCellInTable(cellAddress);
   }
-  getTableDataCells(table) {
-    const { start, endRow, headers } = table;
-    const dataStartRow = start.rowIndex + 1;
-    const endColIndex = start.colIndex + headers.size - 1;
-    const rangeAddress = {
-      workbookName: table.workbookName,
-      sheetName: table.sheetName,
-      range: {
-        start: { col: start.colIndex, row: dataStartRow },
-        end: {
-          col: { type: "number", value: endColIndex },
-          row: endRow
-        }
-      }
-    };
-    return this.workbookManager.getCellsInRange(rangeAddress);
-  }
   addConditionalStyle(style) {
-    this.commandExecutor.execute(new AddConditionalStyleCommand(this.styleManager, style));
+    this.styleManager.addConditionalStyle(style);
+    this.emitUpdate();
   }
   removeConditionalStyle(workbookName, index) {
-    this.commandExecutor.execute(new RemoveConditionalStyleCommand(this.styleManager, workbookName, index));
+    const removed = this.styleManager.removeConditionalStyle(workbookName, index);
+    if (removed) {
+      this.emitUpdate();
+    }
   }
   getConditionalStyleCount(workbookName) {
     const allStyles = this.styleManager.getAllConditionalStyles();
@@ -321,10 +432,14 @@ class FormulaEngine {
     return this.styleManager.getAllConditionalStyles();
   }
   addCellStyle(style) {
-    this.commandExecutor.execute(new AddCellStyleCommand(this.styleManager, style));
+    this.styleManager.addCellStyle(style);
+    this.emitUpdate();
   }
   removeCellStyle(workbookName, index) {
-    this.commandExecutor.execute(new RemoveCellStyleCommand(this.styleManager, workbookName, index));
+    const removed = this.styleManager.removeCellStyle(workbookName, index);
+    if (removed) {
+      this.emitUpdate();
+    }
   }
   getCellStyleCount(workbookName) {
     const allStyles = this.styleManager.getAllCellStyles();
@@ -337,13 +452,69 @@ class FormulaEngine {
     return this.styleManager.getStyleForRange(range);
   }
   clearCellStyles(range) {
-    this.commandExecutor.execute(new ClearCellStylesCommand(this.styleManager, range));
+    this.styleManager.clearCellStyles(range);
+    this.emitUpdate();
+  }
+  getTopLeftCell(cells) {
+    let topLeft = cells[0];
+    for (const cell of cells) {
+      if (cell.rowIndex < topLeft.rowIndex || cell.rowIndex === topLeft.rowIndex && cell.colIndex < topLeft.colIndex) {
+        topLeft = cell;
+      }
+    }
+    return topLeft;
+  }
+  dedupeAddresses(addresses) {
+    return Array.from(new Map(addresses.map((address) => [getMutationAddressKey(address), address])).values());
+  }
+  getPasteTouchedAddresses(source, target, options) {
+    if (source.length === 0) {
+      return [];
+    }
+    const topLeft = this.getTopLeftCell(source);
+    const colOffset = target.colIndex - topLeft.colIndex;
+    const rowOffset = target.rowIndex - topLeft.rowIndex;
+    const targetCells = source.map((sourceCell) => ({
+      workbookName: target.workbookName,
+      sheetName: target.sheetName,
+      colIndex: sourceCell.colIndex + colOffset,
+      rowIndex: sourceCell.rowIndex + rowOffset
+    }));
+    return this.dedupeAddresses(options.cut ? [...source, ...targetCells] : targetCells);
   }
   pasteCells(source, target, options) {
-    this.commandExecutor.execute(new PasteCellsCommand(this.workbookManager, this.copyManager, source, target, options), { validate: this.schemaManager.hasSchemas() });
+    if (source.length === 0) {
+      return;
+    }
+    const touchedAddresses = this.getPasteTouchedAddresses(source, target, options);
+    const before = captureCellContents(this.workbookManager, touchedAddresses);
+    this.copyManager.pasteCells(source, target, options);
+    const after = captureCellContents(this.workbookManager, touchedAddresses);
+    this.emitMutation({
+      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
+        address,
+        before: before.get(getMutationAddressKey(address)),
+        after: after.get(getMutationAddressKey(address))
+      }))),
+      resourceKeys: []
+    });
   }
   fillAreas(seedRange, targetRanges, options) {
-    this.commandExecutor.execute(new FillAreasCommand(this.workbookManager, this.copyManager, seedRange, targetRanges, options), { validate: this.schemaManager.hasSchemas() });
+    const touchedAddresses = this.dedupeAddresses([
+      ...targetRanges.flatMap((targetRange) => getFiniteRangeAddresses(targetRange)),
+      ...options.cut ? getFiniteRangeAddresses(seedRange) : []
+    ]);
+    const before = captureCellContents(this.workbookManager, touchedAddresses);
+    this.copyManager.fillAreas(seedRange, targetRanges, options);
+    const after = captureCellContents(this.workbookManager, touchedAddresses);
+    this.emitMutation({
+      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
+        address,
+        before: before.get(getMutationAddressKey(address)),
+        after: after.get(getMutationAddressKey(address))
+      }))),
+      resourceKeys: []
+    });
   }
   smartPaste(sourceCells, pasteSelection, options) {
     if (sourceCells.length === 0) {
@@ -424,17 +595,27 @@ class FormulaEngine {
     return { minCol, minRow, maxCol, maxRow };
   }
   moveCell(source, target) {
-    this.commandExecutor.execute(new MoveCellCommand(this.workbookManager, this.copyManager, source, target), { validate: this.schemaManager.hasSchemas() });
+    this.pasteCells([source], target, {
+      cut: true,
+      type: "formula",
+      include: "all"
+    });
   }
   moveRange(sourceRange, target) {
-    this.commandExecutor.execute(new MoveRangeCommand(this.workbookManager, this.copyManager, sourceRange, target), { validate: this.schemaManager.hasSchemas() });
+    const cells = this.copyManager.expandRangeToCells(sourceRange);
+    this.pasteCells(cells, target, {
+      cut: true,
+      type: "formula",
+      include: "all"
+    });
   }
   addSheet(opts) {
-    this.commandExecutor.execute(new AddSheetCommand(this.getStructureCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
-    const sheet = this.workbookManager.getSheet(opts);
-    if (!sheet) {
-      throw new Error(`Failed to create sheet '${opts.sheetName}'`);
-    }
+    const sheet = this.workbookManager.addSheet(opts);
+    this.namedExpressionManager.addSheet(opts);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [getSheetResourceKey(opts)]
+    });
     return sheet;
   }
   createSheet(opts) {
@@ -445,10 +626,40 @@ class FormulaEngine {
     });
   }
   removeSheet(opts) {
-    this.commandExecutor.execute(new RemoveSheetCommand(this.getStructureCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const resourceKeys = this.getSheetResourceKeys(opts);
+    this.workbookManager.removeSheet(opts);
+    this.namedExpressionManager.removeSheet(opts);
+    this.tableManager.removeSheet(opts);
+    this.styleManager.removeSheetStyles(opts.workbookName, opts.sheetName);
+    this.referenceManager.invalidateSheet(opts.workbookName, opts.sheetName);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys,
+      removedScopes: [{ type: "sheet", ...opts }]
+    });
   }
   renameSheet(opts) {
-    this.commandExecutor.execute(new RenameSheetCommand(this.getStructureCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const oldResourceKeys = this.getSheetResourceKeys(opts);
+    this.workbookManager.renameSheet(opts);
+    this.namedExpressionManager.renameSheet(opts);
+    this.tableManager.updateTablesForSheetRename(opts);
+    this.styleManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
+    const changedCells = this.workbookManager.updateAllFormulas((formula) => renameSheetInFormula({
+      formula,
+      oldSheetName: opts.sheetName,
+      newSheetName: opts.newSheetName
+    }));
+    this.referenceManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
+    this.emitMutation({
+      touchedCells: buildFormulaTouchedCells(changedCells),
+      resourceKeys: Array.from(new Set([
+        ...oldResourceKeys,
+        ...this.getSheetResourceKeys({
+          workbookName: opts.workbookName,
+          sheetName: opts.newSheetName
+        })
+      ]))
+    });
   }
   hasSheet(opts) {
     return !!this.workbookManager.getSheet(opts);
@@ -474,35 +685,234 @@ class FormulaEngine {
   getSheetSerialized(opts) {
     return this.workbookManager.getSheetSerialized(opts);
   }
+  search(query, options) {
+    return this.workbookManager.search(query, options);
+  }
+  replace(query, replacement, target, options) {
+    const prepared = this.workbookManager.prepareReplace(query, replacement, target, options);
+    this.workbookManager.setCellContent(prepared.address, prepared.afterContent);
+    this.emitMutation({
+      touchedCells: buildTouchedCells([
+        {
+          address: prepared.address,
+          before: prepared.beforeContent,
+          after: prepared.afterContent
+        }
+      ]),
+      resourceKeys: []
+    });
+    return prepared.change;
+  }
+  replaceAll(query, replacement, options) {
+    const preparedReplacements = this.workbookManager.prepareReplaceAll(query, replacement, options);
+    if (preparedReplacements.length === 0) {
+      return [];
+    }
+    for (const prepared of preparedReplacements) {
+      this.workbookManager.setCellContent(prepared.address, prepared.afterContent);
+    }
+    this.emitMutation({
+      touchedCells: buildTouchedCells(preparedReplacements.map((prepared) => ({
+        address: prepared.address,
+        before: prepared.beforeContent,
+        after: prepared.afterContent
+      }))),
+      resourceKeys: []
+    });
+    return preparedReplacements.flatMap((prepared) => prepared.changes);
+  }
   addWorkbook(workbookName) {
-    this.commandExecutor.execute(new AddWorkbookCommand(this.getStructureCommandDeps(), workbookName), { validate: this.schemaManager.hasSchemas() });
+    this.workbookManager.addWorkbook(workbookName);
+    this.namedExpressionManager.addWorkbook(workbookName);
+    this.tableManager.addWorkbook(workbookName);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [getWorkbookResourceKey(workbookName)]
+    });
   }
   removeWorkbook(workbookName) {
-    this.commandExecutor.execute(new RemoveWorkbookCommand(this.getStructureCommandDeps(), workbookName), { validate: this.schemaManager.hasSchemas() });
+    const resourceKeys = this.getWorkbookResourceKeys(workbookName);
+    this.workbookManager.removeWorkbook(workbookName);
+    this.namedExpressionManager.removeWorkbook(workbookName);
+    this.tableManager.removeWorkbook(workbookName);
+    this.styleManager.removeWorkbookStyles(workbookName);
+    this.referenceManager.invalidateWorkbook(workbookName);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys,
+      removedScopes: [{ type: "workbook", workbookName }]
+    });
   }
   hasWorkbook(workbookName) {
     return this.workbookManager.getWorkbooks().has(workbookName);
   }
   cloneWorkbook(fromWorkbookName, toWorkbookName) {
-    this.commandExecutor.execute(new CloneWorkbookCommand(this.getStructureCommandDeps(), fromWorkbookName, toWorkbookName), { validate: this.schemaManager.hasSchemas() });
+    const sourceWorkbook = this.workbookManager.getWorkbooks().get(fromWorkbookName);
+    if (!sourceWorkbook) {
+      throw new Error(`Source workbook "${fromWorkbookName}" not found`);
+    }
+    if (this.workbookManager.getWorkbooks().has(toWorkbookName)) {
+      throw new Error(`Target workbook "${toWorkbookName}" already exists`);
+    }
+    this.workbookManager.addWorkbook(toWorkbookName);
+    this.namedExpressionManager.addWorkbook(toWorkbookName);
+    this.tableManager.addWorkbook(toWorkbookName);
+    for (const [sheetName, sheet] of sourceWorkbook.sheets) {
+      this.workbookManager.addSheet({
+        workbookName: toWorkbookName,
+        sheetName
+      });
+      this.namedExpressionManager.addSheet({
+        workbookName: toWorkbookName,
+        sheetName
+      });
+      this.workbookManager.setSheetContent({ workbookName: toWorkbookName, sheetName }, new Map(sheet.content));
+      const targetSheet = this.workbookManager.getSheet({
+        workbookName: toWorkbookName,
+        sheetName
+      });
+      if (targetSheet) {
+        targetSheet.metadata = new Map(sheet.metadata);
+        if (sheet.sheetMetadata !== undefined) {
+          targetSheet.sheetMetadata = structuredClone(sheet.sheetMetadata);
+        }
+      }
+    }
+    const targetWorkbook = this.workbookManager.getWorkbooks().get(toWorkbookName);
+    if (targetWorkbook && sourceWorkbook.workbookMetadata !== undefined) {
+      targetWorkbook.workbookMetadata = structuredClone(sourceWorkbook.workbookMetadata);
+    }
+    const namedExpressions = this.namedExpressionManager.getNamedExpressions();
+    const sourceWorkbookExpressions = namedExpressions.workbookExpressions.get(fromWorkbookName);
+    if (sourceWorkbookExpressions) {
+      for (const [expressionName, expression] of sourceWorkbookExpressions) {
+        this.namedExpressionManager.addNamedExpression({
+          expressionName,
+          expression: expression.expression,
+          workbookName: toWorkbookName
+        });
+      }
+    }
+    const sourceSheetExpressions = namedExpressions.sheetExpressions.get(fromWorkbookName);
+    if (sourceSheetExpressions) {
+      for (const [sheetName, expressions] of sourceSheetExpressions) {
+        for (const [expressionName, expression] of expressions) {
+          this.namedExpressionManager.addNamedExpression({
+            expressionName,
+            expression: expression.expression,
+            workbookName: toWorkbookName,
+            sheetName
+          });
+        }
+      }
+    }
+    const sourceTables = this.tableManager.tables.get(fromWorkbookName);
+    if (sourceTables) {
+      for (const [tableName] of sourceTables) {
+        this.tableManager.copyTable({ workbookName: fromWorkbookName, tableName }, { workbookName: toWorkbookName, tableName });
+      }
+    }
+    for (const style of this.styleManager.getAllConditionalStyles()) {
+      if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
+        this.styleManager.addConditionalStyle({
+          ...style,
+          areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
+        });
+      }
+    }
+    for (const style of this.styleManager.getAllCellStyles()) {
+      if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
+        this.styleManager.addCellStyle({
+          ...style,
+          areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
+        });
+      }
+    }
+    this.workbookManager.updateFormulasForWorkbook(toWorkbookName, (formula) => renameWorkbookInFormula({
+      formula,
+      oldWorkbookName: fromWorkbookName,
+      newWorkbookName: toWorkbookName
+    }));
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [getWorkbookResourceKey(toWorkbookName)]
+    });
   }
   renameWorkbook(opts) {
-    this.commandExecutor.execute(new RenameWorkbookCommand(this.getStructureCommandDeps(), opts.workbookName, opts.newWorkbookName), { validate: this.schemaManager.hasSchemas() });
+    const oldResourceKeys = this.getWorkbookResourceKeys(opts.workbookName);
+    this.workbookManager.renameWorkbook(opts);
+    this.namedExpressionManager.renameWorkbook(opts);
+    this.tableManager.updateTablesForWorkbookRename(opts);
+    this.styleManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
+    const changedCells = this.workbookManager.updateAllFormulas((formula) => renameWorkbookInFormula({
+      formula,
+      oldWorkbookName: opts.workbookName,
+      newWorkbookName: opts.newWorkbookName
+    }));
+    this.referenceManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
+    this.emitMutation({
+      touchedCells: buildFormulaTouchedCells(changedCells),
+      resourceKeys: Array.from(new Set([
+        ...oldResourceKeys,
+        ...this.getWorkbookResourceKeys(opts.newWorkbookName)
+      ]))
+    });
   }
   getWorkbooks() {
     return this.workbookManager.getWorkbooks();
   }
   setSheetContent(opts, content) {
-    this.commandExecutor.execute(new SetSheetContentCommand(this.workbookManager, opts, content), { validate: this.schemaManager.hasSchemas() });
+    const previousContent = this.getExistingSheetContent(opts);
+    this.workbookManager.setSheetContent(opts, content);
+    this.emitMutation({
+      touchedCells: buildSheetContentTouchedCells(opts, previousContent, content),
+      resourceKeys: []
+    });
   }
   setCellContent(address, content) {
-    this.commandExecutor.execute(new SetCellContentCommand(this.workbookManager, address, content), { validate: this.schemaManager.hasSchemas() });
+    const previousValue = this.workbookManager.getCellContent(address);
+    this.workbookManager.setCellContent(address, content);
+    this.emitMutation({
+      touchedCells: buildTouchedCells([
+        {
+          address,
+          before: previousValue,
+          after: content
+        }
+      ]),
+      resourceKeys: []
+    });
   }
   autoFill(opts, seedRange, fillRanges, direction) {
-    this.commandExecutor.execute(new AutoFillCommand(this.workbookManager, this.styleManager, this.autoFillManager, opts, seedRange, fillRanges, direction), { validate: this.schemaManager.hasSchemas() });
+    const touchedAddresses = this.dedupeAddresses(fillRanges.flatMap((range) => getFiniteRangeAddresses({
+      workbookName: opts.workbookName,
+      sheetName: opts.sheetName,
+      range
+    })));
+    const before = captureCellContents(this.workbookManager, touchedAddresses);
+    this.autoFillManager.fill(opts, seedRange, fillRanges, direction);
+    const after = captureCellContents(this.workbookManager, touchedAddresses);
+    this.emitMutation({
+      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
+        address,
+        before: before.get(getMutationAddressKey(address)),
+        after: after.get(getMutationAddressKey(address))
+      }))),
+      resourceKeys: []
+    });
   }
   clearSpreadsheetRange(address) {
-    this.commandExecutor.execute(new ClearRangeCommand(this.workbookManager, address), { validate: this.schemaManager.hasSchemas() });
+    const clearedCells = Array.from(this.workbookManager.iterateCellsInRange(address));
+    const before = captureCellContents(this.workbookManager, clearedCells);
+    this.workbookManager.clearSpreadsheetRange(address);
+    this.emitMutation({
+      touchedCells: buildTouchedCells(clearedCells.map((cellAddress) => ({
+        address: cellAddress,
+        before: before.get(getMutationAddressKey(cellAddress)),
+        after: undefined
+      }))),
+      resourceKeys: []
+    });
   }
   getState() {
     return {
@@ -558,63 +968,11 @@ class FormulaEngine {
       dependency: deserialized.managers.dependency,
       cache: deserialized.managers.cache
     }, this.evaluationManager);
-    this.commandExecutor.clearHistory();
-    this.commandExecutor.clearActionLog();
     this.eventManager.emitUpdate();
   }
-  undo() {
-    return this.commandExecutor.undo();
-  }
-  redo() {
-    return this.commandExecutor.redo();
-  }
-  canUndo() {
-    return this.commandExecutor.canUndo();
-  }
-  canRedo() {
-    return this.commandExecutor.canRedo();
-  }
-  getActionLog() {
-    return this.commandExecutor.getActionLog();
-  }
-  clearActionLog() {
-    this.commandExecutor.clearActionLog();
-  }
-  clearHistory() {
-    this.commandExecutor.clearHistory();
-  }
-  getStructureCommandDeps() {
-    return {
-      workbookManager: this.workbookManager,
-      namedExpressionManager: this.namedExpressionManager,
-      tableManager: this.tableManager,
-      styleManager: this.styleManager,
-      referenceManager: this.referenceManager,
-      apiSchemaManager: this.schemaManager,
-      renameSheetInFormula,
-      renameWorkbookInFormula
-    };
-  }
-  getTableCommandDeps() {
-    return {
-      tableManager: this.tableManager,
-      namedExpressionManager: this.namedExpressionManager,
-      workbookManager: this.workbookManager,
-      apiSchemaManager: this.schemaManager,
-      getCellValue: (cell) => this.getCellValue(cell),
-      renameTableInFormula
-    };
-  }
-  getNamedExpressionCommandDeps() {
-    return {
-      namedExpressionManager: this.namedExpressionManager,
-      workbookManager: this.workbookManager,
-      renameNamedExpressionInFormula
-    };
-  }
 }
 export {
   FormulaEngine
 };
 
-//# debugId=613601FAC854C5A464756E2164756E21
+//# debugId=E7431D6779F19EBD64756E2164756E21