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

package/lib/es/facade.js

@@ -1,86 +1,82 @@
-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 { Inject, Injector, ICommandService, generateRandomId, DrawingTypeEnum, ImageSourceType, FBase, ArrangeTypeEnum, toDisposable, FEnum, FEventName, FUniver } from "@univerjs/core";
-import { getImageSize, SetDrawingSelectedOperation, IDrawingManagerService } from "@univerjs/drawing";
-import { IRenderManagerService } from "@univerjs/engine-render";
-import { SetSheetDrawingCommand, SetDrawingArrangeCommand, SheetCanvasFloatDomManagerService, InsertSheetDrawingCommand, RemoveSheetDrawingCommand } from "@univerjs/sheets-drawing-ui";
-import { SheetSkeletonManagerService, ISheetSelectionRenderService, convertPositionSheetOverGridToAbsolute, convertPositionCellToSheetOverGrid } from "@univerjs/sheets-ui";
-import { ISheetDrawingService, SheetDrawingAnchorType } from "@univerjs/sheets-drawing";
-import { transformComponentKey } from "@univerjs/sheets-ui/facade";
-import { FWorksheet } from "@univerjs/sheets/facade";
-import { ComponentManager } from "@univerjs/ui";
-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 convertSheetImageToFOverGridImage(sheetImage, sheetSkeletonManagerService) {
-  const { from, to, flipY = !1, flipX = !1, angle = 0, skewX = 0, skewY = 0 } = sheetImage.sheetTransform, { column: fromColumn, columnOffset: fromColumnOffset, row: fromRow, rowOffset: fromRowOffset } = from, absolutePosition = convertPositionSheetOverGridToAbsolute(
-    sheetImage.unitId,
-    sheetImage.subUnitId,
-    { from, to },
-    sheetSkeletonManagerService
-  ), { left, top, width, height } = absolutePosition;
+var L = Object.defineProperty;
+var X = (r, t, e) => t in r ? L(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var T = (r, t, e) => X(r, typeof t != "symbol" ? t + "" : t, e);
+import { Inject as x, Injector as P, ICommandService as W, generateRandomId as Y, DrawingTypeEnum as _, ImageSourceType as I, FBase as V, ArrangeTypeEnum as v, toDisposable as C, FEnum as M, FEventName as z, FUniver as N } from "@univerjs/core";
+import { getImageSize as q, SetDrawingSelectedOperation as A, IDrawingManagerService as l } from "@univerjs/drawing";
+import { IRenderManagerService as F } from "@univerjs/engine-render";
+import { SetSheetDrawingCommand as m, SetDrawingArrangeCommand as w, SheetCanvasFloatDomManagerService as G, InsertSheetDrawingCommand as S, RemoveSheetDrawingCommand as D } from "@univerjs/sheets-drawing-ui";
+import { SheetSkeletonManagerService as U, ISheetSelectionRenderService as J, convertPositionSheetOverGridToAbsolute as Q, convertPositionCellToSheetOverGrid as Z } from "@univerjs/sheets-ui";
+import { ISheetDrawingService as u, SheetDrawingAnchorType as ee } from "@univerjs/sheets-drawing";
+import { transformComponentKey as E } from "@univerjs/sheets-ui/facade";
+import { FWorksheet as $ } from "@univerjs/sheets/facade";
+import { ComponentManager as y } from "@univerjs/ui";
+var te = Object.defineProperty, ie = Object.getOwnPropertyDescriptor, H = (r, t, e, i) => {
+  for (var n = i > 1 ? void 0 : i ? ie(t, e) : t, s = r.length - 1, o; s >= 0; s--)
+    (o = r[s]) && (n = (i ? o(t, e, n) : o(n)) || n);
+  return i && n && te(t, e, n), n;
+}, R = (r, t) => (e, i) => t(e, i, r);
+function re(r, t) {
+  const { from: e, to: i, flipY: n = !1, flipX: s = !1, angle: o = 0, skewX: c = 0, skewY: a = 0 } = r.sheetTransform, { column: h, columnOffset: d, row: f, rowOffset: p } = e, k = Q(
+    r.unitId,
+    r.subUnitId,
+    { from: e, to: i },
+    t
+  ), { left: B, top: j, width: O, height: K } = k;
   return {
-    ...sheetImage,
-    column: fromColumn,
-    columnOffset: fromColumnOffset,
-    row: fromRow,
-    rowOffset: fromRowOffset,
-    width,
-    height,
-    flipY,
-    flipX,
-    angle,
-    skewX,
-    skewY
+    ...r,
+    column: h,
+    columnOffset: d,
+    row: f,
+    rowOffset: p,
+    width: O,
+    height: K,
+    flipY: n,
+    flipX: s,
+    angle: o,
+    skewX: c,
+    skewY: a
   };
 }
-__name(convertSheetImageToFOverGridImage, "convertSheetImageToFOverGridImage");
-function convertFOverGridImageToSheetImage(fOverGridImage, selectionRenderService, sheetSkeletonManagerService) {
-  const { column: fromColumn, columnOffset: fromColumnOffset, row: fromRow, rowOffset: fromRowOffset, flipY = !1, flipX = !1, angle = 0, skewX = 0, skewY = 0, width, height } = fOverGridImage, absolutePosition = convertPositionCellToSheetOverGrid(
-    fOverGridImage.unitId,
-    fOverGridImage.subUnitId,
-    { column: fromColumn, columnOffset: fromColumnOffset, row: fromRow, rowOffset: fromRowOffset },
-    width,
-    height,
-    selectionRenderService,
-    sheetSkeletonManagerService
-  ), { sheetTransform, transform } = absolutePosition;
+function ne(r, t, e) {
+  const { column: i, columnOffset: n, row: s, rowOffset: o, flipY: c = !1, flipX: a = !1, angle: h = 0, skewX: d = 0, skewY: f = 0, width: p, height: k } = r, B = Z(
+    r.unitId,
+    r.subUnitId,
+    { column: i, columnOffset: n, row: s, rowOffset: o },
+    p,
+    k,
+    t,
+    e
+  ), { sheetTransform: j, transform: O } = B;
   return {
-    ...fOverGridImage,
+    ...r,
     sheetTransform: {
-      ...sheetTransform,
-      flipY,
-      flipX,
-      angle,
-      skewX,
-      skewY
+      ...j,
+      flipY: c,
+      flipX: a,
+      angle: h,
+      skewX: d,
+      skewY: f
     },
     transform: {
-      ...transform,
-      flipY,
-      flipX,
-      angle,
-      skewX,
-      skewY
+      ...O,
+      flipY: c,
+      flipX: a,
+      angle: h,
+      skewX: d,
+      skewY: f
     }
   };
 }
-__name(convertFOverGridImageToSheetImage, "convertFOverGridImageToSheetImage");
-var _a;
-let FOverGridImageBuilder = (_a = class {
-  constructor(unitId, subUnitId, _injector) {
-    __publicField(this, "_image");
-    this._injector = _injector, this._image = {
-      drawingId: generateRandomId(6),
-      drawingType: DrawingTypeEnum.DRAWING_IMAGE,
-      imageSourceType: ImageSourceType.BASE64,
+let b = class {
+  constructor(r, t, e) {
+    T(this, "_image");
+    this._injector = e, this._image = {
+      drawingId: Y(6),
+      drawingType: _.DRAWING_IMAGE,
+      imageSourceType: I.BASE64,
       source: "",
-      unitId,
-      subUnitId,
+      unitId: r,
+      subUnitId: t,
       column: 0,
       columnOffset: 0,
       row: 0,
@@ -110,12 +106,12 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setImage(image) {
-    const render = this._injector.get(IRenderManagerService).getRenderById(image.unitId);
-    if (!render)
-      throw new Error(`Render Unit with unitId ${image.unitId} not found`);
-    const skeletonManagerService = render.with(SheetSkeletonManagerService);
-    return image.sheetTransform == null && (image.sheetTransform = {
+  setImage(r) {
+    const e = this._injector.get(F).getRenderById(r.unitId);
+    if (!e)
+      throw new Error(`Render Unit with unitId ${r.unitId} not found`);
+    const i = e.with(U);
+    return r.sheetTransform == null && (r.sheetTransform = {
       from: {
         column: 0,
         columnOffset: 0,
@@ -128,11 +124,11 @@ let FOverGridImageBuilder = (_a = class {
         row: 0,
         rowOffset: 0
       }
-    }), this._image = convertSheetImageToFOverGridImage(image, skeletonManagerService), this;
+    }), this._image = re(r, i), this;
   }
-  setSource(source, sourceType) {
-    const sourceTypeVal = sourceType != null ? sourceType : ImageSourceType.URL;
-    return this._image.source = source, this._image.imageSourceType = sourceTypeVal, this;
+  setSource(r, t) {
+    const e = t != null ? t : I.URL;
+    return this._image.source = r, this._image.imageSourceType = e, this;
   }
   getsource() {
     return this._image.source;
@@ -154,8 +150,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setColumn(column) {
-    return this._image.column = column, this;
+  setColumn(r) {
+    return this._image.column = r, this;
   }
   /**
    * Set the position of the image
@@ -171,8 +167,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setRow(row) {
-    return this._image.row = row, this;
+  setRow(r) {
+    return this._image.row = r, this;
   }
   /**
    * Set the column offset of the image in a unit
@@ -188,8 +184,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setColumnOffset(offset) {
-    return this._image.columnOffset = offset, this;
+  setColumnOffset(r) {
+    return this._image.columnOffset = r, this;
   }
   /**
    * Set the row offset of the image in a unit
@@ -205,8 +201,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setRowOffset(offset) {
-    return this._image.rowOffset = offset, this;
+  setRowOffset(r) {
+    return this._image.rowOffset = r, this;
   }
   /**
    * set the width of the image
@@ -222,8 +218,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setWidth(width) {
-    return this._image.width = width, this;
+  setWidth(r) {
+    return this._image.width = r, this;
   }
   /**
    * Set the height of the image
@@ -239,8 +235,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setHeight(height) {
-    return this._image.height = height, this;
+  setHeight(r) {
+    return this._image.height = r, this;
   }
   /**
    * Set the anchor type of the image, whether the position and size change with the cell
@@ -256,8 +252,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setAnchorType(anchorType) {
-    return this._image.anchorType = anchorType, this;
+  setAnchorType(r) {
+    return this._image.anchorType = r, this;
   }
   /**
    * Set the cropping region of the image by defining the top edges, thereby displaying the specific part of the image you want.
@@ -273,8 +269,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropTop(top) {
-    return this._initializeSrcRect(), this._image.srcRect.top = top, this;
+  setCropTop(r) {
+    return this._initializeSrcRect(), this._image.srcRect.top = r, this;
   }
   /**
    * Set the cropping region of the image by defining the left edges, thereby displaying the specific part of the image you want.
@@ -290,8 +286,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropLeft(left) {
-    return this._initializeSrcRect(), this._image.srcRect.left = left, this;
+  setCropLeft(r) {
+    return this._initializeSrcRect(), this._image.srcRect.left = r, this;
   }
   /**
    * Set the cropping region of the image by defining the bottom edges, thereby displaying the specific part of the image you want.
@@ -307,8 +303,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropBottom(bottom) {
-    return this._initializeSrcRect(), this._image.srcRect.bottom = bottom, this;
+  setCropBottom(r) {
+    return this._initializeSrcRect(), this._image.srcRect.bottom = r, this;
   }
   /**
    * Set the cropping region of the image by defining the right edges, thereby displaying the specific part of the image you want.
@@ -324,8 +320,8 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropRight(right) {
-    return this._initializeSrcRect(), this._image.srcRect.right = right, this;
+  setCropRight(r) {
+    return this._initializeSrcRect(), this._image.srcRect.right = r, this;
   }
   _initializeSrcRect() {
     this._image.srcRect == null && (this._image.srcRect = {
@@ -349,38 +345,37 @@ let FOverGridImageBuilder = (_a = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setRotate(angle) {
-    return this._image.angle = angle, this;
+  setRotate(r) {
+    return this._image.angle = r, this;
   }
   // setPresetGeometry(prstGeom: PresetGeometryType): FOverGridImageBuilder {
   //     this._image.prstGeom = prstGeom;
   //     return this;
   // }
-  setUnitId(unitId) {
-    return this._image.unitId = unitId, this;
+  setUnitId(r) {
+    return this._image.unitId = r, this;
   }
-  setSubUnitId(subUnitId) {
-    return this._image.subUnitId = subUnitId, this;
+  setSubUnitId(r) {
+    return this._image.subUnitId = r, this;
   }
   async buildAsync() {
-    const render = this._injector.get(IRenderManagerService).getRenderById(this._image.unitId);
-    if (!render)
+    const t = this._injector.get(F).getRenderById(this._image.unitId);
+    if (!t)
       throw new Error(`Render Unit with unitId ${this._image.unitId} not found`);
-    const selectionRenderService = render.with(ISheetSelectionRenderService), skeletonManagerService = render.with(SheetSkeletonManagerService);
+    const e = t.with(J), i = t.with(U);
     if (this._image.width === 0 || this._image.height === 0) {
-      const size = await getImageSize(this._image.source), width = size.width, height = size.height;
-      this._image.width === 0 && (this._image.width = width), this._image.height === 0 && (this._image.height = height);
+      const n = await q(this._image.source), s = n.width, o = n.height;
+      this._image.width === 0 && (this._image.width = s), this._image.height === 0 && (this._image.height = o);
     }
-    return convertFOverGridImageToSheetImage(this._image, selectionRenderService, skeletonManagerService);
+    return ne(this._image, e, i);
   }
-}, __name(_a, "FOverGridImageBuilder"), _a);
-FOverGridImageBuilder = __decorateClass([
-  __decorateParam(2, Inject(Injector))
-], FOverGridImageBuilder);
-var _a2;
-let FOverGridImage = (_a2 = class extends FBase {
-  constructor(_image, _commandService, _injector) {
-    super(), this._image = _image, this._commandService = _commandService, this._injector = _injector;
+};
+b = H([
+  R(2, x(P))
+], b);
+let g = class extends V {
+  constructor(r, t, e) {
+    super(), this._image = r, this._commandService = t, this._injector = e;
   }
   getId() {
     return this._image.drawingId;
@@ -401,7 +396,7 @@ let FOverGridImage = (_a2 = class extends FBase {
    * ```
    */
   remove() {
-    return this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [this._image] });
+    return this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [this._image] });
   }
   /**
    * Convert the image to a FOverGridImageBuilder
@@ -418,18 +413,18 @@ let FOverGridImage = (_a2 = class extends FBase {
    * ```
    */
   toBuilder() {
-    const builder = this._injector.createInstance(FOverGridImageBuilder);
-    return builder.setImage(this._image), builder;
+    const r = this._injector.createInstance(b);
+    return r.setImage(this._image), r;
   }
-  setSource(source, sourceType) {
-    const sourceTypeVal = sourceType != null ? sourceType : ImageSourceType.URL;
-    return this._image.source = source, this._image.imageSourceType = sourceTypeVal, this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [this._image] });
+  setSource(r, t) {
+    const e = t != null ? t : I.URL;
+    return this._image.source = r, this._image.imageSourceType = e, this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [this._image] });
   }
-  async setPositionAsync(row, column, rowOffset, columnOffset) {
-    const builder = this.toBuilder();
-    builder.setColumn(column), builder.setRow(row), rowOffset != null && builder.setRowOffset(rowOffset), columnOffset != null && builder.setColumnOffset(columnOffset);
-    const param = await builder.buildAsync();
-    return this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [param] });
+  async setPositionAsync(r, t, e, i) {
+    const n = this.toBuilder();
+    n.setColumn(t), n.setRow(r), e != null && n.setRowOffset(e), i != null && n.setColumnOffset(i);
+    const s = await n.buildAsync();
+    return this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [s] });
   }
   /**
    * Set the size of the image
@@ -444,11 +439,11 @@ let FOverGridImage = (_a2 = class extends FBase {
    * const image = activeSheet.getImages()[0];
    * console.log('Set size state is ', image.setSize(50, 120));
    */
-  async setSizeAsync(width, height) {
-    const builder = this.toBuilder();
-    builder.setWidth(width), builder.setHeight(height);
-    const param = await builder.buildAsync();
-    return this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [param] });
+  async setSizeAsync(r, t) {
+    const e = this.toBuilder();
+    e.setWidth(r), e.setHeight(t);
+    const i = await e.buildAsync();
+    return this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [i] });
   }
   /**
    * Set the cropping region of the image by defining the top, bottom, left, and right edges, thereby displaying the specific part of the image you want.
@@ -466,13 +461,13 @@ let FOverGridImage = (_a2 = class extends FBase {
    * console.log('Set crop state is ', image.setCrop(10, 10, 10, 10));
    * ```
    */
-  setCrop(top, left, bottom, right) {
+  setCrop(r, t, e, i) {
     return this._image.srcRect == null && (this._image.srcRect = {
       top: 0,
       left: 0,
       bottom: 0,
       right: 0
-    }), top != null && (this._image.srcRect.top = top), left != null && (this._image.srcRect.left = left), bottom != null && (this._image.srcRect.bottom = bottom), right != null && (this._image.srcRect.right = right), this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [this._image] });
+    }), r != null && (this._image.srcRect.top = r), t != null && (this._image.srcRect.left = t), e != null && (this._image.srcRect.bottom = e), i != null && (this._image.srcRect.right = i), this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [this._image] });
   }
   // setPresetGeometry(prstGeom: PresetGeometryType): boolean {
   //     this._image.prstGeom = prstGeom;
@@ -491,8 +486,8 @@ let FOverGridImage = (_a2 = class extends FBase {
    * console.log('Set rotate state is ', image.setRotate(90));
    * ```
    */
-  setRotate(angle) {
-    return this._image.sheetTransform.angle = angle, this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [this._image] });
+  setRotate(r) {
+    return this._image.sheetTransform.angle = r, this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [this._image] });
   }
   /**
    * Move the image layer forward by one level
@@ -507,11 +502,11 @@ let FOverGridImage = (_a2 = class extends FBase {
    * ```
    */
   setForward() {
-    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
+    return this._commandService.syncExecuteCommand(w.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: ArrangeTypeEnum.forward
+      arrangeType: v.forward
     });
   }
   /**
@@ -527,11 +522,11 @@ let FOverGridImage = (_a2 = class extends FBase {
    * ```
    */
   setBackward() {
-    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
+    return this._commandService.syncExecuteCommand(w.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: ArrangeTypeEnum.backward
+      arrangeType: v.backward
     });
   }
   /**
@@ -547,11 +542,11 @@ let FOverGridImage = (_a2 = class extends FBase {
    * ```
    */
   setBack() {
-    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
+    return this._commandService.syncExecuteCommand(w.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: ArrangeTypeEnum.back
+      arrangeType: v.back
     });
   }
   /**
@@ -567,144 +562,140 @@ let FOverGridImage = (_a2 = class extends FBase {
    * ```
    */
   setFront() {
-    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
+    return this._commandService.syncExecuteCommand(w.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: ArrangeTypeEnum.front
+      arrangeType: v.front
     });
   }
-}, __name(_a2, "FOverGridImage"), _a2);
-FOverGridImage = __decorateClass([
-  __decorateParam(1, ICommandService),
-  __decorateParam(2, Inject(Injector))
-], FOverGridImage);
-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);
-  }
-  addFloatDomToRange(fRange, layer, domLayout, id) {
-    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), { key, disposableCollection } = transformComponentKey(layer, this._injector.get(ComponentManager)), res = this._injector.get(SheetCanvasFloatDomManagerService).addFloatDomToRange(fRange.getRange(), { ...layer, componentKey: key, unitId, subUnitId }, domLayout, id);
-    return res ? (disposableCollection.add(res.dispose), {
-      id: res.id,
-      dispose: /* @__PURE__ */ __name(() => {
-        disposableCollection.dispose(), res.dispose();
-      }, "dispose")
-    }) : (disposableCollection.dispose(), null);
-  }
-  addFloatDomToColumnHeader(column, layer, domLayout, id) {
-    const unitId = this._workbook.getUnitId(), subUnitId = this._worksheet.getSheetId(), { key, disposableCollection } = transformComponentKey(layer, this._injector.get(ComponentManager)), domRangeDispose = this._injector.get(SheetCanvasFloatDomManagerService).addFloatDomToColumnHeader(column, { ...layer, componentKey: key, unitId, subUnitId }, domLayout, id);
-    return domRangeDispose ? (disposableCollection.add(domRangeDispose.dispose), {
-      id: domRangeDispose.id,
-      dispose: /* @__PURE__ */ __name(() => {
-        disposableCollection.dispose(), domRangeDispose.dispose();
-      }, "dispose")
-    }) : (disposableCollection.dispose(), null);
-  }
-  async insertImage(url, column, row, offsetX, offsetY) {
-    const imageBuilder = this.newOverGridImage();
-    if (typeof url == "string")
-      imageBuilder.setSource(url);
+};
+g = H([
+  R(1, W),
+  R(2, x(P))
+], g);
+class se extends $ {
+  addFloatDomToPosition(t, e) {
+    const i = this._workbook.getUnitId(), n = this._worksheet.getSheetId(), { key: s, disposableCollection: o } = E(t, this._injector.get(y)), a = this._injector.get(G).addFloatDomToPosition({ ...t, componentKey: s, unitId: i, subUnitId: n }, e);
+    return a ? (o.add(a.dispose), {
+      id: a.id,
+      dispose: () => {
+        o.dispose(), a.dispose();
+      }
+    }) : (o.dispose(), null);
+  }
+  addFloatDomToRange(t, e, i, n) {
+    const s = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), { key: c, disposableCollection: a } = E(e, this._injector.get(y)), d = this._injector.get(G).addFloatDomToRange(t.getRange(), { ...e, componentKey: c, unitId: s, subUnitId: o }, i, n);
+    return d ? (a.add(d.dispose), {
+      id: d.id,
+      dispose: () => {
+        a.dispose(), d.dispose();
+      }
+    }) : (a.dispose(), null);
+  }
+  addFloatDomToColumnHeader(t, e, i, n) {
+    const s = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), { key: c, disposableCollection: a } = E(e, this._injector.get(y)), d = this._injector.get(G).addFloatDomToColumnHeader(t, { ...e, componentKey: c, unitId: s, subUnitId: o }, i, n);
+    return d ? (a.add(d.dispose), {
+      id: d.id,
+      dispose: () => {
+        a.dispose(), d.dispose();
+      }
+    }) : (a.dispose(), null);
+  }
+  async insertImage(t, e, i, n, s) {
+    const o = this.newOverGridImage();
+    if (typeof t == "string")
+      o.setSource(t);
     else {
-      const base64 = await url.getBlob().getDataAsString();
-      imageBuilder.setSource(base64, ImageSourceType.BASE64);
+      const h = await t.getBlob().getDataAsString();
+      o.setSource(h, I.BASE64);
     }
-    column !== void 0 ? imageBuilder.setColumn(column) : imageBuilder.setColumn(0), row !== void 0 ? imageBuilder.setRow(row) : imageBuilder.setRow(0), offsetX !== void 0 ? imageBuilder.setColumnOffset(offsetX) : imageBuilder.setColumnOffset(0), offsetY !== void 0 ? imageBuilder.setRowOffset(offsetY) : imageBuilder.setRowOffset(0);
-    const param = await imageBuilder.buildAsync();
-    return this._commandService.syncExecuteCommand(InsertSheetDrawingCommand.id, { unitId: this._fWorkbook.getId(), drawings: [param] });
+    e !== void 0 ? o.setColumn(e) : o.setColumn(0), i !== void 0 ? o.setRow(i) : o.setRow(0), n !== void 0 ? o.setColumnOffset(n) : o.setColumnOffset(0), s !== void 0 ? o.setRowOffset(s) : o.setRowOffset(0);
+    const c = await o.buildAsync();
+    return this._commandService.syncExecuteCommand(S.id, { unitId: this._fWorkbook.getId(), drawings: [c] });
   }
-  insertImages(sheetImages) {
-    const param = sheetImages.map((image) => (image.unitId = this._fWorkbook.getId(), image.subUnitId = this.getSheetId(), image));
-    return this._commandService.syncExecuteCommand(InsertSheetDrawingCommand.id, { unitId: this._fWorkbook.getId(), drawings: param }), this;
+  insertImages(t) {
+    const e = t.map((i) => (i.unitId = this._fWorkbook.getId(), i.subUnitId = this.getSheetId(), i));
+    return this._commandService.syncExecuteCommand(S.id, { unitId: this._fWorkbook.getId(), drawings: e }), this;
   }
-  deleteImages(sheetImages) {
-    const drawings = sheetImages.map((image) => ({
+  deleteImages(t) {
+    const e = t.map((i) => ({
       unitId: this._fWorkbook.getId(),
-      drawingId: image.getId(),
+      drawingId: i.getId(),
       subUnitId: this.getSheetId(),
-      drawingType: image.getType()
+      drawingType: i.getType()
     }));
-    return this._commandService.syncExecuteCommand(RemoveSheetDrawingCommand.id, { unitId: this._fWorkbook.getId(), drawings }), this;
+    return this._commandService.syncExecuteCommand(D.id, { unitId: this._fWorkbook.getId(), drawings: e }), this;
   }
   getImages() {
-    const drawingData = this._injector.get(ISheetDrawingService).getDrawingData(this._fWorkbook.getId(), this.getSheetId()), images = [];
-    for (const drawingId in drawingData) {
-      const drawing = drawingData[drawingId];
-      drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE && images.push(this._injector.createInstance(FOverGridImage, drawing));
+    const e = this._injector.get(u).getDrawingData(this._fWorkbook.getId(), this.getSheetId()), i = [];
+    for (const n in e) {
+      const s = e[n];
+      s.drawingType === _.DRAWING_IMAGE && i.push(this._injector.createInstance(g, s));
     }
-    return images;
+    return i;
   }
-  getImageById(id) {
-    const drawing = this._injector.get(ISheetDrawingService).getDrawingByParam({ unitId: this._fWorkbook.getId(), subUnitId: this.getSheetId(), drawingId: id });
-    return drawing && drawing.drawingType === DrawingTypeEnum.DRAWING_IMAGE ? this._injector.createInstance(FOverGridImage, drawing) : null;
+  getImageById(t) {
+    const i = this._injector.get(u).getDrawingByParam({ unitId: this._fWorkbook.getId(), subUnitId: this.getSheetId(), drawingId: t });
+    return i && i.drawingType === _.DRAWING_IMAGE ? this._injector.createInstance(g, i) : null;
   }
   getActiveImages() {
-    const drawingData = this._injector.get(ISheetDrawingService).getFocusDrawings(), images = [];
-    for (const drawingId in drawingData) {
-      const drawing = drawingData[drawingId];
-      images.push(this._injector.createInstance(FOverGridImage, drawing));
+    const e = this._injector.get(u).getFocusDrawings(), i = [];
+    for (const n in e) {
+      const s = e[n];
+      i.push(this._injector.createInstance(g, s));
     }
-    return images;
+    return i;
   }
-  updateImages(sheetImages) {
-    return this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._fWorkbook.getId(), drawings: sheetImages }), this;
+  updateImages(t) {
+    return this._commandService.syncExecuteCommand(m.id, { unitId: this._fWorkbook.getId(), drawings: t }), this;
   }
-  onImageInserted(callback) {
-    const sheetDrawingService = this._injector.get(ISheetDrawingService);
-    return toDisposable(sheetDrawingService.add$.subscribe((drawingSearches) => {
-      const drawings = drawingSearches.map(
-        (drawingSearch) => this._injector.createInstance(FOverGridImage, sheetDrawingService.getDrawingByParam(drawingSearch))
+  onImageInserted(t) {
+    const e = this._injector.get(u);
+    return C(e.add$.subscribe((i) => {
+      const n = i.map(
+        (s) => this._injector.createInstance(g, e.getDrawingByParam(s))
       );
-      callback(drawings);
+      t(n);
     }));
   }
-  onImageDeleted(callback) {
-    const sheetDrawingService = this._injector.get(ISheetDrawingService);
-    return toDisposable(sheetDrawingService.remove$.subscribe((drawingSearches) => {
-      const drawings = drawingSearches.map(
-        (drawingSearch) => this._injector.createInstance(FOverGridImage, sheetDrawingService.getDrawingByParam(drawingSearch))
+  onImageDeleted(t) {
+    const e = this._injector.get(u);
+    return C(e.remove$.subscribe((i) => {
+      const n = i.map(
+        (s) => this._injector.createInstance(g, e.getDrawingByParam(s))
       );
-      callback(drawings);
+      t(n);
     }));
   }
-  onImageChanged(callback) {
-    const sheetDrawingService = this._injector.get(ISheetDrawingService);
-    return toDisposable(sheetDrawingService.update$.subscribe((drawingSearches) => {
-      const drawings = drawingSearches.map(
-        (drawingSearch) => this._injector.createInstance(FOverGridImage, sheetDrawingService.getDrawingByParam(drawingSearch))
+  onImageChanged(t) {
+    const e = this._injector.get(u);
+    return C(e.update$.subscribe((i) => {
+      const n = i.map(
+        (s) => this._injector.createInstance(g, e.getDrawingByParam(s))
       );
-      callback(drawings);
+      t(n);
     }));
   }
   newOverGridImage() {
-    const unitId = this._fWorkbook.getId(), subUnitId = this.getSheetId();
-    return this._injector.createInstance(FOverGridImageBuilder, unitId, subUnitId);
+    const t = this._fWorkbook.getId(), e = this.getSheetId();
+    return this._injector.createInstance(b, t, e);
   }
-};
-__name(_FWorksheetLegacy, "FWorksheetLegacy");
-let FWorksheetLegacy = _FWorksheetLegacy;
-FWorksheet.extend(FWorksheetLegacy);
-const _FDrawingEnumMixin = class _FDrawingEnumMixin extends FEnum {
+}
+$.extend(se);
+class oe extends M {
   get DrawingType() {
-    return DrawingTypeEnum;
+    return _;
   }
   get ImageSourceType() {
-    return ImageSourceType;
+    return I;
   }
   get SheetDrawingAnchorType() {
-    return SheetDrawingAnchorType;
+    return ee;
   }
-};
-__name(_FDrawingEnumMixin, "FDrawingEnumMixin");
-let FDrawingEnumMixin = _FDrawingEnumMixin;
-FEnum.extend(FDrawingEnumMixin);
-const _FDrawingEventNameMixin = class _FDrawingEventNameMixin extends FEventName {
+}
+M.extend(oe);
+class ae extends z {
   get BeforeOverGridImageChange() {
     return "BeforeOverGridImageChange";
   }
@@ -729,161 +720,154 @@ const _FDrawingEventNameMixin = class _FDrawingEventNameMixin extends FEventName
   get OverGridImageSelected() {
     return "OverGridImageSelected";
   }
-};
-__name(_FDrawingEventNameMixin, "FDrawingEventNameMixin");
-let FDrawingEventNameMixin = _FDrawingEventNameMixin;
-FEventName.extend(FDrawingEventNameMixin);
-const _FUniverDrawingMixin = class _FUniverDrawingMixin extends FUniver {
-  /**
-   * @ignore
-   */
-  _initialize(injector) {
-    const commandService = injector.get(ICommandService);
-    this.disposeWithMe(commandService.beforeCommandExecuted((commandInfo) => {
-      switch (commandInfo.id) {
-        case InsertSheetDrawingCommand.id:
-          this._beforeOverGridImageInsert(commandInfo.params);
+}
+z.extend(ae);
+class ce extends N {
+  _initialize(t) {
+    const e = t.get(W);
+    this.disposeWithMe(e.beforeCommandExecuted((i) => {
+      switch (i.id) {
+        case S.id:
+          this._beforeOverGridImageInsert(i.params);
           break;
-        case RemoveSheetDrawingCommand.id:
-          this._beforeOverGridImageRemove(commandInfo.params);
+        case D.id:
+          this._beforeOverGridImageRemove(i.params);
           break;
-        case SetSheetDrawingCommand.id:
-          this._beforeOverGridImageChange(commandInfo.params);
+        case m.id:
+          this._beforeOverGridImageChange(i.params);
           break;
-        case SetDrawingSelectedOperation.id:
-          this._beforeOverGridImageSelect(commandInfo.params);
+        case A.id:
+          this._beforeOverGridImageSelect(i.params);
           break;
       }
-    })), this.disposeWithMe(commandService.onCommandExecuted((commandInfo) => {
-      switch (commandInfo.id) {
-        case InsertSheetDrawingCommand.id:
-          this._overGridImageInserted(commandInfo.params);
+    })), this.disposeWithMe(e.onCommandExecuted((i) => {
+      switch (i.id) {
+        case S.id:
+          this._overGridImageInserted(i.params);
           break;
-        case RemoveSheetDrawingCommand.id:
-          this._overGridImageRemoved(commandInfo.params);
+        case D.id:
+          this._overGridImageRemoved(i.params);
           break;
-        case SetSheetDrawingCommand.id:
-          this._overGridImageChanged(commandInfo.params);
+        case m.id:
+          this._overGridImageChanged(i.params);
           break;
-        case SetDrawingSelectedOperation.id:
-          this._overGridImageSelected(commandInfo.params);
+        case A.id:
+          this._overGridImageSelected(i.params);
           break;
       }
     }));
   }
-  _beforeOverGridImageInsert(params) {
+  _beforeOverGridImageInsert(t) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageInsert))
       return;
-    const workbook = this.getActiveWorkbook();
-    if (workbook == null || params == null)
+    const e = this.getActiveWorkbook();
+    if (e == null || t == null)
       return;
-    const { drawings } = params, eventParams = {
-      workbook,
-      insertImageParams: drawings
+    const { drawings: i } = t, n = {
+      workbook: e,
+      insertImageParams: i
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageInsert, eventParams), eventParams.cancel)
+    if (this.fireEvent(this.Event.BeforeOverGridImageInsert, n), n.cancel)
       throw new Error("Canceled by BeforeOverGridImageInsert event");
   }
-  _overGridImageInserted(params) {
+  _overGridImageInserted(t) {
     if (!this.hasEventCallback(this.Event.OverGridImageInserted))
       return;
-    const workbook = this.getActiveWorkbook();
-    if (workbook == null || params == null)
+    const e = this.getActiveWorkbook();
+    if (e == null || t == null)
       return;
-    const { drawings } = params;
+    const { drawings: i } = t;
     this.fireEvent(this.Event.OverGridImageInserted, {
-      workbook,
-      images: this._createFOverGridImage(drawings)
+      workbook: e,
+      images: this._createFOverGridImage(i)
     });
   }
-  _beforeOverGridImageRemove(params) {
+  _beforeOverGridImageRemove(t) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageRemove))
       return;
-    const workbook = this.getActiveWorkbook();
-    if (workbook == null || params == null)
+    const e = this.getActiveWorkbook();
+    if (e == null || t == null)
       return;
-    const { drawings } = params, drawingManagerService = this._injector.get(IDrawingManagerService), willRemoveDrawings = drawings.map((drawing) => drawingManagerService.getDrawingByParam(drawing)), eventParams = {
-      workbook,
-      images: this._createFOverGridImage(willRemoveDrawings)
+    const { drawings: i } = t, n = this._injector.get(l), s = i.map((c) => n.getDrawingByParam(c)), o = {
+      workbook: e,
+      images: this._createFOverGridImage(s)
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageRemove, eventParams), eventParams.cancel)
+    if (this.fireEvent(this.Event.BeforeOverGridImageRemove, o), o.cancel)
       throw new Error("Canceled by BeforeOverGridImageRemove event");
   }
-  _overGridImageRemoved(params) {
+  _overGridImageRemoved(t) {
     if (!this.hasEventCallback(this.Event.OverGridImageRemoved))
       return;
-    const workbook = this.getActiveWorkbook();
-    if (workbook == null || params == null)
+    const e = this.getActiveWorkbook();
+    if (e == null || t == null)
       return;
-    const { drawings } = params;
+    const { drawings: i } = t;
     this.fireEvent(this.Event.OverGridImageRemoved, {
-      workbook,
-      removeImageParams: drawings
+      workbook: e,
+      removeImageParams: i
     });
   }
-  _beforeOverGridImageChange(params) {
+  _beforeOverGridImageChange(t) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageChange))
       return;
-    const workbook = this.getActiveWorkbook();
-    if (workbook == null || params == null)
+    const e = this.getActiveWorkbook();
+    if (e == null || t == null)
       return;
-    const { drawings } = params, drawingManagerService = this._injector.get(IDrawingManagerService), images = [];
-    drawings.forEach((drawing) => {
-      const image = drawingManagerService.getDrawingByParam(drawing);
-      image != null && images.push({
-        changeParam: drawing,
-        image: this._injector.createInstance(FOverGridImage, image)
+    const { drawings: i } = t, n = this._injector.get(l), s = [];
+    i.forEach((c) => {
+      const a = n.getDrawingByParam(c);
+      a != null && s.push({
+        changeParam: c,
+        image: this._injector.createInstance(g, a)
       });
     });
-    const eventParams = {
-      workbook,
-      images
+    const o = {
+      workbook: e,
+      images: s
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageChange, eventParams), eventParams.cancel)
-      throw drawingManagerService.updateNotification(drawings), new Error("Canceled by BeforeOverGridImageChange event");
+    if (this.fireEvent(this.Event.BeforeOverGridImageChange, o), o.cancel)
+      throw n.updateNotification(i), new Error("Canceled by BeforeOverGridImageChange event");
   }
-  _overGridImageChanged(params) {
+  _overGridImageChanged(t) {
     if (!this.hasEventCallback(this.Event.OverGridImageChanged))
       return;
-    const workbook = this.getActiveWorkbook();
-    if (workbook == null || params == null)
+    const e = this.getActiveWorkbook();
+    if (e == null || t == null)
       return;
-    const { drawings } = params, drawingManagerService = this._injector.get(IDrawingManagerService), images = drawings.map((drawing) => this._injector.createInstance(FOverGridImage, drawingManagerService.getDrawingByParam(drawing)));
+    const { drawings: i } = t, n = this._injector.get(l), s = i.map((o) => this._injector.createInstance(g, n.getDrawingByParam(o)));
     this.fireEvent(this.Event.OverGridImageChanged, {
-      workbook,
-      images
+      workbook: e,
+      images: s
     });
   }
-  _beforeOverGridImageSelect(drawings) {
+  _beforeOverGridImageSelect(t) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageSelect))
       return;
-    const drawingManagerService = this._injector.get(IDrawingManagerService), workbook = this.getActiveWorkbook();
-    if (workbook == null)
+    const e = this._injector.get(l), i = this.getActiveWorkbook();
+    if (i == null)
       return;
-    const oldSelectedDrawings = drawingManagerService.getFocusDrawings(), selectedDrawings = drawings.map((drawing) => drawingManagerService.getDrawingByParam(drawing)), eventParams = {
-      workbook,
-      selectedImages: this._createFOverGridImage(selectedDrawings),
-      oldSelectedImages: this._createFOverGridImage(oldSelectedDrawings)
+    const n = e.getFocusDrawings(), s = t.map((c) => e.getDrawingByParam(c)), o = {
+      workbook: i,
+      selectedImages: this._createFOverGridImage(s),
+      oldSelectedImages: this._createFOverGridImage(n)
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageSelect, eventParams), eventParams.cancel)
+    if (this.fireEvent(this.Event.BeforeOverGridImageSelect, o), o.cancel)
       throw new Error("Canceled by BeforeOverGridImageSelect event");
   }
-  _overGridImageSelected(drawings) {
+  _overGridImageSelected(t) {
     if (!this.hasEventCallback(this.Event.OverGridImageSelected))
       return;
-    const workbook = this.getActiveWorkbook(), drawingManagerService = this._injector.get(IDrawingManagerService);
-    if (workbook == null)
+    const e = this.getActiveWorkbook(), i = this._injector.get(l);
+    if (e == null)
       return;
-    const selectedDrawings = drawings.map((drawing) => drawingManagerService.getDrawingByParam(drawing));
+    const n = t.map((s) => i.getDrawingByParam(s));
     this.fireEvent(this.Event.OverGridImageSelected, {
-      workbook,
-      selectedImages: this._createFOverGridImage(selectedDrawings)
+      workbook: e,
+      selectedImages: this._createFOverGridImage(n)
     });
   }
-  _createFOverGridImage(drawings) {
-    return drawings.map((drawing) => this._injector.createInstance(FOverGridImage, drawing));
+  _createFOverGridImage(t) {
+    return t.map((e) => this._injector.createInstance(g, e));
   }
-};
-__name(_FUniverDrawingMixin, "FUniverDrawingMixin");
-let FUniverDrawingMixin = _FUniverDrawingMixin;
-FUniver.extend(FUniverDrawingMixin);
+}
+N.extend(ce);