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

package/lib/es/facade.js

@@ -1,537 +1,543 @@
-import { FUniver as ue, ICommandService as _, IUniverInstanceService as D, CanceledError as G, RichTextValue as q, DOCS_NORMAL_EDITOR_UNIT_ID_KEY as B, LifecycleService as Q, DisposableCollection as A, LifecycleStages as ee, UniverInstanceType as pe, ILogService as x, toDisposable as E, awaitTime as Ee, InterceptorEffectEnum as we, FEventName as ve, generateRandomId as ke } from "@univerjs/core";
-import { RichTextEditingMutation as _e } from "@univerjs/docs";
-import { IRenderManagerService as f, DeviceInputEventType as te, SHEET_VIEWPORT_KEY as Ie, sheetContentViewportKeys as Pe } from "@univerjs/engine-render";
-import { SheetsSelectionsService as Re, COMMAND_LISTENER_SKELETON_CHANGE as Me, getSkeletonChangedEffectedRange as ye, SheetInterceptorService as Ue, INTERCEPTOR_POINT as He, InterceptCellContentPriority as xe } from "@univerjs/sheets";
-import { SetCellEditVisibleOperation as I, IEditorBridgeService as L, SetZoomRatioCommand as re, HoverManagerService as y, DragManagerService as W, SheetScrollManagerService as $, SheetPasteShortKeyCommand as ne, ISheetClipboardService as Se, SHEET_VIEW_KEY as R, ISheetSelectionRenderService as U, SheetSkeletonManagerService as H, ChangeZoomRatioCommand as Te, SheetsScrollRenderController as De, SetWorksheetColAutoWidthCommand as Be, SheetCanvasPopManagerService as ie, CellAlertManagerService as Le, IMarkSelectionService as Ae } from "@univerjs/sheets-ui";
-import { FSheetHooks as O, FWorkbook as Ce, FWorksheet as me, FPermission as fe, FRange as be } from "@univerjs/sheets/facade";
-import { KeyCode as T, CutCommand as oe, CopyCommand as se, PasteCommand as ae, IClipboardInterfaceService as We, PLAIN_TEXT_CLIPBOARD_MIME_TYPE as ce, HTML_CLIPBOARD_MIME_TYPE as de, supportClipboardAPI as he, ISidebarService as $e, IDialogService as Oe, ComponentManager as le } from "@univerjs/ui";
-import { filter as S, combineLatest as je } from "rxjs";
-class Fe extends ue {
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+import { FUniver, ICommandService, IUniverInstanceService, CanceledError, RichTextValue, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, LifecycleService, DisposableCollection, LifecycleStages, UniverInstanceType, ILogService, toDisposable, awaitTime, InterceptorEffectEnum, FEventName, generateRandomId } from "@univerjs/core";
+import { RichTextEditingMutation } from "@univerjs/docs";
+import { IRenderManagerService, DeviceInputEventType, SHEET_VIEWPORT_KEY, sheetContentViewportKeys } from "@univerjs/engine-render";
+import { SheetsSelectionsService, COMMAND_LISTENER_SKELETON_CHANGE, getSkeletonChangedEffectedRange, SheetInterceptorService, INTERCEPTOR_POINT, InterceptCellContentPriority } from "@univerjs/sheets";
+import { SetCellEditVisibleOperation, IEditorBridgeService, SetZoomRatioCommand, HoverManagerService, DragManagerService, SheetScrollManagerService, SheetPasteShortKeyCommand, ISheetClipboardService, SheetSkeletonManagerService, SHEET_VIEW_KEY, ISheetSelectionRenderService, ChangeZoomRatioCommand, SheetsScrollRenderController, SetWorksheetColAutoWidthCommand, SheetCanvasPopManagerService, CellAlertManagerService, IMarkSelectionService } from "@univerjs/sheets-ui";
+import { FSheetHooks, FWorkbook, FWorksheet, FPermission, FRange } from "@univerjs/sheets/facade";
+import { KeyCode, CutCommand, CopyCommand, PasteCommand, IClipboardInterfaceService, PLAIN_TEXT_CLIPBOARD_MIME_TYPE, HTML_CLIPBOARD_MIME_TYPE, supportClipboardAPI, ISidebarService, IDialogService, ComponentManager } from "@univerjs/ui";
+import { filter, combineLatest } from "rxjs";
+const _FUniverSheetsUIMixin = class _FUniverSheetsUIMixin extends FUniver {
   // eslint-disable-next-line max-lines-per-function
-  _initSheetUIEvent(e) {
-    const r = e.get(_);
-    this.disposeWithMe(r.beforeCommandExecuted((t) => {
-      if (t.id === I.id) {
+  _initSheetUIEvent(injector) {
+    const commandService = injector.get(ICommandService);
+    this.disposeWithMe(commandService.beforeCommandExecuted((commandInfo) => {
+      if (commandInfo.id === SetCellEditVisibleOperation.id) {
         if (!this._eventListend(this.Event.BeforeSheetEditStart) && !this._eventListend(this.Event.BeforeSheetEditEnd))
           return;
-        const i = this.getCommandSheetTarget(t);
-        if (!i)
+        const target = this.getCommandSheetTarget(commandInfo);
+        if (!target)
           return;
-        const { workbook: o, worksheet: s } = i, c = e.get(L), g = e.get(D), C = t.params, { visible: l, keycode: h, eventType: v } = C, d = c.getEditLocation();
-        if (l) {
-          const b = {
-            row: d.row,
-            column: d.column,
-            eventType: v,
-            keycode: h,
-            workbook: o,
-            worksheet: s,
+        const { workbook, worksheet } = target, editorBridgeService = injector.get(IEditorBridgeService), univerInstanceService = injector.get(IUniverInstanceService), params = commandInfo.params, { visible, keycode, eventType } = params, loc = editorBridgeService.getEditLocation();
+        if (visible) {
+          const eventParams = {
+            row: loc.row,
+            column: loc.column,
+            eventType,
+            keycode,
+            workbook,
+            worksheet,
             isZenEditor: !1
           };
-          if (this.fireEvent(this.Event.BeforeSheetEditStart, b), b.cancel)
-            throw new G();
+          if (this.fireEvent(this.Event.BeforeSheetEditStart, eventParams), eventParams.cancel)
+            throw new CanceledError();
         } else {
-          const b = {
-            row: d.row,
-            column: d.column,
-            eventType: v,
-            keycode: h,
-            workbook: o,
-            worksheet: s,
+          const eventParams = {
+            row: loc.row,
+            column: loc.column,
+            eventType,
+            keycode,
+            workbook,
+            worksheet,
             isZenEditor: !1,
-            value: q.create(g.getUnit(B).getSnapshot()),
-            isConfirm: h !== T.ESC
+            value: RichTextValue.create(univerInstanceService.getUnit(DOCS_NORMAL_EDITOR_UNIT_ID_KEY).getSnapshot()),
+            isConfirm: keycode !== KeyCode.ESC
           };
-          if (this.fireEvent(this.Event.BeforeSheetEditEnd, b), b.cancel)
-            throw new G();
+          if (this.fireEvent(this.Event.BeforeSheetEditEnd, eventParams), eventParams.cancel)
+            throw new CanceledError();
         }
       }
-      if (t.id === re.id) {
+      if (commandInfo.id === SetZoomRatioCommand.id) {
         if (!this._eventListend(this.Event.BeforeSheetZoomChange))
           return;
-        const i = this.getCommandSheetTarget(t);
-        if (!i)
+        const target = this.getCommandSheetTarget(commandInfo);
+        if (!target)
           return;
-        const { workbook: o, worksheet: s } = i;
+        const { workbook, worksheet } = target;
         this.fireEvent(this.Event.BeforeSheetZoomChange, {
-          zoom: t.params.zoomRatio,
-          workbook: o,
-          worksheet: s
+          zoom: commandInfo.params.zoomRatio,
+          workbook,
+          worksheet
         });
       }
-    })), this.disposeWithMe(r.onCommandExecuted((t) => {
-      if (t.id === I.id) {
+    })), this.disposeWithMe(commandService.onCommandExecuted((commandInfo) => {
+      if (commandInfo.id === SetCellEditVisibleOperation.id) {
         if (!this._eventListend(this.Event.SheetEditStarted) && !this._eventListend(this.Event.SheetEditEnded))
           return;
-        const i = this.getCommandSheetTarget(t);
-        if (!i)
+        const target = this.getCommandSheetTarget(commandInfo);
+        if (!target)
           return;
-        const { workbook: o, worksheet: s } = i, c = e.get(L), g = t.params, { visible: C, keycode: l, eventType: h } = g, v = c.getEditLocation();
-        if (C) {
-          const d = {
-            row: v.row,
-            column: v.column,
-            eventType: h,
-            keycode: l,
-            workbook: o,
-            worksheet: s,
+        const { workbook, worksheet } = target, editorBridgeService = injector.get(IEditorBridgeService), params = commandInfo.params, { visible, keycode, eventType } = params, loc = editorBridgeService.getEditLocation();
+        if (visible) {
+          const eventParams = {
+            row: loc.row,
+            column: loc.column,
+            eventType,
+            keycode,
+            workbook,
+            worksheet,
             isZenEditor: !1
           };
-          this.fireEvent(this.Event.SheetEditStarted, d);
+          this.fireEvent(this.Event.SheetEditStarted, eventParams);
         } else {
-          const d = {
-            row: v.row,
-            column: v.column,
-            eventType: h,
-            keycode: l,
-            workbook: o,
-            worksheet: s,
+          const eventParams = {
+            row: loc.row,
+            column: loc.column,
+            eventType,
+            keycode,
+            workbook,
+            worksheet,
             isZenEditor: !1,
-            isConfirm: l !== T.ESC
+            isConfirm: keycode !== KeyCode.ESC
           };
-          this.fireEvent(this.Event.SheetEditEnded, d);
+          this.fireEvent(this.Event.SheetEditEnded, eventParams);
         }
       }
-      if (t.id === _e.id) {
+      if (commandInfo.id === RichTextEditingMutation.id) {
         if (!this._eventListend(this.Event.SheetEditChanging))
           return;
-        const i = this.getCommandSheetTarget(t);
-        if (!i)
+        const target = this.getCommandSheetTarget(commandInfo);
+        if (!target)
           return;
-        const { workbook: o, worksheet: s } = i, c = e.get(L), g = e.get(D), C = t.params;
-        if (!c.isVisible().visible) return;
-        const { unitId: l } = C;
-        if (l === B) {
-          const { row: h, column: v } = c.getEditLocation(), d = {
-            workbook: o,
-            worksheet: s,
-            row: h,
-            column: v,
-            value: q.create(g.getUnit(B).getSnapshot()),
+        const { workbook, worksheet } = target, editorBridgeService = injector.get(IEditorBridgeService), univerInstanceService = injector.get(IUniverInstanceService), params = commandInfo.params;
+        if (!editorBridgeService.isVisible().visible) return;
+        const { unitId } = params;
+        if (unitId === DOCS_NORMAL_EDITOR_UNIT_ID_KEY) {
+          const { row, column } = editorBridgeService.getEditLocation(), eventParams = {
+            workbook,
+            worksheet,
+            row,
+            column,
+            value: RichTextValue.create(univerInstanceService.getUnit(DOCS_NORMAL_EDITOR_UNIT_ID_KEY).getSnapshot()),
             isZenEditor: !1
           };
-          this.fireEvent(this.Event.SheetEditChanging, d);
+          this.fireEvent(this.Event.SheetEditChanging, eventParams);
         }
       }
-      if (t.id === re.id) {
+      if (commandInfo.id === SetZoomRatioCommand.id) {
         if (!this._eventListend(this.Event.SheetZoomChanged))
           return;
-        const i = this.getCommandSheetTarget(t);
-        if (!i)
+        const target = this.getCommandSheetTarget(commandInfo);
+        if (!target)
           return;
-        const { workbook: o, worksheet: s } = i;
+        const { workbook, worksheet } = target;
         this.fireEvent(this.Event.SheetZoomChanged, {
-          zoom: s.getZoom(),
-          workbook: o,
-          worksheet: s
+          zoom: worksheet.getZoom(),
+          workbook,
+          worksheet
         });
       }
-    })), this._initObserverListener(e);
+    })), this._initObserverListener(injector);
   }
   // eslint-disable-next-line max-lines-per-function
-  _initObserverListener(e) {
-    const t = e.get(D).getFocusedUnit(), i = t == null ? void 0 : t.getUnitId(), o = e.get(f);
-    if (i) {
-      const l = e.get(Q), h = new A();
-      this.disposeWithMe(l.lifecycle$.subscribe((v) => {
-        var k, P, u, m, p, j, F, N, V, Z, K, z, Y, X, J;
-        if (v < ee.Rendered) return;
-        h.dispose();
-        const d = e.get(y), b = e.get(W);
-        d && (h.add(
-          (k = d.currentClickedCell$) == null ? void 0 : k.pipe(S((n) => !!n)).subscribe((n) => {
+  _initObserverListener(injector) {
+    const unitM = injector.get(IUniverInstanceService).getFocusedUnit(), unitId = unitM == null ? void 0 : unitM.getUnitId(), renderManagerService = injector.get(IRenderManagerService);
+    if (unitId) {
+      const lifeCycleService2 = injector.get(LifecycleService), disposable = new DisposableCollection();
+      this.disposeWithMe(lifeCycleService2.lifecycle$.subscribe((lifecycle) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+        if (lifecycle < LifecycleStages.Rendered) return;
+        disposable.dispose();
+        const hoverManagerService = injector.get(HoverManagerService), dragManagerService = injector.get(DragManagerService);
+        hoverManagerService && (disposable.add(
+          (_a = hoverManagerService.currentClickedCell$) == null ? void 0 : _a.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.CellClicked)) return;
-            const a = this.getSheetTarget(n.location.unitId, n.location.subUnitId);
-            a && this.fireEvent(this.Event.CellClicked, {
-              ...a,
-              ...n,
-              row: n.location.row,
-              column: n.location.col
+            const baseParams = this.getSheetTarget(cell.location.unitId, cell.location.subUnitId);
+            baseParams && this.fireEvent(this.Event.CellClicked, {
+              ...baseParams,
+              ...cell,
+              row: cell.location.row,
+              column: cell.location.col
             });
           })
-        ), h.add(
-          (P = d.currentRichText$) == null ? void 0 : P.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_b = hoverManagerService.currentRichText$) == null ? void 0 : _b.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.CellHover)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.CellHover, {
-              ...a,
-              ...n,
-              row: n.row,
-              column: n.col
+            const baseParams = this.getSheetTarget(cell.unitId, cell.subUnitId);
+            baseParams && this.fireEvent(this.Event.CellHover, {
+              ...baseParams,
+              ...cell,
+              row: cell.row,
+              column: cell.col
             });
           })
-        ), h.add(
-          (u = d.currentPointerDownCell$) == null ? void 0 : u.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_c = hoverManagerService.currentPointerDownCell$) == null ? void 0 : _c.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.CellPointerDown)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.CellPointerDown, {
-              ...a,
-              ...n,
-              row: n.row,
-              column: n.col
+            const baseParams = this.getSheetTarget(cell.unitId, cell.subUnitId);
+            baseParams && this.fireEvent(this.Event.CellPointerDown, {
+              ...baseParams,
+              ...cell,
+              row: cell.row,
+              column: cell.col
             });
           })
-        ), h.add(
-          (m = d.currentPointerUpCell$) == null ? void 0 : m.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_d = hoverManagerService.currentPointerUpCell$) == null ? void 0 : _d.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.CellPointerUp)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.CellPointerUp, {
-              ...a,
-              ...n,
-              row: n.row,
-              column: n.col
+            const baseParams = this.getSheetTarget(cell.unitId, cell.subUnitId);
+            baseParams && this.fireEvent(this.Event.CellPointerUp, {
+              ...baseParams,
+              ...cell,
+              row: cell.row,
+              column: cell.col
             });
           })
-        ), h.add(
-          (p = d.currentCellPosWithEvent$) == null ? void 0 : p.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_e = hoverManagerService.currentCellPosWithEvent$) == null ? void 0 : _e.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.CellPointerMove)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.CellPointerMove, {
-              ...a,
-              ...n,
-              row: n.row,
-              column: n.col
+            const baseParams = this.getSheetTarget(cell.unitId, cell.subUnitId);
+            baseParams && this.fireEvent(this.Event.CellPointerMove, {
+              ...baseParams,
+              ...cell,
+              row: cell.row,
+              column: cell.col
             });
           })
-        ), h.add(
-          (j = b.currentCell$) == null ? void 0 : j.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_f = dragManagerService.currentCell$) == null ? void 0 : _f.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.DragOver)) return;
-            const a = this.getSheetTarget(n.location.unitId, n.location.subUnitId);
-            a && this.fireEvent(this.Event.DragOver, {
-              ...a,
-              ...n,
-              row: n.location.row,
-              column: n.location.col
+            const baseParams = this.getSheetTarget(cell.location.unitId, cell.location.subUnitId);
+            baseParams && this.fireEvent(this.Event.DragOver, {
+              ...baseParams,
+              ...cell,
+              row: cell.location.row,
+              column: cell.location.col
             });
           })
-        ), h.add(
-          (F = b.endCell$) == null ? void 0 : F.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_g = dragManagerService.endCell$) == null ? void 0 : _g.pipe(filter((cell) => !!cell)).subscribe((cell) => {
             if (!this._eventListend(this.Event.Drop)) return;
-            const a = this.getSheetTarget(n.location.unitId, n.location.subUnitId);
-            a && this.fireEvent(this.Event.Drop, {
-              ...a,
-              ...n,
-              row: n.location.row,
-              column: n.location.col
+            const baseParams = this.getSheetTarget(cell.location.unitId, cell.location.subUnitId);
+            baseParams && this.fireEvent(this.Event.Drop, {
+              ...baseParams,
+              ...cell,
+              row: cell.location.row,
+              column: cell.location.col
             });
           })
-        ), h.add(
-          (N = d.currentRowHeaderClick$) == null ? void 0 : N.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_h = hoverManagerService.currentRowHeaderClick$) == null ? void 0 : _h.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.RowHeaderClick)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.RowHeaderClick, {
-              ...a,
-              row: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.RowHeaderClick, {
+              ...baseParams,
+              row: header.index
             });
           })
-        ), h.add(
-          (V = d.currentRowHeaderPointerDown$) == null ? void 0 : V.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_i = hoverManagerService.currentRowHeaderPointerDown$) == null ? void 0 : _i.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.RowHeaderPointerDown)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.RowHeaderPointerDown, {
-              ...a,
-              row: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.RowHeaderPointerDown, {
+              ...baseParams,
+              row: header.index
             });
           })
-        ), h.add(
-          (Z = d.currentRowHeaderPointerUp$) == null ? void 0 : Z.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_j = hoverManagerService.currentRowHeaderPointerUp$) == null ? void 0 : _j.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.RowHeaderPointerUp)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.RowHeaderPointerUp, {
-              ...a,
-              row: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.RowHeaderPointerUp, {
+              ...baseParams,
+              row: header.index
             });
           })
-        ), h.add(
-          (K = d.currentHoveredRowHeader$) == null ? void 0 : K.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_k = hoverManagerService.currentHoveredRowHeader$) == null ? void 0 : _k.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.RowHeaderHover)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.RowHeaderHover, {
-              ...a,
-              row: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.RowHeaderHover, {
+              ...baseParams,
+              row: header.index
             });
           })
-        ), h.add(
-          (z = d.currentColHeaderClick$) == null ? void 0 : z.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_l = hoverManagerService.currentColHeaderClick$) == null ? void 0 : _l.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.ColumnHeaderClick)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.ColumnHeaderClick, {
-              ...a,
-              column: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.ColumnHeaderClick, {
+              ...baseParams,
+              column: header.index
             });
           })
-        ), h.add(
-          (Y = d.currentColHeaderPointerDown$) == null ? void 0 : Y.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_m = hoverManagerService.currentColHeaderPointerDown$) == null ? void 0 : _m.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.ColumnHeaderPointerDown)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.ColumnHeaderPointerDown, {
-              ...a,
-              column: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.ColumnHeaderPointerDown, {
+              ...baseParams,
+              column: header.index
             });
           })
-        ), h.add(
-          (X = d.currentColHeaderPointerUp$) == null ? void 0 : X.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_n = hoverManagerService.currentColHeaderPointerUp$) == null ? void 0 : _n.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.ColumnHeaderPointerUp)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.ColumnHeaderPointerUp, {
-              ...a,
-              column: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.ColumnHeaderPointerUp, {
+              ...baseParams,
+              column: header.index
             });
           })
-        ), h.add(
-          (J = d.currentHoveredColHeader$) == null ? void 0 : J.pipe(S((n) => !!n)).subscribe((n) => {
+        ), disposable.add(
+          (_o = hoverManagerService.currentHoveredColHeader$) == null ? void 0 : _o.pipe(filter((header) => !!header)).subscribe((header) => {
             if (!this._eventListend(this.Event.ColumnHeaderHover)) return;
-            const a = this.getSheetTarget(n.unitId, n.subUnitId);
-            a && this.fireEvent(this.Event.ColumnHeaderHover, {
-              ...a,
-              column: n.index
+            const baseParams = this.getSheetTarget(header.unitId, header.subUnitId);
+            baseParams && this.fireEvent(this.Event.ColumnHeaderHover, {
+              ...baseParams,
+              column: header.index
             });
           })
         ));
-      })), this.disposeWithMe(h);
+      })), this.disposeWithMe(disposable);
     }
-    const s = /* @__PURE__ */ new Map();
-    let c;
-    const g = e.get(Q), C = je([
-      o.created$,
-      g.lifecycle$
+    const unitMap = /* @__PURE__ */ new Map();
+    let sheetRenderUnit;
+    const lifeCycleService = injector.get(LifecycleService), combined$ = combineLatest([
+      renderManagerService.created$,
+      lifeCycleService.lifecycle$
     ]);
-    this.disposeWithMe(C.subscribe(([l, h]) => {
-      var P;
-      if (l.type === pe.UNIVER_SHEET && (c = l), h <= ee.Rendered) return;
-      const v = new A();
-      if (!c) return;
-      const d = this.getWorkbook(c.unitId);
-      if (!d) return;
-      s.get(c.unitId) && ((P = s.get(c.unitId)) == null || P.dispose()), s.set(c.unitId, v);
-      const b = c.with($);
-      v.add(b.validViewportScrollInfo$.subscribe((u) => {
-        u && this._eventListend(this.Event.Scroll) && this.fireEvent(this.Event.Scroll, {
-          workbook: d,
-          worksheet: d.getActiveSheet(),
-          ...u
+    this.disposeWithMe(combined$.subscribe(([created, lifecycle]) => {
+      var _a;
+      if (created.type === UniverInstanceType.UNIVER_SHEET && (sheetRenderUnit = created), lifecycle <= LifecycleStages.Rendered) return;
+      const disposable = new DisposableCollection();
+      if (!sheetRenderUnit) return;
+      const workbook = this.getWorkbook(sheetRenderUnit.unitId);
+      if (!workbook) return;
+      unitMap.get(sheetRenderUnit.unitId) && ((_a = unitMap.get(sheetRenderUnit.unitId)) == null || _a.dispose()), unitMap.set(sheetRenderUnit.unitId, disposable);
+      const scrollManagerService = sheetRenderUnit.with(SheetScrollManagerService);
+      disposable.add(scrollManagerService.validViewportScrollInfo$.subscribe((params) => {
+        params && this._eventListend(this.Event.Scroll) && this.fireEvent(this.Event.Scroll, {
+          workbook,
+          worksheet: workbook.getActiveSheet(),
+          ...params
         });
       }));
-      const k = c.with(Re);
-      v.add(k.selectionMoveStart$.subscribe((u) => {
-        var m;
+      const selectionService = sheetRenderUnit.with(SheetsSelectionsService);
+      disposable.add(selectionService.selectionMoveStart$.subscribe((selections) => {
+        var _a2;
         this._eventListend(this.Event.SelectionMoveStart) && this.fireEvent(this.Event.SelectionMoveStart, {
-          workbook: d,
-          worksheet: d.getActiveSheet(),
-          selections: (m = u == null ? void 0 : u.map((p) => p.range)) != null ? m : []
+          workbook,
+          worksheet: workbook.getActiveSheet(),
+          selections: (_a2 = selections == null ? void 0 : selections.map((s) => s.range)) != null ? _a2 : []
         });
-      })), v.add(k.selectionMoving$.subscribe((u) => {
-        var m;
+      })), disposable.add(selectionService.selectionMoving$.subscribe((selections) => {
+        var _a2;
         this._eventListend(this.Event.SelectionMoving) && this.fireEvent(this.Event.SelectionMoving, {
-          workbook: d,
-          worksheet: d.getActiveSheet(),
-          selections: (m = u == null ? void 0 : u.map((p) => p.range)) != null ? m : []
+          workbook,
+          worksheet: workbook.getActiveSheet(),
+          selections: (_a2 = selections == null ? void 0 : selections.map((s) => s.range)) != null ? _a2 : []
         });
-      })), v.add(k.selectionMoveEnd$.subscribe((u) => {
-        var m;
+      })), disposable.add(selectionService.selectionMoveEnd$.subscribe((selections) => {
+        var _a2;
         this._eventListend(this.Event.SelectionMoveEnd) && this.fireEvent(this.Event.SelectionMoveEnd, {
-          workbook: d,
-          worksheet: d.getActiveSheet(),
-          selections: (m = u == null ? void 0 : u.map((p) => p.range)) != null ? m : []
+          workbook,
+          worksheet: workbook.getActiveSheet(),
+          selections: (_a2 = selections == null ? void 0 : selections.map((s) => s.range)) != null ? _a2 : []
         });
-      })), v.add(k.selectionChanged$.subscribe((u) => {
-        var m;
+      })), disposable.add(selectionService.selectionChanged$.subscribe((selections) => {
+        var _a2;
         this._eventListend(this.Event.SelectionChanged) && this.fireEvent(this.Event.SelectionChanged, {
-          workbook: d,
-          worksheet: d.getActiveSheet(),
-          selections: (m = u == null ? void 0 : u.map((p) => p.range)) != null ? m : []
+          workbook,
+          worksheet: workbook.getActiveSheet(),
+          selections: (_a2 = selections == null ? void 0 : selections.map((s) => s.range)) != null ? _a2 : []
         });
-      })), c = null, this.disposeWithMe(v);
-    })), this.disposeWithMe(o.disposed$.subscribe((l) => {
-      var h;
-      (h = s.get(l)) == null || h.dispose(), s.delete(l);
+      })), sheetRenderUnit = null, this.disposeWithMe(disposable);
+    })), this.disposeWithMe(renderManagerService.disposed$.subscribe((unitId2) => {
+      var _a;
+      (_a = unitMap.get(unitId2)) == null || _a.dispose(), unitMap.delete(unitId2);
     })), this.disposeWithMe(() => {
-      s.forEach((l) => {
-        l.dispose();
+      unitMap.forEach((disposable) => {
+        disposable.dispose();
       });
     });
   }
-  _initialize(e) {
-    this._initSheetUIEvent(e);
-    const r = e.get(_);
-    this.disposeWithMe(r.beforeCommandExecuted((t) => {
-      switch (t.id) {
-        case se.id:
-        case oe.id:
+  /**
+   * @ignore
+   */
+  _initialize(injector) {
+    this._initSheetUIEvent(injector);
+    const commandService = injector.get(ICommandService);
+    this.disposeWithMe(commandService.beforeCommandExecuted((commandInfo) => {
+      switch (commandInfo.id) {
+        case CopyCommand.id:
+        case CutCommand.id:
           this._beforeClipboardChange();
           break;
-        case ne.id:
-          this._beforeClipboardPaste(t.params);
+        case SheetPasteShortKeyCommand.id:
+          this._beforeClipboardPaste(commandInfo.params);
           break;
       }
-    })), this.disposeWithMe(r.onCommandExecuted((t) => {
-      if (Me.indexOf(t.id) > -1) {
+    })), this.disposeWithMe(commandService.onCommandExecuted((commandInfo) => {
+      if (COMMAND_LISTENER_SKELETON_CHANGE.indexOf(commandInfo.id) > -1) {
         if (!this._eventListend(this.Event.SheetSkeletonChanged)) return;
-        const i = this.getActiveSheet();
-        if (!i) return;
-        const o = ye(t).map((s) => {
-          var c, g;
-          return (g = (c = this.getWorkbook(s.unitId)) == null ? void 0 : c.getSheetBySheetId(s.subUnitId)) == null ? void 0 : g.getRange(s.range);
+        const sheet = this.getActiveSheet();
+        if (!sheet) return;
+        const ranges = getSkeletonChangedEffectedRange(commandInfo).map((range) => {
+          var _a, _b;
+          return (_b = (_a = this.getWorkbook(range.unitId)) == null ? void 0 : _a.getSheetBySheetId(range.subUnitId)) == null ? void 0 : _b.getRange(range.range);
         }).filter(Boolean);
-        if (!o.length) return;
+        if (!ranges.length) return;
         this.fireEvent(this.Event.SheetSkeletonChanged, {
-          workbook: i.workbook,
-          worksheet: i.worksheet,
-          payload: t,
-          skeleton: i.worksheet.getSkeleton(),
-          effectedRanges: o
+          workbook: sheet.workbook,
+          worksheet: sheet.worksheet,
+          payload: commandInfo,
+          skeleton: sheet.worksheet.getSkeleton(),
+          effectedRanges: ranges
         });
         return;
       }
-      switch (t.id) {
-        case se.id:
-        case oe.id:
+      switch (commandInfo.id) {
+        case CopyCommand.id:
+        case CutCommand.id:
           this._clipboardChanged();
           break;
-        case ne.id:
+        case SheetPasteShortKeyCommand.id:
           this._clipboardPaste();
           break;
-        case ae.id:
+        case PasteCommand.id:
           this._clipboardPasteAsync();
           break;
       }
-    })), this.disposeWithMe(r.beforeCommandExecuted(async (t) => {
-      switch (t.id) {
-        case ae.id:
+    })), this.disposeWithMe(commandService.beforeCommandExecuted(async (commandInfo) => {
+      switch (commandInfo.id) {
+        case PasteCommand.id:
           await this._beforeClipboardPasteAsync();
           break;
       }
     }));
   }
   _generateClipboardCopyParam() {
-    const e = this.getActiveWorkbook(), r = e == null ? void 0 : e.getActiveSheet(), t = e == null ? void 0 : e.getActiveRange();
-    if (!e || !r || !t)
+    const workbook = this.getActiveWorkbook(), worksheet = workbook == null ? void 0 : workbook.getActiveSheet(), range = workbook == null ? void 0 : workbook.getActiveRange();
+    if (!workbook || !worksheet || !range)
       return;
-    const o = this._injector.get(Se).generateCopyContent(e.getId(), r.getSheetId(), t.getRange());
-    if (!o)
+    const content = this._injector.get(ISheetClipboardService).generateCopyContent(workbook.getId(), worksheet.getSheetId(), range.getRange());
+    if (!content)
       return;
-    const { html: s, plain: c } = o;
+    const { html, plain } = content;
     return {
-      workbook: e,
-      worksheet: r,
-      text: c,
-      html: s,
-      fromSheet: r,
-      fromRange: t
+      workbook,
+      worksheet,
+      text: plain,
+      html,
+      fromSheet: worksheet,
+      fromRange: range
     };
   }
   _beforeClipboardChange() {
     if (!this.hasEventCallback(this.Event.BeforeClipboardChange))
       return;
-    const e = this._generateClipboardCopyParam();
-    if (e && (this.fireEvent(this.Event.BeforeClipboardChange, e), e.cancel))
+    const eventParams = this._generateClipboardCopyParam();
+    if (eventParams && (this.fireEvent(this.Event.BeforeClipboardChange, eventParams), eventParams.cancel))
       throw new Error("Before clipboard change is canceled");
   }
   _clipboardChanged() {
     if (!this.hasEventCallback(this.Event.ClipboardChanged))
       return;
-    const e = this._generateClipboardCopyParam();
-    if (e && (this.fireEvent(this.Event.ClipboardChanged, e), e.cancel))
+    const eventParams = this._generateClipboardCopyParam();
+    if (eventParams && (this.fireEvent(this.Event.ClipboardChanged, eventParams), eventParams.cancel))
       throw new Error("Clipboard changed is canceled");
   }
-  _generateClipboardPasteParam(e) {
-    if (!e)
+  _generateClipboardPasteParam(params) {
+    if (!params)
       return;
-    const { htmlContent: r, textContent: t } = e, i = this.getActiveWorkbook(), o = i == null ? void 0 : i.getActiveSheet();
-    return !i || !o ? void 0 : {
-      workbook: i,
-      worksheet: o,
-      text: t,
-      html: r
+    const { htmlContent, textContent } = params, workbook = this.getActiveWorkbook(), worksheet = workbook == null ? void 0 : workbook.getActiveSheet();
+    return !workbook || !worksheet ? void 0 : {
+      workbook,
+      worksheet,
+      text: textContent,
+      html: htmlContent
     };
   }
   async _generateClipboardPasteParamAsync() {
-    const e = this.getActiveWorkbook(), r = e == null ? void 0 : e.getActiveSheet();
-    if (!e || !r)
+    const workbook = this.getActiveWorkbook(), worksheet = workbook == null ? void 0 : workbook.getActiveSheet();
+    if (!workbook || !worksheet)
       return;
-    const o = (await this._injector.get(We).read())[0];
-    let s;
-    if (o) {
-      const c = o.types, g = c.indexOf(ce) !== -1 ? await o.getType(ce).then((l) => l && l.text()) : "", C = c.indexOf(de) !== -1 ? await o.getType(de).then((l) => l && l.text()) : "";
-      s = {
-        workbook: e,
-        worksheet: r,
-        text: g,
-        html: C
+    const item = (await this._injector.get(IClipboardInterfaceService).read())[0];
+    let eventParams;
+    if (item) {
+      const types = item.types, text = types.indexOf(PLAIN_TEXT_CLIPBOARD_MIME_TYPE) !== -1 ? await item.getType(PLAIN_TEXT_CLIPBOARD_MIME_TYPE).then((blob) => blob && blob.text()) : "", html = types.indexOf(HTML_CLIPBOARD_MIME_TYPE) !== -1 ? await item.getType(HTML_CLIPBOARD_MIME_TYPE).then((blob) => blob && blob.text()) : "";
+      eventParams = {
+        workbook,
+        worksheet,
+        text,
+        html
       };
     }
-    return s;
+    return eventParams;
   }
-  _beforeClipboardPaste(e) {
+  _beforeClipboardPaste(params) {
     if (!this.hasEventCallback(this.Event.BeforeClipboardPaste))
       return;
-    const r = this._generateClipboardPasteParam(e);
-    if (r && (this.fireEvent(this.Event.BeforeClipboardPaste, r), r.cancel))
+    const eventParams = this._generateClipboardPasteParam(params);
+    if (eventParams && (this.fireEvent(this.Event.BeforeClipboardPaste, eventParams), eventParams.cancel))
       throw new Error("Before clipboard paste is canceled");
   }
-  _clipboardPaste(e) {
+  _clipboardPaste(params) {
     if (!this.hasEventCallback(this.Event.BeforeClipboardPaste))
       return;
-    const r = this._generateClipboardPasteParam(e);
-    if (r && (this.fireEvent(this.Event.BeforeClipboardPaste, r), r.cancel))
+    const eventParams = this._generateClipboardPasteParam(params);
+    if (eventParams && (this.fireEvent(this.Event.BeforeClipboardPaste, eventParams), eventParams.cancel))
       throw new Error("Clipboard pasted is canceled");
   }
   async _beforeClipboardPasteAsync() {
     if (!this.hasEventCallback(this.Event.BeforeClipboardPaste))
       return;
-    if (!he()) {
-      this._injector.get(x).warn("[Facade]: The navigator object only supports the browser environment");
+    if (!supportClipboardAPI()) {
+      this._injector.get(ILogService).warn("[Facade]: The navigator object only supports the browser environment");
       return;
     }
-    const e = await this._generateClipboardPasteParamAsync();
-    if (e && (this.fireEvent(this.Event.BeforeClipboardPaste, e), e.cancel))
+    const eventParams = await this._generateClipboardPasteParamAsync();
+    if (eventParams && (this.fireEvent(this.Event.BeforeClipboardPaste, eventParams), eventParams.cancel))
       throw new Error("Before clipboard paste is canceled");
   }
   async _clipboardPasteAsync() {
     if (!this.hasEventCallback(this.Event.ClipboardPasted))
       return;
-    if (!he()) {
-      this._injector.get(x).warn("[Facade]: The navigator object only supports the browser environment");
+    if (!supportClipboardAPI()) {
+      this._injector.get(ILogService).warn("[Facade]: The navigator object only supports the browser environment");
       return;
     }
-    const e = await this._generateClipboardPasteParamAsync();
-    if (e && (this.fireEvent(this.Event.ClipboardPasted, e), e.cancel))
+    const eventParams = await this._generateClipboardPasteParamAsync();
+    if (eventParams && (this.fireEvent(this.Event.ClipboardPasted, eventParams), eventParams.cancel))
       throw new Error("Clipboard pasted is canceled");
   }
-  customizeColumnHeader(e) {
-    const r = this.getActiveWorkbook();
-    if (!r) {
+  customizeColumnHeader(cfg) {
+    var _a, _b;
+    const wb = this.getActiveWorkbook();
+    if (!wb) {
       console.error("WorkBook not exist");
       return;
     }
-    const t = r == null ? void 0 : r.getId();
-    this._getSheetRenderComponent(t, R.COLUMN).setCustomHeader(e);
+    const unitId = wb == null ? void 0 : wb.getId(), renderManagerService = this._injector.get(IRenderManagerService), activeSheet = wb.getActiveSheet(), subUnitId = activeSheet.getSheetId(), render = renderManagerService.getRenderById(unitId);
+    render && ((_a = cfg.headerStyle) != null && _a.size) && (render.with(SheetSkeletonManagerService).setColumnHeaderSize(render, subUnitId, (_b = cfg.headerStyle) == null ? void 0 : _b.size), activeSheet == null || activeSheet.refreshCanvas()), this._getSheetRenderComponent(unitId, SHEET_VIEW_KEY.COLUMN).setCustomHeader(cfg), activeSheet == null || activeSheet.refreshCanvas();
   }
-  customizeRowHeader(e) {
-    const r = this.getActiveWorkbook();
-    if (!r) {
+  customizeRowHeader(cfg) {
+    const wb = this.getActiveWorkbook();
+    if (!wb) {
       console.error("WorkBook not exist");
       return;
     }
-    const t = r == null ? void 0 : r.getId();
-    this._getSheetRenderComponent(t, R.ROW).setCustomHeader(e);
+    const unitId = wb == null ? void 0 : wb.getId();
+    this._getSheetRenderComponent(unitId, SHEET_VIEW_KEY.ROW).setCustomHeader(cfg);
   }
-  registerSheetRowHeaderExtension(e, ...r) {
-    const t = this._getSheetRenderComponent(e, R.ROW), i = t.register(...r);
-    return E(() => {
-      i.dispose(), t.makeDirty(!0);
+  registerSheetRowHeaderExtension(unitId, ...extensions) {
+    const sheetComponent = this._getSheetRenderComponent(unitId, SHEET_VIEW_KEY.ROW), registerDisposable = sheetComponent.register(...extensions);
+    return toDisposable(() => {
+      registerDisposable.dispose(), sheetComponent.makeDirty(!0);
     });
   }
-  registerSheetColumnHeaderExtension(e, ...r) {
-    const t = this._getSheetRenderComponent(e, R.COLUMN), i = t.register(...r);
-    return E(() => {
-      i.dispose(), t.makeDirty(!0);
+  registerSheetColumnHeaderExtension(unitId, ...extensions) {
+    const sheetComponent = this._getSheetRenderComponent(unitId, SHEET_VIEW_KEY.COLUMN), registerDisposable = sheetComponent.register(...extensions);
+    return toDisposable(() => {
+      registerDisposable.dispose(), sheetComponent.makeDirty(!0);
     });
   }
-  registerSheetMainExtension(e, ...r) {
-    const t = this._getSheetRenderComponent(e, R.MAIN), i = t.register(...r);
-    return E(() => {
-      i.dispose(), t.makeDirty(!0);
+  registerSheetMainExtension(unitId, ...extensions) {
+    const sheetComponent = this._getSheetRenderComponent(unitId, SHEET_VIEW_KEY.MAIN), registerDisposable = sheetComponent.register(...extensions);
+    return toDisposable(() => {
+      registerDisposable.dispose(), sheetComponent.makeDirty(!0);
     });
   }
   /**
@@ -541,81 +547,119 @@ class Fe extends ue {
    * @param {SHEET_VIEW_KEY} viewKey The view key of the spreadsheet.
    * @returns {Nullable<RenderComponentType>} The render component.
    */
-  _getSheetRenderComponent(e, r) {
-    const i = this._injector.get(f).getRenderById(e);
-    if (!i)
-      throw new Error(`Render Unit with unitId ${e} not found`);
-    const { components: o } = i, s = o.get(r);
-    if (!s)
+  _getSheetRenderComponent(unitId, viewKey) {
+    const render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    if (!render)
+      throw new Error(`Render Unit with unitId ${unitId} not found`);
+    const { components } = render, renderComponent = components.get(viewKey);
+    if (!renderComponent)
       throw new Error("Render component not found");
-    return s;
+    return renderComponent;
   }
   /**
    * Get sheet hooks.
    * @returns {FSheetHooks} FSheetHooks instance
    */
   getSheetHooks() {
-    return this._injector.createInstance(O);
+    return this._injector.createInstance(FSheetHooks);
   }
-}
-ue.extend(Fe);
-class Ne extends Ce {
-  openSiderbar(e) {
-    return this._logDeprecation("openSiderbar"), this._injector.get($e).open(e);
-  }
-  openDialog(e) {
+};
+__name(_FUniverSheetsUIMixin, "FUniverSheetsUIMixin");
+let FUniverSheetsUIMixin = _FUniverSheetsUIMixin;
+FUniver.extend(FUniverSheetsUIMixin);
+const _FWorkbookSheetsUIMixin = class _FWorkbookSheetsUIMixin extends FWorkbook {
+  openSiderbar(params) {
+    return this._logDeprecation("openSiderbar"), this._injector.get(ISidebarService).open(params);
+  }
+  openDialog(dialog) {
     this._logDeprecation("openDialog");
-    const t = this._injector.get(Oe).open({
-      ...e,
-      onClose: () => {
-        t.dispose();
-      }
+    const disposable = this._injector.get(IDialogService).open({
+      ...dialog,
+      onClose: /* @__PURE__ */ __name(() => {
+        disposable.dispose();
+      }, "onClose")
     });
-    return t;
+    return disposable;
   }
-  _logDeprecation(e) {
-    this._injector.get(x).warn("[FWorkbook]", `${e} is deprecated. Please use the function of the same name on "FUniver".`);
+  _logDeprecation(name) {
+    this._injector.get(ILogService).warn("[FWorkbook]", `${name} is deprecated. Please use the function of the same name on "FUniver".`);
   }
-  generateCellParams(e) {
-    const r = this.getActiveSheet();
+  generateCellParams(cell) {
+    const worksheet = this.getActiveSheet();
     return {
-      row: e.row,
-      column: e.col,
+      row: cell.row,
+      column: cell.col,
       workbook: this,
-      worksheet: r
+      worksheet
     };
   }
-  onCellClick(e) {
-    const r = this._injector.get(y);
-    return E(
-      r.currentClickedCell$.pipe(S((t) => !!t)).subscribe((t) => {
-        e(t);
+  onCellClick(callback) {
+    const hoverManagerService = this._injector.get(HoverManagerService);
+    return toDisposable(
+      hoverManagerService.currentClickedCell$.pipe(filter((cell) => !!cell)).subscribe((cell) => {
+        callback(cell);
+      })
+    );
+  }
+  onCellHover(callback) {
+    const hoverManagerService = this._injector.get(HoverManagerService);
+    return toDisposable(
+      hoverManagerService.currentRichText$.pipe(filter((cell) => !!cell)).subscribe(callback)
+    );
+  }
+  onCellPointerDown(callback) {
+    const hoverManagerService = this._injector.get(HoverManagerService);
+    return toDisposable(
+      hoverManagerService.currentPointerDownCell$.subscribe(callback)
+    );
+  }
+  onCellPointerUp(callback) {
+    const hoverManagerService = this._injector.get(HoverManagerService);
+    return toDisposable(
+      hoverManagerService.currentPointerUpCell$.subscribe(callback)
+    );
+  }
+  onCellPointerMove(callback) {
+    const hoverManagerService = this._injector.get(HoverManagerService);
+    return toDisposable(
+      hoverManagerService.currentCellPosWithEvent$.pipe(filter((cell) => !!cell)).subscribe((cell) => {
+        callback(cell, cell.event);
       })
     );
   }
-  onCellHover(e) {
-    const r = this._injector.get(y);
-    return E(
-      r.currentRichText$.pipe(S((t) => !!t)).subscribe(e)
+  onDragOver(callback) {
+    const dragManagerService = this._injector.get(DragManagerService);
+    return toDisposable(
+      dragManagerService.currentCell$.pipe(filter((cell) => !!cell)).subscribe((cell) => {
+        callback(cell);
+      })
+    );
+  }
+  onDrop(callback) {
+    const dragManagerService = this._injector.get(DragManagerService);
+    return toDisposable(
+      dragManagerService.endCell$.pipe(filter((cell) => !!cell)).subscribe((cell) => {
+        callback(cell);
+      })
     );
   }
   startEditing() {
-    return this._injector.get(_).syncExecuteCommand(I.id, {
-      eventType: te.Dblclick,
+    return this._injector.get(ICommandService).syncExecuteCommand(SetCellEditVisibleOperation.id, {
+      eventType: DeviceInputEventType.Dblclick,
       unitId: this._workbook.getUnitId(),
       visible: !0
     });
   }
-  async endEditing(e) {
-    return this._injector.get(_).syncExecuteCommand(I.id, {
-      eventType: te.Keyboard,
-      keycode: e ? T.ENTER : T.ESC,
+  async endEditing(save) {
+    return this._injector.get(ICommandService).syncExecuteCommand(SetCellEditVisibleOperation.id, {
+      eventType: DeviceInputEventType.Keyboard,
+      keycode: save ? KeyCode.ENTER : KeyCode.ESC,
       visible: !1,
       unitId: this._workbook.getUnitId()
-    }), await Ee(0), !0;
+    }), await awaitTime(0), !0;
   }
-  endEditingAsync(e = !0) {
-    return this.endEditing(e);
+  endEditingAsync(save = !0) {
+    return this.endEditing(save);
   }
   /**
    * Get scroll state of specified sheet.
@@ -626,149 +670,169 @@ class Ne extends Ce {
    * univerAPI.getActiveWorkbook().getScrollStateBySheetId($sheetId)
    * ```
    */
-  getScrollStateBySheetId(e) {
-    const r = this._workbook.getUnitId(), i = this._injector.get(f).getRenderById(r);
-    return i ? i.with($).getScrollStateByParam({ unitId: r, sheetId: e }) : null;
+  getScrollStateBySheetId(sheetId) {
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render ? render.with(SheetScrollManagerService).getScrollStateByParam({ unitId, sheetId }) : null;
   }
   disableSelection() {
-    const e = this._workbook.getUnitId(), t = this._injector.get(f).getRenderById(e);
-    return t && t.with(U).disableSelection(), this;
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render && render.with(ISheetSelectionRenderService).disableSelection(), this;
   }
   enableSelection() {
-    const e = this._workbook.getUnitId(), t = this._injector.get(f).getRenderById(e);
-    return t && t.with(U).enableSelection(), this;
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render && render.with(ISheetSelectionRenderService).enableSelection(), this;
   }
   transparentSelection() {
-    const e = this._workbook.getUnitId(), t = this._injector.get(f).getRenderById(e);
-    return t && t.with(U).transparentSelection(), this;
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render && render.with(ISheetSelectionRenderService).transparentSelection(), this;
   }
   showSelection() {
-    const e = this._workbook.getUnitId(), t = this._injector.get(f).getRenderById(e);
-    return t && t.with(U).showSelection(), this;
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render && render.with(ISheetSelectionRenderService).showSelection(), this;
   }
-}
-Ce.extend(Ne);
-class Ve extends me {
+};
+__name(_FWorkbookSheetsUIMixin, "FWorkbookSheetsUIMixin");
+let FWorkbookSheetsUIMixin = _FWorkbookSheetsUIMixin;
+FWorkbook.extend(FWorkbookSheetsUIMixin);
+const _FWorksheetSkeletonMixin = class _FWorksheetSkeletonMixin extends FWorksheet {
   refreshCanvas() {
-    const e = this._injector.get(f), r = this._fWorkbook.id, t = e.getRenderById(r);
-    if (!t)
-      throw new Error(`Render Unit with unitId ${r} not found`);
-    t.with(H).reCalculate();
-    const i = t.mainComponent;
-    if (!i)
+    const renderManagerService = this._injector.get(IRenderManagerService), unitId = this._fWorkbook.id, render = renderManagerService.getRenderById(unitId);
+    if (!render)
+      throw new Error(`Render Unit with unitId ${unitId} not found`);
+    render.with(SheetSkeletonManagerService).reCalculate();
+    const mainComponent = render.mainComponent;
+    if (!mainComponent)
       throw new Error("Main component not found");
-    return i.makeDirty(), this;
+    return mainComponent.makeDirty(), this;
   }
-  zoom(e) {
-    return this._injector.get(_).syncExecuteCommand(Te.id, {
+  zoom(zoomRatio) {
+    return this._injector.get(ICommandService).syncExecuteCommand(ChangeZoomRatioCommand.id, {
       unitId: this._workbook.getUnitId(),
       subUnitId: this._worksheet.getSheetId(),
-      zoomRatio: e
+      zoomRatio
     }), this;
   }
   getZoom() {
     return this._worksheet.getZoomRatio();
   }
   getVisibleRange() {
-    const e = this._workbook.getUnitId(), t = this._injector.get(f).getRenderById(e);
-    let i = {
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    let range = {
       startColumn: 0,
       startRow: 0,
       endColumn: 0,
       endRow: 0
     };
-    if (!t) return i;
-    const s = t.with(H).getCurrentSkeleton();
-    if (!s) return i;
-    const c = s == null ? void 0 : s.getVisibleRanges();
-    if (!c) return i;
-    i = s.getVisibleRangeByViewport(Ie.VIEW_MAIN);
-    for (const [g, C] of c)
-      Pe.indexOf(g) !== -1 && (i.startColumn = Math.min(i.startColumn, C.startColumn), i.startRow = Math.min(i.startRow, C.startRow), i.endColumn = Math.max(i.endColumn, C.endColumn), i.endRow = Math.max(i.endRow, C.endRow));
-    return i;
-  }
-  scrollToCell(e, r) {
-    const t = this._workbook.getUnitId(), o = this._injector.get(f).getRenderById(t);
-    return o && (o == null ? void 0 : o.with(De)).scrollToCell(e, r), this;
+    if (!render) return range;
+    const sk = render.with(SheetSkeletonManagerService).getCurrentSkeleton();
+    if (!sk) return range;
+    const visibleRangeMap = sk == null ? void 0 : sk.getVisibleRanges();
+    if (!visibleRangeMap) return range;
+    range = sk.getVisibleRangeByViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
+    for (const [k, r] of visibleRangeMap)
+      sheetContentViewportKeys.indexOf(k) !== -1 && (range.startColumn = Math.min(range.startColumn, r.startColumn), range.startRow = Math.min(range.startRow, r.startRow), range.endColumn = Math.max(range.endColumn, r.endColumn), range.endRow = Math.max(range.endRow, r.endRow));
+    return range;
+  }
+  scrollToCell(row, column) {
+    const unitId = this._workbook.getUnitId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render && (render == null ? void 0 : render.with(SheetsScrollRenderController)).scrollToCell(row, column), this;
   }
   getScrollState() {
-    const e = {
+    const emptyScrollState = {
       offsetX: 0,
       offsetY: 0,
       sheetViewStartColumn: 0,
       sheetViewStartRow: 0
-    }, r = this._workbook.getUnitId(), t = this._worksheet.getSheetId(), o = this._injector.get(f).getRenderById(r);
-    return o && o.with($).getScrollStateByParam({ unitId: r, sheetId: t }) || e;
+    }, unitId = this._workbook.getUnitId(), sheetId = this._worksheet.getSheetId(), render = this._injector.get(IRenderManagerService).getRenderById(unitId);
+    return render && render.with(SheetScrollManagerService).getScrollStateByParam({ unitId, sheetId }) || emptyScrollState;
+  }
+  onScroll(callback) {
+    var _a;
+    const unitId = this._workbook.getUnitId(), scrollManagerService = (_a = this._injector.get(IRenderManagerService).getRenderById(unitId)) == null ? void 0 : _a.with(SheetScrollManagerService);
+    if (scrollManagerService) {
+      const sub = scrollManagerService.validViewportScrollInfo$.subscribe((params) => {
+        callback(params);
+      });
+      return toDisposable(sub);
+    }
+    return toDisposable(() => {
+    });
   }
   getSkeleton() {
-    var r, t;
-    const e = (r = this._injector.get(f).getRenderById(this._workbook.getUnitId())) == null ? void 0 : r.with(H);
-    return (t = e == null ? void 0 : e.getWorksheetSkeleton(this._worksheet.getSheetId())) == null ? void 0 : t.skeleton;
+    var _a, _b;
+    const service = (_a = this._injector.get(IRenderManagerService).getRenderById(this._workbook.getUnitId())) == null ? void 0 : _a.with(SheetSkeletonManagerService);
+    return (_b = service == null ? void 0 : service.getWorksheetSkeleton(this._worksheet.getSheetId())) == null ? void 0 : _b.skeleton;
   }
-  setColumnAutoWidth(e, r) {
-    const t = this._workbook.getUnitId(), i = this._worksheet.getSheetId(), o = [
+  setColumnAutoWidth(columnPosition, numColumn) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), ranges = [
       {
-        startColumn: e,
-        endColumn: e + r - 1,
+        startColumn: columnPosition,
+        endColumn: columnPosition + numColumn - 1,
         startRow: 0,
         endRow: this._worksheet.getRowCount() - 1
       }
     ];
-    return this._commandService.syncExecuteCommand(Be.id, {
-      unitId: t,
-      subUnitId: i,
-      ranges: o
+    return this._commandService.syncExecuteCommand(SetWorksheetColAutoWidthCommand.id, {
+      unitId,
+      subUnitId,
+      ranges
     }), this;
   }
-}
-me.extend(Ve);
-class Ze extends fe {
-  setPermissionDialogVisible(e) {
-    this._permissionService.setShowComponents(e);
-  }
-}
-fe.extend(Ze);
-class Ke extends O {
-  onCellPointerMove(e) {
-    return E(this._injector.get(y).currentPosition$.subscribe(e));
-  }
-  onCellPointerOver(e) {
-    return E(this._injector.get(y).currentCell$.subscribe(e));
-  }
-  onCellDragOver(e) {
-    return E(this._injector.get(W).currentCell$.subscribe(e));
-  }
-  onCellDrop(e) {
-    return E(this._injector.get(W).endCell$.subscribe(e));
+};
+__name(_FWorksheetSkeletonMixin, "FWorksheetSkeletonMixin");
+let FWorksheetSkeletonMixin = _FWorksheetSkeletonMixin;
+FWorksheet.extend(FWorksheetSkeletonMixin);
+const _FPermissionSheetsUIMixin = class _FPermissionSheetsUIMixin extends FPermission {
+  setPermissionDialogVisible(visible) {
+    this._permissionService.setShowComponents(visible);
   }
-  onCellRender(e, r = we.Style, t = xe.DATA_VALIDATION) {
-    return this._injector.get(Ue).intercept(He.CELL_CONTENT, {
-      effect: r,
-      handler: (i, o, s) => s({
-        ...i,
+};
+__name(_FPermissionSheetsUIMixin, "FPermissionSheetsUIMixin");
+let FPermissionSheetsUIMixin = _FPermissionSheetsUIMixin;
+FPermission.extend(FPermissionSheetsUIMixin);
+const _FSheetHooksUIMixin = class _FSheetHooksUIMixin extends FSheetHooks {
+  onCellPointerMove(callback) {
+    return toDisposable(this._injector.get(HoverManagerService).currentPosition$.subscribe(callback));
+  }
+  onCellPointerOver(callback) {
+    return toDisposable(this._injector.get(HoverManagerService).currentCell$.subscribe(callback));
+  }
+  onCellDragOver(callback) {
+    return toDisposable(this._injector.get(DragManagerService).currentCell$.subscribe(callback));
+  }
+  onCellDrop(callback) {
+    return toDisposable(this._injector.get(DragManagerService).endCell$.subscribe(callback));
+  }
+  onCellRender(customRender, effect = InterceptorEffectEnum.Style, priority = InterceptCellContentPriority.DATA_VALIDATION) {
+    return this._injector.get(SheetInterceptorService).intercept(INTERCEPTOR_POINT.CELL_CONTENT, {
+      effect,
+      handler: /* @__PURE__ */ __name((cell, pos, next) => next({
+        ...cell,
         customRender: [
-          ...(i == null ? void 0 : i.customRender) || [],
-          ...e || []
+          ...(cell == null ? void 0 : cell.customRender) || [],
+          ...customRender || []
         ]
-      }),
-      priority: t
+      }), "handler"),
+      priority
     });
   }
-  onBeforeCellEdit(e) {
-    return this._injector.get(_).beforeCommandExecuted((r) => {
-      const t = r.params;
-      r.id === I.id && t.visible && e(t);
+  onBeforeCellEdit(callback) {
+    return this._injector.get(ICommandService).beforeCommandExecuted((command) => {
+      const params = command.params;
+      command.id === SetCellEditVisibleOperation.id && params.visible && callback(params);
     });
   }
-  onAfterCellEdit(e) {
-    return this._injector.get(_).onCommandExecuted((r) => {
-      const t = r.params;
-      r.id === I.id && !t.visible && e(t);
+  onAfterCellEdit(callback) {
+    return this._injector.get(ICommandService).onCommandExecuted((command) => {
+      const params = command.params;
+      command.id === SetCellEditVisibleOperation.id && !params.visible && callback(params);
     });
   }
-}
-O.extend(Ke);
-const M = {
+};
+__name(_FSheetHooksUIMixin, "FSheetHooksUIMixin");
+let FSheetHooksUIMixin = _FSheetHooksUIMixin;
+FSheetHooks.extend(FSheetHooksUIMixin);
+const CellFEventName = {
   CellClicked: "CellClicked",
   CellPointerDown: "CellPointerDown",
   CellPointerUp: "CellPointerUp",
@@ -781,8 +845,7 @@ const M = {
   SelectionMoving: "SelectionMoving",
   SelectionMoveEnd: "SelectionMoveEnd",
   SelectionChanged: "SelectionChanged"
-};
-class ze extends ve {
+}, _FSheetsUIEventName = class _FSheetsUIEventName extends FEventName {
   get BeforeClipboardChange() {
     return "BeforeClipboardChange";
   }
@@ -811,19 +874,19 @@ class ze extends ve {
     return "SheetEditEnded";
   }
   get CellClicked() {
-    return M.CellClicked;
+    return CellFEventName.CellClicked;
   }
   get CellHover() {
-    return M.CellHover;
+    return CellFEventName.CellHover;
   }
   get CellPointerDown() {
-    return M.CellPointerDown;
+    return CellFEventName.CellPointerDown;
   }
   get CellPointerUp() {
-    return M.CellPointerUp;
+    return CellFEventName.CellPointerUp;
   }
   get CellPointerMove() {
-    return M.CellPointerMove;
+    return CellFEventName.CellPointerMove;
   }
   get DragOver() {
     return "DragOver";
@@ -873,43 +936,45 @@ class ze extends ve {
   get SheetSkeletonChanged() {
     return "SheetSkeletonChanged";
   }
-}
-ve.extend(ze);
-class Ye extends be {
+};
+__name(_FSheetsUIEventName, "FSheetsUIEventName");
+let FSheetsUIEventName = _FSheetsUIEventName;
+FEventName.extend(FSheetsUIEventName);
+const _FRangeSheetsUIMixin = class _FRangeSheetsUIMixin extends FRange {
   getCell() {
-    var c;
-    const e = this._injector.get(f), r = this._injector.get(x), t = this._workbook.getUnitId(), i = this._worksheet.getSheetId(), o = e.getRenderById(t), s = (c = o == null ? void 0 : o.with(H).getWorksheetSkeleton(i)) == null ? void 0 : c.skeleton;
-    if (!s)
-      throw r.error("[Facade]: `FRange.getCell` can only be called in current worksheet"), new Error("`FRange.getCell` can only be called in current worksheet");
-    return s.getCellWithCoordByIndex(this._range.startRow, this._range.startColumn);
+    var _a;
+    const renderManagerService = this._injector.get(IRenderManagerService), logService = this._injector.get(ILogService), unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), render = renderManagerService.getRenderById(unitId), skeleton = (_a = render == null ? void 0 : render.with(SheetSkeletonManagerService).getWorksheetSkeleton(subUnitId)) == null ? void 0 : _a.skeleton;
+    if (!skeleton)
+      throw logService.error("[Facade]: `FRange.getCell` can only be called in current worksheet"), new Error("`FRange.getCell` can only be called in current worksheet");
+    return skeleton.getCellWithCoordByIndex(this._range.startRow, this._range.startColumn);
   }
   getCellRect() {
-    const { startX: e, startY: r, endX: t, endY: i } = this.getCell(), o = { x: e, y: r, width: t - e, height: i - r, top: r, left: e, bottom: i, right: t };
-    return { ...o, toJSON: () => JSON.stringify(o) };
+    const { startX: x, startY: y, endX: x2, endY: y2 } = this.getCell(), data = { x, y, width: x2 - x, height: y2 - y, top: y, left: x, bottom: y2, right: x2 };
+    return { ...data, toJSON: /* @__PURE__ */ __name(() => JSON.stringify(data), "toJSON") };
   }
   generateHTML() {
-    var r;
-    const e = this._injector.get(Se).generateCopyContent(
+    var _a;
+    const copyContent = this._injector.get(ISheetClipboardService).generateCopyContent(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       this._range
     );
-    return (r = e == null ? void 0 : e.html) != null ? r : "";
+    return (_a = copyContent == null ? void 0 : copyContent.html) != null ? _a : "";
   }
-  attachPopup(e) {
-    var s, c, g;
-    e.direction = (s = e.direction) != null ? s : "horizontal", e.extraProps = (c = e.extraProps) != null ? c : {}, e.offset = (g = e.offset) != null ? g : [0, 0];
-    const { key: r, disposableCollection: t } = ge(e, this._injector.get(le)), o = this._injector.get(ie).attachPopupToCell(
+  attachPopup(popup) {
+    var _a, _b, _c;
+    popup.direction = (_a = popup.direction) != null ? _a : "horizontal", popup.extraProps = (_b = popup.extraProps) != null ? _b : {}, popup.offset = (_c = popup.offset) != null ? _c : [0, 0];
+    const { key, disposableCollection } = transformComponentKey(popup, this._injector.get(ComponentManager)), disposePopup = this._injector.get(SheetCanvasPopManagerService).attachPopupToCell(
       this._range.startRow,
       this._range.startColumn,
-      { ...e, componentKey: r },
+      { ...popup, componentKey: key },
       this.getUnitId(),
       this._worksheet.getSheetId()
     );
-    return o ? (t.add(o), t) : (t.dispose(), null);
+    return disposePopup ? (disposableCollection.add(disposePopup), disposableCollection) : (disposableCollection.dispose(), null);
   }
-  attachAlertPopup(e) {
-    const r = this._injector.get(Le), t = {
+  attachAlertPopup(alert) {
+    const cellAlertService = this._injector.get(CellAlertManagerService), location = {
       workbook: this._workbook,
       worksheet: this._worksheet,
       row: this._range.startRow,
@@ -917,13 +982,13 @@ class Ye extends be {
       unitId: this.getUnitId(),
       subUnitId: this._worksheet.getSheetId()
     };
-    return r.showAlert({
-      ...e,
-      location: t
+    return cellAlertService.showAlert({
+      ...alert,
+      location
     }), {
-      dispose: () => {
-        r.removeAlert(e.key);
-      }
+      dispose: /* @__PURE__ */ __name(() => {
+        cellAlertService.removeAlert(alert.key);
+      }, "dispose")
     };
   }
   /**
@@ -938,36 +1003,39 @@ class Ye extends be {
       extraProps: { alert: { type: 0, title: 'This is an Info', message: 'This is an info message' } },
       });
    */
-  attachRangePopup(e) {
-    var s, c, g;
-    e.direction = (s = e.direction) != null ? s : "horizontal", e.extraProps = (c = e.extraProps) != null ? c : {}, e.offset = (g = e.offset) != null ? g : [0, 0];
-    const { key: r, disposableCollection: t } = ge(e, this._injector.get(le)), o = this._injector.get(ie).attachRangePopup(
+  attachRangePopup(popup) {
+    var _a, _b, _c;
+    popup.direction = (_a = popup.direction) != null ? _a : "top-center", popup.extraProps = (_b = popup.extraProps) != null ? _b : {}, popup.offset = (_c = popup.offset) != null ? _c : [0, 0];
+    const { key, disposableCollection } = transformComponentKey(popup, this._injector.get(ComponentManager)), disposePopup = this._injector.get(SheetCanvasPopManagerService).attachRangePopup(
       this._range,
-      { ...e, componentKey: r },
+      { ...popup, componentKey: key },
       this.getUnitId(),
       this._worksheet.getSheetId()
     );
-    return o ? (t.add(o), t) : (t.dispose(), null);
+    return disposePopup ? (disposableCollection.add(disposePopup), disposableCollection) : (disposableCollection.dispose(), null);
   }
-  highlight(e, r) {
-    const t = this._injector.get(Ae), i = t.addShape({ range: this._range, style: e, primary: r });
-    if (!i)
+  highlight(style, primary) {
+    const markSelectionService = this._injector.get(IMarkSelectionService), id = markSelectionService.addShape({ range: this._range, style, primary });
+    if (!id)
       throw new Error("Failed to highlight current range");
-    return E(() => {
-      t.removeShape(i);
+    return toDisposable(() => {
+      markSelectionService.removeShape(id);
     });
   }
-}
-be.extend(Ye);
-function ge(w, e) {
-  const { componentKey: r, isVue3: t } = w;
-  let i;
-  const o = new A();
-  return typeof r == "string" ? i = r : (i = `External_${ke(6)}`, o.add(e.register(i, r, { framework: t ? "vue3" : "react" }))), {
-    key: i,
-    disposableCollection: o
+};
+__name(_FRangeSheetsUIMixin, "FRangeSheetsUIMixin");
+let FRangeSheetsUIMixin = _FRangeSheetsUIMixin;
+FRange.extend(FRangeSheetsUIMixin);
+function transformComponentKey(component, componentManager) {
+  const { componentKey, isVue3 } = component;
+  let key;
+  const disposableCollection = new DisposableCollection();
+  return typeof componentKey == "string" ? key = componentKey : (key = `External_${generateRandomId(6)}`, disposableCollection.add(componentManager.register(key, componentKey, { framework: isVue3 ? "vue3" : "react" }))), {
+    key,
+    disposableCollection
   };
 }
+__name(transformComponentKey, "transformComponentKey");
 export {
-  ge as transformComponentKey
+  transformComponentKey
 };