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

package/lib/es/facade.js

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