@ricsam/formula-engine 0.0.17 → 0.0.19

package/dist/cjs/core/engine.cjs

@@ -49,6 +49,15 @@ 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_api_schema_manager = require("./managers/api-schema-manager.cjs");
+var import_api_builder = require("./api/api-builder.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");
 
 class FormulaEngine {
   workbookManager;
@@ -61,6 +70,10 @@ class FormulaEngine {
   styleManager;
   copyManager;
   referenceManager;
+  apiSchemaManager;
+  commandExecutor;
+  api;
+  apiDeclaration;
   _workbookManager;
   _namedExpressionManager;
   _tableManager;
@@ -69,7 +82,8 @@ class FormulaEngine {
   _autoFillManager;
   _dependencyManager;
   _styleManager;
-  constructor() {
+  constructor(api) {
+    this.apiDeclaration = api?.declaration;
     this.eventManager = new import_event_manager.EventManager;
     this.workbookManager = new import_workbook_manager.WorkbookManager;
     this.namedExpressionManager = new import_named_expression_manager.NamedExpressionManager;
@@ -80,8 +94,15 @@ class FormulaEngine {
     this.evaluationManager = new import_evaluation_manager.EvaluationManager(this.workbookManager, this.tableManager, formulaEvaluator, this.dependencyManager);
     this.styleManager = new import_style_manager.StyleManager(this.evaluationManager);
     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);
+    this.autoFillManager = new import_autofill_utils.AutoFill(this.workbookManager, this.styleManager);
     this.referenceManager = new import_reference_manager.ReferenceManager;
+    this.apiSchemaManager = new import_api_schema_manager.ApiSchemaManager(this.tableManager);
+    this.commandExecutor = new import_command_executor.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 = import_api_builder.buildApiFromDeclaration(this, this.apiDeclaration, this.apiSchemaManager);
+    } else {
+      this.api = undefined;
+    }
     this._workbookManager = this.workbookManager;
     this._namedExpressionManager = this.namedExpressionManager;
     this._tableManager = this.tableManager;
@@ -91,8 +112,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);
@@ -105,25 +126,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 import_metadata_commands.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 import_metadata_commands.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 import_metadata_commands.SetWorkbookMetadataCommand(this.workbookManager, workbookName, metadata));
   }
   getWorkbookMetadata(workbookName) {
     return this.workbookManager.getWorkbookMetadata(workbookName);
@@ -149,111 +168,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 import_named_expression_commands.AddNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  removeNamedExpression(opts) {
+    this.commandExecutor.execute(new import_named_expression_commands.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(opts) {
+    this.commandExecutor.execute(new import_named_expression_commands.UpdateNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
-  updateNamedExpression({
-    expression,
-    expressionName,
-    sheetName,
-    workbookName
-  }) {
-    this.namedExpressionManager.updateNamedExpression({
-      expression,
-      expressionName,
-      sheetName,
-      workbookName
-    });
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-  }
-  renameNamedExpression({
-    expressionName,
-    sheetName,
-    workbookName,
-    newName
-  }) {
-    const result = this.namedExpressionManager.renameNamedExpression({
-      expressionName,
-      sheetName,
-      workbookName,
-      newName
-    });
-    this.workbookManager.updateAllFormulas((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, expressionName, newName));
-    this.namedExpressionManager.updateAllNamedExpressions((formula) => import_named_expression_renamer.renameNamedExpressionInFormula(formula, expressionName, newName));
-    this.reevaluate();
-    this.eventManager.emitUpdate();
-    return result;
+  renameNamedExpression(opts) {
+    this.commandExecutor.execute(new import_named_expression_commands.RenameNamedExpressionCommand(this.getNamedExpressionCommandDeps(), opts), { validate: !!this.apiDeclaration });
   }
   setNamedExpressions(opts) {
-    this.namedExpressionManager.setNamedExpressions(opts);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_named_expression_commands.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 import_table_commands.AddTableCommand(this.getTableCommandDeps(), props), { validate: !!this.apiDeclaration });
   }
   renameTable(workbookName, names) {
-    this.tableManager.renameTable(workbookName, names);
-    this.workbookManager.updateAllFormulas((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
-    this.namedExpressionManager.updateAllNamedExpressions((formula) => import_table_renamer.renameTableInFormula(formula, names.oldName, names.newName));
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_table_commands.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 import_table_commands.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 import_table_commands.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 import_table_commands.ResetTablesCommand(this.getTableCommandDeps(), tables), { validate: !!this.apiDeclaration });
   }
   getTables(workbookName) {
     return this.tableManager.getTables(workbookName);
@@ -261,16 +227,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 import_style_commands.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 import_style_commands.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);
@@ -285,15 +267,14 @@ class FormulaEngine {
     return this.styleManager.getAllConditionalStyles();
   }
   addCellStyle(style) {
-    this.styleManager.addCellStyle(style);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_style_commands.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 import_style_commands.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);
@@ -302,18 +283,13 @@ class FormulaEngine {
     return this.styleManager.getStyleForRange(range);
   }
   clearCellStyles(range) {
-    this.styleManager.clearCellStyles(range);
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_style_commands.ClearCellStylesCommand(this.styleManager, range));
   }
   pasteCells(source, target, options) {
-    this.copyManager.pasteCells(source, target, options);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_content_commands.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 import_content_commands.FillAreasCommand(this.workbookManager, this.copyManager, seedRange, targetRanges, options), { validate: !!this.apiDeclaration });
   }
   smartPaste(sourceCells, pasteSelection, options) {
     if (sourceCells.length === 0) {
@@ -394,55 +370,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 import_content_commands.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 import_content_commands.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 import_structure_commands.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 import_structure_commands.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) => import_sheet_renamer.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 import_structure_commands.RenameSheetCommand(this.getStructureCommandDeps(), opts), { validate: !!this.apiDeclaration });
+  }
+  hasSheet(opts) {
+    return !!this.workbookManager.getSheet(opts);
   }
   getSheets(workbookName) {
     return this.workbookManager.getSheets(workbookName);
@@ -457,154 +400,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 import_structure_commands.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 import_structure_commands.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) => import_workbook_renamer.renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: fromWorkbookName,
-      newWorkbookName: toWorkbookName
-    }));
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_structure_commands.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) => import_workbook_renamer.renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: opts.workbookName,
-      newWorkbookName: opts.newWorkbookName
-    }));
-    this.referenceManager.updateWorkbookName(opts.workbookName, opts.newWorkbookName);
-    this.reevaluate();
-    this.eventManager.emitUpdate();
+    this.commandExecutor.execute(new import_structure_commands.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 import_content_commands.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 import_content_commands.SetCellContentCommand(this.workbookManager, address, content), { validate: !!this.apiDeclaration });
   }
   autoFill(opts, seedRange, fillRanges, direction) {
-    this.autoFillManager.fill(opts, seedRange, fillRanges, direction);
+    this.commandExecutor.execute(new import_content_commands.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 import_content_commands.ClearRangeCommand(this.workbookManager, address), { validate: !!this.apiDeclaration });
   }
   getState() {
     return {
@@ -655,9 +478,59 @@ 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: import_sheet_renamer.renameSheetInFormula,
+      renameWorkbookInFormula: import_workbook_renamer.renameWorkbookInFormula
+    };
+  }
+  getTableCommandDeps() {
+    return {
+      tableManager: this.tableManager,
+      namedExpressionManager: this.namedExpressionManager,
+      workbookManager: this.workbookManager,
+      apiSchemaManager: this.apiSchemaManager,
+      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=B077CB19589FE5D864756E2164756E21
+//# debugId=66643F9F298C18FE64756E2164756E21