@univerjs/sheets-ui 0.1.16 → 0.2.0

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

@@ -1,19 +1,46 @@
 import { IUniverInstanceService, Nullable } from '@univerjs/core';
+import { BehaviorSubject } from 'rxjs';
 import { IRenderManagerService } from '@univerjs/engine-render';
 
+export interface IViewportScrollState {
+    scrollX: number;
+    scrollY: number;
+    viewportScrollX: number;
+    viewportScrollY: number;
+}
 export interface IScrollManagerParam {
+    /**
+     * offsetX from startRow, coordinate same as viewport, not scrollbar
+     */
     offsetX: number;
+    /**
+     * offsetY from startColumn, coordinate same as viewport, not scrollbar
+     */
     offsetY: number;
+    /**
+     * currrent start row in viewport visible area
+     */
     sheetViewStartRow: number;
+    /**
+     * current start column in viewport visible area
+     */
     sheetViewStartColumn: number;
+    /**
+     * overall offsetX from sheet cotent topleft, should be same as startRow * rowHeight + offsetY
+     * coordinate same as viewport, not scrollbar
+     */
     viewportScrollX?: number;
+    /**
+     * overall offsetY from sheet content topleft, should be same as startColumn * columnWidth + offsetX
+     * coordinate same as viewport, not scrollbar
+     */
     viewportScrollY?: number;
 }
 export interface IScrollManagerSearchParam {
     unitId: string;
     sheetId: string;
 }
-export interface IScrollManagerInsertParam extends IScrollManagerSearchParam, IScrollManagerParam {
+export interface IScrollManagerWithSearchParam extends IScrollManagerSearchParam, IScrollManagerParam {
 }
 export type IScrollInfo = Map<string, Map<string, IScrollManagerParam>>;
 /**
@@ -25,9 +52,27 @@ export type IScrollInfo = Map<string, Map<string, IScrollManagerParam>>;
 export declare class ScrollManagerService {
     private readonly _univerInstanceService;
     private readonly _renderManagerService;
-    private readonly _scrollInfo;
+    /**
+     * a map holds all scroll info for each sheet
+     */
+    private readonly _scrollInfoMap;
+    /**
+     * a subject for current sheet scrollInfo
+     */
     private readonly _scrollInfo$;
-    readonly scrollInfo$: import('rxjs').Observable<Nullable<IScrollManagerParam>>;
+    /**
+     * a subject for current sheet scrollInfo ( events, ex wheel event and point events add deltaXY to rawScrollInfo$)
+     */
+    readonly rawScrollInfo$: import('rxjs').Observable<Nullable<IScrollManagerParam>>;
+    /**
+     * a subject for current valid scrollInfo, viewport@_scrollCore would limit rawScrollInfo$ exclude negative value or over max value.
+     * use this subject not rawScrollInfo$ when get scrolling state of viewport.
+     */
+    readonly validViewportScrollInfo$: BehaviorSubject<Nullable<IViewportScrollState>>;
+    /**
+     * a subject for current valid scrollInfo, viewport@_scrollCore would limit rawScrollInfo$ exclude negative value or over max value.
+     * use this subject not rawScrollInfo$ when get scrolling state of viewport.
+     */
     private _searchParamForScroll;
     constructor(_univerInstanceService: IUniverInstanceService, _renderManagerService: IRenderManagerService);
     dispose(): void;
@@ -39,26 +84,30 @@ export declare class ScrollManagerService {
     /**
      * set scrollInfo by cmd,
      * call _setScrollInfo twice after one scrolling.
-     * first time set scrollInfo bt scrollOperation, but offsetXY is derived from scroll event.
+     * first time set scrollInfo by scrollOperation, but offsetXY is derived from scroll event.
      * second time set scrollInfo by viewport.scrollTo(scrol.render-controller --> onScrollAfterObserver), this time offsetXY has been limited.
      *
-     * wheelevent --> sheetCanvasView -->  set-scroll.command('sheet.command.set-scroll-relative') --> scrollOperation --> this.setScrollInfo  --> scrollInfo$.next --> scroll.render-controller@viewportMain.scrollTo & notify -->
-     * scroll.render-controller@onScrollAfterObserver --> this.setScrollInfoToCurrSheetWithoutNotify --> this._setScrollInfo({}, false)
+     * wheelevent --> sheetCanvasView -->  set-scroll.command('sheet.command.set-scroll-relative') --> scrollOperation --> scrollManagerService.setScrollInfo  --> scrollInfo$.next --> scroll.render-controller@viewportMain.scrollTo & notify -->
+     * scroll.render-controller@onScrollAfter$ --> this.setScrollInfoToCurrSheetWithoutNotify --> this._setScrollInfo({}, false)
      * call _setScrollInfo again, a loop!, so we should call setScrollInfoToCurrSheetWithoutNotify
      * @param param
      */
-    setScrollInfo(param: IScrollManagerInsertParam): void;
-    setScrollInfoToCurrSheet(scrollInfo: IScrollManagerParam): void;
-    setScrollInfoToCurrSheetWithoutNotify(scroll: IScrollManagerParam): void;
+    setScrollInfoAndEmitEvent(param: IScrollManagerWithSearchParam): void;
+    setScrollInfoToCurrSheetAndEmitEvent(scrollInfo: IScrollManagerParam): void;
+    /**
+     * call _setScrollInfo but no _scrollInfo$.next
+     * @param scroll
+     */
+    justSetScrollInfoToCurrSheet(scroll: IScrollManagerParam): void;
     clear(): void;
-    calcViewportScrollFromOffset(scrollInfo: IScrollManagerInsertParam): {
+    calcViewportScrollFromRowColOffset(scrollInfo: IScrollManagerWithSearchParam): {
         scrollTop: number;
         scrollLeft: number;
-        viewportScrollX?: undefined;
-        viewportScrollY?: undefined;
+        overallScrollX?: undefined;
+        overallScrollY?: undefined;
     } | {
-        viewportScrollX: number;
-        viewportScrollY: number;
+        overallScrollX: number;
+        overallScrollY: number;
         scrollTop?: undefined;
         scrollLeft?: undefined;
     };

package/lib/types/services/selection/mobile-selection-render.service.d.ts

@@ -0,0 +1,179 @@
+import { IRange, IRangeWithCoord, ISelection, ISelectionCell, ISelectionCellWithMergeInfo, Nullable, InterceptorManager, RANGE_TYPE, ThemeService } from '@univerjs/core';
+import { IMouseEvent, IPointerEvent, Scene, SpreadsheetSkeleton, Viewport, IRenderManagerService } from '@univerjs/engine-render';
+import { ISelectionStyle, ISelectionWithCoordAndStyle, ISelectionWithStyle } from '@univerjs/sheets';
+import { IShortcutService } from '@univerjs/ui';
+import { Injector } from '@wendellhu/redi';
+import { SelectionControl } from './selection-shape';
+import { IControlFillConfig, ISelectionRenderService } from './selection-render.service';
+import { MobileSelectionControl } from './mobile-selection-shape';
+
+declare enum ExpandingControl {
+    BOTTOM_RIGHT = "bottom-right",
+    TOP_LEFT = "top-left",
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom"
+}
+export declare class MobileSelectionRenderService implements ISelectionRenderService {
+    private readonly _themeService;
+    private readonly _shortcutService;
+    private readonly _renderManagerService;
+    private readonly _injector;
+    hasSelection: boolean;
+    private _pointerdownSub;
+    private _mainScenePointerUpSub;
+    private _scenePointerMoveSub;
+    private _scenePointerUpSub;
+    private _controlFillConfig$;
+    readonly controlFillConfig$: import('rxjs').Observable<IControlFillConfig | null>;
+    private _selectionControls;
+    private _activeCellRangeOfCurrSelection;
+    private _startOffsetX;
+    private _startOffsetY;
+    private _scrollTimer;
+    private _skeleton;
+    private _scene;
+    private _isHeaderHighlight;
+    private _isDetectMergedCell;
+    private _selectionStyle;
+    private _isSelectionEnabled;
+    private _isShowPreviousEnable;
+    private _isRemainLastEnable;
+    private _isSkipRemainLastEnable;
+    private _isSingleSelection;
+    private readonly _selectionMoveEnd$;
+    readonly selectionMoveEnd$: import('rxjs').Observable<ISelectionWithCoordAndStyle[]>;
+    private readonly _selectionMoving$;
+    /**
+     * Triggered during the drawing of the selection area.
+     */
+    readonly selectionMoving$: import('rxjs').Observable<ISelectionWithCoordAndStyle[]>;
+    private readonly _selectionMoveStart$;
+    /**
+     * Triggered during the start draw the selection area.
+     */
+    readonly selectionMoveStart$: import('rxjs').Observable<ISelectionWithCoordAndStyle[]>;
+    private _activeViewport;
+    /**
+     * This service relies on the scene and skeleton to work
+     * Use usable$ to check if this service works
+     */
+    private readonly _usable$;
+    readonly usable$: import('rxjs').Observable<boolean>;
+    interceptor: InterceptorManager<{
+        RANGE_MOVE_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, null>;
+        RANGE_FILL_PERMISSION_CHECK: import('@univerjs/core').IInterceptor<boolean, {
+            x: number;
+            y: number;
+            skeleton: SpreadsheetSkeleton;
+            scene: Scene;
+        }>;
+    }>;
+    expandingControlMode: ExpandingControl;
+    constructor(_themeService: ThemeService, _shortcutService: IShortcutService, _renderManagerService: IRenderManagerService, _injector: Injector);
+    enableHeaderHighlight(): void;
+    disableHeaderHighlight(): void;
+    enableDetectMergedCell(): void;
+    disableDetectMergedCell(): void;
+    setStyle(style: ISelectionStyle): void;
+    resetStyle(): void;
+    enableSelection(): void;
+    disableSelection(): void;
+    enableShowPrevious(): void;
+    disableShowPrevious(): void;
+    enableRemainLast(): void;
+    disableRemainLast(): void;
+    enableSkipRemainLast(): void;
+    disableSkipRemainLast(): void;
+    enableSingleSelection(): void;
+    disableSingleSelection(): void;
+    getViewPort(): Viewport;
+    /**
+     * add a selection
+     *
+     * in PC:init & pointerup would call this function.
+     *
+     * init
+     * selectionController@_initSkeletonChangeListener --> selectionManagerService.add --> selectionManagerService._selectionMoveEnd$ --> this.addControlToCurrentByRangeData
+     *
+     * selectionMoveEnd$ --> this.addSelectionControlBySelectionData
+     *
+     *
+     *
+     * pointer
+     * engine@_pointerDownEvent --> spreadsheet?.onPointerDownObserve --> eventTrigger --> scene@disableEvent() --> then scene.input-manager currentObject is always scene until scene@enableEvent.
+     * engine@_pointerUpEvent --> scene.input-manager@_onPointerUp --> this._selectionMoveEnd$ --> _selectionManagerService.selectionMoveEnd$ --> this.addControlToCurrentByRangeData
+     *
+     * but in mobile, we do not call disableEvent() in eventTrigger,
+     * so pointerup --> scene.input-manager currentObject is spreadsheet --> this.eventTrigger
+     *
+     *
+     *
+     * @param selectionData
+     */
+    addSelectionControlBySelectionData(selectionData: ISelectionWithCoordAndStyle): void;
+    newSelectionControl(scene: Scene, rangeType: RANGE_TYPE): MobileSelectionControl;
+    updateControlForCurrentByRangeData(selections: ISelectionWithCoordAndStyle[]): void;
+    refreshSelectionMoveStart(): void;
+    changeRuntime(skeleton: Nullable<SpreadsheetSkeleton>, scene: Nullable<Scene>, viewport?: Viewport): void;
+    getSelectionDataWithStyle(): ISelectionWithCoordAndStyle[];
+    getSelectionControls(): SelectionControl[];
+    private _clearSelectionControls;
+    private _getFreeze;
+    private _getViewportByCell;
+    /**
+     * Returns the list of active ranges in the active sheet or null if there are no active ranges.
+     * If there is a single range selected, this method behaves like a getActiveRange() call.
+     */
+    getActiveSelections(): Nullable<ISelection[]>;
+    /**
+     * Returns the selected range in the active sheet, or null if there is no active range. If multiple ranges are selected this method returns only the last selected range.
+     */
+    getActiveRange(): Nullable<IRange>;
+    /**
+     * get last selection control
+     */
+    getActiveSelectionControl(): Nullable<SelectionControl>;
+    endSelection(): void;
+    reset(): void;
+    resetAndEndSelection(): void;
+    expandingSelection: boolean;
+    /**
+     * invoked when pointerup or longpress on spreadsheet, or pointerdown on row&col
+     * then move curr selection to cell at cursor
+     * Main perpose to create a new selection, or update curr selection to a new range.
+     * @param evt
+     * @param _zIndex
+     * @param rangeType
+     * @param viewport
+     */
+    eventTrigger(evt: IPointerEvent | IMouseEvent, _zIndex?: number, rangeType?: RANGE_TYPE, viewport?: Viewport): false | undefined;
+    /**
+     *
+     * @param evt component point event
+     * @param style selection style, Styles for user-customized selectors
+     * @param zIndex Stacking order of the selection object
+     * @param rangeType Determines whether the selection is made normally according to the range or by rows and columns
+     *
+     * invoked by selection.render-controller@pointerDownObserver
+     *
+     * derived from eventTrigger
+     */
+    private _fillControlPointerDownHandler;
+    attachSelectionWithCoord(selectionWithStyle: ISelectionWithStyle): ISelectionWithCoordAndStyle;
+    attachRangeWithCoord(range: IRange): Nullable<IRangeWithCoord>;
+    attachPrimaryWithCoord(primary: Nullable<ISelectionCell>): Nullable<ISelectionCellWithMergeInfo>;
+    getSelectionCellByPosition(x: number, y: number): Nullable<ISelectionCellWithMergeInfo>;
+    /**
+     * When mousedown and mouseup need to go to the coordination and undo stack, when mousemove does not need to go to the coordination and undo stack
+     */
+    private _movingHandler;
+    /**
+     * rm pointerUp & pointerMove Observer on scene
+     */
+    private _endSelection;
+    private _addCancelObserver;
+    private _getCellRangeByCursorPosition;
+}
+export {};

package/lib/types/services/selection/mobile-selection-shape.d.ts

@@ -0,0 +1,53 @@
+import { IRangeWithCoord, Nullable, ThemeService, RANGE_TYPE } from '@univerjs/core';
+import { IRectProps, Scene, Rect } from '@univerjs/engine-render';
+import { ISelectionStyle } from '@univerjs/sheets';
+import { SelectionControl } from './selection-shape';
+
+export declare class MobileSelectionControl extends SelectionControl {
+    protected _scene: Scene;
+    protected _zIndex: number;
+    protected _isHeaderHighlight: boolean;
+    protected readonly _themeService: ThemeService;
+    protected _rangeType: RANGE_TYPE;
+    /**
+     * topLeft controlPointer, it is not visible, just transparent, for handling event.
+     */
+    private _fillControlTopLeft;
+    /**
+     * bottomRight controlPointer, it is not visible, just transparent, for handling event.
+     */
+    private _fillControlBottomRight;
+    /**
+     * a very small visible point, placed in control pointer
+     */
+    private _fillControlTopLeftInner;
+    /**
+     * a very small visible point, placed in control pointer
+     */
+    private _fillControlBottomRightInner;
+    constructor(_scene: Scene, _zIndex: number, _isHeaderHighlight: boolean, _themeService: ThemeService, _rangeType?: RANGE_TYPE);
+    initControlPoints(): void;
+    get fillControlTopLeft(): Rect<IRectProps> | null;
+    set fillControlTopLeft(value: Rect);
+    get fillControlBottomRight(): Rect<IRectProps> | null;
+    set fillControlBottomRight(value: Rect);
+    get rangeType(): RANGE_TYPE;
+    set rangeType(value: RANGE_TYPE);
+    dispose(): void;
+    updateRange(range: IRangeWithCoord): void;
+    protected _updateControl(style: Nullable<ISelectionStyle>, rowHeaderWidth: number, columnHeaderHeight: number): void;
+    getViewportMainScrollInfo(): {
+        viewportScrollX: number;
+        viewportScrollY: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Mainly for row & col selection control point position. update control point position by when scrolling.
+     * @param viewportScrollX viewportScrollX
+     * @param viewportScrollY
+     * @param sheetContentWidth
+     * @param sheetContentHeight max sheet content height, for very short sheet, control pointer shoud not out of sheet
+     */
+    transformControlPoint(viewportScrollX?: number, viewportScrollY?: number, sheetContentWidth?: number, sheetContentHeight?: number): void;
+}

package/lib/types/services/selection/selection-render-model.d.ts

@@ -1,4 +1,4 @@
-import { IRangeWithCoord, ISelectionCellWithCoord, ISelectionWithCoord, Nullable, RANGE_TYPE } from '@univerjs/core';
+import { IRangeWithCoord, ISelectionCellWithMergeInfo, ISelectionWithCoord, Nullable, RANGE_TYPE } from '@univerjs/core';
 
 export declare class SelectionRenderModel implements IRangeWithCoord {
     private _startColumn;
@@ -12,6 +12,11 @@ export declare class SelectionRenderModel implements IRangeWithCoord {
     private _startY;
     private _endX;
     private _endY;
+    /**
+     * highlight cell of selection
+     * when there is no merge info
+     * top left cell of current selection (or bottomLeft of current selection)
+     */
     private _currentCell;
     private _rangeType;
     get startColumn(): number;
@@ -34,7 +39,10 @@ export declare class SelectionRenderModel implements IRangeWithCoord {
      * value from { startY, endY, startX, endX } = getCellPositionByIndex in basics/tools
      */
     get endY(): number;
-    get currentCell(): Nullable<ISelectionCellWithCoord>;
+    /**
+     * highlight cell of selection
+     */
+    get currentCell(): Nullable<ISelectionCellWithMergeInfo>;
     get rangeType(): RANGE_TYPE;
     isEqual(rangeWithCoord: IRangeWithCoord): boolean;
     isInclude(rangeWithCoord: IRangeWithCoord): boolean;
@@ -50,10 +58,11 @@ export declare class SelectionRenderModel implements IRangeWithCoord {
         endY: number;
         rangeType: RANGE_TYPE;
     };
-    getCell(): Nullable<ISelectionCellWithCoord>;
+    getCell(): Nullable<ISelectionCellWithMergeInfo>;
     getRangeType(): RANGE_TYPE;
+    setRangeType(rangeType: RANGE_TYPE): void;
     getValue(): ISelectionWithCoord;
-    setValue(newSelectionRange: IRangeWithCoord, currentCell: Nullable<ISelectionCellWithCoord>): void;
-    setCurrentCell(currentCell: Nullable<ISelectionCellWithCoord>): void;
+    setValue(newSelectionRange: IRangeWithCoord, currentCell: Nullable<ISelectionCellWithMergeInfo>): void;
+    setCurrentCell(currentCell: Nullable<ISelectionCellWithMergeInfo>): void;
     clearCurrentCell(): void;
 }

package/lib/types/services/selection/selection-render.service.d.ts

@@ -1,10 +1,10 @@
-import { IInterceptor, IRange, IRangeWithCoord, ISelection, ISelectionCell, ISelectionCellWithCoord, Nullable, InterceptorManager, IUniverInstanceService, RANGE_TYPE, ThemeService } from '@univerjs/core';
+import { IInterceptor, IRange, IRangeWithCoord, ISelection, ISelectionCell, ISelectionCellWithMergeInfo, Nullable, InterceptorManager, RANGE_TYPE, ThemeService } from '@univerjs/core';
 import { IMouseEvent, IPointerEvent, Scene, SpreadsheetSkeleton, Viewport, IRenderManagerService, ScrollTimerType } from '@univerjs/engine-render';
 import { ISelectionStyle, ISelectionWithCoordAndStyle, ISelectionWithStyle } from '@univerjs/sheets';
 import { IShortcutService } from '@univerjs/ui';
 import { Injector } from '@wendellhu/redi';
 import { Observable } from 'rxjs';
-import { SelectionShape } from './selection-shape';
+import { SelectionControl as SelectionShape } from './selection-shape';
 
 export interface IControlFillConfig {
     oldRange: IRange;
@@ -39,20 +39,20 @@ export interface ISelectionRenderService {
     disableRemainLast(): void;
     enableSkipRemainLast(): void;
     disableSkipRemainLast(): void;
-    addControlToCurrentByRangeData(data: ISelectionWithCoordAndStyle): void;
+    addSelectionControlBySelectionData(data: ISelectionWithCoordAndStyle): void;
     updateControlForCurrentByRangeData(selections: ISelectionWithCoordAndStyle[]): void;
     changeRuntime(skeleton: Nullable<SpreadsheetSkeleton>, scene: Nullable<Scene>, viewport?: Viewport): void;
     /** @deprecated This should not be provided by the selection render service. */
     getViewPort(): Viewport;
-    getCurrentControls(): SelectionShape[];
+    getSelectionControls(): SelectionShape[];
     getActiveSelections(): Nullable<ISelection[]>;
     getActiveRange(): Nullable<IRange>;
-    getActiveSelection(): Nullable<SelectionShape>;
+    getActiveSelectionControl(): Nullable<SelectionShape>;
     getSelectionDataWithStyle(): ISelectionWithCoordAndStyle[];
     attachSelectionWithCoord(selectionWithStyle: ISelectionWithStyle): ISelectionWithCoordAndStyle;
     attachRangeWithCoord(range: IRange): Nullable<IRangeWithCoord>;
-    attachPrimaryWithCoord(primary: Nullable<ISelectionCell>): Nullable<ISelectionCellWithCoord>;
-    getSelectionCellByPosition(x: number, y: number): Nullable<ISelectionCellWithCoord>;
+    attachPrimaryWithCoord(primary: Nullable<ISelectionCell>): Nullable<ISelectionCellWithMergeInfo>;
+    getSelectionCellByPosition(x: number, y: number): Nullable<ISelectionCellWithMergeInfo>;
     eventTrigger(evt: IPointerEvent | IMouseEvent, zIndex: number, rangeType: RANGE_TYPE, viewport?: Viewport, scrollTimerType?: ScrollTimerType): void;
     reset(): void;
     refreshSelectionMoveStart(): void;
@@ -83,12 +83,12 @@ export declare class SelectionRenderService implements ISelectionRenderService {
     private readonly _themeService;
     private readonly _shortcutService;
     private readonly _renderManagerService;
-    private readonly _instanceService;
     private readonly _injector;
     hasSelection: boolean;
-    private _downObserver;
-    private _moveObserver;
-    private _upObserver;
+    private _pointerdownSub;
+    private _mainScenePointerUpSub;
+    private _scenePointerMoveSub;
+    private _scenePointerUpSub;
     private _controlFillConfig$;
     readonly controlFillConfig$: Observable<IControlFillConfig | null>;
     private _selectionControls;
@@ -96,8 +96,6 @@ export declare class SelectionRenderService implements ISelectionRenderService {
     private _startOffsetX;
     private _startOffsetY;
     private _scrollTimer;
-    private _cancelDownObserver;
-    private _cancelUpObserver;
     private _skeleton;
     private _scene;
     private _isHeaderHighlight;
@@ -136,7 +134,7 @@ export declare class SelectionRenderService implements ISelectionRenderService {
             scene: Scene;
         }>;
     }>;
-    constructor(_themeService: ThemeService, _shortcutService: IShortcutService, _renderManagerService: IRenderManagerService, _instanceService: IUniverInstanceService, _injector: Injector);
+    constructor(_themeService: ThemeService, _shortcutService: IShortcutService, _renderManagerService: IRenderManagerService, _injector: Injector);
     enableHeaderHighlight(): void;
     disableHeaderHighlight(): void;
     enableDetectMergedCell(): void;
@@ -156,15 +154,14 @@ export declare class SelectionRenderService implements ISelectionRenderService {
     getViewPort(): Viewport;
     /**
      * add a selection
-     * @param selectionRange
-     * @param curCellRange
+     * @param data
      */
-    addControlToCurrentByRangeData(data: ISelectionWithCoordAndStyle): void;
+    addSelectionControlBySelectionData(data: ISelectionWithCoordAndStyle): void;
     updateControlForCurrentByRangeData(selections: ISelectionWithCoordAndStyle[]): void;
     refreshSelectionMoveStart(): void;
     changeRuntime(skeleton: Nullable<SpreadsheetSkeleton>, scene: Nullable<Scene>, viewport?: Viewport): void;
     getSelectionDataWithStyle(): ISelectionWithCoordAndStyle[];
-    getCurrentControls(): SelectionShape[];
+    getSelectionControls(): SelectionShape[];
     private _clearSelectionControls;
     private _getFreeze;
     private _getViewportByCell;
@@ -185,8 +182,12 @@ export declare class SelectionRenderService implements ISelectionRenderService {
      * get active selection control
      * @returns
      */
-    getActiveSelection(): Nullable<SelectionShape>;
+    getActiveSelectionControl(): Nullable<SelectionShape>;
     endSelection(): void;
+    /**
+     * first, clear All selection controls
+     * then unsubscribe all events
+     */
     reset(): void;
     resetAndEndSelection(): void;
     /**
@@ -199,8 +200,8 @@ export declare class SelectionRenderService implements ISelectionRenderService {
     eventTrigger(evt: IPointerEvent | IMouseEvent, zIndex?: number, rangeType?: RANGE_TYPE, viewport?: Viewport, scrollTimerType?: ScrollTimerType): false | undefined;
     attachSelectionWithCoord(selectionWithStyle: ISelectionWithStyle): ISelectionWithCoordAndStyle;
     attachRangeWithCoord(range: IRange): Nullable<IRangeWithCoord>;
-    attachPrimaryWithCoord(primary: Nullable<ISelectionCell>): Nullable<ISelectionCellWithCoord>;
-    getSelectionCellByPosition(x: number, y: number): Nullable<ISelectionCellWithCoord>;
+    attachPrimaryWithCoord(primary: Nullable<ISelectionCell>): Nullable<ISelectionCellWithMergeInfo>;
+    getSelectionCellByPosition(x: number, y: number): Nullable<ISelectionCellWithMergeInfo>;
     /**
      * When mousedown and mouseup need to go to the coordination and undo stack, when mousemove does not need to go to the coordination and undo stack
      */

package/lib/types/services/selection/selection-shape-extension.d.ts

@@ -1,12 +1,16 @@
 import { IRangeWithCoord, ThemeService } from '@univerjs/core';
 import { Scene, SpreadsheetSkeleton } from '@univerjs/engine-render';
 import { Injector } from '@wendellhu/redi';
-import { SelectionShape } from './selection-shape';
+import { SelectionControl } from './selection-shape';
 
 export interface ISelectionShapeTargetSelection {
-    originControl: SelectionShape;
+    originControl: SelectionControl;
     targetSelection: IRangeWithCoord;
 }
+/**
+ * for auto-fill (crosshair expand selection range)
+ * drag selection range
+ */
 export declare class SelectionShapeExtension {
     private _control;
     private _skeleton;
@@ -19,15 +23,15 @@ export declare class SelectionShapeExtension {
     private _relativeSelectionPositionColumn;
     private _relativeSelectionRowLength;
     private _relativeSelectionColumnLength;
-    private _moveObserver;
-    private _upObserver;
+    private _scenePointerMoveSub;
+    private _scenePointerUpSub;
     private _helperSelection;
     private _scrollTimer;
     private _activeViewport;
     private _targetSelection;
     private _isInMergeState;
     private _fillControlColors;
-    constructor(_control: SelectionShape, _skeleton: SpreadsheetSkeleton, _scene: Scene, _themeService: ThemeService, _injector: Injector);
+    constructor(_control: SelectionControl, _skeleton: SpreadsheetSkeleton, _scene: Scene, _themeService: ThemeService, _injector: Injector);
     get isHelperSelection(): boolean;
     dispose(): void;
     private _getFreeze;