@ricsam/formula-engine 0.0.17 → 0.0.19

package/dist/mjs/core/engine.mjs

@@ -16,6 +16,58 @@ 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 {
+  ApiSchemaManager
+} from "./managers/api-schema-manager.mjs";
+import { buildApiFromDeclaration } from "./api/api-builder.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";
+import {
+  SetCellMetadataCommand,
+  SetSheetMetadataCommand,
+  SetWorkbookMetadataCommand
+} from "./commands/metadata-commands.mjs";
+import {
+  AddConditionalStyleCommand,
+  RemoveConditionalStyleCommand,
+  AddCellStyleCommand,
+  RemoveCellStyleCommand,
+  ClearCellStylesCommand
+} from "./commands/style-commands.mjs";
 
 class FormulaEngine {
   workbookManager;
@@ -28,6 +80,10 @@ class FormulaEngine {
   styleManager;
   copyManager;
   referenceManager;
+  apiSchemaManager;
+  commandExecutor;
+  api;
+  apiDeclaration;
   _workbookManager;
   _namedExpressionManager;
   _tableManager;
@@ -36,7 +92,8 @@ class FormulaEngine {
   _autoFillManager;
   _dependencyManager;
   _styleManager;
-  constructor() {
+  constructor(api) {
+    this.apiDeclaration = api?.declaration;
     this.eventManager = new EventManager;
     this.workbookManager = new WorkbookManager;
     this.namedExpressionManager = new NamedExpressionManager;
@@ -47,8 +104,15 @@ class FormulaEngine {
     this.evaluationManager = new EvaluationManager(this.workbookManager, this.tableManager, formulaEvaluator, this.dependencyManager);
     this.styleManager = new StyleManager(this.evaluationManager);
     this.copyManager = new CopyManager(this.workbookManager, this.evaluationManager, this.styleManager);
-    this.autoFillManager = new AutoFill(this.workbookManager, this.styleManager, this);
+    this.autoFillManager = new AutoFill(this.workbookManager, this.styleManager);
     this.referenceManager = new ReferenceManager;
+    this.apiSchemaManager = new ApiSchemaManager(this.tableManager);
+    this.commandExecutor = new CommandExecutor(this.apiDeclaration, this.evaluationManager, this.eventManager, () => this.apiSchemaManager.validateAllSchemaConstraints((cell) => this.getCellValue(cell), (cell) => this.getCellMetadata(cell), (table) => this.getTableDataCells(table)));
+    if (this.apiDeclaration) {
+      this.api = buildApiFromDeclaration(this, this.apiDeclaration, this.apiSchemaManager);
+    } else {
+      this.api = undefined;
+    }
     this._workbookManager = this.workbookManager;
     this._namedExpressionManager = this.namedExpressionManager;
     this._tableManager = this.tableManager;
@@ -58,8 +122,8 @@ class FormulaEngine {
     this._dependencyManager = this.dependencyManager;
     this._styleManager = this.styleManager;
   }
-  static buildEmpty() {
-    return new FormulaEngine;
+  static buildEmpty(api) {
+    return new FormulaEngine(api);
   }
   getCellEvaluationResult(cellAddress) {
     return this.evaluationManager.getCellEvaluationResult(cellAddress);
@@ -72,25 +136,23 @@ class FormulaEngine {
     return this.evaluationManager.evaluationResultToSerializedValue(result, cellAddress, debug);
   }
   setCellMetadata(address, metadata) {
-    this.workbookManager.setCellMetadata(address, metadata);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new SetCellMetadataCommand(this.workbookManager, address, metadata));
   }
   getCellMetadata(address) {
-    return this.workbookManager.getCellMetadata(address);
+    const metadata = this.workbookManager.getCellMetadata(address);
+    return metadata;
   }
   getSheetMetadataSerialized(opts) {
     return this.workbookManager.getSheetMetadataSerialized(opts);
   }
   setSheetMetadata(opts, metadata) {
-    this.workbookManager.setSheetMetadata(opts, metadata);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new SetSheetMetadataCommand(this.workbookManager, opts, metadata));
   }
   getSheetMetadata(opts) {
     return this.workbookManager.getSheetMetadata(opts);
   }
   setWorkbookMetadata(workbookName, metadata) {
-    this.workbookManager.setWorkbookMetadata(workbookName, metadata);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new SetWorkbookMetadataCommand(this.workbookManager, workbookName, metadata));
   }
   getWorkbookMetadata(workbookName) {
     return this.workbookManager.getWorkbookMetadata(workbookName);
@@ -116,111 +178,58 @@ class FormulaEngine {
   getCellPrecedents(address) {
     throw new Error("Not implemented");
   }
-  addNamedExpression({
-    expression,
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    this.namedExpressionManager.addNamedExpression({
-      expression,
-      expressionName,
-      sheetName,
-      workbookName
+  addNamedExpression(opts) {
+    this.commandExecutor.execute(new AddNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  removeNamedExpression(opts) {
+    this.commandExecutor.execute(new RemoveNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  hasNamedExpression(opts) {
+    const scope = opts.sheetName && opts.workbookName ? {
+      type: "sheet",
+      workbookName: opts.workbookName,
+      sheetName: opts.sheetName
+    } : opts.workbookName ? { type: "workbook", workbookName: opts.workbookName } : { type: "global" };
+    return !!this.namedExpressionManager.getNamedExpression({
+      name: opts.expressionName,
+      scope
     });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
   }
-  removeNamedExpression({
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    const found = this.namedExpressionManager.removeNamedExpression({
-      expressionName,
-      sheetName,
-      workbookName
-    });
-    if (found) {
-      this.reevaluate();
-      this.eventManager.emitUpdate();
-    }
-    return found;
-  }
-  updateNamedExpression({
-    expression,
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    this.namedExpressionManager.updateNamedExpression({
-      expression,
-      expressionName,
-      sheetName,
-      workbookName
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+  updateNamedExpression(opts) {
+    this.commandExecutor.execute(new UpdateNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
-  renameNamedExpression({
-    expressionName,
-    sheetName,
-    workbookName,
-    newName
-  }) {
-    const result = this.namedExpressionManager.renameNamedExpression({
-      expressionName,
-      sheetName,
-      workbookName,
-      newName
-    });
-    this.workbookManager.updateAllFormulas((formula) => renameNamedExpressionInFormula(formula, expressionName, newName));
-    this.namedExpressionManager.updateAllNamedExpressions((formula) => renameNamedExpressionInFormula(formula, expressionName, newName));
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-    return result;
+  renameNamedExpression(opts) {
+    this.commandExecutor.execute(new RenameNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
   setNamedExpressions(opts) {
-    this.namedExpressionManager.setNamedExpressions(opts);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new SetNamedExpressionsCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
   addTable(props) {
-    const table = this.tableManager.addTable({
-      ...props,
-      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-    return table;
+    this.commandExecutor.execute(new AddTableCommand(this.getTableCommandDeps(), props), { validate: !!this.apiDeclaration });
   }
   renameTable(workbookName, names) {
-    this.tableManager.renameTable(workbookName, names);
-    this.workbookManager.updateAllFormulas((formula) => renameTableInFormula(formula, names.oldName, names.newName));
-    this.namedExpressionManager.updateAllNamedExpressions((formula) => renameTableInFormula(formula, names.oldName, names.newName));
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new RenameTableCommand(this.getTableCommandDeps(), workbookName, names.oldName, names.newName), { validate: !!this.apiDeclaration });
   }
   updateTable(opts) {
-    this.tableManager.updateTable({
-      ...opts,
-      getCellValue: (cellAddress) => this.getCellValue(cellAddress)
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new UpdateTableCommand(this.getTableCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
   removeTable(opts) {
-    const found = this.tableManager.removeTable(opts);
-    if (found) {
-      this.reevaluate();
-      this.eventManager.emitUpdate();
-    }
-    return found;
+    this.commandExecutor.execute(new RemoveTableCommand(this.getTableCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  hasTable(opts) {
+    return !!this.tableManager.getTable({
+      workbookName: opts.workbookName,
+      name: opts.tableName
+    });
+  }
+  getTable(opts) {
+    return this.tableManager.getTable({
+      workbookName: opts.workbookName,
+      name: opts.tableName
+    });
   }
   resetTables(tables) {
-    this.tableManager.resetTables(tables);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new ResetTablesCommand(this.getTableCommandDeps(), tables), { validate: !!this.apiDeclaration });
   }
   getTables(workbookName) {
     return this.tableManager.getTables(workbookName);
@@ -228,16 +237,32 @@ 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.styleManager.addConditionalStyle(style);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new AddConditionalStyleCommand(this.styleManager, style));
   }
   removeConditionalStyle(workbookName, index) {
-    const removed = this.styleManager.removeConditionalStyle(workbookName, index);
-    if (removed) {
-      this.eventManager.emitUpdate();
-    }
-    return removed;
+    this.commandExecutor.execute(new RemoveConditionalStyleCommand(this.styleManager, workbookName, index));
+  }
+  getConditionalStyleCount(workbookName) {
+    const allStyles = this.styleManager.getAllConditionalStyles();
+    return allStyles.filter((s) => s.areas.some((a) => a.workbookName === workbookName)).length;
   }
   getConditionalStylesIntersectingWithRange(range) {
     return this.styleManager.getConditionalStylesIntersectingWithRange(range);
@@ -252,15 +277,14 @@ class FormulaEngine {
     return this.styleManager.getAllConditionalStyles();
   }
   addCellStyle(style) {
-    this.styleManager.addCellStyle(style);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new AddCellStyleCommand(this.styleManager, style));
   }
   removeCellStyle(workbookName, index) {
-    const removed = this.styleManager.removeCellStyle(workbookName, index);
-    if (removed) {
-      this.eventManager.emitUpdate();
-    }
-    return removed;
+    this.commandExecutor.execute(new RemoveCellStyleCommand(this.styleManager, workbookName, index));
+  }
+  getCellStyleCount(workbookName) {
+    const allStyles = this.styleManager.getAllCellStyles();
+    return allStyles.filter((s) => s.areas.some((a) => a.workbookName === workbookName)).length;
   }
   getStylesIntersectingWithRange(range) {
     return this.styleManager.getStylesIntersectingWithRange(range);
@@ -269,18 +293,13 @@ class FormulaEngine {
     return this.styleManager.getStyleForRange(range);
   }
   clearCellStyles(range) {
-    this.styleManager.clearCellStyles(range);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new ClearCellStylesCommand(this.styleManager, range));
   }
   pasteCells(source, target, options) {
-    this.copyManager.pasteCells(source, target, options);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new PasteCellsCommand(this.workbookManager, this.copyManager, source, target, options), { validate: !!this.apiDeclaration });
   }
   fillAreas(seedRange, targetRanges, options) {
-    this.copyManager.fillAreas(seedRange, targetRanges, options);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new FillAreasCommand(this.workbookManager, this.copyManager, seedRange, targetRanges, options), { validate: !!this.apiDeclaration });
   }
   smartPaste(sourceCells, pasteSelection, options) {
     if (sourceCells.length === 0) {
@@ -361,55 +380,22 @@ class FormulaEngine {
     return { minCol, minRow, maxCol, maxRow };
   }
   moveCell(source, target) {
-    this.pasteCells([source], target, {
-      cut: true,
-      type: "formula",
-      include: "all"
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new MoveCellCommand(this.workbookManager, this.copyManager, source, target), { validate: !!this.apiDeclaration });
   }
   moveRange(sourceRange, target) {
-    const cells = this.copyManager.expandRangeToCells(sourceRange);
-    this.pasteCells(cells, target, {
-      cut: true,
-      type: "formula",
-      include: "all"
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new MoveRangeCommand(this.workbookManager, this.copyManager, sourceRange, target), { validate: !!this.apiDeclaration });
   }
   addSheet(opts) {
-    const newSheet = this.workbookManager.addSheet(opts);
-    const wbLevel = this.namedExpressionManager.addSheet(opts);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-    return newSheet;
+    this.commandExecutor.execute(new AddSheetCommand(this.getStructureCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
   removeSheet(opts) {
-    const sheet = 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.reevaluate();
-    this.eventManager.emitUpdate();
-    return sheet;
+    this.commandExecutor.execute(new RemoveSheetCommand(this.getStructureCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
   renameSheet(opts) {
-    const sheet = this.workbookManager.renameSheet(opts);
-    this.namedExpressionManager.renameSheet(opts);
-    this.tableManager.updateTablesForSheetRename(opts);
-    this.styleManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-    this.workbookManager.updateAllFormulas((formula) => renameSheetInFormula({
-      formula,
-      oldSheetName: opts.sheetName,
-      newSheetName: opts.newSheetName
-    }));
-    this.referenceManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-    return sheet;
+    this.commandExecutor.execute(new RenameSheetCommand(this.getStructureCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  hasSheet(opts) {
+    return !!this.workbookManager.getSheet(opts);
   }
   getSheets(workbookName) {
     return this.workbookManager.getSheets(workbookName);
@@ -424,154 +410,34 @@ class FormulaEngine {
     return this.workbookManager.getSheetSerialized(opts);
   }
   addWorkbook(workbookName) {
-    this.workbookManager.addWorkbook(workbookName);
-    this.namedExpressionManager.addWorkbook(workbookName);
-    this.tableManager.addWorkbook(workbookName);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new AddWorkbookCommand(this.getStructureCommandDeps(), workbookName), { validate: !!this.apiDeclaration });
   }
   removeWorkbook(workbookName) {
-    this.workbookManager.removeWorkbook(workbookName);
-    this.namedExpressionManager.removeWorkbook(workbookName);
-    this.tableManager.removeWorkbook(workbookName);
-    this.styleManager.removeWorkbookStyles(workbookName);
-    this.referenceManager.invalidateWorkbook(workbookName);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new RemoveWorkbookCommand(this.getStructureCommandDeps(), workbookName), { validate: !!this.apiDeclaration });
+  }
+  hasWorkbook(workbookName) {
+    return this.workbookManager.getWorkbooks().has(workbookName);
   }
   cloneWorkbook(fromWorkbookName, toWorkbookName) {
-    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.addWorkbook(toWorkbookName);
-    for (const [sheetName, sheet] of sourceWorkbook.sheets) {
-      this.addSheet({
-        workbookName: toWorkbookName,
-        sheetName
-      });
-      this.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 sourceWorkbookExpressions = this.namedExpressionManager.getNamedExpressions().workbookExpressions.get(fromWorkbookName);
-    if (sourceWorkbookExpressions) {
-      for (const [name, expression] of sourceWorkbookExpressions) {
-        this.addNamedExpression({
-          expressionName: name,
-          expression: expression.expression,
-          workbookName: toWorkbookName
-        });
-      }
-    }
-    const sourceSheetExpressions = this.namedExpressionManager.getNamedExpressions().sheetExpressions.get(fromWorkbookName);
-    if (sourceSheetExpressions) {
-      for (const [sheetName, sheetExpressions] of sourceSheetExpressions) {
-        for (const [name, expression] of sheetExpressions) {
-          this.addNamedExpression({
-            expressionName: name,
-            expression: expression.expression,
-            workbookName: toWorkbookName,
-            sheetName
-          });
-        }
-      }
-    }
-    const sourceTables = this.tableManager.tables.get(fromWorkbookName);
-    if (sourceTables) {
-      for (const [tableName, table] of sourceTables) {
-        this.tableManager.copyTable({
-          workbookName: fromWorkbookName,
-          tableName
-        }, {
-          workbookName: toWorkbookName,
-          tableName
-        });
-      }
-    }
-    const allConditionalStyles = this.styleManager.getAllConditionalStyles();
-    for (const style of allConditionalStyles) {
-      if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
-        const newStyle = {
-          ...style,
-          areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
-        };
-        this.styleManager.addConditionalStyle(newStyle);
-      }
-    }
-    const allCellStyles = this.styleManager.getAllCellStyles();
-    for (const style of allCellStyles) {
-      if (style.areas.some((area) => area.workbookName === fromWorkbookName)) {
-        const newStyle = {
-          ...style,
-          areas: style.areas.map((area) => area.workbookName === fromWorkbookName ? { ...area, workbookName: toWorkbookName } : area)
-        };
-        this.styleManager.addCellStyle(newStyle);
-      }
-    }
-    this.workbookManager.updateFormulasForWorkbook(toWorkbookName, (formula) => renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: fromWorkbookName,
-      newWorkbookName: toWorkbookName
-    }));
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new CloneWorkbookCommand(this.getStructureCommandDeps(), fromWorkbookName, toWorkbookName), { validate: !!this.apiDeclaration });
   }
   renameWorkbook(opts) {
-    this.workbookManager.renameWorkbook(opts);
-    this.namedExpressionManager.renameWorkbook(opts);
-    this.tableManager.updateTablesForWorkbookRename(opts);
-    this.styleManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
-    this.workbookManager.updateAllFormulas((formula) => renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: opts.workbookName,
-      newWorkbookName: opts.newWorkbookName
-    }));
-    this.referenceManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new RenameWorkbookCommand(this.getStructureCommandDeps(), opts.workbookName, opts.newWorkbookName), { validate: !!this.apiDeclaration });
   }
   getWorkbooks() {
     return this.workbookManager.getWorkbooks();
   }
   setSheetContent(opts, content) {
-    this.workbookManager.setSheetContent(opts, content);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new SetSheetContentCommand(this.workbookManager, opts, content), { validate: !!this.apiDeclaration });
   }
   setCellContent(address, content) {
-    this.workbookManager.setCellContent(address, content);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-  }
-  reevaluate() {
-    this.evaluationManager.clearEvaluationCache();
+    this.commandExecutor.execute(new SetCellContentCommand(this.workbookManager, address, content), { validate: !!this.apiDeclaration });
   }
   autoFill(opts, seedRange, fillRanges, direction) {
-    this.autoFillManager.fill(opts, seedRange, fillRanges, direction);
+    this.commandExecutor.execute(new AutoFillCommand(this.workbookManager, this.styleManager, this.autoFillManager, opts, seedRange, fillRanges, direction), { validate: !!this.apiDeclaration });
   }
   clearSpreadsheetRange(address) {
-    this.workbookManager.clearSpreadsheetRange(address);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new ClearRangeCommand(this.workbookManager, address), { validate: !!this.apiDeclaration });
   }
   getState() {
     return {
@@ -622,12 +488,62 @@ class FormulaEngine {
     if (deserialized.references) {
       this.referenceManager.resetReferences(deserialized.references);
     }
-    this.reevaluate();
+    this.evaluationManager.clearEvaluationCache();
     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.apiSchemaManager,
+      renameSheetInFormula,
+      renameWorkbookInFormula
+    };
+  }
+  getTableCommandDeps() {
+    return {
+      tableManager: this.tableManager,
+      namedExpressionManager: this.namedExpressionManager,
+      workbookManager: this.workbookManager,
+      apiSchemaManager: this.apiSchemaManager,
+      getCellValue: (cell) => this.getCellValue(cell),
+      renameTableInFormula
+    };
+  }
+  getNamedExpressionCommandDeps() {
+    return {
+      namedExpressionManager: this.namedExpressionManager,
+      workbookManager: this.workbookManager,
+      renameNamedExpressionInFormula
+    };
+  }
 }
 export {
   FormulaEngine
 };
 
-//# debugId=1F178B2FD179A2B764756E2164756E21
+//# debugId=569EC0E589E33C2264756E2164756E21