fix: add selection facade API (#4467)

e2e/memory/memory.spec.ts

@@ -57,4 +57,3 @@ test('memory', async ({ page }) => {
     const noUniverLeaking = memoryAfterDisposingUniver - memoryBeforeLoad <= MAX_UNIVER_MEMORY_OVERFLOW;
     expect(noUniverLeaking).toBeTruthy();
 });
-

packages/engine-render/src/render-manager/render-unit.ts

@@ -36,6 +36,7 @@ export interface IRender {
     isThumbNail?: boolean;
 
     with<T>(dependency: DependencyIdentifier<T>): T;
+    getRenderContext?(): IRenderContext;
 }
 
 /**
@@ -140,5 +141,8 @@ export class RenderUnit extends Disposable implements IRender {
             j.get(identifier);
         });
     }
-}
 
+    getRenderContext(): IRenderContext {
+        return this._renderContext;
+    }
+}

packages/facade/src/apis/__tests__/create-test-bed.ts

@@ -16,8 +16,9 @@
 
 /* eslint-disable max-lines-per-function */
 
-import type { Dependency, IWorkbookData, UnitModel } from '@univerjs/core';
+import type { Dependency, IWorkbookData, Nullable, UnitModel } from '@univerjs/core';
 import type { IRender } from '@univerjs/engine-render';
+import type { IDragCellPosition } from '@univerjs/sheets-ui';
 import {
     ILogService,
     Inject,
@@ -58,9 +59,10 @@ import {
 import enUS from '@univerjs/sheets-formula-ui/locale/en-US';
 import zhCN from '@univerjs/sheets-formula-ui/locale/zh-CN';
 import { SheetsThreadCommentModel } from '@univerjs/sheets-thread-comment';
-import { ISheetSelectionRenderService, SheetRenderController, SheetSelectionRenderService, SheetSkeletonManagerService, SheetsRenderService } from '@univerjs/sheets-ui';
+import { DragManagerService, HoverManagerService, ISheetSelectionRenderService, SheetRenderController, SheetScrollManagerService, SheetSelectionRenderService, SheetSkeletonManagerService, SheetsRenderService } from '@univerjs/sheets-ui';
 import { IThreadCommentDataSourceService, ThreadCommentDataSourceService, ThreadCommentModel } from '@univerjs/thread-comment';
 import { IPlatformService, IShortcutService, PlatformService, ShortcutService } from '@univerjs/ui';
+import { Subject } from 'rxjs';
 import { FUniver } from '../everything';
 
 function getTestWorkbookDataDemo(): IWorkbookData {
@@ -176,10 +178,20 @@ export function createFacadeTestBed(workbookData?: IWorkbookData, dependencies?:
             injector.add([RangeProtectionRuleModel]);
             injector.add([WorksheetProtectionRuleModel]);
             injector.add([IDefinedNamesService, { useClass: DefinedNamesService }]);
+            // Create a mock HoverManagerService with currentCell$
+            const mockHoverManagerService = {
+                currentCell$: new Subject<Nullable<IDragCellPosition>>().asObservable(),
+                currentPosition$: new Subject<Nullable<IDragCellPosition>>().asObservable(),
+                currentClickedCell$: new Subject<Nullable<IDragCellPosition>>().asObservable(),
+                endCell$: new Subject<Nullable<IDragCellPosition>>().asObservable(),
+            };
+            injector.add([HoverManagerService, { useValue: mockHoverManagerService as unknown as HoverManagerService }]);
+            injector.add([DragManagerService, { useValue: mockHoverManagerService as unknown as DragManagerService }]);
 
             const renderManagerService = injector.get(IRenderManagerService);
             renderManagerService.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetSkeletonManagerService] as Dependency);
             renderManagerService.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetRenderController] as Dependency);
+            renderManagerService.registerRenderModule(UniverInstanceType.UNIVER_SHEET, [SheetScrollManagerService] as Dependency);
 
             // register feature modules
             ([

packages/sheets-data-validation/src/facade/f-univer.ts

@@ -121,6 +121,7 @@ export class FUnvierDataValidationMixin extends FUniver {
                         ruleId: params.ruleId,
                         newCriteria: params.setting,
                     };
+
                     this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, eventParams);
                     if (eventParams.cancel) {
                         throw new CanceledError();

packages/sheets-ui/src/facade/f-event.ts

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+import type { IEventBase, IRange, RichTextValue } from '@univerjs/core';
 import type { DeviceInputEventType } from '@univerjs/engine-render';
 import type { FRange, FWorkbook, FWorksheet } from '@univerjs/sheets/facade';
 import type { KeyCode } from '@univerjs/ui';
-import { FEventName, type IEventBase, type RichTextValue } from '@univerjs/core';
+import { FEventName } from '@univerjs/core';
 
 /**
  * Event interface triggered when cell editing starts
@@ -141,6 +142,11 @@ export const CellFEventName = {
     CellHover: 'CellHover',
     DragOver: 'DragOver',
     Drop: 'Drop',
+    Scroll: 'Scroll',
+    SelectionMoveStart: 'SelectionMoveStart',
+    SelectionMoving: 'SelectionMoving',
+    SelectionMoveEnd: 'SelectionMoveEnd',
+    SelectionChanged: 'SelectionChanged',
 } as const;
 
 export interface IFSheetsUIEventNameMixin {
@@ -309,10 +315,56 @@ export interface IFSheetsUIEventNameMixin {
      * Event fired when drop on spreadsheet cells
      * @example
      * ```ts
-     * univerAPI.getActiveWorkbook().addEvent('Drop', (p)=> console.log(p));
+     * univerAPI.addEvent('Drop', (p)=> console.log(p));
      * ```
      */
     readonly Drop: 'Drop';
+
+    /**
+     * Event fired when scroll spreadsheet.
+     * @example
+     * ```ts
+     * univerAPI.addEvent('Scroll', (p)=> console.log(p));
+     * ```
+     */
+    readonly Scroll: 'Scroll';
+
+    /**
+     * Event fired when selection changed.
+     * @example
+     * ```ts
+     * univerAPI.addEvent('SelectionChanged', (p)=> console.log(p));
+     * ```
+     */
+    readonly SelectionChanged: 'SelectionChanged';
+
+    /**
+     * Event fired when selection move end
+     * @example
+     * ```ts
+     * univerAPI.addEvent('SelectionMoveStart', (p)=> console.log(p));
+     * ```
+     */
+    readonly SelectionMoveStart: 'SelectionMoveStart';
+
+    /**
+     * Event fired when selection move end
+     * @example
+     * ```ts
+     * univerAPI.addEvent('SelectionMoving', (p)=> console.log(p));
+     * ```
+     */
+    readonly SelectionMoving: 'SelectionMoving';
+
+    /**
+     * Event fired when selection move end
+     * @example
+     * ```ts
+     * univerAPI.addEvent('SelectionMoveEnd', (p)=> console.log(p));
+     * ```
+     */
+    readonly SelectionMoveEnd: 'SelectionMoveEnd';
+
 }
 
 export class FSheetsUIEventName extends FEventName implements IFSheetsUIEventNameMixin {
@@ -379,9 +431,29 @@ export class FSheetsUIEventName extends FEventName implements IFSheetsUIEventNam
     override get Drop(): 'Drop' {
         return 'Drop' as const;
     }
+
+    override get Scroll(): 'Scroll' {
+        return 'Scroll' as const;
+    }
+
+    override get SelectionMoveStart(): 'SelectionMoveStart' {
+        return 'SelectionMoveStart' as const;
+    }
+
+    override get SelectionChanged(): 'SelectionChanged' {
+        return 'SelectionChanged' as const;
+    }
+
+    override get SelectionMoving(): 'SelectionMoving' {
+        return 'SelectionMoving' as const;
+    }
+
+    override get SelectionMoveEnd(): 'SelectionMoveEnd' {
+        return 'SelectionMoveEnd' as const;
+    }
 }
 
-export interface IUIEventBase extends IEventBase {
+export interface ISheetUIEventBase extends IEventBase {
     /**
      * The workbook instance currently being operated on. {@link FWorkbook}
      */
@@ -441,10 +513,20 @@ export interface IBeforeClipboardPasteParam extends IEventBase {
 
 export type IClipboardPastedParam = IBeforeClipboardPasteParam;
 
-export interface ICellEventParam extends IUIEventBase {
+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 IFSheetsUIEventParamConfig {
     BeforeClipboardChange: IBeforeClipboardChangeParam;
     ClipboardChanged: IClipboardChangedParam;
@@ -464,6 +546,13 @@ export interface IFSheetsUIEventParamConfig {
     CellPointerMove: ICellEventParam;
     Drop: ICellEventParam;
     DragOver: ICellEventParam;
+
+    Scroll: IScrollEventParam;
+    SelectionChanging: ISelectionEventParam;
+    SelectionMoveStart: ISelectionEventParam;
+    SelectionMoving: ISelectionEventParam;
+    SelectionMoveEnd: ISelectionEventParam;
+    SelectionChanged: ISelectionEventParam;
 }
 
 FEventName.extend(FSheetsUIEventName);

packages/sheets-ui/src/facade/f-univer.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import type { DocumentDataModel, IDisposable, Injector, Nullable } from '@univerjs/core';
+import type { DocumentDataModel, IDisposable, Injector, IRange, Nullable, Workbook } from '@univerjs/core';
 import type { IRichTextEditingMutationParams } from '@univerjs/docs';
 import type {
     IColumnsHeaderCfgParam,
@@ -25,14 +25,17 @@ import type {
     SpreadsheetColumnHeader,
     SpreadsheetRowHeader,
 } from '@univerjs/engine-render';
-import type { IEditorBridgeServiceVisibleParam, ISheetPasteByShortKeyParams } from '@univerjs/sheets-ui';
-import type { IBeforeClipboardChangeParam, IBeforeClipboardPasteParam, IBeforeSheetEditEndEventParams, IBeforeSheetEditStartEventParams, ISheetEditChangingEventParams, ISheetEditEndedEventParams, ISheetEditStartedEventParams } from './f-event';
-import { CanceledError, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, FUniver, ICommandService, ILogService, IUniverInstanceService, RichTextValue, toDisposable } from '@univerjs/core';
+import type { IEditorBridgeServiceVisibleParam, ISheetPasteByShortKeyParams, IViewportScrollState } from '@univerjs/sheets-ui';
+import type { FWorksheet } from '@univerjs/sheets/facade';
+import type { IBeforeClipboardChangeParam, IBeforeClipboardPasteParam, IBeforeSheetEditEndEventParams, IBeforeSheetEditStartEventParams, ICellEventParam, IScrollEventParam, ISheetEditChangingEventParams, ISheetEditEndedEventParams, ISheetEditStartedEventParams } from './f-event';
+import { CanceledError, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, FUniver, ICommandService, ILogService, IUniverInstanceService, LifecycleService, LifecycleStages, RichTextValue, toDisposable } from '@univerjs/core';
 import { RichTextEditingMutation } from '@univerjs/docs';
 import { IRenderManagerService } from '@univerjs/engine-render';
+import { UniverType } from '@univerjs/protocol';
 import { IEditorBridgeService, ISheetClipboardService, SetCellEditVisibleOperation, SHEET_VIEW_KEY, SheetPasteShortKeyCommand } from '@univerjs/sheets-ui';
-import { FSheetHooks } from '@univerjs/sheets/facade';
+import { FSheetHooks, FWorkbook } from '@univerjs/sheets/facade';
 import { CopyCommand, CutCommand, HTML_CLIPBOARD_MIME_TYPE, IClipboardInterfaceService, KeyCode, PasteCommand, PLAIN_TEXT_CLIPBOARD_MIME_TYPE, supportClipboardAPI } from '@univerjs/ui';
+import { combineLatest } from 'rxjs';
 
 export interface IFUniverSheetsUIMixin {
     /**
@@ -203,6 +206,106 @@ export class FUniverSheetsUIMixin extends FUniver implements IFUniverSheetsUIMix
                 }
             }
         }));
+
+        this._initObserverListener(injector);
+    }
+
+    // eslint-disable-next-line max-lines-per-function
+    _initObserverListener(injector: Injector): void {
+        const univerInstanceService = injector.get(IUniverInstanceService);
+        const unitM = univerInstanceService.getFocusedUnit();
+        const unitId = unitM?.getUnitId();
+        const renderManagerService = injector.get(IRenderManagerService);
+        if (unitId) {
+            const lifeCycleService = this._injector.get(LifecycleService);
+
+            let workbook: Nullable<FWorkbook>;
+            let worksheet: Nullable<FWorksheet>;
+
+            const combined$ = combineLatest([lifeCycleService.lifecycle$, renderManagerService.created$]);
+            combined$.subscribe(([lifecycle, r]) => {
+                if (r.type === UniverType.UNIVER_SHEET) {
+                    if (r.getRenderContext) {
+                        const wb = r.getRenderContext()?.unit as Workbook;
+                        if (wb) {
+                            workbook = this._injector.createInstance(FWorkbook, wb);
+                        }
+                    }
+
+                    worksheet = workbook?.getActiveSheet();
+                }
+                if (lifecycle < LifecycleStages.Rendered) return;
+
+                if (!workbook || !worksheet) return;
+                const baseParams = {
+                    workbook,
+                    worksheet,
+                };
+
+                workbook.onScroll((params: Nullable<IViewportScrollState>) => {
+                    this.fireEvent(this.Event.Scroll, {
+                        scrollX: params?.viewportScrollX,
+                        scrollY: params?.viewportScrollY,
+                        ...baseParams,
+                    } as IScrollEventParam);
+                });
+                workbook.onCellClick((cell) => {
+                    this.fireEvent(this.Event.CellClicked, {
+                        row: cell.location.row,
+                        column: cell.location.col,
+                        ...baseParams,
+                    } as ICellEventParam);
+                });
+
+                workbook.onDrop((cell) => {
+                    this.fireEvent(this.Event.Drop, {
+                        row: cell.location.row,
+                        column: cell.location.col,
+                        ...baseParams,
+                    });
+                });
+
+                workbook.onSelectionMoveStart((selections: IRange[]) => {
+                    this.fireEvent(this.Event.SelectionMoveStart, {
+                        selections,
+                        ...baseParams,
+                    });
+                });
+
+                workbook.onSelectionMoving((selections: IRange[]) => {
+                    this.fireEvent(this.Event.SelectionMoving, {
+                        selections,
+                        ...baseParams,
+                    });
+                });
+
+                workbook.onSelectionMoving((selections: IRange[]) => {
+                    this.fireEvent(this.Event.SelectionMoving, {
+                        selections,
+                        ...baseParams,
+                    });
+                });
+
+                workbook.onSelectionMoveEnd((selections: IRange[]) => {
+                    this.fireEvent(this.Event.SelectionMoveEnd, {
+                        selections,
+                        ...baseParams,
+                    });
+                });
+
+                workbook.onSelectionChanged((selections: IRange[]) => {
+                    this.fireEvent(this.Event.SelectionChanged, {
+                        selections,
+                        ...baseParams,
+                    });
+                });
+            });
+        }
+
+        // too late!
+        // univerInstanceService.unitAdded$.subscribe((p) => {
+        //     console.log('univer ins add', p.getUnitId());
+        // });
     }
 
     override _initialize(injector: Injector): void {