@univerjs/sheets-drawing-ui 0.4.1 → 0.4.2-nightly.202410301606

package/lib/canvas-float-dom-manager.service-DT1kY3QQ.mjs

@@ -0,0 +1,409 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { CommandType, ICommandService, IUndoRedoService, sequenceExecute, Inject, LifecycleService, Disposable, LifecycleStages, DisposableCollection, UniverInstanceType, fromEventSubject, generateRandomId, IUniverInstanceService } from "@univerjs/core";
+import { DrawingTypeEnum, getDrawingShapeKeyByDrawingSearch, IDrawingManagerService } from "@univerjs/drawing";
+import { IRenderManagerService, Rect, ObjectType, DRAWING_OBJECT_LAYER_INDEX, SHEET_VIEWPORT_KEY } from "@univerjs/engine-render";
+import { SheetInterceptorService, getSheetCommandTarget, SetFrozenMutation } from "@univerjs/sheets";
+import { ISheetDrawingService, SetDrawingApplyMutation, DrawingApplyType } from "@univerjs/sheets-drawing";
+import { SheetSkeletonManagerService, VIEWPORT_KEY, SetZoomRatioOperation, ISheetSelectionRenderService } from "@univerjs/sheets-ui";
+import { CanvasFloatDomService } from "@univerjs/ui";
+import { Subject, filter, take, BehaviorSubject, map, switchMap } from "rxjs";
+const ClearSheetDrawingTransformerOperation = {
+  id: "sheet.operation.clear-drawing-transformer",
+  type: CommandType.MUTATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const renderManagerService = accessor.get(IRenderManagerService);
+    return params.forEach((unitId) => {
+      var _a2, _b;
+      (_b = (_a2 = renderManagerService.getRenderById(unitId)) == null ? void 0 : _a2.scene.getTransformer()) == null || _b.debounceRefreshControls();
+    }), !0;
+  }, "handler")
+}, InsertSheetDrawingCommand = {
+  id: "sheet.command.insert-sheet-image",
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDrawingService = accessor.get(ISheetDrawingService), sheetInterceptorService = accessor.get(SheetInterceptorService);
+    if (!params) return !1;
+    const drawings = params.drawings, unitIds = drawings.map((param) => param.unitId), jsonOp = sheetDrawingService.getBatchAddOp(drawings), { unitId, subUnitId, undo, redo, objects } = jsonOp, intercepted = sheetInterceptorService.onCommandExecute({ id: InsertSheetDrawingCommand.id, params }), insertMutation = { id: SetDrawingApplyMutation.id, params: { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.INSERT } }, undoInsertMutation = { id: SetDrawingApplyMutation.id, params: { op: undo, unitId, subUnitId, objects, type: DrawingApplyType.REMOVE } };
+    return sequenceExecute([insertMutation, ...intercepted.redos], commandService) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      undoMutations: [
+        ...intercepted.undos,
+        undoInsertMutation,
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
+      ],
+      redoMutations: [
+        insertMutation,
+        ...intercepted.redos,
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
+      ]
+    }), !0) : !1;
+  }, "handler")
+};
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam");
+function transformBound2DOMBound(originBound, scene, skeleton, worksheet) {
+  const { scaleX, scaleY } = scene.getAncestorScale(), viewMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN), absolute = {
+    left: !0,
+    top: !0
+  };
+  if (!viewMain)
+    return {
+      ...originBound,
+      absolute
+    };
+  const { left, right, top, bottom } = originBound, freeze = worksheet.getFreeze(), { startColumn, startRow, xSplit, ySplit } = freeze, startSheetView = skeleton.getNoMergeCellPositionByIndexWithNoHeader(startRow - ySplit, startColumn - xSplit), endSheetView = skeleton.getNoMergeCellPositionByIndexWithNoHeader(startRow, startColumn), { rowHeaderWidth, columnHeaderHeight } = skeleton, freezeWidth = endSheetView.startX - startSheetView.startX, freezeHeight = endSheetView.startY - startSheetView.startY, { top: freezeTop, left: freezeLeft, viewportScrollX: actualScrollX, viewportScrollY: actualScrollY } = viewMain;
+  let offsetLeft, offsetRight;
+  left < freezeLeft ? (absolute.left = !0, offsetLeft = (freezeWidth + rowHeaderWidth + (left - freezeLeft)) * scaleX, offsetRight = Math.max(
+    Math.min(
+      (freezeWidth + rowHeaderWidth + (right - freezeLeft)) * scaleX,
+      (freezeWidth + rowHeaderWidth) * scaleX
+    ),
+    (right - actualScrollX) * scaleX
+  )) : (absolute.left = !1, offsetLeft = Math.max((left - actualScrollX) * scaleX, (freezeWidth + rowHeaderWidth) * scaleX), offsetRight = Math.max((right - actualScrollX) * scaleX, (freezeWidth + rowHeaderWidth) * scaleX));
+  let offsetTop, offsetBottom;
+  return top < freezeTop ? (absolute.top = !0, offsetTop = (freezeHeight + columnHeaderHeight + (top - freezeTop)) * scaleY, offsetBottom = Math.max(
+    Math.min(
+      (freezeHeight + columnHeaderHeight + (right - freezeTop)) * scaleY,
+      (freezeHeight + columnHeaderHeight) * scaleY
+    ),
+    (bottom - actualScrollY) * scaleY
+  )) : (absolute.top = !1, offsetTop = Math.max((top - actualScrollY) * scaleY, (freezeHeight + columnHeaderHeight) * scaleY), offsetBottom = Math.max((bottom - actualScrollY) * scaleY, (freezeHeight + columnHeaderHeight) * scaleY)), {
+    left: offsetLeft,
+    right: offsetRight,
+    top: offsetTop,
+    bottom: offsetBottom,
+    absolute
+  };
+}
+__name(transformBound2DOMBound, "transformBound2DOMBound");
+const calcPosition = /* @__PURE__ */ __name((targetObject, currentRender, skeleton, worksheet) => {
+  const { scene } = currentRender, { left, top, width, height, angle } = targetObject, bound = {
+    left,
+    right: left + width,
+    top,
+    bottom: top + height
+  }, offsetBound = transformBound2DOMBound(bound, scene, skeleton, worksheet), { scaleX, scaleY } = scene.getAncestorScale();
+  return {
+    startX: offsetBound.left,
+    endX: offsetBound.right,
+    startY: offsetBound.top,
+    endY: offsetBound.bottom,
+    rotate: angle,
+    width: width * scaleX,
+    height: height * scaleY,
+    absolute: offsetBound.absolute
+  };
+}, "calcPosition");
+var _a;
+let SheetCanvasFloatDomManagerService = (_a = class extends Disposable {
+  constructor(_renderManagerService, _univerInstanceService, _commandService, _drawingManagerService, _canvasFloatDomService, _sheetDrawingService, _lifecycleService) {
+    super();
+    __publicField(this, "_domLayerMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_domLayerInfoMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_transformChange$", new Subject());
+    __publicField(this, "transformChange$", this._transformChange$.asObservable());
+    __publicField(this, "_add$", new Subject());
+    __publicField(this, "add$", this._add$.asObservable());
+    __publicField(this, "_remove$", new Subject());
+    __publicField(this, "remove$", this._remove$.asObservable());
+    __publicField(this, "_hooks", []);
+    this._renderManagerService = _renderManagerService, this._univerInstanceService = _univerInstanceService, this._commandService = _commandService, this._drawingManagerService = _drawingManagerService, this._canvasFloatDomService = _canvasFloatDomService, this._sheetDrawingService = _sheetDrawingService, this._lifecycleService = _lifecycleService, this._drawingAddListener(), this._featureUpdateListener(), this._deleteListener(), this._bindScrollEvent();
+  }
+  _bindScrollEvent() {
+    this._lifecycleService.lifecycle$.pipe(filter((s) => s === LifecycleStages.Rendered), take(1)).subscribe(() => {
+      this._scrollUpdateListener();
+    });
+  }
+  _ensureMap(unitId, subUnitId) {
+    let unitMap = this._domLayerMap.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._domLayerMap.set(unitId, unitMap));
+    let subUnitMap = unitMap.get(subUnitId);
+    return subUnitMap || (subUnitMap = /* @__PURE__ */ new Map(), unitMap.set(subUnitId, subUnitMap)), subUnitMap;
+  }
+  getFloatDomInfo(id) {
+    return this._domLayerInfoMap.get(id);
+  }
+  _getSceneAndTransformerByDrawingSearch(unitId) {
+    if (unitId == null)
+      return;
+    const renderObject = this._renderManagerService.getRenderById(unitId), scene = renderObject == null ? void 0 : renderObject.scene;
+    if (renderObject == null || scene == null)
+      return null;
+    const transformer = scene.getTransformerByCreate(), canvas = renderObject.engine.getCanvasElement();
+    return { scene, transformer, renderObject, canvas };
+  }
+  _getFloatDomProps(id) {
+    let props;
+    return this._hooks.forEach((hook) => {
+      props = hook.onGetFloatDomProps(id);
+    }), props;
+  }
+  // eslint-disable-next-line max-lines-per-function
+  _drawingAddListener() {
+    this.disposeWithMe(
+      // eslint-disable-next-line max-lines-per-function
+      this._drawingManagerService.add$.subscribe((params) => {
+        params.forEach((param) => {
+          var _a2, _b, _c;
+          const { unitId, subUnitId, drawingId } = param, target = getSheetCommandTarget(this._univerInstanceService, { unitId, subUnitId }), floatDomParam = this._drawingManagerService.getDrawingByParam(param);
+          if (!floatDomParam || !target)
+            return;
+          const skeleton = (_a2 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a2.with(SheetSkeletonManagerService).getWorksheetSkeleton(subUnitId);
+          if (!skeleton)
+            return;
+          const { transform, drawingType, data } = floatDomParam;
+          if (drawingType !== DrawingTypeEnum.DRAWING_DOM && drawingType !== DrawingTypeEnum.DRAWING_CHART)
+            return;
+          const renderObject = this._getSceneAndTransformerByDrawingSearch(unitId);
+          if (renderObject == null)
+            return;
+          const { scene, canvas } = renderObject;
+          if (transform == null)
+            return !0;
+          const { left, top, width, height, angle, flipX, flipY, skewX, skewY } = transform, rectShapeKey = getDrawingShapeKeyByDrawingSearch({ unitId, subUnitId, drawingId }), rectShape = scene.getObject(rectShapeKey);
+          if (rectShape != null) {
+            rectShape.transformByState({ left, top, width, height, angle, flipX, flipY, skewX, skewY });
+            return;
+          }
+          const imageConfig = {
+            left,
+            top,
+            width,
+            height,
+            zIndex: this._drawingManagerService.getDrawingOrder(unitId, subUnitId).length - 1
+          }, isChart = drawingType === DrawingTypeEnum.DRAWING_CHART;
+          isChart && (imageConfig.fill = "white", imageConfig.rotateEnabled = !1, data && data.border && (imageConfig.stroke = data.border), imageConfig.paintFirst = "stroke", imageConfig.strokeWidth = 1, imageConfig.borderEnabled = !1);
+          const rect = new Rect(rectShapeKey, imageConfig);
+          isChart && rect.setObjectType(ObjectType.CHART), scene.addObject(rect, DRAWING_OBJECT_LAYER_INDEX), floatDomParam.allowTransform !== !1 && scene.attachTransformerTo(rect);
+          const map2 = this._ensureMap(unitId, subUnitId), disposableCollection = new DisposableCollection(), initPosition = calcPosition(rect, renderObject.renderObject, skeleton.skeleton, target.worksheet), position$ = new BehaviorSubject(initPosition), info = {
+            dispose: disposableCollection,
+            rect,
+            position$,
+            unitId,
+            subUnitId
+          };
+          this._canvasFloatDomService.addFloatDom({
+            position$,
+            id: drawingId,
+            componentKey: floatDomParam.componentKey,
+            onPointerDown: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new PointerEvent(evt.type, evt));
+            }, "onPointerDown"),
+            onPointerMove: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new PointerEvent(evt.type, evt));
+            }, "onPointerMove"),
+            onPointerUp: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new PointerEvent(evt.type, evt));
+            }, "onPointerUp"),
+            onWheel: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new WheelEvent(evt.type, evt));
+            }, "onWheel"),
+            props: (_c = (_b = map2.get(drawingId)) == null ? void 0 : _b.props) != null ? _c : this._getFloatDomProps(drawingId),
+            data,
+            unitId
+          });
+          const listener = rect.onTransformChange$.subscribeEvent(() => {
+            const newPosition = calcPosition(rect, renderObject.renderObject, skeleton.skeleton, target.worksheet);
+            position$.next(
+              newPosition
+            );
+          });
+          disposableCollection.add(() => {
+            this._canvasFloatDomService.removeFloatDom(drawingId);
+          }), listener && disposableCollection.add(listener), this._domLayerInfoMap.set(drawingId, info), map2.set(drawingId, {
+            ...map2.get(drawingId)
+          });
+        });
+      })
+    ), this.disposeWithMe(
+      this._drawingManagerService.remove$.subscribe((params) => {
+        params.forEach((param) => {
+          const { unitId, subUnitId, drawingId } = param, rectShapeKey = getDrawingShapeKeyByDrawingSearch({ unitId, subUnitId, drawingId }), renderObject = this._getSceneAndTransformerByDrawingSearch(unitId);
+          if (renderObject == null)
+            return;
+          const { transformer, scene } = renderObject, rectShape = scene.getObject(rectShapeKey);
+          rectShape != null && rectShape.oKey && transformer.clearControlByIds([rectShape == null ? void 0 : rectShape.oKey]);
+        });
+      })
+    );
+  }
+  _scrollUpdateListener() {
+    const updateSheet = /* @__PURE__ */ __name((unitId, subUnitId) => {
+      var _a2;
+      const renderObject = this._getSceneAndTransformerByDrawingSearch(unitId), map2 = this._ensureMap(unitId, subUnitId), ids = Array.from(map2.keys()), target = getSheetCommandTarget(this._univerInstanceService, { unitId, subUnitId }), skeleton = (_a2 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a2.with(SheetSkeletonManagerService).getWorksheetSkeleton(subUnitId);
+      !renderObject || !target || !skeleton || ids.forEach((id) => {
+        const info = this._domLayerInfoMap.get(id);
+        if (info) {
+          const position = calcPosition(info.rect, renderObject.renderObject, skeleton.skeleton, target.worksheet);
+          info.position$.next(position);
+        }
+      });
+    }, "updateSheet");
+    this.disposeWithMe(
+      this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET).pipe(
+        filter((sheet) => !!sheet),
+        map((sheet) => {
+          const render = this._renderManagerService.getRenderById(sheet.getUnitId());
+          return render ? { render, unitId: sheet.getUnitId(), subUnitId: sheet.getActiveSheet().getSheetId() } : null;
+        }),
+        filter((render) => !!render),
+        switchMap(
+          (render) => fromEventSubject(render.render.scene.getViewport(VIEWPORT_KEY.VIEW_MAIN).onScrollAfter$).pipe(map(() => ({ unitId: render.unitId, subUnitId: render.subUnitId })))
+        )
+      ).subscribe(({ unitId, subUnitId }) => {
+        updateSheet(unitId, subUnitId);
+      })
+    ), this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo) => {
+      var _a2, _b;
+      if (commandInfo.id === SetZoomRatioOperation.id) {
+        const params = commandInfo.params, { unitId } = params;
+        Array.from((_b = (_a2 = this._domLayerMap.get(unitId)) == null ? void 0 : _a2.keys()) != null ? _b : []).forEach((subUnitId) => {
+          updateSheet(unitId, subUnitId);
+        });
+      } else if (commandInfo.id === SetFrozenMutation.id) {
+        const { unitId, subUnitId } = commandInfo.params;
+        updateSheet(unitId, subUnitId);
+      }
+    }));
+  }
+  _getPosition(position, unitId) {
+    var _a2;
+    const { startX, endX, startY, endY } = position, selectionRenderService = (_a2 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a2.with(ISheetSelectionRenderService);
+    if (selectionRenderService == null)
+      return;
+    const start = selectionRenderService.getSelectionCellByPosition(startX, startY);
+    if (start == null)
+      return;
+    const from = {
+      column: start.actualColumn,
+      columnOffset: startX - start.startX,
+      row: start.actualRow,
+      rowOffset: startY - start.startY
+    }, end = selectionRenderService.getSelectionCellByPosition(endX, endY);
+    if (end == null)
+      return;
+    const to = {
+      column: end.actualColumn,
+      columnOffset: endX - end.startX,
+      row: end.actualRow,
+      rowOffset: endY - end.startY
+    };
+    return {
+      from,
+      to
+    };
+  }
+  _featureUpdateListener() {
+    this.disposeWithMe(
+      this._drawingManagerService.update$.subscribe((params) => {
+        params.forEach((data) => {
+          const sheetDrawing = this._drawingManagerService.getDrawingByParam(data);
+          if (!sheetDrawing || sheetDrawing.drawingType !== DrawingTypeEnum.DRAWING_DOM && sheetDrawing.drawingType !== DrawingTypeEnum.DRAWING_CHART)
+            return;
+          const newValue = {
+            ...sheetDrawing.transform
+          };
+          this._transformChange$.next({ id: data.drawingId, value: newValue });
+        });
+      })
+    );
+  }
+  _deleteListener() {
+    this.disposeWithMe(
+      this._drawingManagerService.remove$.subscribe((params) => {
+        params.forEach((param) => {
+          this._removeDom(param.drawingId);
+        });
+      })
+    );
+  }
+  updateFloatDomProps(unitId, subUnitId, id, props) {
+    const info = this._domLayerInfoMap.get(id), renderObject = this._getSceneAndTransformerByDrawingSearch(unitId);
+    if (info && renderObject) {
+      const { scene } = renderObject, rectShapeKey = getDrawingShapeKeyByDrawingSearch({ unitId, subUnitId, drawingId: id }), rectShape = scene.getObject(rectShapeKey);
+      rectShape && rectShape instanceof Rect && rectShape.setProps(props);
+    }
+  }
+  addFloatDomToPosition(layer, propId, executeCommand = !0) {
+    const target = getSheetCommandTarget(this._univerInstanceService, {
+      unitId: layer.unitId,
+      subUnitId: layer.subUnitId
+    });
+    if (!target)
+      throw new Error("cannot find current target!");
+    const { unitId, subUnitId } = target, { initPosition, componentKey, data, allowTransform = !0 } = layer, id = propId != null ? propId : generateRandomId(), sheetTransform = this._getPosition(initPosition, unitId);
+    if (sheetTransform == null)
+      return;
+    this._ensureMap(unitId, subUnitId).set(id, layer);
+    const sheetDrawingParam = {
+      unitId,
+      subUnitId,
+      drawingId: id,
+      drawingType: layer.type || DrawingTypeEnum.DRAWING_DOM,
+      componentKey,
+      sheetTransform,
+      transform: {
+        left: initPosition.startX,
+        top: initPosition.startY,
+        width: initPosition.endX - initPosition.startX,
+        height: initPosition.endY - initPosition.startY
+      },
+      data,
+      allowTransform
+    };
+    return executeCommand && this._commandService.executeCommand(InsertSheetDrawingCommand.id, {
+      unitId,
+      drawings: [sheetDrawingParam]
+    }), this._add$.next({ unitId, subUnitId, id }), {
+      id,
+      dispose: /* @__PURE__ */ __name(() => {
+        this._removeDom(id, !0);
+      }, "dispose"),
+      sheetDrawingParam
+    };
+  }
+  _removeDom(id, removeDrawing = !1) {
+    const info = this._domLayerInfoMap.get(id);
+    if (!info)
+      return;
+    const { unitId, subUnitId } = info;
+    this._domLayerInfoMap.delete(id), info.dispose.dispose();
+    const renderObject = this._getSceneAndTransformerByDrawingSearch(unitId);
+    if (renderObject && renderObject.scene.removeObject(info.rect), removeDrawing) {
+      this._ensureMap(unitId, subUnitId).delete(id);
+      const param = this._drawingManagerService.getDrawingByParam({ unitId, subUnitId, drawingId: id });
+      if (!param)
+        return;
+      const jsonOp = this._sheetDrawingService.getBatchRemoveOp([param]), { redo, objects } = jsonOp;
+      this._commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.REMOVE });
+    }
+  }
+  addHook(hook) {
+    return this._hooks.push(hook), {
+      dispose: /* @__PURE__ */ __name(() => {
+        const index = this._hooks.findIndex((h) => h === hook);
+        this._hooks.splice(index, 1);
+      }, "dispose")
+    };
+  }
+}, __name(_a, "SheetCanvasFloatDomManagerService"), _a);
+SheetCanvasFloatDomManagerService = __decorateClass([
+  __decorateParam(0, Inject(IRenderManagerService)),
+  __decorateParam(1, IUniverInstanceService),
+  __decorateParam(2, Inject(ICommandService)),
+  __decorateParam(3, IDrawingManagerService),
+  __decorateParam(4, Inject(CanvasFloatDomService)),
+  __decorateParam(5, ISheetDrawingService),
+  __decorateParam(6, Inject(LifecycleService))
+], SheetCanvasFloatDomManagerService);
+export {
+  ClearSheetDrawingTransformerOperation as C,
+  InsertSheetDrawingCommand as I,
+  SheetCanvasFloatDomManagerService as S
+};

package/lib/es/facade.js

@@ -0,0 +1,20 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+import { FWorksheet } from "@univerjs/sheets/facade";
+import { transformComponentKey } from "@univerjs/sheets-ui/facade";
+import { ComponentManager } from "@univerjs/ui";
+import { S as SheetCanvasFloatDomManagerService } from "../canvas-float-dom-manager.service-DT1kY3QQ.mjs";
+const _FWorksheetLegacy = class _FWorksheetLegacy extends FWorksheet {
+  addFloatDomToPosition(layer, id) {
+    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), { key, disposableCollection } = transformComponentKey(layer, this._injector.get(ComponentManager)), res = this._injector.get(SheetCanvasFloatDomManagerService).addFloatDomToPosition({ ...layer, componentKey: key, unitId, subUnitId }, id);
+    return res ? (disposableCollection.add(res.dispose), {
+      id: res.id,
+      dispose: /* @__PURE__ */ __name(() => {
+        disposableCollection.dispose(), res.dispose();
+      }, "dispose")
+    }) : (disposableCollection.dispose(), null);
+  }
+};
+__name(_FWorksheetLegacy, "FWorksheetLegacy");
+let FWorksheetLegacy = _FWorksheetLegacy;
+FWorksheet.extend(FWorksheetLegacy);