@univerjs/sheets-drawing-ui 0.5.5-nightly.202501210734 → 0.5.5-nightly.202501210925

package/lib/es/facade.js

@@ -1,82 +1,86 @@
-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;
+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;
   return {
-    ...r,
-    column: h,
-    columnOffset: d,
-    row: f,
-    rowOffset: p,
-    width: O,
-    height: K,
-    flipY: n,
-    flipX: s,
-    angle: o,
-    skewX: c,
-    skewY: a
+    ...sheetImage,
+    column: fromColumn,
+    columnOffset: fromColumnOffset,
+    row: fromRow,
+    rowOffset: fromRowOffset,
+    width,
+    height,
+    flipY,
+    flipX,
+    angle,
+    skewX,
+    skewY
   };
 }
-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;
+__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;
   return {
-    ...r,
+    ...fOverGridImage,
     sheetTransform: {
-      ...j,
-      flipY: c,
-      flipX: a,
-      angle: h,
-      skewX: d,
-      skewY: f
+      ...sheetTransform,
+      flipY,
+      flipX,
+      angle,
+      skewX,
+      skewY
     },
     transform: {
-      ...O,
-      flipY: c,
-      flipX: a,
-      angle: h,
-      skewX: d,
-      skewY: f
+      ...transform,
+      flipY,
+      flipX,
+      angle,
+      skewX,
+      skewY
     }
   };
 }
-let b = class {
-  constructor(r, t, e) {
-    T(this, "_image");
-    this._injector = e, this._image = {
-      drawingId: Y(6),
-      drawingType: _.DRAWING_IMAGE,
-      imageSourceType: I.BASE64,
+__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,
       source: "",
-      unitId: r,
-      subUnitId: t,
+      unitId,
+      subUnitId,
       column: 0,
       columnOffset: 0,
       row: 0,
@@ -106,12 +110,12 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  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 = {
+  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 = {
       from: {
         column: 0,
         columnOffset: 0,
@@ -124,11 +128,11 @@ let b = class {
         row: 0,
         rowOffset: 0
       }
-    }), this._image = re(r, i), this;
+    }), this._image = convertSheetImageToFOverGridImage(image, skeletonManagerService), this;
   }
-  setSource(r, t) {
-    const e = t != null ? t : I.URL;
-    return this._image.source = r, this._image.imageSourceType = e, this;
+  setSource(source, sourceType) {
+    const sourceTypeVal = sourceType != null ? sourceType : ImageSourceType.URL;
+    return this._image.source = source, this._image.imageSourceType = sourceTypeVal, this;
   }
   getsource() {
     return this._image.source;
@@ -150,8 +154,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setColumn(r) {
-    return this._image.column = r, this;
+  setColumn(column) {
+    return this._image.column = column, this;
   }
   /**
    * Set the position of the image
@@ -167,8 +171,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setRow(r) {
-    return this._image.row = r, this;
+  setRow(row) {
+    return this._image.row = row, this;
   }
   /**
    * Set the column offset of the image in a unit
@@ -184,8 +188,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setColumnOffset(r) {
-    return this._image.columnOffset = r, this;
+  setColumnOffset(offset) {
+    return this._image.columnOffset = offset, this;
   }
   /**
    * Set the row offset of the image in a unit
@@ -201,8 +205,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setRowOffset(r) {
-    return this._image.rowOffset = r, this;
+  setRowOffset(offset) {
+    return this._image.rowOffset = offset, this;
   }
   /**
    * set the width of the image
@@ -218,8 +222,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setWidth(r) {
-    return this._image.width = r, this;
+  setWidth(width) {
+    return this._image.width = width, this;
   }
   /**
    * Set the height of the image
@@ -235,8 +239,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setHeight(r) {
-    return this._image.height = r, this;
+  setHeight(height) {
+    return this._image.height = height, this;
   }
   /**
    * Set the anchor type of the image, whether the position and size change with the cell
@@ -252,8 +256,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setAnchorType(r) {
-    return this._image.anchorType = r, this;
+  setAnchorType(anchorType) {
+    return this._image.anchorType = anchorType, this;
   }
   /**
    * Set the cropping region of the image by defining the top edges, thereby displaying the specific part of the image you want.
@@ -269,8 +273,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropTop(r) {
-    return this._initializeSrcRect(), this._image.srcRect.top = r, this;
+  setCropTop(top) {
+    return this._initializeSrcRect(), this._image.srcRect.top = top, this;
   }
   /**
    * Set the cropping region of the image by defining the left edges, thereby displaying the specific part of the image you want.
@@ -286,8 +290,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropLeft(r) {
-    return this._initializeSrcRect(), this._image.srcRect.left = r, this;
+  setCropLeft(left) {
+    return this._initializeSrcRect(), this._image.srcRect.left = left, this;
   }
   /**
    * Set the cropping region of the image by defining the bottom edges, thereby displaying the specific part of the image you want.
@@ -303,8 +307,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropBottom(r) {
-    return this._initializeSrcRect(), this._image.srcRect.bottom = r, this;
+  setCropBottom(bottom) {
+    return this._initializeSrcRect(), this._image.srcRect.bottom = bottom, this;
   }
   /**
    * Set the cropping region of the image by defining the right edges, thereby displaying the specific part of the image you want.
@@ -320,8 +324,8 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setCropRight(r) {
-    return this._initializeSrcRect(), this._image.srcRect.right = r, this;
+  setCropRight(right) {
+    return this._initializeSrcRect(), this._image.srcRect.right = right, this;
   }
   _initializeSrcRect() {
     this._image.srcRect == null && (this._image.srcRect = {
@@ -345,37 +349,38 @@ let b = class {
    * activeSheet.insertImages([param]);
    * ```
    */
-  setRotate(r) {
-    return this._image.angle = r, this;
+  setRotate(angle) {
+    return this._image.angle = angle, this;
   }
   // setPresetGeometry(prstGeom: PresetGeometryType): FOverGridImageBuilder {
   //     this._image.prstGeom = prstGeom;
   //     return this;
   // }
-  setUnitId(r) {
-    return this._image.unitId = r, this;
+  setUnitId(unitId) {
+    return this._image.unitId = unitId, this;
   }
-  setSubUnitId(r) {
-    return this._image.subUnitId = r, this;
+  setSubUnitId(subUnitId) {
+    return this._image.subUnitId = subUnitId, this;
   }
   async buildAsync() {
-    const t = this._injector.get(F).getRenderById(this._image.unitId);
-    if (!t)
+    const render = this._injector.get(IRenderManagerService).getRenderById(this._image.unitId);
+    if (!render)
       throw new Error(`Render Unit with unitId ${this._image.unitId} not found`);
-    const e = t.with(J), i = t.with(U);
+    const selectionRenderService = render.with(ISheetSelectionRenderService), skeletonManagerService = render.with(SheetSkeletonManagerService);
     if (this._image.width === 0 || this._image.height === 0) {
-      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);
+      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);
     }
-    return ne(this._image, e, i);
+    return convertFOverGridImageToSheetImage(this._image, selectionRenderService, skeletonManagerService);
   }
-};
-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;
+}, __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;
   }
   getId() {
     return this._image.drawingId;
@@ -396,7 +401,7 @@ let g = class extends V {
    * ```
    */
   remove() {
-    return this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [this._image] });
+    return this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [this._image] });
   }
   /**
    * Convert the image to a FOverGridImageBuilder
@@ -413,18 +418,18 @@ let g = class extends V {
    * ```
    */
   toBuilder() {
-    const r = this._injector.createInstance(b);
-    return r.setImage(this._image), r;
+    const builder = this._injector.createInstance(FOverGridImageBuilder);
+    return builder.setImage(this._image), builder;
   }
-  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] });
+  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] });
   }
-  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] });
+  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] });
   }
   /**
    * Set the size of the image
@@ -439,11 +444,11 @@ let g = class extends V {
    * const image = activeSheet.getImages()[0];
    * console.log('Set size state is ', image.setSize(50, 120));
    */
-  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] });
+  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] });
   }
   /**
    * 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.
@@ -461,13 +466,13 @@ let g = class extends V {
    * console.log('Set crop state is ', image.setCrop(10, 10, 10, 10));
    * ```
    */
-  setCrop(r, t, e, i) {
+  setCrop(top, left, bottom, right) {
     return this._image.srcRect == null && (this._image.srcRect = {
       top: 0,
       left: 0,
       bottom: 0,
       right: 0
-    }), 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] });
+    }), 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] });
   }
   // setPresetGeometry(prstGeom: PresetGeometryType): boolean {
   //     this._image.prstGeom = prstGeom;
@@ -486,8 +491,8 @@ let g = class extends V {
    * console.log('Set rotate state is ', image.setRotate(90));
    * ```
    */
-  setRotate(r) {
-    return this._image.sheetTransform.angle = r, this._commandService.syncExecuteCommand(m.id, { unitId: this._image.unitId, drawings: [this._image] });
+  setRotate(angle) {
+    return this._image.sheetTransform.angle = angle, this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._image.unitId, drawings: [this._image] });
   }
   /**
    * Move the image layer forward by one level
@@ -502,11 +507,11 @@ let g = class extends V {
    * ```
    */
   setForward() {
-    return this._commandService.syncExecuteCommand(w.id, {
+    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: v.forward
+      arrangeType: ArrangeTypeEnum.forward
     });
   }
   /**
@@ -522,11 +527,11 @@ let g = class extends V {
    * ```
    */
   setBackward() {
-    return this._commandService.syncExecuteCommand(w.id, {
+    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: v.backward
+      arrangeType: ArrangeTypeEnum.backward
     });
   }
   /**
@@ -542,11 +547,11 @@ let g = class extends V {
    * ```
    */
   setBack() {
-    return this._commandService.syncExecuteCommand(w.id, {
+    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: v.back
+      arrangeType: ArrangeTypeEnum.back
     });
   }
   /**
@@ -562,140 +567,144 @@ let g = class extends V {
    * ```
    */
   setFront() {
-    return this._commandService.syncExecuteCommand(w.id, {
+    return this._commandService.syncExecuteCommand(SetDrawingArrangeCommand.id, {
       unitId: this._image.unitId,
       subUnitId: this._image.subUnitId,
       drawingIds: [this._image.drawingId],
-      arrangeType: v.front
+      arrangeType: ArrangeTypeEnum.front
     });
   }
-};
-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);
+}, __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);
     else {
-      const h = await t.getBlob().getDataAsString();
-      o.setSource(h, I.BASE64);
+      const base64 = await url.getBlob().getDataAsString();
+      imageBuilder.setSource(base64, ImageSourceType.BASE64);
     }
-    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] });
+    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] });
   }
-  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;
+  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;
   }
-  deleteImages(t) {
-    const e = t.map((i) => ({
+  deleteImages(sheetImages) {
+    const drawings = sheetImages.map((image) => ({
       unitId: this._fWorkbook.getId(),
-      drawingId: i.getId(),
+      drawingId: image.getId(),
       subUnitId: this.getSheetId(),
-      drawingType: i.getType()
+      drawingType: image.getType()
     }));
-    return this._commandService.syncExecuteCommand(D.id, { unitId: this._fWorkbook.getId(), drawings: e }), this;
+    return this._commandService.syncExecuteCommand(RemoveSheetDrawingCommand.id, { unitId: this._fWorkbook.getId(), drawings }), this;
   }
   getImages() {
-    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));
+    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));
     }
-    return i;
+    return images;
   }
-  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;
+  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;
   }
   getActiveImages() {
-    const e = this._injector.get(u).getFocusDrawings(), i = [];
-    for (const n in e) {
-      const s = e[n];
-      i.push(this._injector.createInstance(g, s));
+    const drawingData = this._injector.get(ISheetDrawingService).getFocusDrawings(), images = [];
+    for (const drawingId in drawingData) {
+      const drawing = drawingData[drawingId];
+      images.push(this._injector.createInstance(FOverGridImage, drawing));
     }
-    return i;
+    return images;
   }
-  updateImages(t) {
-    return this._commandService.syncExecuteCommand(m.id, { unitId: this._fWorkbook.getId(), drawings: t }), this;
+  updateImages(sheetImages) {
+    return this._commandService.syncExecuteCommand(SetSheetDrawingCommand.id, { unitId: this._fWorkbook.getId(), drawings: sheetImages }), this;
   }
-  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))
+  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))
       );
-      t(n);
+      callback(drawings);
     }));
   }
-  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))
+  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))
       );
-      t(n);
+      callback(drawings);
     }));
   }
-  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))
+  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))
       );
-      t(n);
+      callback(drawings);
     }));
   }
   newOverGridImage() {
-    const t = this._fWorkbook.getId(), e = this.getSheetId();
-    return this._injector.createInstance(b, t, e);
+    const unitId = this._fWorkbook.getId(), subUnitId = this.getSheetId();
+    return this._injector.createInstance(FOverGridImageBuilder, unitId, subUnitId);
   }
-}
-$.extend(se);
-class oe extends M {
+};
+__name(_FWorksheetLegacy, "FWorksheetLegacy");
+let FWorksheetLegacy = _FWorksheetLegacy;
+FWorksheet.extend(FWorksheetLegacy);
+const _FDrawingEnumMixin = class _FDrawingEnumMixin extends FEnum {
   get DrawingType() {
-    return _;
+    return DrawingTypeEnum;
   }
   get ImageSourceType() {
-    return I;
+    return ImageSourceType;
   }
   get SheetDrawingAnchorType() {
-    return ee;
+    return SheetDrawingAnchorType;
   }
-}
-M.extend(oe);
-class ae extends z {
+};
+__name(_FDrawingEnumMixin, "FDrawingEnumMixin");
+let FDrawingEnumMixin = _FDrawingEnumMixin;
+FEnum.extend(FDrawingEnumMixin);
+const _FDrawingEventNameMixin = class _FDrawingEventNameMixin extends FEventName {
   get BeforeOverGridImageChange() {
     return "BeforeOverGridImageChange";
   }
@@ -720,154 +729,161 @@ class ae extends z {
   get OverGridImageSelected() {
     return "OverGridImageSelected";
   }
-}
-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);
+};
+__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);
           break;
-        case D.id:
-          this._beforeOverGridImageRemove(i.params);
+        case RemoveSheetDrawingCommand.id:
+          this._beforeOverGridImageRemove(commandInfo.params);
           break;
-        case m.id:
-          this._beforeOverGridImageChange(i.params);
+        case SetSheetDrawingCommand.id:
+          this._beforeOverGridImageChange(commandInfo.params);
           break;
-        case A.id:
-          this._beforeOverGridImageSelect(i.params);
+        case SetDrawingSelectedOperation.id:
+          this._beforeOverGridImageSelect(commandInfo.params);
           break;
       }
-    })), this.disposeWithMe(e.onCommandExecuted((i) => {
-      switch (i.id) {
-        case S.id:
-          this._overGridImageInserted(i.params);
+    })), this.disposeWithMe(commandService.onCommandExecuted((commandInfo) => {
+      switch (commandInfo.id) {
+        case InsertSheetDrawingCommand.id:
+          this._overGridImageInserted(commandInfo.params);
           break;
-        case D.id:
-          this._overGridImageRemoved(i.params);
+        case RemoveSheetDrawingCommand.id:
+          this._overGridImageRemoved(commandInfo.params);
           break;
-        case m.id:
-          this._overGridImageChanged(i.params);
+        case SetSheetDrawingCommand.id:
+          this._overGridImageChanged(commandInfo.params);
           break;
-        case A.id:
-          this._overGridImageSelected(i.params);
+        case SetDrawingSelectedOperation.id:
+          this._overGridImageSelected(commandInfo.params);
           break;
       }
     }));
   }
-  _beforeOverGridImageInsert(t) {
+  _beforeOverGridImageInsert(params) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageInsert))
       return;
-    const e = this.getActiveWorkbook();
-    if (e == null || t == null)
+    const workbook = this.getActiveWorkbook();
+    if (workbook == null || params == null)
       return;
-    const { drawings: i } = t, n = {
-      workbook: e,
-      insertImageParams: i
+    const { drawings } = params, eventParams = {
+      workbook,
+      insertImageParams: drawings
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageInsert, n), n.cancel)
+    if (this.fireEvent(this.Event.BeforeOverGridImageInsert, eventParams), eventParams.cancel)
       throw new Error("Canceled by BeforeOverGridImageInsert event");
   }
-  _overGridImageInserted(t) {
+  _overGridImageInserted(params) {
     if (!this.hasEventCallback(this.Event.OverGridImageInserted))
       return;
-    const e = this.getActiveWorkbook();
-    if (e == null || t == null)
+    const workbook = this.getActiveWorkbook();
+    if (workbook == null || params == null)
       return;
-    const { drawings: i } = t;
+    const { drawings } = params;
     this.fireEvent(this.Event.OverGridImageInserted, {
-      workbook: e,
-      images: this._createFOverGridImage(i)
+      workbook,
+      images: this._createFOverGridImage(drawings)
     });
   }
-  _beforeOverGridImageRemove(t) {
+  _beforeOverGridImageRemove(params) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageRemove))
       return;
-    const e = this.getActiveWorkbook();
-    if (e == null || t == null)
+    const workbook = this.getActiveWorkbook();
+    if (workbook == null || params == null)
       return;
-    const { drawings: i } = t, n = this._injector.get(l), s = i.map((c) => n.getDrawingByParam(c)), o = {
-      workbook: e,
-      images: this._createFOverGridImage(s)
+    const { drawings } = params, drawingManagerService = this._injector.get(IDrawingManagerService), willRemoveDrawings = drawings.map((drawing) => drawingManagerService.getDrawingByParam(drawing)), eventParams = {
+      workbook,
+      images: this._createFOverGridImage(willRemoveDrawings)
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageRemove, o), o.cancel)
+    if (this.fireEvent(this.Event.BeforeOverGridImageRemove, eventParams), eventParams.cancel)
       throw new Error("Canceled by BeforeOverGridImageRemove event");
   }
-  _overGridImageRemoved(t) {
+  _overGridImageRemoved(params) {
     if (!this.hasEventCallback(this.Event.OverGridImageRemoved))
       return;
-    const e = this.getActiveWorkbook();
-    if (e == null || t == null)
+    const workbook = this.getActiveWorkbook();
+    if (workbook == null || params == null)
       return;
-    const { drawings: i } = t;
+    const { drawings } = params;
     this.fireEvent(this.Event.OverGridImageRemoved, {
-      workbook: e,
-      removeImageParams: i
+      workbook,
+      removeImageParams: drawings
     });
   }
-  _beforeOverGridImageChange(t) {
+  _beforeOverGridImageChange(params) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageChange))
       return;
-    const e = this.getActiveWorkbook();
-    if (e == null || t == null)
+    const workbook = this.getActiveWorkbook();
+    if (workbook == null || params == null)
       return;
-    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 { 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 o = {
-      workbook: e,
-      images: s
+    const eventParams = {
+      workbook,
+      images
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageChange, o), o.cancel)
-      throw n.updateNotification(i), new Error("Canceled by BeforeOverGridImageChange event");
+    if (this.fireEvent(this.Event.BeforeOverGridImageChange, eventParams), eventParams.cancel)
+      throw drawingManagerService.updateNotification(drawings), new Error("Canceled by BeforeOverGridImageChange event");
   }
-  _overGridImageChanged(t) {
+  _overGridImageChanged(params) {
     if (!this.hasEventCallback(this.Event.OverGridImageChanged))
       return;
-    const e = this.getActiveWorkbook();
-    if (e == null || t == null)
+    const workbook = this.getActiveWorkbook();
+    if (workbook == null || params == null)
       return;
-    const { drawings: i } = t, n = this._injector.get(l), s = i.map((o) => this._injector.createInstance(g, n.getDrawingByParam(o)));
+    const { drawings } = params, drawingManagerService = this._injector.get(IDrawingManagerService), images = drawings.map((drawing) => this._injector.createInstance(FOverGridImage, drawingManagerService.getDrawingByParam(drawing)));
     this.fireEvent(this.Event.OverGridImageChanged, {
-      workbook: e,
-      images: s
+      workbook,
+      images
     });
   }
-  _beforeOverGridImageSelect(t) {
+  _beforeOverGridImageSelect(drawings) {
     if (!this.hasEventCallback(this.Event.BeforeOverGridImageSelect))
       return;
-    const e = this._injector.get(l), i = this.getActiveWorkbook();
-    if (i == null)
+    const drawingManagerService = this._injector.get(IDrawingManagerService), workbook = this.getActiveWorkbook();
+    if (workbook == null)
       return;
-    const n = e.getFocusDrawings(), s = t.map((c) => e.getDrawingByParam(c)), o = {
-      workbook: i,
-      selectedImages: this._createFOverGridImage(s),
-      oldSelectedImages: this._createFOverGridImage(n)
+    const oldSelectedDrawings = drawingManagerService.getFocusDrawings(), selectedDrawings = drawings.map((drawing) => drawingManagerService.getDrawingByParam(drawing)), eventParams = {
+      workbook,
+      selectedImages: this._createFOverGridImage(selectedDrawings),
+      oldSelectedImages: this._createFOverGridImage(oldSelectedDrawings)
     };
-    if (this.fireEvent(this.Event.BeforeOverGridImageSelect, o), o.cancel)
+    if (this.fireEvent(this.Event.BeforeOverGridImageSelect, eventParams), eventParams.cancel)
       throw new Error("Canceled by BeforeOverGridImageSelect event");
   }
-  _overGridImageSelected(t) {
+  _overGridImageSelected(drawings) {
     if (!this.hasEventCallback(this.Event.OverGridImageSelected))
       return;
-    const e = this.getActiveWorkbook(), i = this._injector.get(l);
-    if (e == null)
+    const workbook = this.getActiveWorkbook(), drawingManagerService = this._injector.get(IDrawingManagerService);
+    if (workbook == null)
       return;
-    const n = t.map((s) => i.getDrawingByParam(s));
+    const selectedDrawings = drawings.map((drawing) => drawingManagerService.getDrawingByParam(drawing));
     this.fireEvent(this.Event.OverGridImageSelected, {
-      workbook: e,
-      selectedImages: this._createFOverGridImage(n)
+      workbook,
+      selectedImages: this._createFOverGridImage(selectedDrawings)
     });
   }
-  _createFOverGridImage(t) {
-    return t.map((e) => this._injector.createInstance(g, e));
+  _createFOverGridImage(drawings) {
+    return drawings.map((drawing) => this._injector.createInstance(FOverGridImage, drawing));
   }
-}
-N.extend(ce);
+};
+__name(_FUniverDrawingMixin, "FUniverDrawingMixin");
+let FUniverDrawingMixin = _FUniverDrawingMixin;
+FUniver.extend(FUniverDrawingMixin);