@ricsam/formula-engine 0.0.16 → 0.0.18

package/dist/mjs/core/engine.mjs

@@ -15,6 +15,45 @@ import { EvaluationManager } from "./managers/evaluation-manager.mjs";
 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,
+  SetCellContentCommand,
+  SetSheetContentCommand,
+  ClearRangeCommand,
+  PasteCellsCommand,
+  FillAreasCommand,
+  MoveCellCommand,
+  MoveRangeCommand,
+  AutoFillCommand,
+  AddWorkbookCommand,
+  RemoveWorkbookCommand,
+  RenameWorkbookCommand,
+  CloneWorkbookCommand,
+  AddSheetCommand,
+  RemoveSheetCommand,
+  RenameSheetCommand,
+  AddTableCommand,
+  RemoveTableCommand,
+  RenameTableCommand,
+  UpdateTableCommand,
+  ResetTablesCommand,
+  AddNamedExpressionCommand,
+  RemoveNamedExpressionCommand,
+  UpdateNamedExpressionCommand,
+  RenameNamedExpressionCommand,
+  SetNamedExpressionsCommand,
+  SetCellMetadataCommand,
+  SetSheetMetadataCommand,
+  SetWorkbookMetadataCommand,
+  AddConditionalStyleCommand,
+  RemoveConditionalStyleCommand,
+  AddCellStyleCommand,
+  RemoveCellStyleCommand,
+  ClearCellStylesCommand
+} from "./commands.mjs";
 
 class FormulaEngine {
   workbookManager;
@@ -26,6 +65,11 @@ class FormulaEngine {
   dependencyManager;
   styleManager;
   copyManager;
+  referenceManager;
+  apiSchemaManager;
+  commandExecutor;
+  api;
+  apiDeclaration;
   _workbookManager;
   _namedExpressionManager;
   _tableManager;
@@ -34,7 +78,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;
@@ -45,7 +90,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;
@@ -55,8 +108,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);
@@ -68,6 +121,40 @@ class FormulaEngine {
     }
     return this.evaluationManager.evaluationResultToSerializedValue(result, cellAddress, debug);
   }
+  setCellMetadata(address, metadata) {
+    this.commandExecutor.execute(new SetCellMetadataCommand(this.workbookManager, address, metadata));
+  }
+  getCellMetadata(address) {
+    const metadata = this.workbookManager.getCellMetadata(address);
+    return metadata;
+  }
+  getSheetMetadataSerialized(opts) {
+    return this.workbookManager.getSheetMetadataSerialized(opts);
+  }
+  setSheetMetadata(opts, metadata) {
+    this.commandExecutor.execute(new SetSheetMetadataCommand(this.workbookManager, opts, metadata));
+  }
+  getSheetMetadata(opts) {
+    return this.workbookManager.getSheetMetadata(opts);
+  }
+  setWorkbookMetadata(workbookName, metadata) {
+    this.commandExecutor.execute(new SetWorkbookMetadataCommand(this.workbookManager, workbookName, metadata));
+  }
+  getWorkbookMetadata(workbookName) {
+    return this.workbookManager.getWorkbookMetadata(workbookName);
+  }
+  createRef(address) {
+    return this.referenceManager.createRef(address);
+  }
+  getRefAddress(refId) {
+    return this.referenceManager.getRefAddress(refId);
+  }
+  deleteRef(refId) {
+    return this.referenceManager.deleteRef(refId);
+  }
+  getInvalidRefs() {
+    return this.referenceManager.getInvalidRefs();
+  }
   evaluateFormula(formula, cellAddress) {
     return this.evaluationManager.evaluateFormula(formula, cellAddress);
   }
@@ -77,111 +164,54 @@ class FormulaEngine {
   getCellPrecedents(address) {
     throw new Error("Not implemented");
   }
-  addNamedExpression({
-    expression,
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    this.namedExpressionManager.addNamedExpression({
-      expression,
-      expressionName,
-      sheetName,
-      workbookName
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+  addNamedExpression(opts) {
+    this.commandExecutor.execute(new AddNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
-  removeNamedExpression({
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    const found = this.namedExpressionManager.removeNamedExpression({
-      expressionName,
-      sheetName,
-      workbookName
-    });
-    if (found) {
-      this.reevaluate();
-      this.eventManager.emitUpdate();
-    }
-    return found;
+  removeNamedExpression(opts) {
+    this.commandExecutor.execute(new RemoveNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
-  updateNamedExpression({
-    expression,
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    this.namedExpressionManager.updateNamedExpression({
-      expression,
-      expressionName,
-      sheetName,
-      workbookName
+  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();
   }
-  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;
+  updateNamedExpression(opts) {
+    this.commandExecutor.execute(new UpdateNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  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);
@@ -189,16 +219,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);
@@ -206,16 +252,21 @@ class FormulaEngine {
   getCellStyle(cellAddress) {
     return this.styleManager.getCellStyle(cellAddress);
   }
+  getAllCellStyles() {
+    return this.styleManager.getAllCellStyles();
+  }
+  getAllConditionalStyles() {
+    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);
@@ -224,23 +275,30 @@ 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.copyCells(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) {
       return;
     }
+    if (options.cut === true) {
+      for (const area of pasteSelection.areas) {
+        const target = {
+          workbookName: pasteSelection.workbookName,
+          sheetName: pasteSelection.sheetName,
+          colIndex: area.start.col,
+          rowIndex: area.start.row
+        };
+        this.pasteCells(sourceCells, target, options);
+      }
+      return;
+    }
     const sourceBounds = this.getBoundsFromCells(sourceCells);
     const sourceWidth = sourceBounds.maxCol - sourceBounds.minCol + 1;
     const sourceHeight = sourceBounds.maxRow - sourceBounds.minRow + 1;
@@ -303,35 +361,23 @@ class FormulaEngine {
     }
     return { minCol, minRow, maxCol, maxRow };
   }
+  moveCell(source, target) {
+    this.commandExecutor.execute(new MoveCellCommand(this.workbookManager, this.copyManager, source, target), { validate: !!this.apiDeclaration });
+  }
+  moveRange(sourceRange, target) {
+    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.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.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);
@@ -346,144 +392,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.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 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.area.workbookName === fromWorkbookName) {
-        const newStyle = {
-          ...style,
-          area: {
-            ...style.area,
-            workbookName: toWorkbookName
-          }
-        };
-        this.styleManager.addConditionalStyle(newStyle);
-      }
-    }
-    const allCellStyles = this.styleManager.getAllCellStyles();
-    for (const style of allCellStyles) {
-      if (style.area.workbookName === fromWorkbookName) {
-        const newStyle = {
-          ...style,
-          area: {
-            ...style.area,
-            workbookName: toWorkbookName
-          }
-        };
-        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.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 {
@@ -491,7 +427,8 @@ class FormulaEngine {
       namedExpressions: this.namedExpressionManager.getNamedExpressions(),
       tables: this.tableManager.tables,
       conditionalStyles: this.styleManager.getAllConditionalStyles(),
-      cellStyles: this.styleManager.getAllCellStyles()
+      cellStyles: this.styleManager.getAllCellStyles(),
+      references: this.referenceManager.getAllReferences()
     };
   }
   onUpdate(listener) {
@@ -530,12 +467,65 @@ class FormulaEngine {
       }
     }
     this.styleManager.resetStyles(conditionalStylesArray, cellStylesArray);
-    this.reevaluate();
+    if (deserialized.references) {
+      this.referenceManager.resetReferences(deserialized.references);
+    }
+    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=7C47241B744792D164756E2164756E21
+//# debugId=ACD6AB3C2CAB92F864756E2164756E21