@univerjs/sheets-ui 0.5.4 → 0.5.5-experimental.20250122-3362a4a

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

@@ -1,8 +1,9 @@
 import { ICommandService, IContextService, IUndoRedoService, IUniverInstanceService, RxDisposable } from '@univerjs/core';
 import { DocSelectionManagerService } from '@univerjs/docs';
+import { IEditorService } from '@univerjs/docs-ui';
 import { IRenderManagerService } from '@univerjs/engine-render';
-import { IFormulaEditorManagerService } from '../../services/editor/formula-editor-manager.service';
 import { IEditorBridgeService } from '../../services/editor-bridge.service';
+import { IFormulaEditorManagerService } from '../../services/editor/formula-editor-manager.service';
 export declare class FormulaEditorController extends RxDisposable {
     private readonly _univerInstanceService;
     private readonly _renderManagerService;
@@ -12,8 +13,9 @@ export declare class FormulaEditorController extends RxDisposable {
     private readonly _formulaEditorManagerService;
     private readonly _undoRedoService;
     private readonly _textSelectionManagerService;
+    private readonly _editorService;
     private _loadedMap;
-    constructor(_univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _editorBridgeService: IEditorBridgeService, _commandService: ICommandService, _contextService: IContextService, _formulaEditorManagerService: IFormulaEditorManagerService, _undoRedoService: IUndoRedoService, _textSelectionManagerService: DocSelectionManagerService);
+    constructor(_univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService, _editorBridgeService: IEditorBridgeService, _commandService: ICommandService, _contextService: IContextService, _formulaEditorManagerService: IFormulaEditorManagerService, _undoRedoService: IUndoRedoService, _textSelectionManagerService: DocSelectionManagerService, _editorService: IEditorService);
     private _initialize;
     private _handleContentChange;
     private _create;

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

@@ -1,8 +1,12 @@
-import { Disposable, ICommandService, Injector, InterceptorManager, ThemeService, Workbook } from '@univerjs/core';
-import { SheetInterceptorService, SheetsSelectionsService } from '@univerjs/sheets';
+import { Workbook, Disposable, ICommandService, Injector, InterceptorManager, ThemeService } from '@univerjs/core';
 import { IRenderContext, IRenderModule } from '@univerjs/engine-render';
+import { SheetInterceptorService, SheetsSelectionsService } from '@univerjs/sheets';
 import { SheetScrollManagerService } from '../../services/scroll-manager.service';
 import { SheetSkeletonManagerService } from '../../services/sheet-skeleton-manager.service';
+export declare const FREEZE_ROW_MAIN_NAME = "__SpreadsheetFreezeRowMainName__";
+export declare const FREEZE_ROW_HEADER_NAME = "__SpreadsheetFreezeRowHeaderName__";
+export declare const FREEZE_COLUMN_MAIN_NAME = "__SpreadsheetFreezeColumnMainName__";
+export declare const FREEZE_COLUMN_HEADER_NAME = "__SpreadsheetFreezeColumnHeaderName__";
 export declare const FREEZE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, null>;
 export declare class HeaderFreezeRenderController extends Disposable implements IRenderModule {
     private readonly _context;

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

@@ -1,7 +1,8 @@
-import { DeviceInputEventType } from '@univerjs/engine-render';
+import { IEventBase, IRange, RichTextValue, FEventName } from '@univerjs/core';
+import { DeviceInputEventType, SpreadsheetSkeleton } from '@univerjs/engine-render';
+import { CommandListenerSkeletonChange } from '@univerjs/sheets';
 import { FRange, FWorkbook, FWorksheet } from '@univerjs/sheets/facade';
 import { KeyCode } from '@univerjs/ui';
-import { FEventName, IEventBase, RichTextValue } from '@univerjs/core';
 /**
  * Event interface triggered when cell editing starts
  * @interface ISheetEditStartedEventParams
@@ -119,6 +120,11 @@ export declare const CellFEventName: {
     readonly CellHover: "CellHover";
     readonly DragOver: "DragOver";
     readonly Drop: "Drop";
+    readonly Scroll: "Scroll";
+    readonly SelectionMoveStart: "SelectionMoveStart";
+    readonly SelectionMoving: "SelectionMoving";
+    readonly SelectionMoveEnd: "SelectionMoveEnd";
+    readonly SelectionChanged: "SelectionChanged";
 };
 export interface IFSheetsUIEventNameMixin {
     /**
@@ -230,60 +236,257 @@ export interface IFSheetsUIEventNameMixin {
     readonly SheetEditEnded: 'SheetEditEnded';
     /**
      * Event fired when a cell is clicked
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('CellClicked', (p)=> console.log(p));
+     * univerAPI.addEvent(univerAPI.Event.CellClicked, (params)=> {
+     *      const { worksheet, workbook, row, column, value, isZenEditor } = params;
+     * });
      * ```
      */
     readonly CellClicked: 'CellClicked';
     /**
      * Event fired when a cell is pointer down
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('CellPointerDown', (p)=> console.log(p));
+     * univerAPI.addEvent(univerAPI.Event.CellPointerDown, (params)=> {
+     *      const { worksheet, workbook, row, column } = params;
+     * });
      * ```
      */
     readonly CellPointerDown: 'CellPointerDown';
     /**
      * Event fired when a cell is pointer up
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('CellPointerUp', (p)=> console.log(p));
+     * univerAPI.addEvent(univerAPI.Event.CellPointerUp, (params)=> {
+     *      const { worksheet, workbook, row, column } = params;
+     * });
      * ```
      */
     readonly CellPointerUp: 'CellPointerUp';
     /**
      * Event fired when a cell is hovered
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('CellHover', (p)=> console.log(p));
+     * univerAPI.addEvent(univerAPI.Event.CellHover, (params)=> {
+     *      const { worksheet, workbook, row, column } = params;
+     * });
      * ```
      */
     readonly CellHover: 'CellHover';
     /**
      * Event fired when move on spreadsheet cells
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('CellPointerMove', (p)=> console.log(p));
+     * univerAPI.addEvent(univerAPI.Event.CellPointerMove, (params)=> {
+     *      const { worksheet, workbook, row, column } = params;
+     * });
      * ```
      */
     readonly CellPointerMove: 'CellPointerMove';
+    /**
+     * Triggered when a row header is clicked
+     * @param {ISheetRowHeaderEvent} params - Event parameters containing unitId, subUnitId, and row index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.RowHeaderClick, (params) => {
+     *   console.log(`Row ${params.row} header clicked in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly RowHeaderClick: 'RowHeaderClick';
+    /**
+     * Triggered when pointer is pressed down on a row header
+     * @param {ISheetRowHeaderEvent} params - Event parameters containing unitId, subUnitId, and row index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.RowHeaderPointerDown, (params) => {
+     *   console.log(`Pointer down on row ${params.row} header in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly RowHeaderPointerDown: 'RowHeaderPointerDown';
+    /**
+     * Triggered when pointer is released on a row header
+     * @param {ISheetRowHeaderEvent} params - Event parameters containing unitId, subUnitId, and row index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.RowHeaderPointerUp, (params) => {
+     *   console.log(`Pointer up on row ${params.row} header in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly RowHeaderPointerUp: 'RowHeaderPointerUp';
+    /**
+     * Triggered when pointer hovers over a row header
+     * @param {ISheetRowHeaderEvent} params - Event parameters containing unitId, subUnitId, and row index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.RowHeaderHover, (params) => {
+     *   console.log(`Hovering over row ${params.row} header in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly RowHeaderHover: 'RowHeaderHover';
+    /**
+     * Triggered when a column header is clicked
+     * @param {ISheetColumnHeaderEvent} params - Event parameters containing unitId, subUnitId, and column index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.ColumnHeaderClick, (params) => {
+     *   console.log(`Column ${params.column} header clicked in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly ColumnHeaderClick: 'ColumnHeaderClick';
+    /**
+     * Triggered when pointer is pressed down on a column header
+     * @param {ISheetColumnHeaderEvent} params - Event parameters containing unitId, subUnitId, and column index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.ColumnHeaderPointerDown, (params) => {
+     *   console.log(`Pointer down on column ${params.column} header in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly ColumnHeaderPointerDown: 'ColumnHeaderPointerDown';
+    /**
+     * Triggered when pointer is released on a column header
+     * @param {ISheetColumnHeaderEvent} params - Event parameters containing unitId, subUnitId, and column index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.ColumnHeaderPointerUp, (params) => {
+     *   console.log(`Pointer up on column ${params.column} header in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly ColumnHeaderPointerUp: 'ColumnHeaderPointerUp';
+    /**
+     * Triggered when pointer hovers over a column header
+     * @param {ISheetColumnHeaderEvent} params - Event parameters containing unitId, subUnitId, and column index
+     * @example
+     * ```typescript
+     * univerAPI.onSheetEvent(Event.ColumnHeaderHover, (params) => {
+     *   console.log(`Hovering over column ${params.column} header in sheet ${params.worksheet.getSheetId()}`);
+     * });
+     * ```
+     */
+    readonly ColumnHeaderHover: 'ColumnHeaderHover';
     /**
      * Event fired when drag over spreadsheet cells
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('DragOver', (p)=> console.log(p));
+     * univerAPI.getActiveWorkbook().addEvent(univerAPI.Event.DragOver, (params)=> {
+     *      const { worksheet, workbook, row, column } = params;
+     * });
      * ```
      */
     readonly DragOver: 'DragOver';
     /**
      * Event fired when drop on spreadsheet cells
+     * @see {@link ICellEventParam}
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('Drop', (p)=> console.log(p));
+     * univerAPI.getActiveWorkbook().addEvent(univerAPI.Event.Drop, (params)=> {
+     *      const { worksheet, workbook, row, column } = params;
+     * });
      * ```
      */
     readonly Drop: 'Drop';
+    /**
+     * Event fired when scroll spreadsheet.
+     * @see {@link IScrollEventParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.Scroll, (params)=> {
+     *      const { worksheet, workbook, scrollX, scrollY } = params;
+     * });
+     * ```
+     */
+    readonly Scroll: 'Scroll';
+    /**
+     * Event fired when selection changed.
+     * @see {@link ISelectionEventParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SelectionChanged, (p)=> {
+     *      const { worksheet, workbook, selections } = p;
+     * });
+     * ```
+     */
+    readonly SelectionChanged: 'SelectionChanged';
+    /**
+     * Event fired when selection move start
+     * @see {@link ISelectionEventParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SelectionMoveStart, (p)=> {
+     *      const { worksheet, workbook, selections } = p;
+     * });
+     * ```
+     */
+    readonly SelectionMoveStart: 'SelectionMoveStart';
+    /**
+     * Event fired when selection move end
+     * @see {@link ISelectionEventParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SelectionMoving, (p)=> {
+     *      const { worksheet, workbook, selections } = p;
+     * });
+     * ```
+     */
+    readonly SelectionMoving: 'SelectionMoving';
+    /**
+     * Event fired when selection move end
+     * @see {@link ISelectionEventParam}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SelectionMoveEnd, (p)=> {
+     *      const { worksheet, workbook, selections } = p;
+     * });
+     * ```
+     */
+    readonly SelectionMoveEnd: 'SelectionMoveEnd';
+    /**
+     * Event fired when zoom changed
+     * @see {@link ISheetZoomEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SheetZoomChanged, (p)=> {
+     *      const { worksheet, workbook, zoom } = p;
+     * });
+     * ```
+     */
+    readonly SheetZoomChanged: 'SheetZoomChanged';
+    /**
+     * Event fired before zoom changed
+     * @see {@link ISheetZoomEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.BeforeSheetZoomChange, (p)=> {
+     *      const { worksheet, workbook, zoom } = p;
+     * });
+     * ```
+     */
+    readonly BeforeSheetZoomChange: 'BeforeSheetZoomChange';
+    /**
+     * Event fired when sheet skeleton changed
+     * @see {@link ISheetSkeletonChangedEvent}
+     * @example
+     * ```ts
+     * univerAPI.addEvent(univerAPI.Event.SheetSkeletonChanged, (p)=> {
+     *      const { worksheet, workbook } = p;
+     * });
+     * ```
+     */
+    readonly SheetSkeletonChanged: 'SheetSkeletonChanged';
 }
 export declare class FSheetsUIEventName extends FEventName implements IFSheetsUIEventNameMixin {
     get BeforeClipboardChange(): 'BeforeClipboardChange';
@@ -302,8 +505,22 @@ export declare class FSheetsUIEventName extends FEventName implements IFSheetsUI
     get CellPointerMove(): 'CellPointerMove';
     get DragOver(): 'DragOver';
     get Drop(): 'Drop';
+    get Scroll(): 'Scroll';
+    get SelectionMoveStart(): 'SelectionMoveStart';
+    get SelectionChanged(): 'SelectionChanged';
+    get SelectionMoving(): 'SelectionMoving';
+    get SelectionMoveEnd(): 'SelectionMoveEnd';
+    get RowHeaderClick(): 'RowHeaderClick';
+    get RowHeaderPointerDown(): 'RowHeaderPointerDown';
+    get RowHeaderPointerUp(): 'RowHeaderPointerUp';
+    get RowHeaderHover(): 'RowHeaderHover';
+    get ColumnHeaderClick(): 'ColumnHeaderClick';
+    get ColumnHeaderPointerDown(): 'ColumnHeaderPointerDown';
+    get ColumnHeaderPointerUp(): 'ColumnHeaderPointerUp';
+    get ColumnHeaderHover(): 'ColumnHeaderHover';
+    get SheetSkeletonChanged(): 'SheetSkeletonChanged';
 }
-export interface IUIEventBase extends IEventBase {
+export interface ISheetUIEventBase extends IEventBase {
     /**
      * The workbook instance currently being operated on. {@link FWorkbook}
      */
@@ -359,10 +576,42 @@ export interface IBeforeClipboardPasteParam extends IEventBase {
     html?: string;
 }
 export type IClipboardPastedParam = IBeforeClipboardPasteParam;
-export interface ICellEventParam extends IUIEventBase {
+export interface ISheetZoomEvent extends IEventBase {
+    /**
+     * Zoom ratio
+     */
+    zoom: number;
+    /**
+     * The workbook instance currently being operated on. {@link FWorkbook}
+     */
+    workbook: FWorkbook;
+    /**
+     * The worksheet instance currently being operated on. {@link FWorkbook}
+     */
+    worksheet: FWorksheet;
+}
+export interface ICellEventParam extends ISheetUIEventBase {
     row: number;
     column: number;
 }
+export interface IScrollEventParam extends ISheetUIEventBase {
+    scrollX: number;
+    scrollY: number;
+}
+export interface ISelectionEventParam extends ISheetUIEventBase {
+    selections: IRange[];
+}
+export interface ISheetRowHeaderEvent extends ISheetUIEventBase {
+    row: number;
+}
+export interface ISheetColumnHeaderEvent extends ISheetUIEventBase {
+    column: number;
+}
+export interface ISheetSkeletonChangedEvent extends ISheetUIEventBase {
+    skeleton: SpreadsheetSkeleton;
+    payload: CommandListenerSkeletonChange;
+    effectedRanges: FRange[];
+}
 export interface IFSheetsUIEventParamConfig {
     BeforeClipboardChange: IBeforeClipboardChangeParam;
     ClipboardChanged: IClipboardChangedParam;
@@ -380,6 +629,25 @@ export interface IFSheetsUIEventParamConfig {
     CellPointerMove: ICellEventParam;
     Drop: ICellEventParam;
     DragOver: ICellEventParam;
+    RowHeaderClick: ISheetRowHeaderEvent;
+    RowHeaderDbClick: ISheetRowHeaderEvent;
+    RowHeaderHover: ISheetRowHeaderEvent;
+    RowHeaderPointerDown: ISheetRowHeaderEvent;
+    RowHeaderPointerUp: ISheetRowHeaderEvent;
+    ColumnHeaderClick: ISheetColumnHeaderEvent;
+    ColumnHeaderDbClick: ISheetColumnHeaderEvent;
+    ColumnHeaderHover: ISheetColumnHeaderEvent;
+    ColumnHeaderPointerDown: ISheetColumnHeaderEvent;
+    ColumnHeaderPointerUp: ISheetColumnHeaderEvent;
+    Scroll: IScrollEventParam;
+    SelectionChanging: ISelectionEventParam;
+    SelectionMoveStart: ISelectionEventParam;
+    SelectionMoving: ISelectionEventParam;
+    SelectionMoveEnd: ISelectionEventParam;
+    SelectionChanged: ISelectionEventParam;
+    SheetZoomChanged: ISheetZoomEvent;
+    BeforeSheetZoomChange: ISheetZoomEvent;
+    SheetSkeletonChanged: ISheetSkeletonChangedEvent;
 }
 declare module '@univerjs/core' {
     interface FEventName extends IFSheetsUIEventNameMixin {

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

@@ -55,11 +55,21 @@ interface IFRangeSheetsUIMixin {
      * @returns The disposable object to detach the popup, if the popup is not attached, return `null`.
      * @example
     ```
+        univerAPI.getComponentManager().register(
+            'myPopup',
+            () => React.createElement('div', {
+                style: {
+                    color: 'red',
+                    fontSize: '14px'
+                }
+            }, 'Custom Popup')
+        );
+
         let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
         let range = sheet.getRange(2, 2, 3, 3);
+        univerAPI.getActiveWorkbook().setActiveRange(range);
         let disposable = range.attachPopup({
-        componentKey: 'univer.sheet.cell-alert',
-        extraProps: { alert: { type: 0, title: 'This is an Info', message: 'This is an info message' } },
+            componentKey: 'myPopup'
         });
     ```
      */
@@ -76,6 +86,32 @@ interface IFRangeSheetsUIMixin {
      * ```
      */
     attachAlertPopup(alert: Omit<ICellAlert, 'location'>): IDisposable;
+    /**
+     * Attach a DOM popup to the current range.
+     * @param alert The alert to attach
+     * @returns The disposable object to detach the alert.
+     * @example
+     * ```ts
+        let sheet = univerAPI.getActiveWorkbook().getActiveSheet();
+        let range = sheet.getRange(2, 2, 3, 3);
+        univerAPI.getActiveWorkbook().setActiveRange(range);
+
+        univerAPI.getComponentManager().register(
+            'myPopup',
+            () => React.createElement('div', {
+                style: {
+                    background: 'red',
+                    fontSize: '14px'
+                }
+            }, 'Custom Popup')
+        );
+        let disposable = range.attachRangePopup({
+            componentKey: 'myPopup',
+            direction: 'top' // 'vertical' | 'horizontal' | 'top' | 'right' | 'left' | 'bottom' | 'bottom-center' | 'top-center';
+        });
+     * ```
+     */
+    attachRangePopup(popup: IFCanvasPopup): Nullable<IDisposable>;
     /**
      *  Highlight the range with the specified style and primary cell.
      * @param style - style for highlight range.
@@ -97,6 +133,7 @@ declare module '@univerjs/sheets/facade' {
  * Transform component key
  * @param {IFComponentKey} component - The component key to transform.
  * @param {ComponentManager} componentManager - The component manager to use for registration.
+ * @returns {string} The transformed component key.
  */
 export declare function transformComponentKey(component: IFComponentKey, componentManager: ComponentManager): {
     key: string;

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

@@ -7,7 +7,7 @@ export interface IFUniverSheetsUIMixin {
      * @param {IColumnsHeaderCfgParam} cfg The configuration of the column header.
      * @example
      * ```typescript
-     * univerAPI.customizeColumnHeader({ headerStyle: { backgroundColor: 'pink', fontSize: 9 }, columnsCfg: ['MokaII', undefined, null, { text: 'Size', textAlign: 'left' }] });
+     * univerAPI.customizeColumnHeader({ headerStyle: { fontColor: '#fff', size: 40, backgroundColor: '#4e69ee', fontSize: 9 }, columnsCfg: ['MokaII', undefined, null, { text: 'Size', textAlign: 'left' }] });
      * ```
      */
     customizeColumnHeader(cfg: IColumnsHeaderCfgParam): void;
@@ -48,6 +48,10 @@ export interface IFUniverSheetsUIMixin {
 }
 export declare class FUniverSheetsUIMixin extends FUniver implements IFUniverSheetsUIMixin {
     private _initSheetUIEvent;
+    _initObserverListener(injector: Injector): void;
+    /**
+     * @ignore
+     */
     _initialize(injector: Injector): void;
     private _generateClipboardCopyParam;
     private _beforeClipboardChange;

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

@@ -1,9 +1,9 @@
 import { IDisposable, Nullable } from '@univerjs/core';
 import { IMouseEvent, IPointerEvent } from '@univerjs/engine-render';
 import { ICellPosWithEvent, IDragCellPosition, IHoverRichTextInfo, IHoverRichTextPosition, IScrollState } from '@univerjs/sheets-ui';
+import { ICellEventParam } from './f-event';
 import { FWorkbook } from '@univerjs/sheets/facade';
 import { IDialogPartMethodOptions, ISidebarMethodOptions } from '@univerjs/ui';
-import { ICellEventParam, IFSheetsUIEventParamConfig } from './f-event';
 export interface IFWorkbookSheetsUIMixin {
     /**
      * Open a sidebar.
@@ -20,33 +20,32 @@ export interface IFWorkbookSheetsUIMixin {
      */
     openDialog(dialog: IDialogPartMethodOptions): IDisposable;
     /**
-     * Subscribe to cell click events
-     * @param callback - The callback function to be called when a cell is clicked
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.CellClick, () => {})` instead
      */
     onCellClick(callback: (cell: IHoverRichTextInfo) => void): IDisposable;
     /**
-     * Subscribe cell hover events
-     * @param callback - The callback function to be called when a cell is hovered
-     * @returns A disposable object that can be used to unsubscribe from the event
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.CellHover, () => {})` instead
      */
     onCellHover(callback: (cell: IHoverRichTextPosition) => void): IDisposable;
     /**
-     * Subscribe to pointer move events on workbook. Just like onCellHover, but with event information.
-     * @param {function(ICellPosWithEvent): any} callback The callback function accept cell location and event.
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.CellPointerMove, () => {})` instead
      */
     onCellPointerMove(callback: (cell: ICellPosWithEvent, event: IPointerEvent | IMouseEvent) => void): IDisposable;
     /**
-     * Subscribe to cell pointer down events.
-     * @param {function(ICellPosWithEvent): any} callback The callback function accept cell location and event.
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.CellPointerDown, () => {})` instead
      */
     onCellPointerDown(callback: (cell: ICellPosWithEvent) => void): IDisposable;
     /**
-     * Subscribe to cell pointer up events.
-     * @param {function(ICellPosWithEvent): any} callback The callback function accept cell location and event.
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.CellPointerUp, () => {})` instead
      */
     onCellPointerUp(callback: (cell: ICellPosWithEvent) => void): IDisposable;
+    /**
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.DragOver, () => {})` instead
+     */
     onDragOver(callback: (cell: IDragCellPosition) => void): IDisposable;
+    /**
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.Drop, () => {})` instead
+     */
     onDrop(callback: (cell: IDragCellPosition) => void): IDisposable;
     /**
      * Start the editing process
@@ -58,22 +57,18 @@ export interface IFWorkbookSheetsUIMixin {
      */
     startEditing(): boolean;
     /**
-     * Use endEditingAsync as instead
-     * @deprecated
-     * End the editing process
-     * @async
-     * @param save - Whether to save the changes
-     * @returns A promise that resolves to a boolean value
-     * @example
-     * ``` ts
-     * univerAPI.getActiveWorkbook().endEditing(true);
-     * ```
+     * @deprecated Use `endEditingAsync` as instead
      */
     endEditing(save?: boolean): Promise<boolean>;
     /**
      * @async
+     * End the editing process
      * @param {boolean} save - Whether to save the changes, default is true
      * @returns {Promise<boolean>} A promise that resolves to a boolean value
+     * @example
+     * ```ts
+     * await univerAPI.getActiveWorkbook().endEditingAsync(false);
+     * ```
      */
     endEditingAsync(save?: boolean): Promise<boolean>;
     getScrollStateBySheetId(sheetId: string): Nullable<IScrollState>;
@@ -115,7 +110,6 @@ export declare class FWorkbookSheetsUIMixin extends FWorkbook implements IFWorkb
     openSiderbar(params: ISidebarMethodOptions): IDisposable;
     openDialog(dialog: IDialogPartMethodOptions): IDisposable;
     private _logDeprecation;
-    addUIEvent(event: keyof IFSheetsUIEventParamConfig, _callback: (params: IFSheetsUIEventParamConfig[typeof event]) => void): IDisposable;
     generateCellParams(cell: IHoverRichTextPosition | ICellPosWithEvent): ICellEventParam;
     onCellClick(callback: (cell: IHoverRichTextInfo) => void): IDisposable;
     onCellHover(callback: (cell: IHoverRichTextPosition) => void): IDisposable;

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

@@ -1,4 +1,5 @@
 import { IDisposable, IRange, Nullable } from '@univerjs/core';
+import { SpreadsheetSkeleton } from '@univerjs/engine-render';
 import { IScrollState, IViewportScrollState } from '@univerjs/sheets-ui';
 import { FWorksheet } from '@univerjs/sheets/facade';
 export interface IFWorksheetSkeletonMixin {
@@ -65,14 +66,32 @@ export interface IFWorksheetSkeletonMixin {
      */
     getScrollState(): IScrollState;
     /**
-     * Invoked when scrolling the sheet.
-     * @param {function(Nullable<IViewportScrollState>): void} callback The scrolling callback function.
-     * @returns {IDisposable} The disposable object to remove the event listener.
+     * Get the skeleton service of the worksheet.
+     * @returns {Nullable<SpreadsheetSkeleton>} The skeleton of the worksheet.
      * @example
-     * ``` ts
-     * univerAPI.getActiveWorkbook().getActiveSheet().onScroll((params) => {...})
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const skeleton = fWorksheet.getSkeleton();
+     * console.log(skeleton);
      * ```
      */
+    getSkeleton(): Nullable<SpreadsheetSkeleton>;
+    /**
+     * Set the given column width to fix-content.
+     * @param {number} columnPosition - Column position
+     * @param {number} numColumn - Number of columns
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * fWorksheet.setColumnAutoWidth(0, 3);
+     * ```
+     */
+    setColumnAutoWidth(columnPosition: number, numColumn: number): FWorksheet;
+    /**
+     * @deprecated use `univerAPI.addEvent(univerAPI.Event.Scroll, () => {})` instead
+     */
     onScroll(callback: (params: Nullable<IViewportScrollState>) => void): IDisposable;
 }
 export declare class FWorksheetSkeletonMixin extends FWorksheet implements IFWorksheetSkeletonMixin {
@@ -83,6 +102,8 @@ export declare class FWorksheetSkeletonMixin extends FWorksheet implements IFWor
     scrollToCell(row: number, column: number): FWorksheet;
     getScrollState(): IScrollState;
     onScroll(callback: (params: Nullable<IViewportScrollState>) => void): IDisposable;
+    getSkeleton(): Nullable<SpreadsheetSkeleton>;
+    setColumnAutoWidth(columnPosition: number, numColumn: number): FWorksheet;
 }
 declare module '@univerjs/sheets/facade' {
     interface FWorksheet extends IFWorksheetSkeletonMixin {

package/lib/types/index.d.ts

@@ -92,6 +92,7 @@ export { FormatPainterStatus, IFormatPainterService } from './services/format-pa
 export type { IFormatPainterBeforeApplyHookParams, IFormatPainterHook } from './services/format-painter/format-painter.service';
 export { SELECTION_SHAPE_DEPTH } from './services/selection/const';
 export { type IBaseSheetBarProps } from './views/sheet-bar/sheet-bar-tabs/SheetBarItem';
+export { SetWorksheetColAutoWidthCommand } from './commands/commands/set-worksheet-auto-col-width.command';
 export { AutoClearContentCommand, AutoFillCommand } from './commands/commands/auto-fill.command';
 export { type ISheetPasteByShortKeyParams, type ISheetPasteParams, SheetCopyCommand, SheetCutCommand, SheetPasteBesidesBorderCommand, SheetPasteColWidthCommand, SheetPasteCommand, SheetPasteFormatCommand, SheetPasteShortKeyCommand, SheetPasteValueCommand, } from './commands/commands/clipboard.command';
 export { DeleteRangeMoveLeftConfirmCommand } from './commands/commands/delete-range-move-left-confirm.command';
@@ -108,7 +109,7 @@ export { ApplyFormatPainterCommand, SetInfiniteFormatPainterCommand, SetOnceForm
 export { SetColumnFrozenCommand, SetRowFrozenCommand, SetSelectionFrozenCommand } from './commands/commands/set-frozen.command';
 export { type IScrollCommandParams, type IScrollToCellCommandParams, type ISetScrollRelativeCommandParams, ResetScrollCommand, ScrollCommand, ScrollToCellCommand, SetScrollRelativeCommand, } from './commands/commands/set-scroll.command';
 export { ExpandSelectionCommand, JumpOver, MoveSelectionCommand, MoveSelectionEnterAndTabCommand, SelectAllCommand } from './commands/commands/set-selection.command';
-export { ChangeZoomRatioCommand, SetZoomRatioCommand } from './commands/commands/set-zoom-ratio.command';
+export { ChangeZoomRatioCommand, type ISetZoomRatioCommandParams, SetZoomRatioCommand } from './commands/commands/set-zoom-ratio.command';
 export { ShowMenuListCommand } from './commands/commands/unhide.command';
 export { ChangeSheetProtectionFromSheetBarCommand, DeleteWorksheetProtectionFormSheetBarCommand, } from './commands/commands/worksheet-protection.command';
 export { SetActivateCellEditOperation } from './commands/operations/activate-cell-edit.operation';