@ricsam/formula-engine 0.2.7 → 0.2.9

package/dist/cjs/core/engine.cjs

@@ -59,19 +59,9 @@ var import_dependency_manager = require("./managers/dependency-manager.cjs");
 var import_style_manager = require("./managers/style-manager.cjs");
 var import_copy_manager = require("./managers/copy-manager.cjs");
 var import_reference_manager = require("./managers/reference-manager.cjs");
-var import_schema_manager = require("./managers/schema-manager.cjs");
-var import_schema_builder = require("./schema/schema-builder.cjs");
-var import_table_orm = require("./schema/table-orm.cjs");
-var import_cell_orm = require("./schema/cell-orm.cjs");
-var import_grid_orm = require("./schema/grid-orm.cjs");
 var import_engine_snapshot = require("./engine-snapshot.cjs");
-var import_command_executor = require("./commands/command-executor.cjs");
-var import_content_commands = require("./commands/content-commands.cjs");
-var import_structure_commands = require("./commands/structure-commands.cjs");
-var import_table_commands = require("./commands/table-commands.cjs");
-var import_named_expression_commands = require("./commands/named-expression-commands.cjs");
-var import_metadata_commands = require("./commands/metadata-commands.cjs");
-var import_style_commands = require("./commands/style-commands.cjs");
+var import_mutation_invalidation = require("./mutation-invalidation.cjs");
+var import_resource_keys = require("./resource-keys.cjs");
 
 class FormulaEngine {
   workbookManager;
@@ -84,10 +74,6 @@ class FormulaEngine {
   styleManager;
   copyManager;
   referenceManager;
-  schemaManager;
-  commandExecutor;
-  schema;
-  schemaDeclaration;
   _workbookManager;
   _namedExpressionManager;
   _tableManager;
@@ -96,8 +82,7 @@ class FormulaEngine {
   _autoFillManager;
   _dependencyManager;
   _styleManager;
-  constructor(schema) {
-    this.schemaDeclaration = schema?.declaration;
+  constructor() {
     this.eventManager = new import_event_manager.EventManager;
     this.workbookManager = new import_workbook_manager.WorkbookManager;
     this.namedExpressionManager = new import_named_expression_manager.NamedExpressionManager;
@@ -110,13 +95,6 @@ class FormulaEngine {
     this.copyManager = new import_copy_manager.CopyManager(this.workbookManager, this.evaluationManager, this.styleManager);
     this.autoFillManager = new import_autofill_utils.AutoFill(this.workbookManager, this.styleManager);
     this.referenceManager = new import_reference_manager.ReferenceManager;
-    this.schemaManager = new import_schema_manager.SchemaManager(this.tableManager);
-    this.commandExecutor = new import_command_executor.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 = import_schema_builder.buildSchemaFromDeclaration(this, this.schemaDeclaration, this.schemaManager);
-    } else {
-      this.schema = {};
-    }
     this._workbookManager = this.workbookManager;
     this._namedExpressionManager = this.namedExpressionManager;
     this._tableManager = this.tableManager;
@@ -126,26 +104,63 @@ class FormulaEngine {
     this._dependencyManager = this.dependencyManager;
     this._styleManager = this.styleManager;
   }
-  static buildEmpty(schema) {
-    return new FormulaEngine(schema);
+  static buildEmpty() {
+    return new FormulaEngine;
+  }
+  emitMutation(footprint) {
+    this.evaluationManager.invalidateFromMutation(footprint);
+    this.eventManager.emitUpdate();
   }
-  addTableSchema(namespace, address, headers) {
-    this.schemaManager.registerTableSchema(namespace, address.workbookName, address.tableName, headers);
-    const orm = new import_table_orm.TableOrm(this, address.workbookName, address.tableName, headers, namespace);
-    this.schema[namespace] = orm;
-    return orm;
+  emitUpdate() {
+    this.eventManager.emitUpdate();
   }
-  addCellSchema(namespace, cellAddress, parse, write = (value) => ({ value })) {
-    this.schemaManager.registerCellSchema(namespace, cellAddress, parse);
-    const orm = new import_cell_orm.CellOrm(this, cellAddress, parse, write, namespace);
-    this.schema[namespace] = orm;
-    return orm;
+  getExistingSheetContent(opts) {
+    const sheet = this.workbookManager.getSheet(opts);
+    return sheet ? new Map(sheet.content) : undefined;
   }
-  addGridSchema(namespace, address, range, parse, write = (value) => ({ value })) {
-    this.schemaManager.registerGridSchema(namespace, address.workbookName, address.sheetName, range, parse);
-    const orm = new import_grid_orm.GridOrm(this, address.workbookName, address.sheetName, range, parse, write, namespace);
-    this.schema[namespace] = orm;
-    return orm;
+  getWorkbookResourceKeys(workbookName) {
+    const resourceKeys = new Set([import_resource_keys.getWorkbookResourceKey(workbookName)]);
+    for (const sheetName of this.workbookManager.getWorkbooks().get(workbookName)?.sheets.keys() ?? []) {
+      resourceKeys.add(import_resource_keys.getSheetResourceKey({ workbookName, sheetName }));
+    }
+    for (const tableName of this.tableManager.getTables(workbookName).keys()) {
+      resourceKeys.add(import_resource_keys.getTableResourceKey({ workbookName, tableName }));
+    }
+    const namedExpressions = this.namedExpressionManager.getNamedExpressions();
+    for (const name of namedExpressions.workbookExpressions.get(workbookName)?.keys() ?? []) {
+      resourceKeys.add(import_resource_keys.getNamedExpressionResourceKey({ expressionName: name, workbookName }));
+    }
+    for (const [sheetName, expressions] of namedExpressions.sheetExpressions.get(workbookName) ?? []) {
+      resourceKeys.add(import_resource_keys.getSheetResourceKey({ workbookName, sheetName }));
+      for (const name of expressions.keys()) {
+        resourceKeys.add(import_resource_keys.getNamedExpressionResourceKey({
+          expressionName: name,
+          workbookName,
+          sheetName
+        }));
+      }
+    }
+    return Array.from(resourceKeys);
+  }
+  getSheetResourceKeys(opts) {
+    const resourceKeys = new Set([
+      import_resource_keys.getWorkbookResourceKey(opts.workbookName),
+      import_resource_keys.getSheetResourceKey(opts)
+    ]);
+    for (const [tableName, table] of this.tableManager.getTables(opts.workbookName)) {
+      if (table.sheetName === opts.sheetName) {
+        resourceKeys.add(import_resource_keys.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(import_resource_keys.getNamedExpressionResourceKey({
+        expressionName: name,
+        workbookName: opts.workbookName,
+        sheetName: opts.sheetName
+      }));
+    }
+    return Array.from(resourceKeys);
   }
   getCellEvaluationResult(cellAddress) {
     return this.evaluationManager.getCellEvaluationResult(cellAddress);
@@ -158,7 +173,8 @@ class FormulaEngine {
     return this.evaluationManager.evaluationResultToSerializedValue(result, cellAddress, debug);
   }
   setCellMetadata(address, metadata) {
-    this.commandExecutor.execute(new import_metadata_commands.SetCellMetadataCommand(this.workbookManager, address, metadata));
+    this.workbookManager.setCellMetadata(address, metadata);
+    this.emitUpdate();
   }
   getCellMetadata(address) {
     const metadata = this.workbookManager.getCellMetadata(address);
@@ -168,13 +184,15 @@ class FormulaEngine {
     return this.workbookManager.getSheetMetadataSerialized(opts);
   }
   setSheetMetadata(opts, metadata) {
-    this.commandExecutor.execute(new import_metadata_commands.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 import_metadata_commands.SetWorkbookMetadataCommand(this.workbookManager, workbookName, metadata));
+    this.workbookManager.setWorkbookMetadata(workbookName, metadata);
+    this.emitUpdate();
   }
   getWorkbookMetadata(workbookName) {
     return this.workbookManager.getWorkbookMetadata(workbookName);
@@ -201,10 +219,20 @@ class FormulaEngine {
     throw new Error("Not implemented");
   }
   addNamedExpression(opts) {
-    this.commandExecutor.execute(new import_named_expression_commands.AddNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    this.namedExpressionManager.addNamedExpression(opts);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
+    });
   }
   removeNamedExpression(opts) {
-    this.commandExecutor.execute(new import_named_expression_commands.RemoveNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    const removed = this.namedExpressionManager.removeNamedExpression(opts);
+    if (removed) {
+      this.emitMutation({
+        touchedCells: [],
+        resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
+      });
+    }
   }
   hasNamedExpression(opts) {
     const scope = opts.sheetName && opts.workbookName ? {
@@ -218,25 +246,154 @@ class FormulaEngine {
     });
   }
   updateNamedExpression(opts) {
-    this.commandExecutor.execute(new import_named_expression_commands.UpdateNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    this.namedExpressionManager.updateNamedExpression(opts);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [import_resource_keys.getNamedExpressionResourceKey(opts)]
+    });
   }
   renameNamedExpression(opts) {
-    this.commandExecutor.execute(new import_named_expression_commands.RenameNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: this.schemaManager.hasSchemas() });
+    this.namedExpressionManager.renameNamedExpression(opts);
+    const changedCells = this.workbookManager.updateAllFormulas((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
+    const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, opts.expressionName, opts.newName));
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
+      resourceKeys: [
+        import_resource_keys.getNamedExpressionResourceKey({
+          expressionName: opts.expressionName,
+          workbookName: opts.workbookName,
+          sheetName: opts.sheetName
+        }),
+        import_resource_keys.getNamedExpressionResourceKey({
+          expressionName: opts.newName,
+          workbookName: opts.workbookName,
+          sheetName: opts.sheetName
+        }),
+        ...changedNamedExpressions
+      ]
+    });
   }
   setNamedExpressions(opts) {
-    this.commandExecutor.execute(new import_named_expression_commands.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: [
+        ...import_mutation_invalidation.getNamedExpressionScopeResourceKeys(previousExpressions.keys(), scope),
+        ...import_mutation_invalidation.getNamedExpressionScopeResourceKeys(opts.expressions.keys(), scope)
+      ]
+    });
   }
   addTable(props) {
-    this.commandExecutor.execute(new import_table_commands.AddTableCommand(this.getTableCommandDeps(), props), { validate: this.schemaManager.hasSchemas() });
+    const table = this.tableManager.addTable({
+      ...props,
+      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
+    });
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [table]),
+      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [table]),
+      resourceKeys: [
+        import_resource_keys.getTableResourceKey({
+          workbookName: props.workbookName,
+          tableName: props.tableName
+        })
+      ]
+    });
   }
   renameTable(workbookName, names) {
-    this.commandExecutor.execute(new import_table_commands.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) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
+    const changedNamedExpressions = this.namedExpressionManager.updateAllNamedExpressions((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
+    const newTable = this.tableManager.getTable({
+      workbookName,
+      name: names.newName
+    });
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [newTable]), import_mutation_invalidation.buildFormulaTouchedCells(changedCells)),
+      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
+      resourceKeys: [
+        import_resource_keys.getTableResourceKey({
+          workbookName,
+          tableName: names.oldName
+        }),
+        import_resource_keys.getTableResourceKey({
+          workbookName,
+          tableName: names.newName
+        }),
+        ...changedNamedExpressions
+      ]
+    });
   }
   updateTable(opts) {
-    this.commandExecutor.execute(new import_table_commands.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: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [oldTableSnapshot]), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [newTable])),
+      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot, newTable]),
+      resourceKeys: [
+        import_resource_keys.getTableResourceKey({
+          workbookName: opts.workbookName,
+          tableName: opts.tableName
+        })
+      ]
+    });
   }
   removeTable(opts) {
-    this.commandExecutor.execute(new import_table_commands.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: import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, [
+          oldTableSnapshot
+        ]),
+        tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [oldTableSnapshot]),
+        resourceKeys: [
+          import_resource_keys.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({
@@ -251,7 +408,21 @@ class FormulaEngine {
     });
   }
   resetTables(tables) {
-    this.commandExecutor.execute(new import_table_commands.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(import_resource_keys.getTableResourceKey({
+        workbookName: table.workbookName,
+        tableName: table.name
+      }));
+    }
+    this.tableManager.resetTables(tables);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.mergeTouchedCells(import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, oldTables), import_mutation_invalidation.buildTableTouchedCells(this.workbookManager, newTables)),
+      tableContextChangedCells: import_mutation_invalidation.buildTableContextChangedCells(this.workbookManager, [...oldTables, ...newTables]),
+      resourceKeys: Array.from(resourceKeys)
+    });
   }
   getTables(workbookName) {
     return this.tableManager.getTables(workbookName);
@@ -259,28 +430,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 import_style_commands.AddConditionalStyleCommand(this.styleManager, style));
+    this.styleManager.addConditionalStyle(style);
+    this.emitUpdate();
   }
   removeConditionalStyle(workbookName, index) {
-    this.commandExecutor.execute(new import_style_commands.RemoveConditionalStyleCommand(this.styleManager, workbookName, index));
+    const removed = this.styleManager.removeConditionalStyle(workbookName, index);
+    if (removed) {
+      this.emitUpdate();
+    }
   }
   getConditionalStyleCount(workbookName) {
     const allStyles = this.styleManager.getAllConditionalStyles();
@@ -299,10 +457,14 @@ class FormulaEngine {
     return this.styleManager.getAllConditionalStyles();
   }
   addCellStyle(style) {
-    this.commandExecutor.execute(new import_style_commands.AddCellStyleCommand(this.styleManager, style));
+    this.styleManager.addCellStyle(style);
+    this.emitUpdate();
   }
   removeCellStyle(workbookName, index) {
-    this.commandExecutor.execute(new import_style_commands.RemoveCellStyleCommand(this.styleManager, workbookName, index));
+    const removed = this.styleManager.removeCellStyle(workbookName, index);
+    if (removed) {
+      this.emitUpdate();
+    }
   }
   getCellStyleCount(workbookName) {
     const allStyles = this.styleManager.getAllCellStyles();
@@ -315,13 +477,69 @@ class FormulaEngine {
     return this.styleManager.getStyleForRange(range);
   }
   clearCellStyles(range) {
-    this.commandExecutor.execute(new import_style_commands.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) => [import_mutation_invalidation.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 import_content_commands.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 = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+    this.copyManager.pasteCells(source, target, options);
+    const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
+        address,
+        before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
+        after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
+      }))),
+      resourceKeys: []
+    });
   }
   fillAreas(seedRange, targetRanges, options) {
-    this.commandExecutor.execute(new import_content_commands.FillAreasCommand(this.workbookManager, this.copyManager, seedRange, targetRanges, options), { validate: this.schemaManager.hasSchemas() });
+    const touchedAddresses = this.dedupeAddresses([
+      ...targetRanges.flatMap((targetRange) => import_mutation_invalidation.getFiniteRangeAddresses(targetRange)),
+      ...options.cut ? import_mutation_invalidation.getFiniteRangeAddresses(seedRange) : []
+    ]);
+    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+    this.copyManager.fillAreas(seedRange, targetRanges, options);
+    const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
+        address,
+        before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
+        after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
+      }))),
+      resourceKeys: []
+    });
   }
   smartPaste(sourceCells, pasteSelection, options) {
     if (sourceCells.length === 0) {
@@ -402,17 +620,27 @@ class FormulaEngine {
     return { minCol, minRow, maxCol, maxRow };
   }
   moveCell(source, target) {
-    this.commandExecutor.execute(new import_content_commands.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 import_content_commands.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 import_structure_commands.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: [import_resource_keys.getSheetResourceKey(opts)]
+    });
     return sheet;
   }
   createSheet(opts) {
@@ -423,10 +651,40 @@ class FormulaEngine {
     });
   }
   removeSheet(opts) {
-    this.commandExecutor.execute(new import_structure_commands.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 import_structure_commands.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) => import_sheet_renamer.renameSheetInFormula({
+      formula,
+      oldSheetName: opts.sheetName,
+      newSheetName: opts.newSheetName
+    }));
+    this.referenceManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
+      resourceKeys: Array.from(new Set([
+        ...oldResourceKeys,
+        ...this.getSheetResourceKeys({
+          workbookName: opts.workbookName,
+          sheetName: opts.newSheetName
+        })
+      ]))
+    });
   }
   hasSheet(opts) {
     return !!this.workbookManager.getSheet(opts);
@@ -453,34 +711,197 @@ class FormulaEngine {
     return this.workbookManager.getSheetSerialized(opts);
   }
   addWorkbook(workbookName) {
-    this.commandExecutor.execute(new import_structure_commands.AddWorkbookCommand(this.getStructureCommandDeps(), workbookName), { validate: this.schemaManager.hasSchemas() });
+    this.workbookManager.addWorkbook(workbookName);
+    this.namedExpressionManager.addWorkbook(workbookName);
+    this.tableManager.addWorkbook(workbookName);
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [import_resource_keys.getWorkbookResourceKey(workbookName)]
+    });
   }
   removeWorkbook(workbookName) {
-    this.commandExecutor.execute(new import_structure_commands.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 import_structure_commands.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) => import_workbook_renamer.renameWorkbookInFormula({
+      formula,
+      oldWorkbookName: fromWorkbookName,
+      newWorkbookName: toWorkbookName
+    }));
+    this.emitMutation({
+      touchedCells: [],
+      resourceKeys: [import_resource_keys.getWorkbookResourceKey(toWorkbookName)]
+    });
   }
   renameWorkbook(opts) {
-    this.commandExecutor.execute(new import_structure_commands.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) => import_workbook_renamer.renameWorkbookInFormula({
+      formula,
+      oldWorkbookName: opts.workbookName,
+      newWorkbookName: opts.newWorkbookName
+    }));
+    this.referenceManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildFormulaTouchedCells(changedCells),
+      resourceKeys: Array.from(new Set([
+        ...oldResourceKeys,
+        ...this.getWorkbookResourceKeys(opts.newWorkbookName)
+      ]))
+    });
   }
   getWorkbooks() {
     return this.workbookManager.getWorkbooks();
   }
   setSheetContent(opts, content) {
-    this.commandExecutor.execute(new import_content_commands.SetSheetContentCommand(this.workbookManager, opts, content), { validate: this.schemaManager.hasSchemas() });
+    const previousContent = this.getExistingSheetContent(opts);
+    this.workbookManager.setSheetContent(opts, content);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildSheetContentTouchedCells(opts, previousContent, content),
+      resourceKeys: []
+    });
   }
   setCellContent(address, content) {
-    this.commandExecutor.execute(new import_content_commands.SetCellContentCommand(this.workbookManager, address, content), { validate: this.schemaManager.hasSchemas() });
+    const previousValue = this.workbookManager.getCellContent(address);
+    this.workbookManager.setCellContent(address, content);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildTouchedCells([
+        {
+          address,
+          before: previousValue,
+          after: content
+        }
+      ]),
+      resourceKeys: []
+    });
   }
   autoFill(opts, seedRange, fillRanges, direction) {
-    this.commandExecutor.execute(new import_content_commands.AutoFillCommand(this.workbookManager, this.styleManager, this.autoFillManager, opts, seedRange, fillRanges, direction), { validate: this.schemaManager.hasSchemas() });
+    const touchedAddresses = this.dedupeAddresses(fillRanges.flatMap((range) => import_mutation_invalidation.getFiniteRangeAddresses({
+      workbookName: opts.workbookName,
+      sheetName: opts.sheetName,
+      range
+    })));
+    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+    this.autoFillManager.fill(opts, seedRange, fillRanges, direction);
+    const after = import_mutation_invalidation.captureCellContents(this.workbookManager, touchedAddresses);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildTouchedCells(touchedAddresses.map((address) => ({
+        address,
+        before: before.get(import_mutation_invalidation.getMutationAddressKey(address)),
+        after: after.get(import_mutation_invalidation.getMutationAddressKey(address))
+      }))),
+      resourceKeys: []
+    });
   }
   clearSpreadsheetRange(address) {
-    this.commandExecutor.execute(new import_content_commands.ClearRangeCommand(this.workbookManager, address), { validate: this.schemaManager.hasSchemas() });
+    const clearedCells = Array.from(this.workbookManager.iterateCellsInRange(address));
+    const before = import_mutation_invalidation.captureCellContents(this.workbookManager, clearedCells);
+    this.workbookManager.clearSpreadsheetRange(address);
+    this.emitMutation({
+      touchedCells: import_mutation_invalidation.buildTouchedCells(clearedCells.map((cellAddress) => ({
+        address: cellAddress,
+        before: before.get(import_mutation_invalidation.getMutationAddressKey(cellAddress)),
+        after: undefined
+      }))),
+      resourceKeys: []
+    });
   }
   getState() {
     return {
@@ -536,60 +957,8 @@ 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: import_sheet_renamer.renameSheetInFormula,
-      renameWorkbookInFormula: import_workbook_renamer.renameWorkbookInFormula
-    };
-  }
-  getTableCommandDeps() {
-    return {
-      tableManager: this.tableManager,
-      namedExpressionManager: this.namedExpressionManager,
-      workbookManager: this.workbookManager,
-      apiSchemaManager: this.schemaManager,
-      getCellValue: (cell) => this.getCellValue(cell),
-      renameTableInFormula: import_table_renamer.renameTableInFormula
-    };
-  }
-  getNamedExpressionCommandDeps() {
-    return {
-      namedExpressionManager: this.namedExpressionManager,
-      workbookManager: this.workbookManager,
-      renameNamedExpressionInFormula: import_named_expression_renamer.renameNamedExpressionInFormula
-    };
-  }
 }
 
-//# debugId=0F6ECFEB7F27772864756E2164756E21
+//# debugId=1447559B44E2B85C64756E2164756E21