@ricsam/formula-engine 0.2.7 → 0.2.9

package/dist/cjs/core/commands/structure-commands.cjs

@@ -1,696 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/core/commands/structure-commands.ts
-var exports_structure_commands = {};
-__export(exports_structure_commands, {
-  RenameWorkbookCommand: () => RenameWorkbookCommand,
-  RenameSheetCommand: () => RenameSheetCommand,
-  RemoveWorkbookCommand: () => RemoveWorkbookCommand,
-  RemoveSheetCommand: () => RemoveSheetCommand,
-  CloneWorkbookCommand: () => CloneWorkbookCommand,
-  AddWorkbookCommand: () => AddWorkbookCommand,
-  AddSheetCommand: () => AddSheetCommand
-});
-module.exports = __toCommonJS(exports_structure_commands);
-var import_types = require("./types.cjs");
-var import_resource_keys = require("../resource-keys.cjs");
-
-class AddWorkbookCommand {
-  deps;
-  workbookName;
-  requiresReevaluation = true;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, workbookName) {
-    this.deps = deps;
-    this.workbookName = workbookName;
-  }
-  execute() {
-    this.deps.workbookManager.addWorkbook(this.workbookName);
-    this.deps.namedExpressionManager.addWorkbook(this.workbookName);
-    this.deps.tableManager.addWorkbook(this.workbookName);
-    this.executeFootprint = {
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getWorkbookResourceKey(this.workbookName)]
-    };
-    this.undoFootprint = {
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getWorkbookResourceKey(this.workbookName)],
-      removedScopes: [{ type: "workbook", workbookName: this.workbookName }]
-    };
-  }
-  undo() {
-    this.deps.workbookManager.removeWorkbook(this.workbookName);
-    this.deps.namedExpressionManager.removeWorkbook(this.workbookName);
-    this.deps.tableManager.removeWorkbook(this.workbookName);
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.ADD_WORKBOOK,
-      payload: { workbookName: this.workbookName }
-    };
-  }
-}
-function captureWorkbookSnapshot(deps, workbookName) {
-  const workbook = deps.workbookManager.getWorkbooks().get(workbookName);
-  if (!workbook)
-    return;
-  const clonedSheets = new Map;
-  for (const [name, sheet] of workbook.sheets) {
-    clonedSheets.set(name, {
-      name: sheet.name,
-      index: sheet.index,
-      content: new Map(sheet.content),
-      metadata: new Map(sheet.metadata),
-      sheetMetadata: sheet.sheetMetadata
-    });
-  }
-  const namedExpressions = deps.namedExpressionManager.getNamedExpressions();
-  const snapshot = {
-    workbook: {
-      name: workbook.name,
-      sheets: clonedSheets,
-      workbookMetadata: workbook.workbookMetadata
-    },
-    namedExpressions: {
-      workbookLevel: new Map(namedExpressions.workbookExpressions.get(workbookName) || []),
-      sheetLevel: new Map
-    },
-    tables: new Map(deps.tableManager.getTables(workbookName)),
-    conditionalStyles: deps.styleManager.getAllConditionalStyles().filter((s) => s.areas.some((a) => a.workbookName === workbookName)),
-    cellStyles: deps.styleManager.getAllCellStyles().filter((s) => s.areas.some((a) => a.workbookName === workbookName))
-  };
-  const sheetExpressions = namedExpressions.sheetExpressions.get(workbookName);
-  if (sheetExpressions) {
-    for (const [sheetName, expressions] of sheetExpressions) {
-      snapshot.namedExpressions.sheetLevel.set(sheetName, new Map(expressions));
-    }
-  }
-  return snapshot;
-}
-function removeWorkbook(deps, workbookName) {
-  deps.workbookManager.removeWorkbook(workbookName);
-  deps.namedExpressionManager.removeWorkbook(workbookName);
-  deps.tableManager.removeWorkbook(workbookName);
-  deps.styleManager.removeWorkbookStyles(workbookName);
-  deps.referenceManager.invalidateWorkbook(workbookName);
-}
-function renameWorkbookAcrossManagers(deps, oldName, newName) {
-  deps.workbookManager.renameWorkbook({
-    workbookName: oldName,
-    newWorkbookName: newName
-  });
-  deps.namedExpressionManager.renameWorkbook({
-    workbookName: oldName,
-    newWorkbookName: newName
-  });
-  deps.tableManager.updateTablesForWorkbookRename({
-    workbookName: oldName,
-    newWorkbookName: newName
-  });
-  deps.styleManager.updateWorkbookName(oldName, newName);
-  const changedCells = deps.workbookManager.updateAllFormulas((formula) => deps.renameWorkbookInFormula({
-    formula,
-    oldWorkbookName: oldName,
-    newWorkbookName: newName
-  }));
-  deps.referenceManager.updateWorkbookName(oldName, newName);
-  deps.apiSchemaManager.updateForWorkbookRename(oldName, newName);
-  return changedCells;
-}
-function renameSheetAcrossManagers(deps, opts) {
-  deps.workbookManager.renameSheet(opts);
-  deps.namedExpressionManager.renameSheet(opts);
-  deps.tableManager.updateTablesForSheetRename(opts);
-  deps.styleManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-  const changedCells = deps.workbookManager.updateAllFormulas((formula) => deps.renameSheetInFormula({
-    formula,
-    oldSheetName: opts.sheetName,
-    newSheetName: opts.newSheetName
-  }));
-  deps.referenceManager.updateSheetName(opts.workbookName, opts.sheetName, opts.newSheetName);
-  deps.apiSchemaManager.updateForSheetRename(opts.workbookName, opts.sheetName, opts.newSheetName);
-  return changedCells;
-}
-function getWorkbookSnapshotResourceKeys(workbookName, snapshot) {
-  const resourceKeys = new Set([import_resource_keys.getWorkbookResourceKey(workbookName)]);
-  if (!snapshot) {
-    return Array.from(resourceKeys);
-  }
-  for (const tableName of snapshot.tables.keys()) {
-    resourceKeys.add(import_resource_keys.getTableResourceKey({ workbookName, tableName }));
-  }
-  for (const name of snapshot.namedExpressions.workbookLevel.keys()) {
-    resourceKeys.add(import_resource_keys.getNamedExpressionResourceKey({ expressionName: name, workbookName }));
-  }
-  for (const [sheetName, expressions] of snapshot.namedExpressions.sheetLevel) {
-    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);
-}
-function getSheetSnapshotResourceKeys(workbookName, sheetName, snapshot) {
-  const resourceKeys = new Set([
-    import_resource_keys.getWorkbookResourceKey(workbookName),
-    import_resource_keys.getSheetResourceKey({ workbookName, sheetName })
-  ]);
-  if (!snapshot) {
-    return Array.from(resourceKeys);
-  }
-  for (const tableName of snapshot.tables.keys()) {
-    resourceKeys.add(import_resource_keys.getTableResourceKey({ workbookName, tableName }));
-  }
-  for (const name of snapshot.namedExpressions.keys()) {
-    resourceKeys.add(import_resource_keys.getNamedExpressionResourceKey({
-      expressionName: name,
-      workbookName,
-      sheetName
-    }));
-  }
-  return Array.from(resourceKeys);
-}
-function restoreTables(tableManager, tables, workbookName) {
-  for (const [tableName, table] of tables) {
-    tableManager.addTable({
-      workbookName,
-      tableName,
-      sheetName: table.sheetName,
-      start: `${String.fromCharCode(65 + table.start.colIndex)}${table.start.rowIndex + 1}`,
-      numRows: table.endRow,
-      numCols: table.headers.size,
-      getCellValue: () => {
-        return;
-      }
-    });
-  }
-}
-function restoreStyles(styleManager, conditionalStyles, cellStyles) {
-  for (const style of conditionalStyles) {
-    styleManager.addConditionalStyle(style);
-  }
-  for (const style of cellStyles) {
-    styleManager.addCellStyle(style);
-  }
-}
-
-class RemoveWorkbookCommand {
-  deps;
-  workbookName;
-  requiresReevaluation = true;
-  snapshot;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, workbookName) {
-    this.deps = deps;
-    this.workbookName = workbookName;
-  }
-  execute() {
-    this.snapshot = captureWorkbookSnapshot(this.deps, this.workbookName);
-    removeWorkbook(this.deps, this.workbookName);
-    const resourceKeys = getWorkbookSnapshotResourceKeys(this.workbookName, this.snapshot);
-    this.executeFootprint = {
-      touchedCells: [],
-      resourceKeys,
-      removedScopes: [{ type: "workbook", workbookName: this.workbookName }]
-    };
-    this.undoFootprint = {
-      touchedCells: [],
-      resourceKeys
-    };
-  }
-  undo() {
-    if (!this.snapshot)
-      return;
-    this.deps.workbookManager.addWorkbook(this.workbookName);
-    this.deps.namedExpressionManager.addWorkbook(this.workbookName);
-    this.deps.tableManager.addWorkbook(this.workbookName);
-    for (const [sheetName, sheet] of this.snapshot.workbook.sheets) {
-      this.deps.workbookManager.addSheet({
-        workbookName: this.workbookName,
-        sheetName
-      });
-      this.deps.namedExpressionManager.addSheet({
-        workbookName: this.workbookName,
-        sheetName
-      });
-      this.deps.workbookManager.setSheetContent({ workbookName: this.workbookName, sheetName }, sheet.content);
-    }
-    for (const [name, expr] of this.snapshot.namedExpressions.workbookLevel) {
-      this.deps.namedExpressionManager.addNamedExpression({
-        expressionName: name,
-        expression: expr.expression,
-        workbookName: this.workbookName
-      });
-    }
-    for (const [sheetName, expressions] of this.snapshot.namedExpressions.sheetLevel) {
-      for (const [name, expr] of expressions) {
-        this.deps.namedExpressionManager.addNamedExpression({
-          expressionName: name,
-          expression: expr.expression,
-          workbookName: this.workbookName,
-          sheetName
-        });
-      }
-    }
-    restoreTables(this.deps.tableManager, this.snapshot.tables, this.workbookName);
-    restoreStyles(this.deps.styleManager, this.snapshot.conditionalStyles, this.snapshot.cellStyles);
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.REMOVE_WORKBOOK,
-      payload: { workbookName: this.workbookName }
-    };
-  }
-}
-
-class RenameWorkbookCommand {
-  deps;
-  workbookName;
-  newWorkbookName;
-  requiresReevaluation = true;
-  snapshot;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, workbookName, newWorkbookName) {
-    this.deps = deps;
-    this.workbookName = workbookName;
-    this.newWorkbookName = newWorkbookName;
-  }
-  execute() {
-    this.snapshot = captureWorkbookSnapshot(this.deps, this.workbookName);
-    const changedCells = renameWorkbookAcrossManagers(this.deps, this.workbookName, this.newWorkbookName);
-    this.executeFootprint = {
-      touchedCells: changedCells.map((address) => ({
-        address,
-        beforeKind: "formula",
-        afterKind: "formula"
-      })),
-      resourceKeys: Array.from(new Set([
-        ...getWorkbookSnapshotResourceKeys(this.workbookName, this.snapshot),
-        ...getWorkbookSnapshotResourceKeys(this.newWorkbookName, this.snapshot)
-      ]))
-    };
-  }
-  undo() {
-    const changedCells = renameWorkbookAcrossManagers(this.deps, this.newWorkbookName, this.workbookName);
-    this.undoFootprint = {
-      touchedCells: changedCells.map((address) => ({
-        address,
-        beforeKind: "formula",
-        afterKind: "formula"
-      })),
-      resourceKeys: Array.from(new Set([
-        ...getWorkbookSnapshotResourceKeys(this.workbookName, this.snapshot),
-        ...getWorkbookSnapshotResourceKeys(this.newWorkbookName, this.snapshot)
-      ]))
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.RENAME_WORKBOOK,
-      payload: {
-        workbookName: this.workbookName,
-        newWorkbookName: this.newWorkbookName
-      }
-    };
-  }
-}
-
-class CloneWorkbookCommand {
-  deps;
-  fromWorkbookName;
-  toWorkbookName;
-  requiresReevaluation = true;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, fromWorkbookName, toWorkbookName) {
-    this.deps = deps;
-    this.fromWorkbookName = fromWorkbookName;
-    this.toWorkbookName = toWorkbookName;
-  }
-  execute() {
-    const {
-      workbookManager,
-      namedExpressionManager,
-      tableManager,
-      styleManager,
-      renameWorkbookInFormula
-    } = this.deps;
-    const sourceWorkbook = workbookManager.getWorkbooks().get(this.fromWorkbookName);
-    if (!sourceWorkbook) {
-      throw new Error(`Source workbook "${this.fromWorkbookName}" not found`);
-    }
-    if (workbookManager.getWorkbooks().has(this.toWorkbookName)) {
-      throw new Error(`Target workbook "${this.toWorkbookName}" already exists`);
-    }
-    workbookManager.addWorkbook(this.toWorkbookName);
-    namedExpressionManager.addWorkbook(this.toWorkbookName);
-    tableManager.addWorkbook(this.toWorkbookName);
-    for (const [sheetName, sheet] of sourceWorkbook.sheets) {
-      workbookManager.addSheet({
-        workbookName: this.toWorkbookName,
-        sheetName
-      });
-      namedExpressionManager.addSheet({
-        workbookName: this.toWorkbookName,
-        sheetName
-      });
-      workbookManager.setSheetContent({ workbookName: this.toWorkbookName, sheetName }, new Map(sheet.content));
-      const targetSheet = workbookManager.getSheet({
-        workbookName: this.toWorkbookName,
-        sheetName
-      });
-      if (targetSheet) {
-        targetSheet.metadata = new Map(sheet.metadata);
-        if (sheet.sheetMetadata !== undefined) {
-          targetSheet.sheetMetadata = structuredClone(sheet.sheetMetadata);
-        }
-      }
-    }
-    const targetWorkbook = workbookManager.getWorkbooks().get(this.toWorkbookName);
-    if (targetWorkbook && sourceWorkbook.workbookMetadata !== undefined) {
-      targetWorkbook.workbookMetadata = structuredClone(sourceWorkbook.workbookMetadata);
-    }
-    const allExpressions = namedExpressionManager.getNamedExpressions();
-    const sourceWorkbookExpressions = allExpressions.workbookExpressions.get(this.fromWorkbookName);
-    if (sourceWorkbookExpressions) {
-      for (const [expressionName, expression] of sourceWorkbookExpressions) {
-        namedExpressionManager.addNamedExpression({
-          expressionName,
-          expression: expression.expression,
-          workbookName: this.toWorkbookName
-        });
-      }
-    }
-    const sourceSheetExpressions = allExpressions.sheetExpressions.get(this.fromWorkbookName);
-    if (sourceSheetExpressions) {
-      for (const [sheetName, sheetExpressions] of sourceSheetExpressions) {
-        for (const [expressionName, expression] of sheetExpressions) {
-          namedExpressionManager.addNamedExpression({
-            expressionName,
-            expression: expression.expression,
-            workbookName: this.toWorkbookName,
-            sheetName
-          });
-        }
-      }
-    }
-    const sourceTables = tableManager.tables.get(this.fromWorkbookName);
-    if (sourceTables) {
-      for (const [tableName] of sourceTables) {
-        tableManager.copyTable({ workbookName: this.fromWorkbookName, tableName }, { workbookName: this.toWorkbookName, tableName });
-      }
-    }
-    const allConditionalStyles = styleManager.getAllConditionalStyles();
-    for (const style of allConditionalStyles) {
-      if (style.areas.some((area) => area.workbookName === this.fromWorkbookName)) {
-        const newStyle = {
-          ...style,
-          areas: style.areas.map((area) => area.workbookName === this.fromWorkbookName ? { ...area, workbookName: this.toWorkbookName } : area)
-        };
-        styleManager.addConditionalStyle(newStyle);
-      }
-    }
-    const allCellStyles = styleManager.getAllCellStyles();
-    for (const style of allCellStyles) {
-      if (style.areas.some((area) => area.workbookName === this.fromWorkbookName)) {
-        const newStyle = {
-          ...style,
-          areas: style.areas.map((area) => area.workbookName === this.fromWorkbookName ? { ...area, workbookName: this.toWorkbookName } : area)
-        };
-        styleManager.addCellStyle(newStyle);
-      }
-    }
-    workbookManager.updateFormulasForWorkbook(this.toWorkbookName, (formula) => renameWorkbookInFormula({
-      formula,
-      oldWorkbookName: this.fromWorkbookName,
-      newWorkbookName: this.toWorkbookName
-    }));
-    this.executeFootprint = {
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getWorkbookResourceKey(this.toWorkbookName)]
-    };
-    this.undoFootprint = {
-      touchedCells: [],
-      resourceKeys: [import_resource_keys.getWorkbookResourceKey(this.toWorkbookName)],
-      removedScopes: [{ type: "workbook", workbookName: this.toWorkbookName }]
-    };
-  }
-  undo() {
-    removeWorkbook(this.deps, this.toWorkbookName);
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.CLONE_WORKBOOK,
-      payload: {
-        fromWorkbookName: this.fromWorkbookName,
-        toWorkbookName: this.toWorkbookName
-      }
-    };
-  }
-}
-
-class AddSheetCommand {
-  deps;
-  opts;
-  requiresReevaluation = true;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, opts) {
-    this.deps = deps;
-    this.opts = opts;
-  }
-  execute() {
-    this.deps.workbookManager.addSheet(this.opts);
-    this.deps.namedExpressionManager.addSheet(this.opts);
-    const resourceKey = import_resource_keys.getSheetResourceKey(this.opts);
-    this.executeFootprint = {
-      touchedCells: [],
-      resourceKeys: [resourceKey]
-    };
-    this.undoFootprint = {
-      touchedCells: [],
-      resourceKeys: [resourceKey],
-      removedScopes: [{ type: "sheet", ...this.opts }]
-    };
-  }
-  undo() {
-    this.deps.workbookManager.removeSheet(this.opts);
-    this.deps.namedExpressionManager.removeSheet(this.opts);
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.ADD_SHEET,
-      payload: this.opts
-    };
-  }
-}
-
-class RemoveSheetCommand {
-  deps;
-  opts;
-  requiresReevaluation = true;
-  snapshot;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, opts) {
-    this.deps = deps;
-    this.opts = opts;
-  }
-  execute() {
-    const sheet = this.deps.workbookManager.getSheet(this.opts);
-    if (sheet) {
-      const namedExpressions = this.deps.namedExpressionManager.getNamedExpressions();
-      const sheetExpressions = namedExpressions.sheetExpressions.get(this.opts.workbookName)?.get(this.opts.sheetName) || new Map;
-      const allTables = this.deps.tableManager.getTables(this.opts.workbookName);
-      const sheetTables = new Map;
-      for (const [name, table] of allTables) {
-        if (table.sheetName === this.opts.sheetName) {
-          sheetTables.set(name, table);
-        }
-      }
-      this.snapshot = {
-        sheet: {
-          name: sheet.name,
-          index: sheet.index,
-          content: new Map(sheet.content),
-          metadata: new Map(sheet.metadata),
-          sheetMetadata: sheet.sheetMetadata
-        },
-        namedExpressions: new Map(sheetExpressions),
-        tables: sheetTables,
-        conditionalStyles: this.deps.styleManager.getAllConditionalStyles().filter((s) => s.areas.some((a) => a.workbookName === this.opts.workbookName && a.sheetName === this.opts.sheetName)),
-        cellStyles: this.deps.styleManager.getAllCellStyles().filter((s) => s.areas.some((a) => a.workbookName === this.opts.workbookName && a.sheetName === this.opts.sheetName))
-      };
-    }
-    this.deps.workbookManager.removeSheet(this.opts);
-    this.deps.namedExpressionManager.removeSheet(this.opts);
-    this.deps.tableManager.removeSheet(this.opts);
-    this.deps.styleManager.removeSheetStyles(this.opts.workbookName, this.opts.sheetName);
-    this.deps.referenceManager.invalidateSheet(this.opts.workbookName, this.opts.sheetName);
-    const resourceKeys = getSheetSnapshotResourceKeys(this.opts.workbookName, this.opts.sheetName, this.snapshot);
-    this.executeFootprint = {
-      touchedCells: [],
-      resourceKeys,
-      removedScopes: [{ type: "sheet", ...this.opts }]
-    };
-    this.undoFootprint = {
-      touchedCells: [],
-      resourceKeys
-    };
-  }
-  undo() {
-    if (!this.snapshot)
-      return;
-    this.deps.workbookManager.addSheet(this.opts);
-    this.deps.namedExpressionManager.addSheet(this.opts);
-    this.deps.workbookManager.setSheetContent(this.opts, this.snapshot.sheet.content);
-    for (const [name, expr] of this.snapshot.namedExpressions) {
-      this.deps.namedExpressionManager.addNamedExpression({
-        expressionName: name,
-        expression: expr.expression,
-        workbookName: this.opts.workbookName,
-        sheetName: this.opts.sheetName
-      });
-    }
-    restoreTables(this.deps.tableManager, this.snapshot.tables, this.opts.workbookName);
-    restoreStyles(this.deps.styleManager, this.snapshot.conditionalStyles, this.snapshot.cellStyles);
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.REMOVE_SHEET,
-      payload: this.opts
-    };
-  }
-}
-
-class RenameSheetCommand {
-  deps;
-  opts;
-  requiresReevaluation = true;
-  snapshot;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(deps, opts) {
-    this.deps = deps;
-    this.opts = opts;
-  }
-  execute() {
-    const namedExpressions = this.deps.namedExpressionManager.getNamedExpressions().sheetExpressions.get(this.opts.workbookName)?.get(this.opts.sheetName) || new Map;
-    const tables = new Map;
-    for (const [name, table] of this.deps.tableManager.getTables(this.opts.workbookName)) {
-      if (table.sheetName === this.opts.sheetName) {
-        tables.set(name, table);
-      }
-    }
-    const sheet = this.deps.workbookManager.getSheet(this.opts);
-    this.snapshot = {
-      sheet,
-      namedExpressions: new Map(namedExpressions),
-      tables,
-      conditionalStyles: [],
-      cellStyles: []
-    };
-    const changedCells = renameSheetAcrossManagers(this.deps, this.opts);
-    this.executeFootprint = {
-      touchedCells: changedCells.map((address) => ({
-        address,
-        beforeKind: "formula",
-        afterKind: "formula"
-      })),
-      resourceKeys: Array.from(new Set([
-        ...getSheetSnapshotResourceKeys(this.opts.workbookName, this.opts.sheetName, this.snapshot),
-        ...getSheetSnapshotResourceKeys(this.opts.workbookName, this.opts.newSheetName, this.snapshot)
-      ]))
-    };
-  }
-  undo() {
-    const changedCells = renameSheetAcrossManagers(this.deps, {
-      workbookName: this.opts.workbookName,
-      sheetName: this.opts.newSheetName,
-      newSheetName: this.opts.sheetName
-    });
-    this.undoFootprint = {
-      touchedCells: changedCells.map((address) => ({
-        address,
-        beforeKind: "formula",
-        afterKind: "formula"
-      })),
-      resourceKeys: Array.from(new Set([
-        ...getSheetSnapshotResourceKeys(this.opts.workbookName, this.opts.sheetName, this.snapshot),
-        ...getSheetSnapshotResourceKeys(this.opts.workbookName, this.opts.newSheetName, this.snapshot)
-      ]))
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.RENAME_SHEET,
-      payload: this.opts
-    };
-  }
-}
-
-//# debugId=9D7106D25079DB6D64756E2164756E21