@univerjs/sheets-ui 0.1.12 → 0.1.13

package/lib/types/commands/commands/worksheet-protection.command.d.ts

@@ -0,0 +1,21 @@
+import { ICommand } from '@univerjs/core';
+import { IWorksheetProtectionRule } from '@univerjs/sheets';
+
+export interface IAddWorksheetProtectionParams {
+    unitId: string;
+    rule: IWorksheetProtectionRule;
+}
+export interface IDeleteWorksheetProtectionParams {
+    unitId: string;
+    subUnitId: string;
+    rule: IWorksheetProtectionRule;
+}
+export interface ISetWorksheetProtectionParams {
+    permissionId: string;
+    rule: IWorksheetProtectionRule;
+}
+export declare const AddWorksheetProtectionCommand: ICommand<IAddWorksheetProtectionParams>;
+export declare const DeleteWorksheetProtectionCommand: ICommand<IDeleteWorksheetProtectionParams>;
+export declare const SetWorksheetProtectionCommand: ICommand<ISetWorksheetProtectionParams>;
+export declare const DeleteWorksheetProtectionFormSheetBarCommand: ICommand;
+export declare const ChangeSheetProtectionFromSheetBarCommand: ICommand;

package/lib/types/commands/operations/sheet-permission-open-dialog.operation.d.ts

@@ -0,0 +1,3 @@
+import { ICommand } from '@univerjs/core';
+
+export declare const SheetPermissionOpenDialogOperation: ICommand;

package/lib/types/commands/operations/sheet-permission-open-panel.operation.d.ts

@@ -0,0 +1,7 @@
+import { ICommand } from '@univerjs/core';
+
+export interface IPermissionOpenPanelParam {
+    fromSheetBar?: boolean;
+    showDetail?: boolean;
+}
+export declare const SheetPermissionOpenPanelOperation: ICommand<IPermissionOpenPanelParam>;

package/lib/types/common/keys.d.ts

@@ -31,7 +31,8 @@ export declare enum VIEWPORT_KEY {
     VIEW_LEFT_TOP = "viewLeftTop"
 }
 export declare const SHEET_COMPONENT_MAIN_LAYER_INDEX = 0;
-export declare const SHEET_COMPONENT_HEADER_LAYER_INDEX = 2;
-export declare const SHEET_COMPONENT_SELECTION_LAYER_INDEX = 3;
+export declare const SHEET_COMPONENT_SELECTION_LAYER_INDEX = 1;
+export declare const SHEET_COMPONENT_HEADER_LAYER_INDEX = 10;
 export declare const SHEET_ZOOM_RANGE: number[];
-export declare const SHEET_COMPONENT_UNHIDE_LAYER_INDEX = 1001;
+export declare const SHEET_COMPONENT_HEADER_SELECTION_LAYER_INDEX = 11;
+export declare const SHEET_COMPONENT_UNHIDE_LAYER_INDEX = 12;

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

@@ -2,8 +2,10 @@ import { ICellData, IMutationInfo, IPosition, IRange, Nullable, Workbook, Worksh
 import { ISheetLocation } from '@univerjs/sheets';
 import { IAccessor } from '@wendellhu/redi';
 import { IBoundRectNoAngle, IRender, Scene, SpreadsheetSkeleton } from '@univerjs/engine-render';
+import { ICollaborator } from '@univerjs/protocol';
 import { ISheetSkeletonManagerParam } from '../services/sheet-skeleton-manager.service';
 
+export declare function getUserListEqual(userList1: ICollaborator[], userList2: ICollaborator[]): boolean;
 export declare function checkCellContentInRanges(worksheet: Worksheet, ranges: IRange[]): boolean;
 export declare function checkCellContentInRange(worksheet: Worksheet, range: IRange): boolean;
 export declare function getClearContentMutationParamsForRanges(accessor: IAccessor, unitId: string, worksheet: Worksheet, ranges: IRange[]): {

package/lib/types/controllers/clipboard/utils.d.ts

@@ -23,7 +23,7 @@ export declare function getSetCellValueMutations(pasteTo: ISheetDiscreteRangeLoc
     undos: IMutationInfo<object>[];
     redos: IMutationInfo<object>[];
 };
-export declare function getSetCellStyleMutations(pasteTo: ISheetDiscreteRangeLocation, matrix: ObjectMatrix<ICellDataWithSpanInfo>, accessor: IAccessor): {
+export declare function getSetCellStyleMutations(pasteTo: ISheetDiscreteRangeLocation, matrix: ObjectMatrix<ICellDataWithSpanInfo>, accessor: IAccessor, withRichFormat?: boolean): {
     undos: IMutationInfo<object>[];
     redos: IMutationInfo<object>[];
 };

package/lib/types/controllers/editor/formula-editor.controller.d.ts

@@ -1,9 +1,13 @@
-import { ICommandService, IContextService, IUndoRedoService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { ICommandService, IContextService, InterceptorManager, IUndoRedoService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
 import { DocSkeletonManagerService, DocViewModelManagerService, TextSelectionManagerService } from '@univerjs/docs';
 import { IRenderManagerService } from '@univerjs/engine-render';
 import { IFormulaEditorManagerService } from '../../services/editor/formula-editor-manager.service';
 import { IEditorBridgeService } from '../../services/editor-bridge.service';
 
+export declare const FORMULA_EDIT_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, {
+    row: number;
+    col: number;
+}>;
 export declare class FormulaEditorController extends RxDisposable {
     private readonly _univerInstanceService;
     private readonly _renderManagerService;
@@ -16,6 +20,12 @@ export declare class FormulaEditorController extends RxDisposable {
     private readonly _docViewModelManagerService;
     private readonly _textSelectionManagerService;
     private _loadedMap;
+    interceptor: InterceptorManager<{
+        FORMULA_EDIT_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, {
+            row: number;
+            col: number;
+        }>;
+    }>;
     constructor(_univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _editorBridgeService: IEditorBridgeService, _commandService: ICommandService, _contextService: IContextService, _formulaEditorManagerService: IFormulaEditorManagerService, _undoRedoService: IUndoRedoService, _docSkeletonManagerService: DocSkeletonManagerService, _docViewModelManagerService: DocViewModelManagerService, _textSelectionManagerService: TextSelectionManagerService);
     private _initialize;
     private _create;

package/lib/types/controllers/hover-render.controller.d.ts

@@ -2,12 +2,15 @@ import { Workbook, Disposable } from '@univerjs/core';
 import { IRenderContext, IRenderController, IRenderManagerService } from '@univerjs/engine-render';
 import { HoverManagerService } from '../services/hover-manager.service';
 import { SheetSkeletonManagerService } from '../services/sheet-skeleton-manager.service';
+import { ScrollManagerService } from '../services/scroll-manager.service';
 
 export declare class HoverRenderController extends Disposable implements IRenderController {
     private readonly _context;
     private _renderManagerService;
     private _hoverManagerService;
     private _sheetSkeletonManagerService;
-    constructor(_context: IRenderContext<Workbook>, _renderManagerService: IRenderManagerService, _hoverManagerService: HoverManagerService, _sheetSkeletonManagerService: SheetSkeletonManagerService);
+    private _scrollManagerService;
+    constructor(_context: IRenderContext<Workbook>, _renderManagerService: IRenderManagerService, _hoverManagerService: HoverManagerService, _sheetSkeletonManagerService: SheetSkeletonManagerService, _scrollManagerService: ScrollManagerService);
     private _initPointerEvent;
+    private _initScrollEvent;
 }

package/lib/types/controllers/menu/menu-util.d.ts

@@ -1,4 +1,5 @@
-import { IUniverInstanceService, Workbook, Worksheet } from '@univerjs/core';
+import { IPermissionTypes, Workbook, Worksheet, IUniverInstanceService } from '@univerjs/core';
+import { IAccessor } from '@wendellhu/redi';
 import { Observable } from 'rxjs';
 
 interface IActive {
@@ -6,4 +7,12 @@ interface IActive {
     worksheet: Worksheet;
 }
 export declare function deriveStateFromActiveSheet$<T>(univerInstanceService: IUniverInstanceService, defaultValue: T, callback: (active: IActive) => Observable<T>): Observable<T>;
+export declare function getCurrentRangeDisable$(accessor: IAccessor, permissionTypes?: IPermissionTypes): Observable<boolean>;
+export declare function getCommentDisable$(accessor: IAccessor, permissionTypes?: IPermissionTypes): Observable<boolean>;
+export declare function getBaseRangeMenuHidden$(accessor: IAccessor): Observable<boolean>;
+export declare function getInsertAfterMenuHidden$(accessor: IAccessor, type: 'row' | 'col'): Observable<boolean>;
+export declare function getInsertBeforeMenuHidden$(accessor: IAccessor, type: 'row' | 'col'): Observable<boolean>;
+export declare function getDeleteMenuHidden$(accessor: IAccessor, type: 'row' | 'col'): Observable<boolean>;
+export declare function getCellMenuHidden$(accessor: IAccessor, type: 'row' | 'col'): Observable<boolean>;
+export declare function getWorkbookPermissionDisable$(accessor: IAccessor): Observable<boolean>;
 export {};

package/lib/types/controllers/menu/permission-menu-util.d.ts

@@ -0,0 +1,14 @@
+import { ICellData } from '@univerjs/core';
+import { ISheetRenderExtension } from '@univerjs/engine-render';
+import { IAccessor } from '@wendellhu/redi';
+
+export declare function getAddPermissionHidden$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getEditPermissionHidden$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getPermissionDisableBase$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getAddPermissionDisableBase$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getAddPermissionFromSheetBarDisable$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getRemovePermissionFromSheetBarDisable$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getSetPermissionFromSheetBarDisable$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getRemovePermissionDisable$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare function getViewPermissionDisable$(accessor: IAccessor): import('rxjs').Observable<boolean>;
+export declare const changeRenderExtensionSkip: (cellData: ICellData & ISheetRenderExtension, key: keyof ISheetRenderExtension, value: boolean) => void;

package/lib/types/controllers/menu/permission.menu.d.ts

@@ -0,0 +1,14 @@
+import { IMenuButtonItem, IMenuItem, IMenuSelectorItem } from '@univerjs/ui';
+import { IAccessor } from '@wendellhu/redi';
+
+export declare const tmpIcon = "data-validation-single";
+export declare function sheetPermissionToolbarMenuFactory(accessor: IAccessor): IMenuItem;
+export declare function sheetPermissionContextMenuFactory(): IMenuSelectorItem<string>;
+export declare function sheetPermissionAddProtectContextMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionEditProtectContextMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionRemoveProtectContextMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionViewAllProtectRuleContextMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionProtectSheetInSheetBarMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionRemoveProtectionSheetBarMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionChangeSheetPermissionSheetBarMenuFactory(accessor: IAccessor): IMenuButtonItem;
+export declare function sheetPermissionViewAllProtectRuleSheetBarMenuFactory(accessor: IAccessor): IMenuButtonItem;

package/lib/types/controllers/permission/sheet-permission-init.controller.d.ts

@@ -0,0 +1,26 @@
+import { Disposable, IAuthzIoService, IPermissionService, IUniverInstanceService, UserManagerService } from '@univerjs/core';
+import { RangeProtectionRenderModel, RangeProtectionRuleModel, SheetInterceptorService, WorksheetProtectionPointModel, WorksheetProtectionRuleModel } from '@univerjs/sheets';
+import { IDialogService } from '@univerjs/ui';
+
+export declare class SheetPermissionInitController extends Disposable {
+    private readonly _univerInstanceService;
+    private readonly _dialogService;
+    private _permissionService;
+    private _authzIoService;
+    private _rangeProtectionRuleModel;
+    private _worksheetProtectionRuleModel;
+    private _userManagerService;
+    private _worksheetProtectionPointRuleModel;
+    private _sheetInterceptorService;
+    private _selectionProtectionRenderModel;
+    constructor(_univerInstanceService: IUniverInstanceService, _dialogService: IDialogService, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel, _userManagerService: UserManagerService, _worksheetProtectionPointRuleModel: WorksheetProtectionPointModel, _sheetInterceptorService: SheetInterceptorService, _selectionProtectionRenderModel: RangeProtectionRenderModel);
+    private _initRangePermissionFromSnapshot;
+    private _initRangePermissionChange;
+    private _initWorkbookPermissionChange;
+    private _initWorksheetPermissionChange;
+    private _initWorksheetPermissionPointsChange;
+    private _initWorksheetPermissionFromSnapshot;
+    private _initUserChange;
+    private _initViewModelByRangeInterceptor;
+    private _initViewModelBySheetInterceptor;
+}

package/lib/types/controllers/permission/sheet-permission-interceptor-base.controller.d.ts

@@ -0,0 +1,37 @@
+import { IPermissionTypes, IRange, Disposable, DisposableCollection, ICommandService, IContextService, IPermissionService, IUniverInstanceService, LocaleService } from '@univerjs/core';
+import { RangeProtectionRuleModel, SelectionManagerService, WorksheetProtectionRuleModel } from '@univerjs/sheets';
+import { IDialogService } from '@univerjs/ui';
+import { IDefinedNamesService, LexerTreeBuilder } from '@univerjs/engine-formula';
+import { IAutoFillService } from '../../services/auto-fill/auto-fill.service';
+
+export declare const SHEET_PERMISSION_PASTE_PLUGIN = "SHEET_PERMISSION_PASTE_PLUGIN";
+export declare class SheetPermissionInterceptorBaseController extends Disposable {
+    private readonly _commandService;
+    private readonly _univerInstanceService;
+    private readonly _permissionService;
+    private readonly _selectionManagerService;
+    private readonly _dialogService;
+    private _rangeProtectionRuleModel;
+    private _worksheetProtectionRuleModel;
+    private _autoFillService;
+    private readonly _localeService;
+    private readonly _lexerTreeBuilder;
+    private readonly _contextService;
+    private readonly _definedNamesService;
+    disposableCollection: DisposableCollection;
+    constructor(_commandService: ICommandService, _univerInstanceService: IUniverInstanceService, _permissionService: IPermissionService, _selectionManagerService: SelectionManagerService, _dialogService: IDialogService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _worksheetProtectionRuleModel: WorksheetProtectionRuleModel, _autoFillService: IAutoFillService, _localeService: LocaleService, _lexerTreeBuilder: LexerTreeBuilder, _contextService: IContextService, _definedNamesService: IDefinedNamesService);
+    haveNotPermissionHandle(errorMsg: string): void;
+    private _getPermissionCheck;
+    private _initialize;
+    private _commandExecutedListener;
+    private _permissionCheckWithInsertRangeMove;
+    private _permissionCheckByWorksheetCommand;
+    permissionCheckWithoutRange(permissionTypes: IPermissionTypes): boolean;
+    permissionCheckWithRanges(permissionTypes: IPermissionTypes, selectionRanges?: IRange[], unitId?: string, subUnitId?: string): boolean;
+    private _permissionCheckByPaste;
+    private _permissionCheckByMoveCommand;
+    private _permissionCheckByAutoFillCommand;
+    private _permissionCheckByMoveRangeCommand;
+    private _permissionCheckBySetRangeValue;
+    private _permissionCheckWithFormula;
+}

package/lib/types/controllers/permission/sheet-permission-interceptor-canvas-render.controller.d.ts

@@ -0,0 +1,29 @@
+import { Workbook, DisposableCollection, IPermissionService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { RangeProtectionRuleModel, SelectionManagerService } from '@univerjs/sheets';
+import { IDialogService } from '@univerjs/ui';
+import { IRenderContext, IRenderController } from '@univerjs/engine-render';
+import { HeaderMoveRenderController } from '../render-controllers/header-move.render-controller';
+import { HeaderResizeRenderController } from '../render-controllers/header-resize.render-controller';
+import { ISelectionRenderService } from '../../services/selection/selection-render.service';
+import { HeaderFreezeRenderController } from '../render-controllers/freeze.render-controller';
+
+export declare const SHEET_PERMISSION_PASTE_PLUGIN = "SHEET_PERMISSION_PASTE_PLUGIN";
+export declare class SheetPermissionInterceptorCanvasRenderController extends RxDisposable implements IRenderController {
+    private readonly _context;
+    private readonly _univerInstanceService;
+    private readonly _permissionService;
+    private readonly _selectionManagerService;
+    private readonly _dialogService;
+    private _rangeProtectionRuleModel;
+    private _headerMoveRenderController;
+    private _headerResizeRenderController;
+    private _selectionRenderService;
+    private _headerFreezeRenderController;
+    disposableCollection: DisposableCollection;
+    constructor(_context: IRenderContext<Workbook>, _univerInstanceService: IUniverInstanceService, _permissionService: IPermissionService, _selectionManagerService: SelectionManagerService, _dialogService: IDialogService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _headerMoveRenderController: HeaderMoveRenderController, _headerResizeRenderController: HeaderResizeRenderController, _selectionRenderService: ISelectionRenderService, _headerFreezeRenderController: HeaderFreezeRenderController);
+    private _initHeaderMovePermissionInterceptor;
+    private _initHeaderResizePermissionInterceptor;
+    private _initRangeFillPermissionInterceptor;
+    private _initRangeMovePermissionInterceptor;
+    private _initFreezePermissionInterceptor;
+}

package/lib/types/controllers/permission/sheet-permission-interceptor-clipboard.controller.d.ts

@@ -0,0 +1,16 @@
+import { Disposable, DisposableCollection, IUniverInstanceService, LocaleService } from '@univerjs/core';
+import { SelectionManagerService } from '@univerjs/sheets';
+import { ISheetClipboardService } from '../../services/clipboard/clipboard.service';
+import { SheetPermissionInterceptorBaseController } from './sheet-permission-interceptor-base.controller';
+
+export declare const SHEET_PERMISSION_PASTE_PLUGIN = "SHEET_PERMISSION_PASTE_PLUGIN";
+export declare class SheetPermissionInterceptorClipboardController extends Disposable {
+    private readonly _univerInstanceService;
+    private readonly _selectionManagerService;
+    private readonly _localService;
+    private _sheetClipboardService;
+    private readonly _sheetPermissionInterceptorBaseController;
+    disposableCollection: DisposableCollection;
+    constructor(_univerInstanceService: IUniverInstanceService, _selectionManagerService: SelectionManagerService, _localService: LocaleService, _sheetClipboardService: ISheetClipboardService, _sheetPermissionInterceptorBaseController: SheetPermissionInterceptorBaseController);
+    private _initClipboardHook;
+}

package/lib/types/controllers/permission/sheet-permission-interceptor-formula-render.controller.d.ts

@@ -0,0 +1,19 @@
+import { Workbook, DisposableCollection, IPermissionService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
+import { RangeProtectionRuleModel } from '@univerjs/sheets';
+import { Injector } from '@wendellhu/redi';
+import { IRenderContext, IRenderController } from '@univerjs/engine-render';
+import { StatusBarController } from '../status-bar.controller';
+
+export declare const SHEET_PERMISSION_PASTE_PLUGIN = "SHEET_PERMISSION_PASTE_PLUGIN";
+export declare class SheetPermissionInterceptorFormulaRenderController extends RxDisposable implements IRenderController {
+    private readonly _context;
+    private readonly _injector;
+    private readonly _univerInstanceService;
+    private readonly _permissionService;
+    private _rangeProtectionRuleModel;
+    private readonly _statusBarController;
+    disposableCollection: DisposableCollection;
+    constructor(_context: IRenderContext<Workbook>, _injector: Injector, _univerInstanceService: IUniverInstanceService, _permissionService: IPermissionService, _rangeProtectionRuleModel: RangeProtectionRuleModel, _statusBarController: StatusBarController);
+    private _initStatusBarPermissionInterceptor;
+    private _initFormulaEditorPermissionInterceptor;
+}

package/lib/types/controllers/permission/sheet-permission-render.controller.d.ts

@@ -0,0 +1,19 @@
+import { Disposable } from '@univerjs/core';
+import { MenuConfig, ComponentManager, IMenuService } from '@univerjs/ui';
+import { Injector } from '@wendellhu/redi';
+
+export interface IUniverSheetsPermissionMenuConfig {
+    menu: MenuConfig;
+}
+export declare const DefaultSheetPermissionMenuConfig: {};
+export declare class SheetPermissionRenderController extends Disposable {
+    private readonly _config;
+    private _menuService;
+    private _componentManager;
+    private readonly _injector;
+    constructor(_config: Partial<IUniverSheetsPermissionMenuConfig>, _menuService: IMenuService, _componentManager: ComponentManager, _injector: Injector);
+    private _init;
+    private _initToolbarMenu;
+    private _initContextMenu;
+    private _initComponents;
+}

package/lib/types/controllers/render-controllers/freeze.render-controller.d.ts

@@ -1,10 +1,11 @@
-import { Workbook, Disposable, ICommandService, ThemeService } from '@univerjs/core';
+import { Workbook, Disposable, ICommandService, InterceptorManager, ThemeService } from '@univerjs/core';
 import { IRenderContext, IRenderController } from '@univerjs/engine-render';
 import { SelectionManagerService, SheetInterceptorService } from '@univerjs/sheets';
 import { Injector } from '@wendellhu/redi';
 import { ScrollManagerService } from '../../services/scroll-manager.service';
 import { SheetSkeletonManagerService } from '../../services/sheet-skeleton-manager.service';
 
+export declare const FREEZE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, null>;
 export declare class HeaderFreezeRenderController extends Disposable implements IRenderController {
     private readonly _context;
     private readonly _sheetSkeletonManagerService;
@@ -33,6 +34,9 @@ export declare class HeaderFreezeRenderController extends Disposable implements
     private _freezeActiveColor;
     private _freezeHoverColor;
     private _lastFreeze;
+    interceptor: InterceptorManager<{
+        FREEZE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, null>;
+    }>;
     constructor(_context: IRenderContext<Workbook>, _sheetSkeletonManagerService: SheetSkeletonManagerService, _commandService: ICommandService, _selectionManagerService: SelectionManagerService, _scrollManagerService: ScrollManagerService, _themeService: ThemeService, _sheetInterceptorService: SheetInterceptorService, _injector: Injector);
     dispose(): void;
     private _initialize;
@@ -59,5 +63,14 @@ export declare class HeaderFreezeRenderController extends Disposable implements
     private _getPositionByIndex;
     private _getFreeze;
     private _getSheetObject;
+    /**
+     * 调整冻结 & 缩放都会进入
+     * 但是窗口 resize 并不会进入
+     * @param startRow
+     * @param startColumn
+     * @param ySplit
+     * @param xSplit
+     * @param resetScroll
+     */
     private _refreshFreeze;
 }

package/lib/types/controllers/render-controllers/header-move.render-controller.d.ts

@@ -1,9 +1,10 @@
-import { Workbook, Disposable, ICommandService } from '@univerjs/core';
+import { IRange, Workbook, Disposable, ICommandService, InterceptorManager } from '@univerjs/core';
 import { IRenderContext, IRenderController } from '@univerjs/engine-render';
 import { SelectionManagerService } from '@univerjs/sheets';
 import { ISelectionRenderService } from '../../services/selection/selection-render.service';
 import { SheetSkeletonManagerService } from '../../services/sheet-skeleton-manager.service';
 
+export declare const HEADER_MOVE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, IRange>;
 export declare class HeaderMoveRenderController extends Disposable implements IRenderController {
     private readonly _context;
     private readonly _sheetSkeletonManagerService;
@@ -24,6 +25,9 @@ export declare class HeaderMoveRenderController extends Disposable implements IR
     private _changeFromRow;
     private _changeToColumn;
     private _changeToRow;
+    interceptor: InterceptorManager<{
+        HEADER_MOVE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, IRange>;
+    }>;
     dispose(): void;
     constructor(_context: IRenderContext<Workbook>, _sheetSkeletonManagerService: SheetSkeletonManagerService, _commandService: ICommandService, _selectionRenderService: ISelectionRenderService, _selectionManagerService: SelectionManagerService);
     private _initialize;

package/lib/types/controllers/render-controllers/header-resize.render-controller.d.ts

@@ -1,8 +1,12 @@
-import { Workbook, Disposable, ICommandService } from '@univerjs/core';
+import { Workbook, Disposable, ICommandService, InterceptorManager } from '@univerjs/core';
 import { IRenderContext, IRenderController } from '@univerjs/engine-render';
 import { IEditorBridgeService } from '../../services/editor-bridge.service';
 import { SheetSkeletonManagerService } from '../../services/sheet-skeleton-manager.service';
 
+export declare const HEADER_RESIZE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, {
+    row?: number | undefined;
+    col?: number | undefined;
+}>;
 export declare class HeaderResizeRenderController extends Disposable implements IRenderController {
     private readonly _context;
     private readonly _sheetSkeletonManagerService;
@@ -18,6 +22,12 @@ export declare class HeaderResizeRenderController extends Disposable implements
     private _resizeHelperShape;
     private _startOffsetX;
     private _startOffsetY;
+    interceptor: InterceptorManager<{
+        HEADER_RESIZE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, {
+            row?: number | undefined;
+            col?: number | undefined;
+        }>;
+    }>;
     constructor(_context: IRenderContext<Workbook>, _sheetSkeletonManagerService: SheetSkeletonManagerService, _commandService: ICommandService, _editorBridgeService: IEditorBridgeService);
     dispose(): void;
     private _init;

package/lib/types/controllers/sheet-render.controller.d.ts

@@ -24,4 +24,15 @@ export declare class SheetRenderController extends RxDisposable {
     private _createSheetRenderer;
     private _initCommandListener;
     private _initContextListener;
+    private _spreadsheetViewports;
+    private _markSpreadsheetDirty;
+    /**
+     * cellValue data structure:
+     * {[row]: { [col]: value}}
+     * @param cellValue
+     * @returns
+     */
+    private _cellValueToRange;
+    private _rangeToBounds;
+    private _markViewportDirty;
 }

package/lib/types/controllers/status-bar.controller.d.ts

@@ -1,8 +1,9 @@
-import { Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
-import { FormulaDataModel, IFunctionService } from '@univerjs/engine-formula';
+import { Disposable, ICommandService, InterceptorManager, IUniverInstanceService } from '@univerjs/core';
+import { ArrayValueObject, FormulaDataModel, IFunctionService } from '@univerjs/engine-formula';
 import { INumfmtService, SelectionManagerService } from '@univerjs/sheets';
 import { IStatusBarService } from '../services/status-bar.service';
 
+export declare const STATUS_BAR_PERMISSION_CORRECT: import('@univerjs/core').IInterceptor<ArrayValueObject[], ArrayValueObject[]>;
 export declare class StatusBarController extends Disposable {
     private readonly _univerInstanceService;
     private readonly _selectionManagerService;
@@ -12,6 +13,9 @@ export declare class StatusBarController extends Disposable {
     private readonly _formulaDataModel;
     private _numfmtService;
     private _calculateTimeout;
+    interceptor: InterceptorManager<{
+        STATUS_BAR_PERMISSION_CORRECT: import('@univerjs/core').IInterceptor<ArrayValueObject[], ArrayValueObject[]>;
+    }>;
     constructor(_univerInstanceService: IUniverInstanceService, _selectionManagerService: SelectionManagerService, _functionService: IFunctionService, _statusBarService: IStatusBarService, _commandService: ICommandService, _formulaDataModel: FormulaDataModel, _numfmtService: INumfmtService);
     private _init;
     private _registerSelectionListener;

package/lib/types/hooks/useHighlightRange.d.ts

@@ -0,0 +1,3 @@
+import { IRange } from '@univerjs/core';
+
+export declare const useHighlightRange: (ranges?: IRange[]) => void;

package/lib/types/index.d.ts

@@ -16,14 +16,13 @@
 export * from './basics';
 export { getEditorObject } from './basics/editor/get-editor-object';
 export { AutoFillCommand } from './commands/commands/auto-fill.command';
-export { SheetPasteCommand } from './commands/commands/clipboard.command';
 export { SheetCopyCommand } from './commands/commands/clipboard.command';
 export { expandToContinuousRange } from './commands/commands/utils/selection-utils';
 export { ExpandSelectionCommand, JumpOver, MoveSelectionCommand } from './commands/commands/set-selection.command';
 export { SetCellEditVisibleArrowOperation, SetCellEditVisibleOperation } from './commands/operations/cell-edit.operation';
 export { SetScrollOperation } from './commands/operations/scroll.operation';
 export { SheetsScrollRenderController } from './controllers/render-controllers/scroll.render-controller';
-export { deriveStateFromActiveSheet$ } from './controllers/menu/menu-util';
+export { deriveStateFromActiveSheet$, getCurrentRangeDisable$, getCommentDisable$ } from './controllers/menu/menu-util';
 export { SheetRenderController } from './controllers/sheet-render.controller';
 export { SetZoomRatioOperation } from './commands/operations/set-zoom-ratio.operation';
 export { ResetScrollCommand, ScrollCommand, ScrollToCellCommand, SetScrollRelativeCommand, type IScrollCommandParams, type IScrollToCellCommandParams, type ISetScrollRelativeCommandParams, } from './commands/commands/set-scroll.command';
@@ -36,7 +35,6 @@ export { getCoordByCell, getCoordByOffset, getSheetObject, getTransformCoord, }
 export { useActiveWorkbook, useActiveWorksheet } from './components/hook';
 export { whenSheetEditorFocused } from './controllers/shortcuts/utils';
 export type { IEditorBridgeServiceParam } from './services/editor-bridge.service';
-export { enUS, zhCN, ruRU } from './locale';
 export { AutoFillService, IAutoFillService } from './services/auto-fill/auto-fill.service';
 export { getAutoFillRepeatRange } from './services/auto-fill/tools';
 export type { ICopyDataPiece, ISheetAutoFillHook } from './services/auto-fill/type';
@@ -73,3 +71,14 @@ export { type IHoverCellPosition } from './services/hover-manager.service';
 export { AutoHeightController } from './controllers/auto-height.controller';
 export { type IDragCellPosition } from './services/drag-manager.service';
 export { SheetMenuPosition } from './controllers/menu/menu';
+export { useHighlightRange } from './hooks/useHighlightRange';
+export { HeaderMoveRenderController } from './controllers/render-controllers/header-move.render-controller';
+export { HeaderResizeRenderController } from './controllers/render-controllers/header-resize.render-controller';
+export type { ISheetPasteParams } from './commands/commands/clipboard.command';
+export { SheetCutCommand, SheetPasteColWidthCommand, SheetPasteCommand, SheetPasteShortKeyCommand } from './commands/commands/clipboard.command';
+export { SetRangeBoldCommand, SetRangeItalicCommand, SetRangeUnderlineCommand, SetRangeStrickThroughCommand } from './commands/commands/inline-format.command';
+export { ApplyFormatPainterCommand } from './commands/commands/set-format-painter.command';
+export { HeaderFreezeRenderController } from './controllers/render-controllers/freeze.render-controller';
+export { FormulaEditorController } from './controllers/editor/formula-editor.controller';
+export { StatusBarController } from './controllers/status-bar.controller';
+export { SheetPermissionInterceptorBaseController } from './controllers/permission/sheet-permission-interceptor-base.controller';

package/lib/types/locale/zh-CN.d.ts

@@ -304,6 +304,10 @@ declare const locale: {
         sheetNameAlreadyExistsError: string;
         deleteSheet: string;
         deleteSheetContent: string;
+        addProtectSheet: string;
+        removeProtectSheet: string;
+        changeSheetPermission: string;
+        viewAllProtectArea: string;
     };
     rightClick: {
         copy: string;
@@ -404,6 +408,11 @@ declare const locale: {
         deleteAllColumnsAlert: string;
         hideAllRowsAlert: string;
         hideAllColumnsAlert: string;
+        protectRange: string;
+        editProtectRange: string;
+        removeProtectRange: string;
+        turnOnProtectRange: string;
+        viewAllProtectArea: string;
     };
     info: {
         tooltip: string;
@@ -526,5 +535,94 @@ declare const locale: {
         nameInvalid: string;
         nameSheetConflict: string;
     };
+    uploadLoading: {
+        loading: string;
+        error: string;
+    };
+    permission: {
+        toolbarMenu: string;
+        panel: {
+            title: string;
+            name: string;
+            protectedRange: string;
+            permissionDirection: string;
+            permissionDirectionPlaceholder: string;
+            editPermission: string;
+            onlyICanEdit: string;
+            designedUserCanEdit: string;
+            viewPermission: string;
+            othersCanView: string;
+            noOneElseCanView: string;
+            designedPerson: string;
+            addPerson: string;
+            canEdit: string;
+            canView: string;
+            delete: string;
+            currentSheet: string;
+            allSheet: string;
+            edit: string;
+            Print: string;
+            Comment: string;
+            Copy: string;
+            SetCellStyle: string;
+            SetCellValue: string;
+            SetHyperLink: string;
+            Sort: string;
+            Filter: string;
+            PivotTable: string;
+            FloatImage: string;
+            RowHeightColWidth: string;
+            RowHeightColWidthReadonly: string;
+            FilterReadonly: string;
+            nameError: string;
+            created: string;
+            iCanEdit: string;
+            iCanNotEdit: string;
+            iCanView: string;
+            iCanNotView: string;
+            emptyRangeError: string;
+            rangeOverlapError: string;
+            rangeOverlapOverPermissionError: string;
+            InsertHyperlink: string;
+            SetRowStyle: string;
+            SetColumnStyle: string;
+            InsertColumn: string;
+            InsertRow: string;
+            DeleteRow: string;
+            DeleteColumn: string;
+            EditExtraObject: string;
+        };
+        dialog: {
+            allowUserToEdit: string;
+            allowedPermissionType: string;
+            setCellValue: string;
+            setCellStyle: string;
+            copy: string;
+            alert: string;
+            alertContent: string;
+            userEmpty: string;
+            listEmpty: string;
+            commonErr: string;
+            editErr: string;
+            pasteErr: string;
+            setStyleErr: string;
+            copyErr: string;
+            setRowColStyleErr: string;
+            moveRowColErr: string;
+            moveRangeErr: string;
+            autoFillErr: string;
+            filterErr: string;
+            operatorSheetErr: string;
+            insertOrDeleteMoveRangeErr: string;
+            printErr: string;
+            formulaErr: string;
+            hyperLinkErr: string;
+        };
+        button: {
+            confirm: string;
+            cancel: string;
+            addNewPermission: string;
+        };
+    };
 };
 export default locale;

package/lib/types/services/hover-manager.service.d.ts

@@ -22,6 +22,5 @@ export declare class HoverManagerService extends Disposable {
     private _initCellDisposableListener;
     private _calcActiveCell;
     onMouseMove(offsetX: number, offsetY: number): void;
-    onScrollStart(): void;
-    onScrollEnd(): void;
+    onScroll(): void;
 }