@univerjs/sheets 0.4.1 → 0.4.2-nightly.202410301606

package/lib/es/facade.js

@@ -0,0 +1,1818 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { Inject, Injector, IAuthzIoService, FBase, generateRandomId, Rectangle, ICommandService, IPermissionService, HorizontalAlign, VerticalAlign, isFormulaString, isCellV, isICellData, ObjectMatrix, Tools, RANGE_TYPE, BooleanNumber, WrapStrategy, Dimension, Direction, IResourceLoaderService, mergeWorksheetSnapshotWithDefault, UndoCommand, RedoCommand, toDisposable, UniverInstanceType, IUniverInstanceService, ILogService, FUniver } from "@univerjs/core";
+import { WorksheetProtectionRuleModel, RangeProtectionRuleModel, WorksheetProtectionPointModel, WorkbookEditablePermission, UnitObject, AddWorksheetProtectionMutation, DeleteWorksheetProtectionMutation, getAllWorksheetPermissionPoint, getAllWorksheetPermissionPointByPointPanel, SetWorksheetPermissionPointsMutation, AddRangeProtectionMutation, DeleteRangeProtectionMutation, SetRangeProtectionMutation, WorksheetEditPermission, WorksheetViewPermission } from "@univerjs/sheets";
+import { al as SetStyleCommand, aa as SetRangeValuesCommand, ao as SetTextWrapCommand, ap as SetVerticalTextAlignCommand, a9 as SetHorizontalTextAlignCommand, bm as addMergeCellsUtil, aI as getAddMergeMutationRangeByType, X as RemoveWorksheetMergeCommand, S as SheetsSelectionsService, ay as SetWorksheetDefaultStyleMutation, a4 as SetColDataCommand, af as SetRowDataCommand, bl as copyRangeStyles, J as InsertRowCommand, T as RemoveRowCommand, P as MoveRowsCommand, ac as SetRowHiddenCommand, ak as SetSpecificRowsVisibleCommand, ab as SetRowHeightCommand, as as SetWorksheetRowIsAutoHeightCommand, B as InsertColCommand, Q as RemoveColCommand, N as MoveColsCommand, a0 as SetColHiddenCommand, aj as SetSpecificColsVisibleCommand, a3 as SetColWidthCommand, a6 as SetFrozenCommand, a8 as CancelFrozenCommand, aw as ToggleGridlinesCommand, c as SetRangeValuesMutation, K as InsertSheetCommand, h as SetWorksheetActiveOperation, U as RemoveSheetCommand, W as WorkbookEditablePermission$1, bg as getPrimaryForRange, av as SetSelectionsOperation } from "../add-worksheet-merge.command-0cuLfO_2.mjs";
+import { FormulaDataModel, deserializeRangeWithSheet } from "@univerjs/engine-formula";
+var __defProp$4 = Object.defineProperty, __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor, __decorateClass$4 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$4(target, key, result), result;
+}, "__decorateClass$4"), __decorateParam$4 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$4"), _a;
+let FPermission = (_a = class extends FBase {
+  constructor(_injector, _commandService, _permissionService, _worksheetProtectionRuleModel, _rangeProtectionRuleModel, _worksheetProtectionPointRuleModel, _authzIoService) {
+    super(), this._injector = _injector, this._commandService = _commandService, this._permissionService = _permissionService, this._worksheetProtectionRuleModel = _worksheetProtectionRuleModel, this._rangeProtectionRuleModel = _rangeProtectionRuleModel, this._worksheetProtectionPointRuleModel = _worksheetProtectionPointRuleModel, this._authzIoService = _authzIoService;
+  }
+  /**
+   * Configures a specific permission point for a workbook.
+   *
+   * This function sets or updates a permission point for a workbook identified by `unitId`.
+   * It creates a new permission point if it does not already exist, and updates the point with the provided value.
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {WorkbookPermissionPointConstructor} FPointClass - The constructor function for creating a permission point instance. Other point constructors can See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+   * @param {boolean} value - The boolean value to determine whether the permission point is enabled or disabled.
+   *
+   */
+  setWorkbookPermissionPoint(unitId, FPointClass, value) {
+    const instance = new FPointClass(unitId);
+    this._permissionService.getPermissionPoint(instance.id) || this._permissionService.addPermissionPoint(instance), this._permissionService.updatePermissionPoint(instance.id, value);
+  }
+  /**
+   * This function is used to set whether the workbook can be edited
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {boolean} value - A value that controls whether the workbook can be edited
+   *
+   */
+  setWorkbookEditPermission(unitId, value) {
+    this.setWorkbookPermissionPoint(unitId, WorkbookEditablePermission, value);
+  }
+  /**
+   * This function is used to add a base permission for a worksheet.
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {string} subUnitId - The unique identifier of the worksheet for which the permission is being set.
+   *
+   * @returns {Promise<string | undefined>} - Returns the `permissionId` if the permission is successfully added. If the operation fails or no result is returned, it resolves to `undefined`.
+   */
+  async addWorksheetBasePermission(unitId, subUnitId) {
+    if (this._rangeProtectionRuleModel.getSubunitRuleList(unitId, subUnitId).length > 0)
+      throw new Error("sheet protection cannot intersect with range protection");
+    const permissionId = await this._authzIoService.create({ objectType: UnitObject.Worksheet });
+    if (this._commandService.syncExecuteCommand(AddWorksheetProtectionMutation.id, {
+      unitId,
+      subUnitId,
+      rule: {
+        permissionId,
+        unitType: UnitObject.Worksheet,
+        unitId,
+        subUnitId
+      }
+    }))
+      return permissionId;
+  }
+  /**
+   * Delete the entire table protection set for the worksheet and reset the point permissions of the worksheet to true
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {string} subUnitId - The unique identifier of the worksheet for which the permission is being set.
+   */
+  removeWorksheetPermission(unitId, subUnitId) {
+    this._commandService.syncExecuteCommand(DeleteWorksheetProtectionMutation.id, {
+      unitId,
+      subUnitId
+    }), [...getAllWorksheetPermissionPoint(), ...getAllWorksheetPermissionPointByPointPanel()].forEach((F) => {
+      const instance = new F(unitId, subUnitId);
+      this._permissionService.updatePermissionPoint(instance.id, !0);
+    }), this._worksheetProtectionPointRuleModel.deleteRule(unitId, subUnitId);
+  }
+  /**
+   * Sets the worksheet permission point by updating or adding the permission point for the worksheet.
+   * If the worksheet doesn't have a base permission, it creates one to used render
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet.
+   * @param {WorkSheetPermissionPointConstructor} FPointClass - The constructor for the permission point class.
+   *    See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+   * @param {boolean} value - The new permission value to be set for the worksheet.
+   *
+   * @returns {Promise<string | undefined>} - Returns the `permissionId` if the permission point is successfully set or created. If no permission is set, it resolves to `undefined`.
+   */
+  async setWorksheetPermissionPoint(unitId, subUnitId, FPointClass, value) {
+    const hasBasePermission = this._worksheetProtectionRuleModel.getRule(unitId, subUnitId);
+    let permissionId;
+    if (FPointClass === WorksheetEditPermission || FPointClass === WorksheetViewPermission)
+      if (hasBasePermission)
+        permissionId = hasBasePermission.permissionId;
+      else {
+        if (this._rangeProtectionRuleModel.getSubunitRuleList(unitId, subUnitId).length > 0)
+          throw new Error("sheet protection cannot intersect with range protection");
+        permissionId = await this.addWorksheetBasePermission(unitId, subUnitId);
+      }
+    else {
+      const rule = this._worksheetProtectionPointRuleModel.getRule(unitId, subUnitId);
+      rule ? permissionId = rule.permissionId : (permissionId = await this._authzIoService.create({ objectType: UnitObject.Worksheet }), this._commandService.executeCommand(SetWorksheetPermissionPointsMutation.id, { unitId, subUnitId, permissionId }));
+    }
+    const instance = new FPointClass(unitId, subUnitId);
+    return this._permissionService.getPermissionPoint(instance.id) || this._permissionService.addPermissionPoint(instance), this._permissionService.updatePermissionPoint(instance.id, value), permissionId;
+  }
+  /**
+   * Adds a range protection to the worksheet.
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet.
+   * @param {IRange[]} ranges - The ranges to be protected.
+   *
+   * @returns {Promise<{ permissionId: string, ruleId: string } | undefined>} - Returns an object containing the `permissionId` and `ruleId` if the range protection is successfully added. If the operation fails or no result is returned, it resolves to `undefined`. permissionId is used to stitch permission point ID，ruleId is used to store permission rules
+   */
+  async addRangeBaseProtection(unitId, subUnitId, ranges) {
+    const permissionId = await this._authzIoService.create({ objectType: UnitObject.SelectRange }), ruleId = `ruleId_${generateRandomId(6)}`;
+    if (this._worksheetProtectionRuleModel.getRule(unitId, subUnitId))
+      throw new Error("sheet protection cannot intersect with range protection");
+    if (this._rangeProtectionRuleModel.getSubunitRuleList(unitId, subUnitId).some((rule) => rule.ranges.some((range) => ranges.some((newRange) => Rectangle.intersects(newRange, range)))))
+      throw new Error("range protection cannot intersect");
+    if (this._commandService.syncExecuteCommand(AddRangeProtectionMutation.id, {
+      unitId,
+      subUnitId,
+      rules: [{
+        permissionId,
+        unitType: UnitObject.SelectRange,
+        unitId,
+        subUnitId,
+        ranges,
+        id: ruleId
+      }]
+    }))
+      return {
+        permissionId,
+        ruleId
+      };
+  }
+  /**
+   * Removes the range protection from the worksheet.
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet.
+   * @param {string[]} ruleIds - The rule IDs of the range protection to be removed.
+   */
+  removeRangeProtection(unitId, subUnitId, ruleIds) {
+    this._commandService.syncExecuteCommand(DeleteRangeProtectionMutation.id, {
+      unitId,
+      subUnitId,
+      ruleIds
+    }) && this._rangeProtectionRuleModel.getSubunitRuleList(unitId, subUnitId).length === 0 && (this._worksheetProtectionPointRuleModel.deleteRule(unitId, subUnitId), [...getAllWorksheetPermissionPointByPointPanel()].forEach((F) => {
+      const instance = new F(unitId, subUnitId);
+      this._permissionService.updatePermissionPoint(instance.id, instance.value);
+    }));
+  }
+  /**
+   * Modify the permission points of a custom area
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet within the workbook.
+   * @param {string} permissionId - The unique identifier of the permission that controls access to the range.
+   * @param {RangePermissionPointConstructor} FPointClass - The constructor for the range permission point class.
+   *    See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+   * @param {boolean} value - The new permission value to be set for the range (e.g., true for allowing access, false for restricting access).
+   */
+  setRangeProtectionPermissionPoint(unitId, subUnitId, permissionId, FPointClass, value) {
+    const instance = new FPointClass(unitId, subUnitId, permissionId);
+    this._permissionService.getPermissionPoint(instance.id) || this._permissionService.addPermissionPoint(instance), this._permissionService.updatePermissionPoint(instance.id, value);
+  }
+  /**
+   * Sets the ranges for range protection in a worksheet.
+   *
+   * This method finds the rule by unitId, subUnitId, and ruleId, and updates the rule with the provided ranges.
+   * It checks for overlaps with existing ranges in the same subunit and shows an error message if any overlap is detected.
+   * If no overlap is found, it executes the command to update the range protection with the new ranges.
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet within the workbook.
+   * @param {string} ruleId - The ruleId of the range protection rule that is being updated.
+   * @param {IRange[]} ranges - The array of new ranges to be set for the range protection rule.
+   */
+  setRangeProtectionRanges(unitId, subUnitId, ruleId, ranges) {
+    const rule = this._rangeProtectionRuleModel.getRule(unitId, subUnitId, ruleId);
+    if (rule) {
+      if (this._rangeProtectionRuleModel.getSubunitRuleList(unitId, subUnitId).filter((r) => r.id !== ruleId).some((rule2) => rule2.ranges.some((range) => ranges.some((newRange) => Rectangle.intersects(newRange, range)))))
+        throw new Error("range protection cannot intersect");
+      this._commandService.syncExecuteCommand(SetRangeProtectionMutation.id, {
+        unitId,
+        subUnitId,
+        ruleId,
+        rule: {
+          ...rule,
+          ranges
+        }
+      });
+    }
+  }
+}, __name(_a, "FPermission"), _a);
+FPermission = __decorateClass$4([
+  __decorateParam$4(0, Inject(Injector)),
+  __decorateParam$4(1, ICommandService),
+  __decorateParam$4(2, IPermissionService),
+  __decorateParam$4(3, Inject(WorksheetProtectionRuleModel)),
+  __decorateParam$4(4, Inject(RangeProtectionRuleModel)),
+  __decorateParam$4(5, Inject(WorksheetProtectionPointModel)),
+  __decorateParam$4(6, Inject(IAuthzIoService))
+], FPermission);
+function transformFacadeHorizontalAlignment(value) {
+  switch (value) {
+    case "left":
+      return HorizontalAlign.LEFT;
+    case "center":
+      return HorizontalAlign.CENTER;
+    case "normal":
+      return HorizontalAlign.RIGHT;
+    default:
+      throw new Error(`Invalid horizontal alignment: ${value}`);
+  }
+}
+__name(transformFacadeHorizontalAlignment, "transformFacadeHorizontalAlignment");
+function transformCoreHorizontalAlignment(value) {
+  switch (value) {
+    case HorizontalAlign.LEFT:
+      return "left";
+    case HorizontalAlign.CENTER:
+      return "center";
+    case HorizontalAlign.RIGHT:
+      return "normal";
+    default:
+      throw new Error(`Invalid horizontal alignment: ${value}`);
+  }
+}
+__name(transformCoreHorizontalAlignment, "transformCoreHorizontalAlignment");
+function transformFacadeVerticalAlignment(value) {
+  switch (value) {
+    case "top":
+      return VerticalAlign.TOP;
+    case "middle":
+      return VerticalAlign.MIDDLE;
+    case "bottom":
+      return VerticalAlign.BOTTOM;
+    default:
+      throw new Error(`Invalid vertical alignment: ${value}`);
+  }
+}
+__name(transformFacadeVerticalAlignment, "transformFacadeVerticalAlignment");
+function transformCoreVerticalAlignment(value) {
+  switch (value) {
+    case VerticalAlign.TOP:
+      return "top";
+    case VerticalAlign.MIDDLE:
+      return "middle";
+    case VerticalAlign.BOTTOM:
+      return "bottom";
+    default:
+      throw new Error(`Invalid vertical alignment: ${value}`);
+  }
+}
+__name(transformCoreVerticalAlignment, "transformCoreVerticalAlignment");
+function covertCellValue(value) {
+  return isFormulaString(value) ? {
+    f: value
+  } : isCellV(value) ? {
+    v: value
+  } : (isICellData(value), value);
+}
+__name(covertCellValue, "covertCellValue");
+function covertCellValues(value, range) {
+  const cellValue = new ObjectMatrix(), { startRow, startColumn, endRow, endColumn } = range;
+  if (Tools.isArray(value))
+    for (let r = 0; r <= endRow - startRow; r++)
+      for (let c = 0; c <= endColumn - startColumn; c++)
+        cellValue.setValue(r + startRow, c + startColumn, covertCellValue(value[r][c]));
+  else
+    new ObjectMatrix(value).forValue((r, c, v) => {
+      cellValue.setValue(r, c, covertCellValue(v));
+    });
+  return cellValue.getMatrix();
+}
+__name(covertCellValues, "covertCellValues");
+function covertToRowRange(range, worksheet) {
+  return {
+    startRow: range.startRow,
+    endRow: range.endRow,
+    startColumn: 0,
+    endColumn: worksheet.getColumnCount() - 1,
+    rangeType: RANGE_TYPE.ROW
+  };
+}
+__name(covertToRowRange, "covertToRowRange");
+function covertToColRange(range, worksheet) {
+  return {
+    startRow: 0,
+    endRow: worksheet.getRowCount() - 1,
+    startColumn: range.startColumn,
+    endColumn: range.endColumn,
+    rangeType: RANGE_TYPE.COLUMN
+  };
+}
+__name(covertToColRange, "covertToColRange");
+var __defProp$3 = Object.defineProperty, __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor, __decorateClass$3 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$3(target, key, result), result;
+}, "__decorateClass$3"), __decorateParam$3 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$3"), _a2;
+let FRange = (_a2 = class extends FBase {
+  constructor(_workbook, _worksheet, _range, _injector, _commandService, _formulaDataModel) {
+    super(), this._workbook = _workbook, this._worksheet = _worksheet, this._range = _range, this._injector = _injector, this._commandService = _commandService, this._formulaDataModel = _formulaDataModel;
+  }
+  /**
+   * Get the unit ID of the current workbook
+   *
+   * @return The unit ID of the workbook
+   */
+  getUnitId() {
+    return this._workbook.getUnitId();
+  }
+  /**
+   * Gets the name of the worksheet
+   *
+   * @return The name of the worksheet
+   */
+  getSheetName() {
+    return this._worksheet.getName();
+  }
+  /**
+   * Gets the area where the statement is applied
+   *
+   * @return The area where the statement is applied
+   */
+  getRange() {
+    return this._range;
+  }
+  /**
+   * Gets the starting row number of the applied area
+   *
+   * @return The starting row number of the area
+   */
+  getRow() {
+    return this._range.startRow;
+  }
+  /**
+   * Gets the starting column number of the applied area
+   *
+   * @return The starting column number of the area
+   */
+  getColumn() {
+    return this._range.startColumn;
+  }
+  /**
+   * Gets the width of the applied area
+   *
+   * @return The width of the area
+   */
+  getWidth() {
+    return this._range.endColumn - this._range.startColumn + 1;
+  }
+  /**
+   * Gets the height of the applied area
+   *
+   * @return The height of the area
+   */
+  getHeight() {
+    return this._range.endRow - this._range.startRow + 1;
+  }
+  /**
+   * Return first cell model data in this range
+   * @returns The cell model data
+   */
+  getCellData() {
+    var _a6;
+    return (_a6 = this._worksheet.getCell(this._range.startRow, this._range.startColumn)) != null ? _a6 : null;
+  }
+  /**
+   * Return range whether this range is merged
+   * @returns if true is merged
+   */
+  isMerged() {
+    const { startColumn, startRow, endColumn, endRow } = this._range;
+    return this._worksheet.getMergedCellRange(startRow, startColumn, endRow, endColumn).some((range) => Rectangle.equals(range, this._range));
+  }
+  /**
+   * Return first cell style data in this range
+   * @returns The cell style data
+   */
+  getCellStyleData() {
+    var _a6;
+    const cell = this.getCellData(), styles = this._workbook.getStyles();
+    return cell && styles && (_a6 = styles.getStyleByCell(cell)) != null ? _a6 : null;
+  }
+  /**
+   * Returns the value of the cell at the start of this range.
+   * @returns The value of the cell.
+   */
+  getValue() {
+    var _a6, _b;
+    return (_b = (_a6 = this._worksheet.getCell(this._range.startRow, this._range.startColumn)) == null ? void 0 : _a6.v) != null ? _b : null;
+  }
+  /**
+   * Returns the rectangular grid of values for this range.
+   * Returns a two-dimensional array of values, indexed by row, then by column.
+   * @returns A two-dimensional array of values.
+   */
+  getValues() {
+    var _a6, _b;
+    const { startRow, endRow, startColumn, endColumn } = this._range, range = [];
+    for (let r = startRow; r <= endRow; r++) {
+      const row = [];
+      for (let c = startColumn; c <= endColumn; c++)
+        row.push((_b = (_a6 = this._worksheet.getCell(r, c)) == null ? void 0 : _a6.v) != null ? _b : null);
+      range.push(row);
+    }
+    return range;
+  }
+  /**
+   * Returns the cell data for the cells in the range.
+   * @returns A two-dimensional array of cell data.
+   */
+  getCellDataGrid() {
+    const { startRow, endRow, startColumn, endColumn } = this._range, range = [];
+    for (let r = startRow; r <= endRow; r++) {
+      const row = [];
+      for (let c = startColumn; c <= endColumn; c++)
+        row.push(this._worksheet.getCellRaw(r, c));
+      range.push(row);
+    }
+    return range;
+  }
+  /**
+   * Returns the formulas (A1 notation) for the cells in the range. Entries in the 2D array are empty strings for cells with no formula.
+   * @returns A two-dimensional array of formulas in string format.
+   */
+  getFormulas() {
+    const formulas = [], { startRow, endRow, startColumn, endColumn } = this._range, sheetId = this._worksheet.getSheetId(), unitId = this._workbook.getUnitId();
+    for (let row = startRow; row <= endRow; row++) {
+      const rowFormulas = [];
+      for (let col = startColumn; col <= endColumn; col++) {
+        const formulaString = this._formulaDataModel.getFormulaStringByCell(row, col, sheetId, unitId);
+        rowFormulas.push(formulaString || "");
+      }
+      formulas.push(rowFormulas);
+    }
+    return formulas;
+  }
+  getWrap() {
+    return this._worksheet.getRange(this._range).getWrap() === BooleanNumber.TRUE;
+  }
+  getWrapStrategy() {
+    return this._worksheet.getRange(this._range).getWrapStrategy();
+  }
+  getHorizontalAlignment() {
+    return transformCoreHorizontalAlignment(this._worksheet.getRange(this._range).getHorizontalAlignment());
+  }
+  getVerticalAlignment() {
+    return transformCoreVerticalAlignment(this._worksheet.getRange(this._range).getVerticalAlignment());
+  }
+  // #region editing
+  setBackgroundColor(color) {
+    return this._commandService.executeCommand(SetStyleCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: {
+        type: "bg",
+        value: {
+          rgb: color
+        }
+      }
+    });
+  }
+  /**
+   * The value can be a number, string, boolean, or standard cell format. If it begins with `=`, it is interpreted as a formula. The value is tiled to all cells in the range.
+   * @param value
+   */
+  setValue(value) {
+    const realValue = covertCellValue(value);
+    if (!realValue)
+      throw new Error("Invalid value");
+    return this._commandService.executeCommand(SetRangeValuesCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: realValue
+    });
+  }
+  /**
+   * Set the cell wrap of the given range.
+   * Cells with wrap enabled (the default) resize to display their full content. Cells with wrap disabled display as much as possible in the cell without resizing or running to multiple lines.
+   */
+  setWrap(isWrapEnabled) {
+    return this._commandService.executeCommand(SetTextWrapCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: isWrapEnabled ? WrapStrategy.WRAP : WrapStrategy.UNSPECIFIED
+    });
+  }
+  /**
+   * Sets the text wrapping strategy for the cells in the range.
+   */
+  setWrapStrategy(strategy) {
+    return this._commandService.executeCommand(SetTextWrapCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: strategy
+    });
+  }
+  /**
+   * Set the vertical (top to bottom) alignment for the given range (top/middle/bottom).
+   */
+  setVerticalAlignment(alignment) {
+    return this._commandService.executeCommand(SetVerticalTextAlignCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: transformFacadeVerticalAlignment(alignment)
+    });
+  }
+  /**
+   * Set the horizontal (left to right) alignment for the given range (left/center/right).
+   */
+  setHorizontalAlignment(alignment) {
+    return this._commandService.executeCommand(SetHorizontalTextAlignCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: transformFacadeHorizontalAlignment(alignment)
+    });
+  }
+  /**
+   * Sets a different value for each cell in the range. The value can be a two-dimensional array or a standard range matrix (must match the dimensions of this range), consisting of numbers, strings, Boolean values or Composed of standard cell formats. If a value begins with `=`, it is interpreted as a formula.
+   * @param value
+   */
+  setValues(value) {
+    const realValue = covertCellValues(value, this._range);
+    return this._commandService.executeCommand(SetRangeValuesCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: realValue
+    });
+  }
+  /**
+   * Sets the font weight for the given range (normal/bold),
+   * @param fontWeight The font weight, either 'normal' or 'bold'; a null value resets the font weight.
+   */
+  setFontWeight(fontWeight) {
+    let value;
+    if (fontWeight === "bold")
+      value = BooleanNumber.TRUE;
+    else if (fontWeight === "normal")
+      value = BooleanNumber.FALSE;
+    else if (fontWeight === null)
+      value = null;
+    else
+      throw new Error("Invalid fontWeight");
+    const style = {
+      type: "bl",
+      value
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    return this._commandService.executeCommand(SetStyleCommand.id, setStyleParams), this;
+  }
+  /**
+   * Sets the font style for the given range ('italic' or 'normal').
+   * @param fontStyle The font style, either 'italic' or 'normal'; a null value resets the font style.
+   */
+  setFontStyle(fontStyle) {
+    let value;
+    if (fontStyle === "italic")
+      value = BooleanNumber.TRUE;
+    else if (fontStyle === "normal")
+      value = BooleanNumber.FALSE;
+    else if (fontStyle === null)
+      value = null;
+    else
+      throw new Error("Invalid fontStyle");
+    const style = {
+      type: "it",
+      value
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    return this._commandService.executeCommand(SetStyleCommand.id, setStyleParams), this;
+  }
+  /**
+   * Sets the font line style of the given range ('underline', 'line-through', or 'none').
+   * @param fontLine The font line style, either 'underline', 'line-through', or 'none'; a null value resets the font line style.
+   */
+  setFontLine(fontLine) {
+    if (fontLine === "underline")
+      this._setFontUnderline({
+        s: BooleanNumber.TRUE
+      });
+    else if (fontLine === "line-through")
+      this._setFontStrikethrough({
+        s: BooleanNumber.TRUE
+      });
+    else if (fontLine === "none")
+      this._setFontUnderline({
+        s: BooleanNumber.FALSE
+      }), this._setFontStrikethrough({
+        s: BooleanNumber.FALSE
+      });
+    else if (fontLine === null)
+      this._setFontUnderline(null), this._setFontStrikethrough(null);
+    else
+      throw new Error("Invalid fontLine");
+    return this;
+  }
+  /**
+   * Sets the font underline style of the given ITextDecoration
+   */
+  _setFontUnderline(value) {
+    const style = {
+      type: "ul",
+      value
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    this._commandService.executeCommand(SetStyleCommand.id, setStyleParams);
+  }
+  /**
+   * Sets the font strikethrough style of the given ITextDecoration
+   */
+  _setFontStrikethrough(value) {
+    const style = {
+      type: "st",
+      value
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    this._commandService.executeCommand(SetStyleCommand.id, setStyleParams);
+  }
+  /**
+   * Sets the font family, such as "Arial" or "Helvetica".
+   * @param fontFamily The font family to set; a null value resets the font family.
+   */
+  setFontFamily(fontFamily) {
+    const style = {
+      type: "ff",
+      value: fontFamily
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    return this._commandService.executeCommand(SetStyleCommand.id, setStyleParams), this;
+  }
+  /**
+   * Sets the font size, with the size being the point size to use.
+   * @param size A font size in point size. A null value resets the font size.
+   */
+  setFontSize(size) {
+    const style = {
+      type: "fs",
+      value: size
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    return this._commandService.executeCommand(SetStyleCommand.id, setStyleParams), this;
+  }
+  /**
+   * Sets the font color in CSS notation (such as '#ffffff' or 'white').
+   * @param color The font color in CSS notation (such as '#ffffff' or 'white'); a null value resets the color.
+   */
+  setFontColor(color) {
+    const style = {
+      type: "cl",
+      value: color === null ? null : { rgb: color }
+    }, setStyleParams = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style
+    };
+    return this._commandService.executeCommand(SetStyleCommand.id, setStyleParams), this;
+  }
+  // #endregion editing
+  //#region Merge cell
+  /**
+   * Merge cells in a range into one merged cell
+   * @returns This range, for chaining
+   */
+  async merge() {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId();
+    return await addMergeCellsUtil(this._injector, unitId, subUnitId, [this._range]), this;
+  }
+  /**
+   * Merges cells in a range horizontally.
+   * @returns This range, for chaining
+   */
+  async mergeAcross() {
+    const ranges = getAddMergeMutationRangeByType([this._range], Dimension.ROWS), unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId();
+    return await addMergeCellsUtil(this._injector, unitId, subUnitId, ranges), this;
+  }
+  /**
+   * Merges cells in a range vertically.
+   * @returns This range, for chaining
+   */
+  async mergeVertically() {
+    const ranges = getAddMergeMutationRangeByType([this._range], Dimension.COLUMNS), unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId();
+    return await addMergeCellsUtil(this._injector, unitId, subUnitId, ranges), this;
+  }
+  /**
+   * Returns true if cells in the current range overlap a merged cell.
+   * @returns {boolean} is overlap with a merged cell
+   */
+  isPartOfMerge() {
+    const { startRow, startColumn, endRow, endColumn } = this._range;
+    return this._worksheet.getMergedCellRange(startRow, startColumn, endRow, endColumn).length > 0;
+  }
+  /**
+   * Unmerge cells in the range
+   * @returns This range, for chaining
+   */
+  breakApart() {
+    return this._commandService.executeCommand(RemoveWorksheetMergeCommand.id, { ranges: [this._range] }), this;
+  }
+  //#endregion
+  /**
+   * Iterate cells in this range. Merged cells will be respected.
+   * @param callback
+   */
+  forEach(callback) {
+    const { startColumn, startRow, endColumn, endRow } = this._range;
+    this._worksheet.getMatrixWithMergedCells(startRow, startColumn, endRow, endColumn).forValue((row, col, value) => {
+      callback(row, col, value);
+    });
+  }
+}, __name(_a2, "FRange"), _a2);
+FRange = __decorateClass$3([
+  __decorateParam$3(3, Inject(Injector)),
+  __decorateParam$3(4, ICommandService),
+  __decorateParam$3(5, Inject(FormulaDataModel))
+], FRange);
+var __defProp$2 = Object.defineProperty, __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor, __decorateClass$2 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$2(target, key, result), result;
+}, "__decorateClass$2"), __decorateParam$2 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$2"), _a3;
+let FSelection = (_a3 = class {
+  constructor(_workbook, _worksheet, _selections, _injector) {
+    this._workbook = _workbook, this._worksheet = _worksheet, this._selections = _selections, this._injector = _injector;
+  }
+  getActiveRange() {
+    const active = this._selections.find((selection) => !!selection.primary);
+    return active ? this._injector.createInstance(FRange, this._workbook, this._worksheet, active.range) : null;
+  }
+}, __name(_a3, "FSelection"), _a3);
+FSelection = __decorateClass$2([
+  __decorateParam$2(3, Inject(Injector))
+], FSelection);
+var __defProp$1 = Object.defineProperty, __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor, __decorateClass$1 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$1(target, key, result), result;
+}, "__decorateClass$1"), __decorateParam$1 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$1"), _a4;
+let FWorksheet = (_a4 = class extends FBase {
+  constructor(_fWorkbook, _workbook, _worksheet, _injector, _selectionManagerService, _commandService) {
+    super();
+    /**
+     * Sets the active selection region for this sheet.
+     * @param range The range to set as the active selection.
+     */
+    __publicField(this, "setActiveSelection", this.setActiveRange);
+    this._fWorkbook = _fWorkbook, this._workbook = _workbook, this._worksheet = _worksheet, this._injector = _injector, this._selectionManagerService = _selectionManagerService, this._commandService = _commandService;
+  }
+  /**
+   * Returns the injector
+   * @returns The injector
+   */
+  getInject() {
+    return this._injector;
+  }
+  /**
+   * Returns the workbook
+   * @returns The workbook
+   */
+  getWorkbook() {
+    return this._workbook;
+  }
+  /**
+   * Returns the worksheet id
+   * @returns The id of the worksheet
+   */
+  getSheetId() {
+    return this._worksheet.getSheetId();
+  }
+  /**
+   * Returns the worksheet name
+   * @returns The name of the worksheet
+   */
+  getSheetName() {
+    return this._worksheet.getName();
+  }
+  getSelection() {
+    const selections = this._selectionManagerService.getCurrentSelections();
+    return selections ? this._injector.createInstance(FSelection, this._workbook, this._worksheet, selections) : null;
+  }
+  // #region rows
+  // #region default style
+  /**
+   * Get the default style of the worksheet
+   * @returns Default style
+   */
+  getDefaultStyle() {
+    return this._worksheet.getDefaultCellStyle();
+  }
+  /**
+   * Get the default style of the worksheet row
+   * @param {number} index The row index
+   * @param {boolean} [keepRaw] If true, return the raw style data maybe the style name or style data, otherwise return the data from row manager
+   * @returns {Nullable<IStyleData> | string} The default style of the worksheet row name or style data
+   */
+  getRowDefaultStyle(index, keepRaw = !1) {
+    return this._worksheet.getRowStyle(index, keepRaw);
+  }
+  /**
+   * Get the default style of the worksheet column
+   * @param {number} index The column index
+   * @param  {boolean} [keepRaw] If true, return the raw style data maybe the style name or style data, otherwise return the data from col manager
+   * @returns {Nullable<IStyleData> | string} The default style of the worksheet column name or style data
+   */
+  getColumnDefaultStyle(index, keepRaw = !1) {
+    return this._worksheet.getColumnStyle(index, keepRaw);
+  }
+  /**
+   * Set the default style of the worksheet
+   * @param style default style
+   * @returns this worksheet
+   */
+  async setDefaultStyle(style) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId();
+    return await this._commandService.executeCommand(SetWorksheetDefaultStyleMutation.id, {
+      unitId,
+      subUnitId,
+      defaultStyle: style
+    }), this._worksheet.setDefaultCellStyle(style), this;
+  }
+  /**
+   * Set the default style of the worksheet row
+   * @param {number} index The row index
+   * @param {string | Nullable<IStyleData>} style The style name or style data
+   */
+  async setColumnDefaultStyle(index, style) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), params = {
+      unitId,
+      subUnitId,
+      columnData: {
+        [index]: {
+          s: style
+        }
+      }
+    };
+    return await this._commandService.executeCommand(SetColDataCommand.id, params), this;
+  }
+  /**
+   * Set the default style of the worksheet column
+   * @param {number} index The column index
+   * @param {string | Nullable<IStyleData>} style The style name or style data
+   */
+  async setRowDefaultStyle(index, style) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), params = {
+      unitId,
+      subUnitId,
+      rowData: {
+        [index]: {
+          s: style
+        }
+      }
+    };
+    return await this._commandService.executeCommand(SetRowDataCommand.id, params), this;
+  }
+  getRange(rowOrA1Notation, column, numRows, numColumns) {
+    let range, sheet;
+    if (typeof rowOrA1Notation == "string") {
+      const { range: parsedRange, sheetName } = deserializeRangeWithSheet(rowOrA1Notation), rangeSheet = sheetName ? this._workbook.getSheetBySheetName(sheetName) : this._worksheet;
+      if (!rangeSheet)
+        throw new Error("Range not found");
+      sheet = rangeSheet, range = {
+        ...parsedRange,
+        unitId: this._workbook.getUnitId(),
+        sheetId: sheet.getSheetId(),
+        // Use the current range instead of the future actual range to match Apps Script behavior.
+        // Users can create the latest range in real time when needed.
+        rangeType: RANGE_TYPE.NORMAL,
+        startRow: parsedRange.rangeType === RANGE_TYPE.COLUMN ? 0 : parsedRange.startRow,
+        endRow: parsedRange.rangeType === RANGE_TYPE.COLUMN ? sheet.getMaxRows() - 1 : parsedRange.endRow,
+        startColumn: parsedRange.rangeType === RANGE_TYPE.ROW ? 0 : parsedRange.startColumn,
+        endColumn: parsedRange.rangeType === RANGE_TYPE.ROW ? sheet.getMaxColumns() - 1 : parsedRange.endColumn
+      };
+    } else if (typeof rowOrA1Notation == "number" && column !== void 0)
+      sheet = this._worksheet, range = {
+        startRow: rowOrA1Notation,
+        endRow: rowOrA1Notation + (numRows != null ? numRows : 1) - 1,
+        startColumn: column,
+        endColumn: column + (numColumns != null ? numColumns : 1) - 1,
+        unitId: this._workbook.getUnitId(),
+        sheetId: this._worksheet.getSheetId()
+      };
+    else
+      throw new Error("Invalid range specification");
+    return this._injector.createInstance(FRange, this._workbook, sheet, range);
+  }
+  /**
+   * Returns the current number of columns in the sheet, regardless of content.
+   * @return The maximum columns count of the sheet
+   */
+  getMaxColumns() {
+    return this._worksheet.getMaxColumns();
+  }
+  /**
+   * Returns the current number of rows in the sheet, regardless of content.
+   * @return The maximum rows count of the sheet
+   */
+  getMaxRows() {
+    return this._worksheet.getMaxRows();
+  }
+  /**
+   * Inserts a row after the given row position.
+   * @param afterPosition The row after which the new row should be added, starting at 0 for the first row.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowAfter(afterPosition) {
+    return this.insertRowsAfter(afterPosition, 1);
+  }
+  /**
+   * Inserts a row before the given row position.
+   * @param beforePosition The row before which the new row should be added, starting at 0 for the first row.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowBefore(beforePosition) {
+    return this.insertRowsBefore(beforePosition, 1);
+  }
+  /**
+   * Inserts one or more consecutive blank rows in a sheet starting at the specified location.
+   * @param rowIndex The index indicating where to insert a row, starting at 0 for the first row.
+   * @param numRows The number of rows to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertRows(rowIndex, numRows = 1) {
+    return this.insertRowsBefore(rowIndex, numRows);
+  }
+  /**
+   * Inserts a number of rows after the given row position.
+   * @param afterPosition The row after which the new rows should be added, starting at 0 for the first row.
+   * @param howMany The number of rows to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowsAfter(afterPosition, howMany) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), direction = Direction.DOWN, startRow = afterPosition + 1, endRow = afterPosition + howMany, startColumn = 0, endColumn = this._worksheet.getColumnCount() - 1, cellValue = copyRangeStyles(this._worksheet, startRow, endRow, startColumn, endColumn, !0, afterPosition);
+    return await this._commandService.executeCommand(InsertRowCommand.id, {
+      unitId,
+      subUnitId,
+      direction,
+      range: {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn
+      },
+      cellValue
+    }), this;
+  }
+  /**
+   * Inserts a number of rows before the given row position.
+   * @param beforePosition The row before which the new rows should be added, starting at 0 for the first row.
+   * @param howMany The number of rows to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowsBefore(beforePosition, howMany) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), direction = Direction.UP, startRow = beforePosition, endRow = beforePosition + howMany - 1, startColumn = 0, endColumn = this._worksheet.getColumnCount() - 1, cellValue = copyRangeStyles(this._worksheet, startRow, endRow, startColumn, endColumn, !0, beforePosition - 1);
+    return await this._commandService.executeCommand(InsertRowCommand.id, {
+      unitId,
+      subUnitId,
+      direction,
+      range: {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn
+      },
+      cellValue
+    }), this;
+  }
+  /**
+   * Deletes the row at the given row position.
+   * @param rowPosition The position of the row, starting at 0 for the first row.
+   * @returns This sheet, for chaining.
+   */
+  async deleteRow(rowPosition) {
+    return this.deleteRows(rowPosition, 1);
+  }
+  /**
+   * Deletes a number of rows starting at the given row position.
+   * @param rowPosition The position of the first row to delete, starting at 0 for the first row.
+   * @param howMany The number of rows to delete.
+   * @returns This sheet, for chaining.
+   */
+  async deleteRows(rowPosition, howMany) {
+    const range = {
+      startRow: rowPosition,
+      endRow: rowPosition + howMany - 1,
+      startColumn: 0,
+      endColumn: this._worksheet.getColumnCount() - 1
+    };
+    return await this._commandService.executeCommand(RemoveRowCommand.id, {
+      range
+    }), this;
+  }
+  /**
+   * Moves the rows selected by the given range to the position indicated by the destinationIndex. The rowSpec itself does not have to exactly represent an entire row or group of rows to move—it selects all rows that the range spans.
+   * @param rowSpec A range spanning the rows that should be moved.
+   * @param destinationIndex The index that the rows should be moved to. Note that this index is based on the coordinates before the rows are moved. Existing data is shifted down to make room for the moved rows while the source rows are removed from the grid. Therefore, the data may end up at a different index than originally specified. Use 0-index for this method.
+   * @returns This sheet, for chaining.
+   */
+  async moveRows(rowSpec, destinationIndex) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = covertToRowRange(rowSpec.getRange(), this._worksheet), fromRange = range, toRange = {
+      startRow: destinationIndex,
+      endRow: destinationIndex,
+      startColumn: range.startColumn,
+      endColumn: range.endColumn
+    };
+    return await this._commandService.executeCommand(MoveRowsCommand.id, {
+      unitId,
+      subUnitId,
+      range,
+      fromRange,
+      toRange
+    }), this;
+  }
+  /**
+   * Hides the rows in the given range.
+   * @param row The row range to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideRow(row) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = covertToRowRange(row.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(SetRowHiddenCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Hides one or more consecutive rows starting at the given index. Use 0-index for this method.
+   * @param rowIndex The starting index of the rows to hide.
+   * @param numRows The number of rows to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideRows(rowIndex, numRows = 1) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = {
+      startRow: rowIndex,
+      endRow: rowIndex + numRows - 1,
+      startColumn: 0,
+      endColumn: this._worksheet.getColumnCount() - 1,
+      rangeType: RANGE_TYPE.ROW
+    };
+    return await this._commandService.executeCommand(SetRowHiddenCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Unhides the row in the given range.
+   * @param row The range to unhide, if hidden.
+   * @returns This sheet, for chaining.
+   */
+  async unhideRow(row) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = covertToRowRange(row.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(SetSpecificRowsVisibleCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Unhides one or more consecutive rows starting at the given index. Use 0-index for this method.
+   * @param rowIndex The starting index of the rows to unhide.
+   * @param numRows The number of rows to unhide.
+   * @returns This sheet, for chaining.
+   */
+  async showRows(rowIndex, numRows = 1) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = {
+      startRow: rowIndex,
+      endRow: rowIndex + numRows - 1,
+      startColumn: 0,
+      endColumn: this._worksheet.getColumnCount() - 1,
+      rangeType: RANGE_TYPE.ROW
+    };
+    return await this._commandService.executeCommand(SetSpecificRowsVisibleCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Sets the row height of the given row in pixels. By default, rows grow to fit cell contents. If you want to force rows to a specified height, use setRowHeightsForced(startRow, numRows, height).
+   * @param rowPosition The row position to change.
+   * @param height The height in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setRowHeight(rowPosition, height) {
+    return this.setRowHeights(rowPosition, 1, height);
+  }
+  /**
+   * Sets the height of the given rows in pixels. By default, rows grow to fit cell contents. If you want to force rows to a specified height, use setRowHeightsForced(startRow, numRows, height).
+   * @param startRow The starting row position to change.
+   * @param numRows The number of rows to change.
+   * @param height The height in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setRowHeights(startRow, numRows, height) {
+    var _a6;
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), rowManager = this._worksheet.getRowManager(), autoHeightRanges = [], rowHeightRanges = [];
+    for (let i = startRow; i < startRow + numRows; i++) {
+      const autoRowHeight = ((_a6 = rowManager.getRow(i)) == null ? void 0 : _a6.ah) || this._worksheet.getConfig().defaultRowHeight, range = {
+        startRow: i,
+        endRow: i,
+        startColumn: 0,
+        endColumn: this._worksheet.getColumnCount() - 1
+      };
+      height <= autoRowHeight ? autoHeightRanges.push(range) : rowHeightRanges.push(range);
+    }
+    return rowHeightRanges.length > 0 && await this._commandService.executeCommand(SetRowHeightCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: rowHeightRanges,
+      value: height
+    }), autoHeightRanges.length > 0 && await this._commandService.executeCommand(SetWorksheetRowIsAutoHeightCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: autoHeightRanges
+    }), this;
+  }
+  /**
+   * Sets the height of the given rows in pixels. By default, rows grow to fit cell contents. When you use setRowHeightsForced, rows are forced to the specified height even if the cell contents are taller than the row height.
+   * @param startRow The starting row position to change.
+   * @param numRows The number of rows to change.
+   * @param height The height in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setRowHeightsForced(startRow, numRows, height) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), ranges = [
+      {
+        startRow,
+        endRow: startRow + numRows - 1,
+        startColumn: 0,
+        endColumn: this._worksheet.getColumnCount() - 1
+      }
+    ];
+    return await this._commandService.executeCommand(SetRowHeightCommand.id, {
+      unitId,
+      subUnitId,
+      ranges,
+      value: height
+    }), this;
+  }
+  // #endregion
+  /**
+   * Set custom properties for given rows.
+   * @param custom The custom properties to set.
+   * @returns This sheet, for chaining.
+   */
+  async setRowCustom(custom) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), rowData = {};
+    for (const [rowIndex, customData] of Object.entries(custom))
+      rowData[Number(rowIndex)] = {
+        custom: customData
+      };
+    const params = {
+      unitId,
+      subUnitId,
+      rowData
+    };
+    return await this._commandService.executeCommand(SetRowDataCommand.id, params), this;
+  }
+  // #region Column
+  /**
+   * Inserts a column after the given column position.
+   * @param afterPosition The column after which the new column should be added, starting at 0 for the first column.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnAfter(afterPosition) {
+    return this.insertColumnsAfter(afterPosition, 1);
+  }
+  /**
+   * Inserts a column before the given column position.
+   * @param beforePosition The column before which the new column should be added, starting at 0 for the first column.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnBefore(beforePosition) {
+    return this.insertColumnsBefore(beforePosition, 1);
+  }
+  /**
+   * Inserts one or more consecutive blank columns in a sheet starting at the specified location.
+   * @param columnIndex The index indicating where to insert a column, starting at 0 for the first column.
+   * @param numColumns The number of columns to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumns(columnIndex, numColumns = 1) {
+    return this.insertColumnsBefore(columnIndex, numColumns);
+  }
+  /**
+   * Inserts a given number of columns after the given column position.
+   * @param afterPosition The column after which the new column should be added, starting at 0 for the first column.
+   * @param howMany The number of columns to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnsAfter(afterPosition, howMany) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), direction = Direction.RIGHT, startRow = 0, endRow = this._worksheet.getRowCount() - 1, startColumn = afterPosition + 1, endColumn = afterPosition + howMany, cellValue = copyRangeStyles(this._worksheet, startRow, endRow, startColumn, endColumn, !1, afterPosition);
+    return await this._commandService.executeCommand(InsertColCommand.id, {
+      unitId,
+      subUnitId,
+      direction,
+      range: {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn
+      },
+      cellValue
+    }), this;
+  }
+  /**
+   * Inserts a number of columns before the given column position.
+   * @param beforePosition The column before which the new column should be added, starting at 0 for the first column.
+   * @param howMany The number of columns to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnsBefore(beforePosition, howMany) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), direction = Direction.LEFT, startRow = 0, endRow = this._worksheet.getRowCount() - 1, startColumn = beforePosition, endColumn = beforePosition + howMany - 1, cellValue = copyRangeStyles(this._worksheet, startRow, endRow, startColumn, endColumn, !1, beforePosition - 1);
+    return await this._commandService.executeCommand(InsertColCommand.id, {
+      unitId,
+      subUnitId,
+      direction,
+      range: {
+        startRow,
+        endRow,
+        startColumn,
+        endColumn
+      },
+      cellValue
+    }), this;
+  }
+  /**
+   * Deletes the column at the given column position.
+   * @param columnPosition The position of the column, starting at 0 for the first column.
+   * @returns This sheet, for chaining.
+   */
+  async deleteColumn(columnPosition) {
+    return this.deleteColumns(columnPosition, 1);
+  }
+  /**
+   * Deletes a number of columns starting at the given column position.
+   * @param columnPosition The position of the first column to delete, starting at 0 for the first column.
+   * @param howMany The number of columns to delete.
+   * @returns This sheet, for chaining.
+   */
+  async deleteColumns(columnPosition, howMany) {
+    const range = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: columnPosition,
+      endColumn: columnPosition + howMany - 1
+    };
+    return await this._commandService.executeCommand(RemoveColCommand.id, {
+      range
+    }), this;
+  }
+  /**
+   * Moves the columns selected by the given range to the position indicated by the destinationIndex. The columnSpec itself does not have to exactly represent an entire column or group of columns to move—it selects all columns that the range spans.
+   * @param columnSpec A range spanning the columns that should be moved.
+   * @param destinationIndex The index that the columns should be moved to. Note that this index is based on the coordinates before the columns are moved. Existing data is shifted right to make room for the moved columns while the source columns are removed from the grid. Therefore, the data may end up at a different index than originally specified. Use 0-index for this method.
+   * @returns This sheet, for chaining.
+   */
+  async moveColumns(columnSpec, destinationIndex) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = covertToColRange(columnSpec.getRange(), this._worksheet), fromRange = range, toRange = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: destinationIndex,
+      endColumn: destinationIndex
+    };
+    return await this._commandService.executeCommand(MoveColsCommand.id, {
+      unitId,
+      subUnitId,
+      range,
+      fromRange,
+      toRange
+    }), this;
+  }
+  /**
+   * Hides the column or columns in the given range.
+   * @param column The column range to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideColumn(column) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = covertToColRange(column.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(SetColHiddenCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Hides one or more consecutive columns starting at the given index. Use 0-index for this method.
+   * @param columnIndex The starting index of the columns to hide.
+   * @param numColumns The number of columns to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideColumns(columnIndex, numColumns = 1) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: columnIndex,
+      endColumn: columnIndex + numColumns - 1,
+      rangeType: RANGE_TYPE.COLUMN
+    };
+    return await this._commandService.executeCommand(SetColHiddenCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Unhides the column in the given range.
+   * @param column The range to unhide, if hidden.
+   * @returns This sheet, for chaining.
+   */
+  async unhideColumn(column) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = covertToColRange(column.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(SetSpecificColsVisibleCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Unhides one or more consecutive columns starting at the given index. Use 0-index for this method.
+   * @param columnIndex The starting index of the columns to unhide.
+   * @param numColumns The number of columns to unhide.
+   * @returns This sheet, for chaining.
+   */
+  async showColumns(columnIndex, numColumns = 1) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), range = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: columnIndex,
+      endColumn: columnIndex + numColumns - 1,
+      rangeType: RANGE_TYPE.COLUMN
+    };
+    return await this._commandService.executeCommand(SetSpecificColsVisibleCommand.id, {
+      unitId,
+      subUnitId,
+      ranges: [range]
+    }), this;
+  }
+  /**
+   * Sets the width of the given column in pixels.
+   * @param columnPosition The position of the given column to set.
+   * @param width The width in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setColumnWidth(columnPosition, width) {
+    return this.setColumnWidths(columnPosition, 1, width);
+  }
+  /**
+   * Sets the width of the given columns in pixels.
+   * @param startColumn The starting column position to change.
+   * @param numColumns The number of columns to change.
+   * @param width The width in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setColumnWidths(startColumn, numColumns, width) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), ranges = [
+      {
+        startColumn,
+        endColumn: startColumn + numColumns - 1,
+        startRow: 0,
+        endRow: this._worksheet.getRowCount() - 1
+      }
+    ];
+    return await this._commandService.executeCommand(SetColWidthCommand.id, {
+      unitId,
+      subUnitId,
+      ranges,
+      value: width
+    }), this;
+  }
+  // #endregion
+  /**
+   * Set custom properties for given columns.
+   * @param custom The custom properties to set.
+   * @returns This sheet, for chaining.
+   */
+  async setColumnCustom(custom) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), columnData = {};
+    for (const [columnIndex, customData] of Object.entries(custom))
+      columnData[Number(columnIndex)] = {
+        custom: customData
+      };
+    const params = {
+      unitId,
+      subUnitId,
+      columnData
+    };
+    return await this._commandService.executeCommand(SetColDataCommand.id, params), this;
+  }
+  // #region merge cells
+  /**
+   * Get all merged cells in the current sheet
+   * @returns all merged cells
+   */
+  getMergedRanges() {
+    return this._worksheet.getSnapshot().mergeData.map((merge) => this._injector.createInstance(FRange, this._workbook, this._worksheet, merge));
+  }
+  /**
+   * Get the merged cell data of the specified row and column.
+   * @param {number} row The row index.
+   * @param {number} column The column index.
+   * @returns {FRange|undefined} The merged cell data, or undefined if the cell is not merged.
+   */
+  getCellMergeData(row, column) {
+    const mergeData = this._worksheet.getMergedCell(row, column);
+    if (mergeData)
+      return this._injector.createInstance(FRange, this._workbook, this._worksheet, mergeData);
+  }
+  // #endregion
+  /**
+   * Returns the selected range in the active sheet, or null if there is no active range.
+   * @returns the active range
+   */
+  getActiveRange() {
+    return this._fWorkbook.getActiveRange();
+  }
+  /**
+   * Sets the active selection region for this sheet.
+   * @param range The range to set as the active selection.
+   */
+  setActiveRange(range) {
+    const { unitId, sheetId } = range.getRange();
+    if (unitId !== this._workbook.getUnitId() || sheetId !== this._worksheet.getSheetId())
+      throw new Error("Specified range must be part of the sheet.");
+    this._fWorkbook.setActiveRange(range);
+  }
+  /**
+   * Sets the frozen state of the current sheet.
+   * @param freeze - The freeze object containing the parameters for freezing the sheet.
+   * @returns True if the command was successful, false otherwise.
+   */
+  setFreeze(freeze) {
+    return this._commandService.syncExecuteCommand(SetFrozenCommand.id, {
+      ...freeze,
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this.getSheetId()
+    });
+  }
+  /**
+   * Cancels the frozen state of the current sheet.
+   * @returns True if the command was successful, false otherwise.
+   */
+  cancelFreeze() {
+    return this._commandService.syncExecuteCommand(CancelFrozenCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this.getSheetId()
+    });
+  }
+  /**
+   * Get the freeze state of the current sheet.
+   * @returns The freeze state of the current sheet.
+   */
+  getFreeze() {
+    return this._worksheet.getFreeze();
+  }
+  /**
+   * Set the number of frozen columns.
+   * @param columns The number of columns to freeze.
+   * To unfreeze all columns, set this value to 0.
+   */
+  setFrozenColumns(columns) {
+    const currentFreeze = this.getFreeze();
+    this.setFreeze({
+      ...currentFreeze,
+      startColumn: columns > 0 ? columns : -1,
+      xSplit: columns
+    });
+  }
+  /**
+   * Set the number of frozen rows.
+   * @param rows The number of rows to freeze.
+   * To unfreeze all rows, set this value to 0.
+   */
+  setFrozenRows(rows) {
+    const currentFreeze = this.getFreeze();
+    this.setFreeze({
+      ...currentFreeze,
+      startRow: rows > 0 ? rows : -1,
+      ySplit: rows
+    });
+  }
+  /**
+   * Get the number of frozen columns.
+   * @returns The number of frozen columns.
+   * Returns 0 if no columns are frozen.
+   */
+  getFrozenColumns() {
+    const freeze = this.getFreeze();
+    return freeze.startColumn === -1 ? 0 : freeze.startColumn;
+  }
+  /**
+   * Get the number of frozen rows.
+   * @returns The number of frozen rows.
+   * Returns 0 if no rows are frozen.
+   */
+  getFrozenRows() {
+    const freeze = this.getFreeze();
+    return freeze.startRow === -1 ? 0 : freeze.startRow;
+  }
+  /**
+   * Returns true if the sheet's gridlines are hidden; otherwise returns false. Gridlines are visible by default.
+   */
+  hasHiddenGridLines() {
+    return this._worksheet.getConfig().showGridlines === BooleanNumber.FALSE;
+  }
+  /**
+   * Hides or reveals the sheet gridlines.
+   * @param {boolean} hidden If `true`, hide gridlines in this sheet; otherwise show the gridlines.
+   */
+  setHiddenGridlines(hidden) {
+    return this._commandService.executeCommand(ToggleGridlinesCommand.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      showGridlines: hidden ? BooleanNumber.FALSE : BooleanNumber.TRUE
+    });
+  }
+  /**
+   * Subscribe to the cell data change event.
+   * @param callback - The callback function to be executed when the cell data changes.
+   * @returns - A disposable object to unsubscribe from the event.
+   */
+  onCellDataChange(callback) {
+    return this._injector.get(ICommandService).onCommandExecuted((command) => {
+      if (command.id === SetRangeValuesMutation.id) {
+        const params = command.params;
+        params.unitId === this._workbook.getUnitId() && params.subUnitId === this._worksheet.getSheetId() && params.cellValue && callback(new ObjectMatrix(params.cellValue));
+      }
+    });
+  }
+  /**
+   * Subscribe to the cell data change event.
+   * @param callback - The callback function to be executed before the cell data changes.
+   * @returns - A disposable object to unsubscribe from the event.
+   */
+  onBeforeCellDataChange(callback) {
+    return this._injector.get(ICommandService).beforeCommandExecuted((command) => {
+      if (command.id === SetRangeValuesMutation.id) {
+        const params = command.params;
+        params.unitId === this._workbook.getUnitId() && params.subUnitId === this._worksheet.getSheetId() && params.cellValue && callback(new ObjectMatrix(params.cellValue));
+      }
+    });
+  }
+}, __name(_a4, "FWorksheet"), _a4);
+FWorksheet = __decorateClass$1([
+  __decorateParam$1(3, Inject(Injector)),
+  __decorateParam$1(4, Inject(SheetsSelectionsService)),
+  __decorateParam$1(5, ICommandService)
+], FWorksheet);
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam"), _a5;
+let FWorkbook = (_a5 = class extends FBase {
+  constructor(_workbook, _injector, _resourceLoaderService, _selectionManagerService, _univerInstanceService, _commandService, _permissionService, _logService) {
+    super();
+    __publicField(this, "id");
+    this._workbook = _workbook, this._injector = _injector, this._resourceLoaderService = _resourceLoaderService, this._selectionManagerService = _selectionManagerService, this._univerInstanceService = _univerInstanceService, this._commandService = _commandService, this._permissionService = _permissionService, this._logService = _logService, this.id = this._workbook.getUnitId();
+  }
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this._workbook.getName();
+  }
+  /**
+   * save workbook snapshot data, including conditional formatting, data validation, and other plugin data.
+   */
+  save() {
+    return this._resourceLoaderService.saveUnit(this._workbook.getUnitId());
+  }
+  /**
+   * @deprecated use 'save' instead.
+   * @return {*}  {IWorkbookData}
+   * @memberof FWorkbook
+   */
+  getSnapshot() {
+    return this._logService.warn("use 'save' instead of 'getSnapshot'"), this.save();
+  }
+  /**
+   * Get the active sheet of the workbook.
+   * @returns The active sheet of the workbook
+   */
+  getActiveSheet() {
+    const activeSheet = this._workbook.getActiveSheet();
+    return this._injector.createInstance(FWorksheet, this, this._workbook, activeSheet);
+  }
+  /**
+   * Gets all the worksheets in this workbook
+   * @returns An array of all the worksheets in the workbook
+   */
+  getSheets() {
+    return this._workbook.getSheets().map((sheet) => this._injector.createInstance(FWorksheet, this, this._workbook, sheet));
+  }
+  /**
+   * Create a new worksheet and returns a handle to it.
+   * @param name Name of the new sheet
+   * @param rows How may rows would the new sheet have
+   * @param column How many columns would the new sheet have
+   * @returns The new created sheet
+   */
+  create(name, rows, column) {
+    const newSheet = mergeWorksheetSnapshotWithDefault({});
+    newSheet.rowCount = rows, newSheet.columnCount = column, newSheet.name = name, newSheet.id = name.toLowerCase().replace(/ /g, "-"), this._commandService.syncExecuteCommand(InsertSheetCommand.id, {
+      unitId: this.id,
+      index: this._workbook.getSheets().length,
+      sheet: newSheet
+    }), this._commandService.syncExecuteCommand(SetWorksheetActiveOperation.id, {
+      unitId: this.id,
+      subUnitId: this._workbook.getSheets()[this._workbook.getSheets().length - 1].getSheetId()
+    });
+    const worksheet = this._workbook.getActiveSheet();
+    if (!worksheet)
+      throw new Error("No active sheet found");
+    return this._injector.createInstance(FWorksheet, this, this._workbook, worksheet);
+  }
+  /**
+   * Get a worksheet by sheet id.
+   * @param sheetId The id of the sheet to get.
+   * @return The worksheet with given sheet id
+   */
+  getSheetBySheetId(sheetId) {
+    const worksheet = this._workbook.getSheetBySheetId(sheetId);
+    return worksheet ? this._injector.createInstance(FWorksheet, this, this._workbook, worksheet) : null;
+  }
+  /**
+   * Get a worksheet by sheet name.
+   * @param name 	The name of the sheet to get.
+   * @returns The worksheet with given sheet name
+   */
+  getSheetByName(name) {
+    const worksheet = this._workbook.getSheetBySheetName(name);
+    return worksheet ? this._injector.createInstance(FWorksheet, this, this._workbook, worksheet) : null;
+  }
+  /**
+   * Sets the given worksheet to be the active worksheet in the workbook.
+   * @param sheet The worksheet to set as the active worksheet.
+   * @returns The active worksheet
+   */
+  setActiveSheet(sheet) {
+    return this._commandService.syncExecuteCommand(SetWorksheetActiveOperation.id, {
+      unitId: this.id,
+      subUnitId: sheet.getSheetId()
+    }), sheet;
+  }
+  /**
+   * Inserts a new worksheet into the workbook.
+   * Using a default sheet name. The new sheet becomes the active sheet
+   * @returns The new sheet
+   */
+  insertSheet() {
+    this._commandService.syncExecuteCommand(InsertSheetCommand.id);
+    const unitId = this.id, subUnitId = this._workbook.getSheets()[this._workbook.getSheets().length - 1].getSheetId();
+    this._commandService.syncExecuteCommand(SetWorksheetActiveOperation.id, {
+      unitId,
+      subUnitId
+    });
+    const worksheet = this._workbook.getActiveSheet();
+    if (!worksheet)
+      throw new Error("No active sheet found");
+    return this._injector.createInstance(FWorksheet, this, this._workbook, worksheet);
+  }
+  /**
+   * Deletes the specified worksheet.
+   * @param sheet The worksheet to delete.
+   */
+  deleteSheet(sheet) {
+    const unitId = this.id, subUnitId = sheet.getSheetId();
+    this._commandService.executeCommand(RemoveSheetCommand.id, {
+      unitId,
+      subUnitId
+    });
+  }
+  // #region editing
+  undo() {
+    return this._univerInstanceService.focusUnit(this.id), this._commandService.executeCommand(UndoCommand.id);
+  }
+  redo() {
+    return this._univerInstanceService.focusUnit(this.id), this._commandService.executeCommand(RedoCommand.id);
+  }
+  /**
+   * Register a callback that will be triggered before invoking a command targeting the Univer sheet.
+   * @param callback the callback.
+   * @returns A function to dispose the listening.
+   */
+  onBeforeCommandExecute(callback) {
+    return this._commandService.beforeCommandExecuted((command) => {
+      var _a6;
+      ((_a6 = command.params) == null ? void 0 : _a6.unitId) === this.id && callback(command);
+    });
+  }
+  /**
+   * Register a callback that will be triggered when a command is invoked targeting the Univer sheet.
+   * @param callback the callback.
+   * @returns A function to dispose the listening.
+   */
+  onCommandExecuted(callback) {
+    return this._commandService.onCommandExecuted((command) => {
+      var _a6;
+      ((_a6 = command.params) == null ? void 0 : _a6.unitId) === this.id && callback(command);
+    });
+  }
+  onSelectionChange(callback) {
+    return toDisposable(
+      this._selectionManagerService.selectionMoveEnd$.subscribe((selections) => {
+        this._univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET).getUnitId() === this.id && (selections != null && selections.length ? callback(selections.map((s) => s.range)) : callback([]));
+      })
+    );
+  }
+  /**
+   * Used to modify the editing permissions of the workbook. When the value is false, editing is not allowed.
+   * @param {boolean} value  editable value want to set
+   */
+  setEditable(value) {
+    const instance = new WorkbookEditablePermission$1(this._workbook.getUnitId());
+    this._permissionService.getPermissionPoint(instance.id) || this._permissionService.addPermissionPoint(instance), this._permissionService.updatePermissionPoint(instance.id, value);
+  }
+  /**
+   * Sets the active selection region for this sheet.
+   * @param range The range to set as the active selection.
+   */
+  setActiveRange(range) {
+    const sheet = this.getActiveSheet(), sheetId = range.getRange().sheetId || sheet.getSheetId(), worksheet = sheetId ? this._workbook.getSheetBySheetId(sheetId) : this._workbook.getActiveSheet(!0);
+    if (!worksheet)
+      throw new Error("No active sheet found");
+    worksheet.getSheetId() !== sheet.getSheetId() && this.setActiveSheet(this._injector.createInstance(FWorksheet, this, this._workbook, worksheet));
+    const setSelectionOperationParams = {
+      unitId: this.getId(),
+      subUnitId: sheetId,
+      selections: [range].map((r) => ({ range: r.getRange(), primary: getPrimaryForRange(r.getRange(), worksheet), style: null }))
+    };
+    this._commandService.syncExecuteCommand(SetSelectionsOperation.id, setSelectionOperationParams);
+  }
+  /**
+   * Returns the selected range in the active sheet, or null if there is no active range.
+   * @returns the active range
+   */
+  getActiveRange() {
+    const activeSheet = this._workbook.getActiveSheet(), active = this._selectionManagerService.getCurrentSelections().find((selection) => !!selection.primary);
+    return active ? this._injector.createInstance(FRange, this._workbook, activeSheet, active.range) : null;
+  }
+}, __name(_a5, "FWorkbook"), _a5);
+FWorkbook = __decorateClass([
+  __decorateParam(1, Inject(Injector)),
+  __decorateParam(2, Inject(IResourceLoaderService)),
+  __decorateParam(3, Inject(SheetsSelectionsService)),
+  __decorateParam(4, IUniverInstanceService),
+  __decorateParam(5, ICommandService),
+  __decorateParam(6, IPermissionService),
+  __decorateParam(7, ILogService)
+], FWorkbook);
+const _FUniverSheetsMixin = class _FUniverSheetsMixin extends FUniver {
+  createUniverSheet(data) {
+    const workbook = this._injector.get(IUniverInstanceService).createUnit(UniverInstanceType.UNIVER_SHEET, data);
+    return this._injector.createInstance(FWorkbook, workbook);
+  }
+  getActiveWorkbook() {
+    const workbook = this._univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET);
+    return workbook ? this._injector.createInstance(FWorkbook, workbook) : null;
+  }
+  getPermission() {
+    return this._injector.createInstance(FPermission);
+  }
+};
+__name(_FUniverSheetsMixin, "FUniverSheetsMixin");
+let FUniverSheetsMixin = _FUniverSheetsMixin;
+FUniver.extend(FUniverSheetsMixin);
+export {
+  FPermission,
+  FRange,
+  FSelection,
+  FWorkbook,
+  FWorksheet
+};