@univerjs/sheets 0.4.2 → 0.5.0-alpha.0

package/lib/types/facade/f-worksheet.d.ts

@@ -0,0 +1,408 @@
+import { CustomData, ICellData, IDisposable, IFreeze, IObjectArrayPrimitiveType, IStyleData, Nullable, Workbook, Worksheet, FBase, ICommandService, Injector, ObjectMatrix } from '@univerjs/core';
+import { FWorkbook } from './f-workbook';
+import { SheetsSelectionsService } from '@univerjs/sheets';
+import { FRange } from './f-range';
+import { FSelection } from './f-selection';
+export declare class FWorksheet extends FBase {
+    protected readonly _fWorkbook: FWorkbook;
+    protected readonly _workbook: Workbook;
+    protected readonly _worksheet: Worksheet;
+    protected readonly _injector: Injector;
+    protected readonly _selectionManagerService: SheetsSelectionsService;
+    protected readonly _commandService: ICommandService;
+    constructor(_fWorkbook: FWorkbook, _workbook: Workbook, _worksheet: Worksheet, _injector: Injector, _selectionManagerService: SheetsSelectionsService, _commandService: ICommandService);
+    /**
+     * Returns the injector
+     * @returns The injector
+     */
+    getInject(): Injector;
+    /**
+     * Returns the workbook
+     * @returns The workbook
+     */
+    getWorkbook(): Workbook;
+    /**
+     * Returns the worksheet id
+     * @returns The id of the worksheet
+     */
+    getSheetId(): string;
+    /**
+     * Returns the worksheet name
+     * @returns The name of the worksheet
+     */
+    getSheetName(): string;
+    getSelection(): FSelection | null;
+    /**
+     * Get the default style of the worksheet
+     * @returns Default style
+     */
+    getDefaultStyle(): Nullable<IStyleData> | string;
+    /**
+     * 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: number, keepRaw?: boolean): Nullable<IStyleData> | string;
+    /**
+     * 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: number, keepRaw?: boolean): Nullable<IStyleData> | string;
+    /**
+     * Set the default style of the worksheet
+     * @param style default style
+     * @returns this worksheet
+     */
+    setDefaultStyle(style: string): Promise<FWorksheet>;
+    /**
+     * 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
+     */
+    setColumnDefaultStyle(index: number, style: string | Nullable<IStyleData>): Promise<FWorksheet>;
+    /**
+     * 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
+     */
+    setRowDefaultStyle(index: number, style: string | Nullable<IStyleData>): Promise<FWorksheet>;
+    /**
+     * Returns a Range object representing a single cell at the specified row and column.
+     * @param row The row index of the cell.
+     * @param column The column index of the cell.
+     * @returns A Range object representing the specified cell.
+     */
+    getRange(row: number, column: number): FRange;
+    /**
+     * Returns a Range object representing a range starting at the specified row and column, with the specified number of rows.
+     * @param row The starting row index of the range.
+     * @param column The starting column index of the range.
+     * @param numRows The number of rows in the range.
+     * @returns A Range object representing the specified range.
+     */
+    getRange(row: number, column: number, numRows: number): FRange;
+    /**
+     * Returns a Range object representing a range starting at the specified row and column, with the specified number of rows and columns.
+     * @param row The starting row index of the range.
+     * @param column The starting column index of the range.
+     * @param numRows The number of rows in the range.
+     * @param numColumns The number of columns in the range.
+     * @returns A Range object representing the specified range.
+     */
+    getRange(row: number, column: number, numRows: number, numColumns: number): FRange;
+    /**
+     * Returns a Range object specified by A1 notation.
+     * @param a1Notation A string representing a range in A1 notation.
+     * @returns A Range object representing the specified range.
+     */
+    getRange(a1Notation: string): FRange;
+    /**
+     * Returns the current number of columns in the sheet, regardless of content.
+     * @return The maximum columns count of the sheet
+     */
+    getMaxColumns(): number;
+    /**
+     * Returns the current number of rows in the sheet, regardless of content.
+     * @return The maximum rows count of the sheet
+     */
+    getMaxRows(): number;
+    /**
+     * 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.
+     */
+    insertRowAfter(afterPosition: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertRowBefore(beforePosition: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertRows(rowIndex: number, numRows?: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertRowsAfter(afterPosition: number, howMany: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertRowsBefore(beforePosition: number, howMany: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    deleteRow(rowPosition: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    deleteRows(rowPosition: number, howMany: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    moveRows(rowSpec: FRange, destinationIndex: number): Promise<FWorksheet>;
+    /**
+     * Hides the rows in the given range.
+     * @param row The row range to hide.
+     * @returns This sheet, for chaining.
+     */
+    hideRow(row: FRange): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    hideRows(rowIndex: number, numRows?: number): Promise<FWorksheet>;
+    /**
+     * Unhides the row in the given range.
+     * @param row The range to unhide, if hidden.
+     * @returns This sheet, for chaining.
+     */
+    unhideRow(row: FRange): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    showRows(rowIndex: number, numRows?: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    setRowHeight(rowPosition: number, height: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    setRowHeights(startRow: number, numRows: number, height: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    setRowHeightsForced(startRow: number, numRows: number, height: number): Promise<FWorksheet>;
+    /**
+     * Set custom properties for given rows.
+     * @param custom The custom properties to set.
+     * @returns This sheet, for chaining.
+     */
+    setRowCustom(custom: IObjectArrayPrimitiveType<CustomData>): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertColumnAfter(afterPosition: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertColumnBefore(beforePosition: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertColumns(columnIndex: number, numColumns?: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertColumnsAfter(afterPosition: number, howMany: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    insertColumnsBefore(beforePosition: number, howMany: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    deleteColumn(columnPosition: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    deleteColumns(columnPosition: number, howMany: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    moveColumns(columnSpec: FRange, destinationIndex: number): Promise<FWorksheet>;
+    /**
+     * Hides the column or columns in the given range.
+     * @param column The column range to hide.
+     * @returns This sheet, for chaining.
+     */
+    hideColumn(column: FRange): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    hideColumns(columnIndex: number, numColumns?: number): Promise<FWorksheet>;
+    /**
+     * Unhides the column in the given range.
+     * @param column The range to unhide, if hidden.
+     * @returns This sheet, for chaining.
+     */
+    unhideColumn(column: FRange): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    showColumns(columnIndex: number, numColumns?: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    setColumnWidth(columnPosition: number, width: number): Promise<FWorksheet>;
+    /**
+     * 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.
+     */
+    setColumnWidths(startColumn: number, numColumns: number, width: number): Promise<FWorksheet>;
+    /**
+     * Set custom properties for given columns.
+     * @param custom The custom properties to set.
+     * @returns This sheet, for chaining.
+     */
+    setColumnCustom(custom: IObjectArrayPrimitiveType<CustomData>): Promise<FWorksheet>;
+    /**
+     * Get all merged cells in the current sheet
+     * @returns all merged cells
+     */
+    getMergedRanges(): FRange[];
+    /**
+     * 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: number, column: number): FRange | undefined;
+    /**
+     * Returns the selected range in the active sheet, or null if there is no active range.
+     * @returns the active range
+     */
+    getActiveRange(): FRange | null;
+    /**
+     * Sets the active selection region for this sheet.
+     * @param range The range to set as the active selection.
+     */
+    setActiveRange(range: FRange): void;
+    /**
+     * Sets the active selection region for this sheet.
+     * @param range The range to set as the active selection.
+     */
+    setActiveSelection: (range: FRange) => void;
+    /**
+     * 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: IFreeze): boolean;
+    /**
+     * Cancels the frozen state of the current sheet.
+     * @returns True if the command was successful, false otherwise.
+     */
+    cancelFreeze(): boolean;
+    /**
+     * Get the freeze state of the current sheet.
+     * @returns The freeze state of the current sheet.
+     */
+    getFreeze(): IFreeze;
+    /**
+     * 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: number): void;
+    /**
+     * 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: number): void;
+    /**
+     * Get the number of frozen columns.
+     * @returns The number of frozen columns.
+     * Returns 0 if no columns are frozen.
+     */
+    getFrozenColumns(): number;
+    /**
+     * Get the number of frozen rows.
+     * @returns The number of frozen rows.
+     * Returns 0 if no rows are frozen.
+     */
+    getFrozenRows(): number;
+    /**
+     * Returns true if the sheet's gridlines are hidden; otherwise returns false. Gridlines are visible by default.
+     */
+    hasHiddenGridLines(): boolean;
+    /**
+     * Hides or reveals the sheet gridlines.
+     * @param {boolean} hidden If `true`, hide gridlines in this sheet; otherwise show the gridlines.
+     */
+    setHiddenGridlines(hidden: boolean): Promise<boolean>;
+    /**
+     * 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: (cellValue: ObjectMatrix<Nullable<ICellData>>) => void): IDisposable;
+    /**
+     * 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: (cellValue: ObjectMatrix<Nullable<ICellData>>) => void): IDisposable;
+}

package/lib/types/facade/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import './f-univer';
+export { FPermission } from './f-permission';
+export { FRange } from './f-range';
+export type { FontLine, FontStyle, FontWeight } from './f-range';
+export { FSelection } from './f-selection';
+export { FWorkbook } from './f-workbook';
+export { FWorksheet } from './f-worksheet';

package/lib/types/facade/utils.d.ts

@@ -0,0 +1,24 @@
+import { CellValue, ICellData, IObjectMatrixPrimitiveType, IRange, IRangeWithCoord, Worksheet, HorizontalAlign, VerticalAlign } from '@univerjs/core';
+export type FHorizontalAlignment = 'left' | 'center' | 'normal';
+export type FVerticalAlignment = 'top' | 'middle' | 'bottom';
+export declare function transformFacadeHorizontalAlignment(value: FHorizontalAlignment): HorizontalAlign;
+export declare function transformCoreHorizontalAlignment(value: HorizontalAlign): FHorizontalAlignment;
+export declare function transformFacadeVerticalAlignment(value: FVerticalAlignment): VerticalAlign;
+export declare function transformCoreVerticalAlignment(value: VerticalAlign): FVerticalAlignment;
+/**
+ * covert cell value to cell data
+ * @param value
+ * @returns
+ */
+export declare function covertCellValue(value: CellValue | ICellData): ICellData;
+/**
+ * covert cell value array or matrix to cell data
+ * @param value
+ * @param range
+ * @returns
+ */
+export declare function covertCellValues(value: CellValue[][] | IObjectMatrixPrimitiveType<CellValue> | ICellData[][] | IObjectMatrixPrimitiveType<ICellData>, range: IRange): IObjectMatrixPrimitiveType<ICellData>;
+export declare function isCellMerged(mergeInfo: IRangeWithCoord, range: IRange): boolean;
+export declare function isSingleCell(mergeInfo: IRangeWithCoord, range: IRange): boolean;
+export declare function covertToRowRange(range: IRange, worksheet: Worksheet): IRange;
+export declare function covertToColRange(range: IRange, worksheet: Worksheet): IRange;

package/lib/types/index.d.ts

@@ -36,7 +36,7 @@ export { EffectRefRangId, OperatorType } from './services/ref-range/type';
 export { DefinedNameDataController } from './controllers/defined-name-data.controller';
 export { handleBaseInsertRange, handleBaseMoveRowsCols, handleBaseRemoveRange, handleCommonDefaultRangeChangeWithEffectRefCommands, handleCommonRangeChangeWithEffectRefCommandsSkipNoInterests, handleDefaultRangeChangeWithEffectRefCommands, handleDefaultRangeChangeWithEffectRefCommandsSkipNoInterests, handleDeleteRangeMoveLeft, handleDeleteRangeMoveUp, handleInsertCol, handleInsertRangeMoveDown, handleInsertRangeMoveRight, handleInsertRow, handleIRemoveCol, handleIRemoveRow, handleMoveCols, handleMoveRange, handleMoveRows, rotateRange, runRefRangeMutations, } from './services/ref-range/util';
 export { InterceptCellContentPriority, INTERCEPTOR_POINT } from './services/sheet-interceptor/interceptor-const';
-export { SheetInterceptorService } from './services/sheet-interceptor/sheet-interceptor.service';
+export { AFTER_CELL_EDIT, AFTER_CELL_EDIT_ASYNC, BEFORE_CELL_EDIT, SheetInterceptorService } from './services/sheet-interceptor/sheet-interceptor.service';
 export type { ISheetLocation, ISheetLocationBase, ISheetRowLocation } from './services/sheet-interceptor/utils/interceptor';
 export { MERGE_CELL_INTERCEPTOR_CHECK, MergeCellController } from './controllers/merge-cell.controller';
 export { AddMergeRedoSelectionsOperationFactory, AddMergeUndoSelectionsOperationFactory } from './commands/utils/handle-merge-operation';
@@ -51,7 +51,7 @@ export { WorkbookCommentPermission, WorkbookCopyPermission, WorkbookCreateProtec
 export { UnitAction, UnitObject } from '@univerjs/protocol';
 export { checkRangesEditablePermission } from './services/permission/util';
 export { type ICellPermission, RangeProtectionRenderModel } from './model/range-protection-render.model';
-export { type IModel, type IObjectModel, type IRangeProtectionRule, RangeProtectionRuleModel } from './model/range-protection-rule.model';
+export { EditStateEnum, type IModel, type IObjectModel, type IRangeProtectionRule, RangeProtectionRuleModel, ViewStateEnum } from './model/range-protection-rule.model';
 export { RangeProtectionCache } from './model/range-protection.cache';
 export type { IWorksheetProtectionRenderCellData } from './services/permission/worksheet-permission/type';
 export { RangeProtectionRefRangeService } from './services/permission/range-permission/range-protection.ref-range';
@@ -73,6 +73,9 @@ export { handleInsertRangeMutation } from './commands/utils/handle-range-mutatio
 export { type ISheetCommandSharedParams } from './commands/utils/interface';
 export { copyRangeStyles } from './commands/commands/utils/selection-utils';
 export { AddRangeProtectionCommand, type IAddRangeProtectionCommandParams } from './commands/commands/add-range-protection.command';
+export { AddWorksheetProtectionCommand } from './commands/commands/add-worksheet-protection.command';
+export { SetWorksheetProtectionCommand } from './commands/commands/set-worksheet-protection.command';
+export { DeleteWorksheetProtectionCommand } from './commands/commands/delete-worksheet-protection.command';
 export { addMergeCellsUtil, AddWorksheetMergeAllCommand, AddWorksheetMergeCommand, AddWorksheetMergeHorizontalCommand, AddWorksheetMergeVerticalCommand, } from './commands/commands/add-worksheet-merge.command';
 export { ClearSelectionAllCommand } from './commands/commands/clear-selection-all.command';
 export { ClearSelectionContentCommand } from './commands/commands/clear-selection-content.command';
@@ -103,10 +106,9 @@ export { type IReorderRangeCommandParams, ReorderRangeCommand } from './commands
 export { type ISetBorderBasicCommandParams, type ISetBorderColorCommandParams, type ISetBorderCommandParams, type ISetBorderPositionCommandParams, type ISetBorderStyleCommandParams, SetBorderBasicCommand, SetBorderColorCommand, SetBorderCommand, SetBorderPositionCommand, SetBorderStyleCommand, } from './commands/commands/set-border-command';
 export { type ISetSpecificColsVisibleCommandParams, SetColHiddenCommand, SetSelectedColsVisibleCommand, SetSpecificColsVisibleCommand, } from './commands/commands/set-col-visible.command';
 export { SetDefinedNameCommand } from './commands/commands/set-defined-name.command';
-export { SetFrozenCancelCommand } from './commands/commands/set-frozen-cancel.command';
-export { SetFrozenCommand } from './commands/commands/set-frozen.command';
+export { type ICancelFrozenCommandParams, type ISetFrozenCommandParams } from './commands/commands/set-frozen.command';
+export { CancelFrozenCommand, SetFrozenCommand } from './commands/commands/set-frozen.command';
 export { type IToggleGridlinesCommandParams, ToggleGridlinesCommand } from './commands/commands/toggle-gridlines.command';
-export { type ISetRangeProtectionCommandParams, SetRangeProtectionCommand } from './commands/commands/set-range-protection.command';
 export { type ISetRangeValuesCommandParams, SetRangeValuesCommand } from './commands/commands/set-range-values.command';
 export { type ISetSpecificRowsVisibleCommandParams, SetRowHiddenCommand, SetSelectedRowsVisibleCommand, SetSpecificRowsVisibleCommand, } from './commands/commands/set-row-visible.command';
 export { type ISetColorCommandParams, type ISetFontFamilyCommandParams, type ISetFontSizeCommandParams, type ISetHorizontalTextAlignCommandParams, type ISetStyleCommandParams, type ISetTextRotationCommandParams, type ISetTextWrapCommandParams, type ISetVerticalTextAlignCommandParams, type IStyleTypeValue, ResetBackgroundColorCommand, ResetTextColorCommand, SetBackgroundColorCommand, SetBoldCommand, SetFontFamilyCommand, SetFontSizeCommand, SetHorizontalTextAlignCommand, SetItalicCommand, SetOverlineCommand, SetStrikeThroughCommand, SetStyleCommand, SetTextColorCommand, SetTextRotationCommand, SetTextWrapCommand, SetUnderlineCommand, SetVerticalTextAlignCommand, } from './commands/commands/set-style.command';
@@ -123,6 +125,7 @@ export { DeltaRowHeightCommand, type IDeltaRowHeightCommand, type ISetWorksheetR
 export { SetWorksheetShowCommand } from './commands/commands/set-worksheet-show.command';
 export type { ISetWorksheetShowCommandParams } from './commands/commands/set-worksheet-show.command';
 export { AddRangeProtectionMutation, FactoryAddRangeProtectionMutation, type IAddRangeProtectionMutationParams } from './commands/mutations/add-range-protection.mutation';
+export { SetProtectionCommand } from './commands/commands/set-protection.command';
 export { AddMergeUndoMutationFactory, AddWorksheetMergeMutation } from './commands/mutations/add-worksheet-merge.mutation';
 export { AddWorksheetProtectionMutation, type IAddWorksheetProtectionParams } from './commands/mutations/add-worksheet-protection.mutation';
 export { DeleteRangeProtectionMutation, FactoryDeleteRangeProtectionMutation, type IDeleteRangeProtectionMutationParams } from './commands/mutations/delete-range-protection.mutation';

package/lib/types/model/range-protection-rule.model.d.ts

@@ -1,14 +1,23 @@
 import { IRange } from '@univerjs/core';
 import { UnitObject } from '@univerjs/protocol';
+export declare enum ViewStateEnum {
+    OthersCanView = "othersCanView",
+    NoOneElseCanView = "noOneElseCanView"
+}
+export declare enum EditStateEnum {
+    DesignedUserCanEdit = "designedUserCanEdit",
+    OnlyMe = "onlyMe"
+}
 export interface IRangeProtectionRule {
     ranges: IRange[];
     permissionId: string;
     id: string;
-    name: string;
     description?: string;
     unitType: UnitObject;
     unitId: string;
     subUnitId: string;
+    viewState: ViewStateEnum;
+    editState: EditStateEnum;
 }
 export type IObjectModel = Record<string, Record<string, IRangeProtectionRule[]>>;
 export type IModel = Map<string, Map<string, Map<string, IRangeProtectionRule>>>;

package/lib/types/services/permission/type.d.ts

@@ -1,11 +1,13 @@
 import { UnitObject } from '@univerjs/protocol';
+import { EditStateEnum, ViewStateEnum } from '../../model/range-protection-rule.model';
 export interface IWorksheetProtectionRule {
     permissionId: string;
     description?: string;
     unitType: UnitObject;
     unitId: string;
     subUnitId: string;
-    name: string;
+    viewState: ViewStateEnum;
+    editState: EditStateEnum;
 }
 export interface IWorksheetProtectionPointRule {
     unitId: string;

package/lib/types/services/permission/worksheet-permission/worksheet-permission.service.d.ts

@@ -1,4 +1,4 @@
-import { Injector, IPermissionService, IResourceManagerService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { ILogService, Injector, IPermissionService, IResourceManagerService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
 import { RangeProtectionRuleModel } from '../../../model/range-protection-rule.model';
 import { WorksheetProtectionPointModel } from './worksheet-permission-point.model';
 import { WorksheetProtectionRuleModel } from './worksheet-permission-rule.model';
@@ -12,7 +12,8 @@ export declare class WorksheetPermissionService extends RxDisposable {
     private _worksheetProtectionPointRuleModel;
     private _resourceManagerService;
     private _rangeProtectionRuleModel;
-    constructor(_permissionService: IPermissionService, _univerInstanceService: IUniverInstanceService, _injector: Injector, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel, _worksheetProtectionPointRuleModel: WorksheetProtectionPointModel, _resourceManagerService: IResourceManagerService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
+    private _logService;
+    constructor(_permissionService: IPermissionService, _univerInstanceService: IUniverInstanceService, _injector: Injector, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel, _worksheetProtectionPointRuleModel: WorksheetProtectionPointModel, _resourceManagerService: IResourceManagerService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _logService: ILogService);
     private _init;
     private _initRuleChange;
     private _initRuleSnapshot;

package/lib/types/services/sheet-interceptor/sheet-interceptor.service.d.ts

@@ -1,4 +1,5 @@
-import { ICommandInfo, IDisposable, IInterceptor, IRange, IUndoRedoCommandInfosByInterceptor, Nullable, Disposable, InterceptorEffectEnum, IUniverInstanceService } from '@univerjs/core';
+import { ICellData, ICellDataForSheetInterceptor, ICommandInfo, IDisposable, IInterceptor, IRange, IUndoRedoCommandInfosByInterceptor, Nullable, Workbook, Worksheet, Disposable, InterceptorEffectEnum, InterceptorManager, IUniverInstanceService } from '@univerjs/core';
+import { ISheetLocation } from './utils/interceptor';
 export interface IBeforeCommandInterceptor {
     priority?: number;
     performCheck(info: ICommandInfo): Promise<boolean>;
@@ -16,6 +17,12 @@ export interface IRangeInterceptors {
     priority?: number;
     getMutations(rangesInfo: IRangesInfo): IUndoRedoCommandInfosByInterceptor;
 }
+interface ISheetLocationForEditor extends ISheetLocation {
+    origin: Nullable<ICellData>;
+}
+export declare const BEFORE_CELL_EDIT: IInterceptor<ICellDataForSheetInterceptor, ISheetLocationForEditor>;
+export declare const AFTER_CELL_EDIT: IInterceptor<ICellDataForSheetInterceptor, ISheetLocationForEditor>;
+export declare const AFTER_CELL_EDIT_ASYNC: IInterceptor<Promise<Nullable<ICellDataForSheetInterceptor>>, ISheetLocationForEditor>;
 /**
  * This class expose methods for sheet features to inject code to sheet underlying logic.
  */
@@ -27,10 +34,38 @@ export declare class SheetInterceptorService extends Disposable {
     private _beforeCommandInterceptor;
     private readonly _workbookDisposables;
     private readonly _worksheetDisposables;
+    readonly writeCellInterceptor: InterceptorManager<{
+        BEFORE_CELL_EDIT: IInterceptor<ICellDataForSheetInterceptor, ISheetLocationForEditor>;
+        AFTER_CELL_EDIT: IInterceptor<ICellDataForSheetInterceptor, ISheetLocationForEditor>;
+        AFTER_CELL_EDIT_ASYNC: IInterceptor<Promise<Nullable<ICellDataForSheetInterceptor>>, ISheetLocationForEditor>;
+    }>;
     /** @ignore */
     constructor(_univerInstanceService: IUniverInstanceService);
     dispose(): void;
+    /**
+     * Add a listener function to a specific command to add affiliated mutations. It should be called in controllers.
+     *
+     * Pairs with {@link onCommandExecute}.
+     *
+     * @param interceptor
+     * @returns
+     */
     interceptCommand(interceptor: ICommandInterceptor): IDisposable;
+    /**
+     * When command is executing, call this method to gether undo redo mutations from upper features.
+     * @param command
+     * @returns
+     */
+    onCommandExecute(info: ICommandInfo): IUndoRedoCommandInfosByInterceptor;
+    /**
+     * Add a listener function to a specific command to deteminte if the command can execute mutations. It should be
+     * called in controllers.
+     *
+     * Pairs with {@link beforeCommandExecute}.
+     *
+     * @param interceptor
+     * @returns
+     */
     interceptBeforeCommand(interceptor: IBeforeCommandInterceptor): IDisposable;
     /**
      * before command execute, call this method to get the flag of whether it can be executed the command，
@@ -44,16 +79,12 @@ export declare class SheetInterceptorService extends Disposable {
      * @returns IDisposable
      */
     interceptRanges(interceptor: IRangeInterceptors): IDisposable;
-    /**
-     * When command is executing, call this method to gether undo redo mutations from upper features.
-     * @param command
-     * @returns
-     */
-    onCommandExecute(info: ICommandInfo): IUndoRedoCommandInfosByInterceptor;
     generateMutationsByRanges(info: IRangesInfo): IUndoRedoCommandInfosByInterceptor;
+    onWriteCell(workbook: Workbook, worksheet: Worksheet, row: number, col: number, cellData: ICellData): Promise<Nullable<ICellDataForSheetInterceptor>>;
     intercept<T extends IInterceptor<any, any>>(name: T, interceptor: T): IDisposable;
     fetchThroughInterceptors<T, C>(name: IInterceptor<T, C>, effect?: InterceptorEffectEnum): (initValue: Nullable<T>, initContext: C) => Nullable<T>;
     private _interceptWorkbook;
     private _disposeWorkbookInterceptor;
     private _disposeSheetInterceptor;
 }
+export {};