@univerjs/sheets-drawing-ui 0.4.2-nightly.202411071606 → 0.4.2-nightly.202411081606

package/lib/es/facade.js

@@ -1,20 +1,422 @@
-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-t4WyJLnC.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);
+var de = Object.defineProperty;
+var he = (h, n, e) => n in h ? de(h, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[n] = e;
+var w = (h, n, e) => he(h, typeof n != "symbol" ? n + "" : n, e);
+import { FWorksheet as te } from "@univerjs/sheets/facade";
+import { transformComponentKey as le } from "@univerjs/sheets-ui/facade";
+import { CanvasFloatDomService as ge, ComponentManager as pe } from "@univerjs/ui";
+import { CommandType as ne, ICommandService as re, IUndoRedoService as fe, sequenceExecute as me, Inject as W, LifecycleService as ue, IUniverInstanceService as Se, Disposable as _e, LifecycleStages as ve, DisposableCollection as we, UniverInstanceType as Ie, fromEventSubject as Me, generateRandomId as ye } from "@univerjs/core";
+import { IDrawingManagerService as be, DrawingTypeEnum as P, getDrawingShapeKeyByDrawingSearch as x } from "@univerjs/drawing";
+import { IRenderManagerService as oe, Rect as J, ObjectType as De, DRAWING_OBJECT_LAYER_INDEX as Ee, SHEET_VIEWPORT_KEY as Oe } from "@univerjs/engine-render";
+import { SheetInterceptorService as Te, getSheetCommandTarget as $, SetFrozenMutation as Ce } from "@univerjs/sheets";
+import { ISheetDrawingService as se, SetDrawingApplyMutation as X, DrawingApplyType as H } from "@univerjs/sheets-drawing";
+import { SheetSkeletonManagerService as Z, VIEWPORT_KEY as Re, SetZoomRatioOperation as Pe, ISheetSelectionRenderService as Ae } from "@univerjs/sheets-ui";
+import { Subject as F, filter as Y, take as Be, BehaviorSubject as Ue, map as Q, switchMap as We } from "rxjs";
+const ee = {
+  id: "sheet.operation.clear-drawing-transformer",
+  type: ne.MUTATION,
+  handler: (h, n) => {
+    const e = h.get(oe);
+    return n.forEach((t) => {
+      var r, o;
+      (o = (r = e.getRenderById(t)) == null ? void 0 : r.scene.getTransformer()) == null || o.debounceRefreshControls();
+    }), !0;
   }
+}, ie = {
+  id: "sheet.command.insert-sheet-image",
+  type: ne.COMMAND,
+  handler: (h, n) => {
+    var b, S, _;
+    const e = h.get(re), t = h.get(fe), r = h.get(se), o = h.get(Te);
+    if (!n) return !1;
+    const s = n.drawings, i = s.map((I) => I.unitId), a = r.getBatchAddOp(s), { unitId: d, subUnitId: c, undo: l, redo: g, objects: p } = a, f = o.onCommandExecute({ id: ie.id, params: n }), M = { id: X.id, params: { op: g, unitId: d, subUnitId: c, objects: p, type: H.INSERT } }, y = { id: X.id, params: { op: l, unitId: d, subUnitId: c, objects: p, type: H.REMOVE } };
+    return me([...(b = f.preRedos) != null ? b : [], M, ...f.redos], e) ? (t.pushUndoRedo({
+      unitID: d,
+      undoMutations: [
+        ...(S = f.preUndos) != null ? S : [],
+        y,
+        ...f.undos,
+        { id: ee.id, params: i }
+      ],
+      redoMutations: [
+        ...(_ = f.preRedos) != null ? _ : [],
+        M,
+        ...f.redos,
+        { id: ee.id, params: i }
+      ]
+    }), !0) : !1;
+  }
+};
+var ke = Object.defineProperty, je = Object.getOwnPropertyDescriptor, Le = (h, n, e, t) => {
+  for (var r = t > 1 ? void 0 : t ? je(n, e) : n, o = h.length - 1, s; o >= 0; o--)
+    (s = h[o]) && (r = (t ? s(n, e, r) : s(r)) || r);
+  return t && r && ke(n, e, r), r;
+}, E = (h, n) => (e, t) => n(e, t, h);
+function xe(h, n, e, t) {
+  const { scaleX: r, scaleY: o } = n.getAncestorScale(), s = n.getViewport(Oe.VIEW_MAIN), i = {
+    left: !0,
+    top: !0
+  };
+  if (!s)
+    return {
+      ...h,
+      absolute: i
+    };
+  const { left: a, right: d, top: c, bottom: l } = h, g = t.getFreeze(), { startColumn: p, startRow: f, xSplit: M, ySplit: y } = g, O = e.getNoMergeCellPositionByIndexWithNoHeader(f - y, p - M), b = e.getNoMergeCellPositionByIndexWithNoHeader(f, p), { rowHeaderWidth: S, columnHeaderHeight: _ } = e, I = b.startX - O.startX, D = b.startY - O.startY, { top: A, left: B, viewportScrollX: U, viewportScrollY: T } = s;
+  let C, u;
+  a < B ? (i.left = !0, C = (I + S + (a - B)) * r, u = Math.max(
+    Math.min(
+      (I + S + (d - B)) * r,
+      (I + S) * r
+    ),
+    (d - U) * r
+  )) : (i.left = !1, C = Math.max((a - U) * r, (I + S) * r), u = Math.max((d - U) * r, (I + S) * r));
+  let R, v;
+  return c < A ? (i.top = !0, R = (D + _ + (c - A)) * o, v = Math.max(
+    Math.min(
+      (D + _ + (d - A)) * o,
+      (D + _) * o
+    ),
+    (l - T) * o
+  )) : (i.top = !1, R = Math.max((c - T) * o, (D + _) * o), v = Math.max((l - T) * o, (D + _) * o)), {
+    left: C,
+    right: u,
+    top: R,
+    bottom: v,
+    absolute: i
+  };
+}
+const N = (h, n, e, t) => {
+  const { scene: r } = n, { left: o, top: s, width: i, height: a, angle: d } = h, c = {
+    left: o,
+    right: o + i,
+    top: s,
+    bottom: s + a
+  }, l = xe(c, r, e, t), { scaleX: g, scaleY: p } = r.getAncestorScale();
+  return {
+    startX: l.left,
+    endX: l.right,
+    startY: l.top,
+    endY: l.bottom,
+    rotate: d,
+    width: i * g,
+    height: a * p,
+    absolute: l.absolute
+  };
 };
-__name(_FWorksheetLegacy, "FWorksheetLegacy");
-let FWorksheetLegacy = _FWorksheetLegacy;
-FWorksheet.extend(FWorksheetLegacy);
+let K = class extends _e {
+  constructor(n, e, t, r, o, s, i) {
+    super();
+    w(this, "_domLayerMap", /* @__PURE__ */ new Map());
+    w(this, "_domLayerInfoMap", /* @__PURE__ */ new Map());
+    w(this, "_transformChange$", new F());
+    w(this, "transformChange$", this._transformChange$.asObservable());
+    w(this, "_add$", new F());
+    w(this, "add$", this._add$.asObservable());
+    w(this, "_remove$", new F());
+    w(this, "remove$", this._remove$.asObservable());
+    w(this, "_hooks", []);
+    this._renderManagerService = n, this._univerInstanceService = e, this._commandService = t, this._drawingManagerService = r, this._canvasFloatDomService = o, this._sheetDrawingService = s, this._lifecycleService = i, this._drawingAddListener(), this._featureUpdateListener(), this._deleteListener(), this._bindScrollEvent();
+  }
+  _bindScrollEvent() {
+    this._lifecycleService.lifecycle$.pipe(Y((n) => n === ve.Rendered), Be(1)).subscribe(() => {
+      this._scrollUpdateListener();
+    });
+  }
+  _ensureMap(n, e) {
+    let t = this._domLayerMap.get(n);
+    t || (t = /* @__PURE__ */ new Map(), this._domLayerMap.set(n, t));
+    let r = t.get(e);
+    return r || (r = /* @__PURE__ */ new Map(), t.set(e, r)), r;
+  }
+  getFloatDomInfo(n) {
+    return this._domLayerInfoMap.get(n);
+  }
+  _getSceneAndTransformerByDrawingSearch(n) {
+    if (n == null)
+      return;
+    const e = this._renderManagerService.getRenderById(n), t = e == null ? void 0 : e.scene;
+    if (e == null || t == null)
+      return null;
+    const r = t.getTransformerByCreate(), o = e.engine.getCanvasElement();
+    return { scene: t, transformer: r, renderObject: e, canvas: o };
+  }
+  _getFloatDomProps(n) {
+    let e;
+    return this._hooks.forEach((t) => {
+      e = t.onGetFloatDomProps(n);
+    }), e;
+  }
+  // eslint-disable-next-line max-lines-per-function
+  _drawingAddListener() {
+    this.disposeWithMe(
+      // eslint-disable-next-line max-lines-per-function
+      this._drawingManagerService.add$.subscribe((n) => {
+        n.forEach((e) => {
+          var z, G, q;
+          const { unitId: t, subUnitId: r, drawingId: o } = e, s = $(this._univerInstanceService, { unitId: t, subUnitId: r }), i = this._drawingManagerService.getDrawingByParam(e), a = this._univerInstanceService.getUnit(t);
+          if (!a)
+            return;
+          const d = a.getActiveSheet().getSheetId();
+          if (!i || !s)
+            return;
+          const c = (z = this._renderManagerService.getRenderById(t)) == null ? void 0 : z.with(Z).getWorksheetSkeleton(r);
+          if (!c)
+            return;
+          const { transform: l, drawingType: g, data: p } = i;
+          if (g !== P.DRAWING_DOM && g !== P.DRAWING_CHART)
+            return;
+          const f = this._getSceneAndTransformerByDrawingSearch(t);
+          if (f == null)
+            return;
+          const { scene: M, canvas: y } = f;
+          if (l == null)
+            return !0;
+          if (d !== r)
+            return;
+          const { left: O, top: b, width: S, height: _, angle: I, flipX: D, flipY: A, skewX: B, skewY: U } = l, T = x({ unitId: t, subUnitId: r, drawingId: o }), C = M.getObject(T);
+          if (C != null) {
+            C.transformByState({ left: O, top: b, width: S, height: _, angle: I, flipX: D, flipY: A, skewX: B, skewY: U });
+            return;
+          }
+          const u = {
+            left: O,
+            top: b,
+            width: S,
+            height: _,
+            zIndex: this._drawingManagerService.getDrawingOrder(t, r).length - 1
+          }, R = g === P.DRAWING_CHART;
+          R && (u.fill = "white", u.rotateEnabled = !1, p && p.border && (u.stroke = p.border), u.paintFirst = "stroke", u.strokeWidth = 1, u.borderEnabled = !1, u.radius = 8);
+          const v = new J(T, u);
+          R && v.setObjectType(De.CHART), M.addObject(v, Ee), i.allowTransform !== !1 && M.attachTransformerTo(v);
+          const k = this._ensureMap(t, r), j = new we(), ae = N(v, f.renderObject, c.skeleton, s.worksheet), L = new Ue(ae), ce = {
+            dispose: j,
+            rect: v,
+            position$: L,
+            unitId: t,
+            subUnitId: r
+          };
+          this._canvasFloatDomService.addFloatDom({
+            position$: L,
+            id: o,
+            componentKey: i.componentKey,
+            onPointerDown: (m) => {
+              y.dispatchEvent(new PointerEvent(m.type, m));
+            },
+            onPointerMove: (m) => {
+              y.dispatchEvent(new PointerEvent(m.type, m));
+            },
+            onPointerUp: (m) => {
+              y.dispatchEvent(new PointerEvent(m.type, m));
+            },
+            onWheel: (m) => {
+              y.dispatchEvent(new WheelEvent(m.type, m));
+            },
+            props: (q = (G = k.get(o)) == null ? void 0 : G.props) != null ? q : this._getFloatDomProps(o),
+            data: p,
+            unitId: t
+          });
+          const V = v.onTransformChange$.subscribeEvent(() => {
+            const m = N(v, f.renderObject, c.skeleton, s.worksheet);
+            L.next(
+              m
+            );
+          });
+          j.add(() => {
+            this._canvasFloatDomService.removeFloatDom(o);
+          }), V && j.add(V), this._domLayerInfoMap.set(o, ce), k.set(o, {
+            ...k.get(o)
+          });
+        });
+      })
+    ), this.disposeWithMe(
+      this._drawingManagerService.remove$.subscribe((n) => {
+        n.forEach((e) => {
+          const { unitId: t, subUnitId: r, drawingId: o } = e, s = x({ unitId: t, subUnitId: r, drawingId: o }), i = this._getSceneAndTransformerByDrawingSearch(t);
+          if (i == null)
+            return;
+          const { transformer: a, scene: d } = i, c = d.getObject(s);
+          c != null && c.oKey && a.clearControlByIds([c == null ? void 0 : c.oKey]);
+        });
+      })
+    );
+  }
+  _scrollUpdateListener() {
+    const n = (e, t) => {
+      var d;
+      const r = this._getSceneAndTransformerByDrawingSearch(e), o = this._ensureMap(e, t), s = Array.from(o.keys()), i = $(this._univerInstanceService, { unitId: e, subUnitId: t }), a = (d = this._renderManagerService.getRenderById(e)) == null ? void 0 : d.with(Z).getWorksheetSkeleton(t);
+      !r || !i || !a || s.forEach((c) => {
+        const l = this._domLayerInfoMap.get(c);
+        if (l) {
+          const g = N(l.rect, r.renderObject, a.skeleton, i.worksheet);
+          l.position$.next(g);
+        }
+      });
+    };
+    this.disposeWithMe(
+      this._univerInstanceService.getCurrentTypeOfUnit$(Ie.UNIVER_SHEET).pipe(
+        Y((e) => !!e),
+        Q((e) => {
+          const t = this._renderManagerService.getRenderById(e.getUnitId());
+          return t ? { render: t, unitId: e.getUnitId(), subUnitId: e.getActiveSheet().getSheetId() } : null;
+        }),
+        Y((e) => !!e),
+        We(
+          (e) => Me(e.render.scene.getViewport(Re.VIEW_MAIN).onScrollAfter$).pipe(Q(() => ({ unitId: e.unitId, subUnitId: e.subUnitId })))
+        )
+      ).subscribe(({ unitId: e, subUnitId: t }) => {
+        n(e, t);
+      })
+    ), this.disposeWithMe(this._commandService.onCommandExecuted((e) => {
+      var t, r;
+      if (e.id === Pe.id) {
+        const o = e.params, { unitId: s } = o;
+        Array.from((r = (t = this._domLayerMap.get(s)) == null ? void 0 : t.keys()) != null ? r : []).forEach((a) => {
+          n(s, a);
+        });
+      } else if (e.id === Ce.id) {
+        const { unitId: o, subUnitId: s } = e.params;
+        n(o, s);
+      }
+    }));
+  }
+  _getPosition(n, e) {
+    var g;
+    const { startX: t, endX: r, startY: o, endY: s } = n, i = (g = this._renderManagerService.getRenderById(e)) == null ? void 0 : g.with(Ae);
+    if (i == null)
+      return;
+    const a = i.getSelectionCellByPosition(t, o);
+    if (a == null)
+      return;
+    const d = {
+      column: a.actualColumn,
+      columnOffset: t - a.startX,
+      row: a.actualRow,
+      rowOffset: o - a.startY
+    }, c = i.getSelectionCellByPosition(r, s);
+    if (c == null)
+      return;
+    const l = {
+      column: c.actualColumn,
+      columnOffset: r - c.startX,
+      row: c.actualRow,
+      rowOffset: s - c.startY
+    };
+    return {
+      from: d,
+      to: l
+    };
+  }
+  _featureUpdateListener() {
+    this.disposeWithMe(
+      this._drawingManagerService.update$.subscribe((n) => {
+        n.forEach((e) => {
+          const t = this._drawingManagerService.getDrawingByParam(e);
+          if (!t || t.drawingType !== P.DRAWING_DOM && t.drawingType !== P.DRAWING_CHART)
+            return;
+          const r = {
+            ...t.transform
+          };
+          this._transformChange$.next({ id: e.drawingId, value: r });
+        });
+      })
+    );
+  }
+  _deleteListener() {
+    this.disposeWithMe(
+      this._drawingManagerService.remove$.subscribe((n) => {
+        n.forEach((e) => {
+          this._removeDom(e.drawingId);
+        });
+      })
+    );
+  }
+  updateFloatDomProps(n, e, t, r) {
+    const o = this._domLayerInfoMap.get(t), s = this._getSceneAndTransformerByDrawingSearch(n);
+    if (o && s) {
+      const { scene: i } = s, a = x({ unitId: n, subUnitId: e, drawingId: t }), d = i.getObject(a);
+      d && d instanceof J && d.setProps(r);
+    }
+  }
+  addFloatDomToPosition(n, e) {
+    const t = $(this._univerInstanceService, {
+      unitId: n.unitId,
+      subUnitId: n.subUnitId
+    });
+    if (!t)
+      throw new Error("cannot find current target!");
+    const { unitId: r, subUnitId: o } = t, { initPosition: s, componentKey: i, data: a, allowTransform: d = !0 } = n, c = e != null ? e : ye(), l = this._getPosition(s, r);
+    if (l == null)
+      return;
+    this._ensureMap(r, o).set(c, n);
+    const p = {
+      unitId: r,
+      subUnitId: o,
+      drawingId: c,
+      drawingType: n.type || P.DRAWING_DOM,
+      componentKey: i,
+      sheetTransform: l,
+      transform: {
+        left: s.startX,
+        top: s.startY,
+        width: s.endX - s.startX,
+        height: s.endY - s.startY
+      },
+      data: a,
+      allowTransform: d
+    };
+    return this._commandService.executeCommand(ie.id, {
+      unitId: r,
+      drawings: [p]
+    }), this._add$.next({ unitId: r, subUnitId: o, id: c }), {
+      id: c,
+      dispose: () => {
+        this._removeDom(c, !0);
+      }
+    };
+  }
+  _removeDom(n, e = !1) {
+    const t = this._domLayerInfoMap.get(n);
+    if (!t)
+      return;
+    const { unitId: r, subUnitId: o } = t;
+    this._domLayerInfoMap.delete(n), t.dispose.dispose();
+    const s = this._getSceneAndTransformerByDrawingSearch(r);
+    if (s && s.scene.removeObject(t.rect), e) {
+      this._ensureMap(r, o).delete(n);
+      const a = this._drawingManagerService.getDrawingByParam({ unitId: r, subUnitId: o, drawingId: n });
+      if (!a)
+        return;
+      const d = this._sheetDrawingService.getBatchRemoveOp([a]), { redo: c, objects: l } = d;
+      this._commandService.syncExecuteCommand(X.id, { unitId: r, subUnitId: o, op: c, objects: l, type: H.REMOVE });
+    }
+  }
+  addHook(n) {
+    return this._hooks.push(n), {
+      dispose: () => {
+        const e = this._hooks.findIndex((t) => t === n);
+        this._hooks.splice(e, 1);
+      }
+    };
+  }
+};
+K = Le([
+  E(0, W(oe)),
+  E(1, Se),
+  E(2, W(re)),
+  E(3, be),
+  E(4, W(ge)),
+  E(5, se),
+  E(6, W(ue))
+], K);
+class $e extends te {
+  addFloatDomToPosition(n, e) {
+    const t = this._workbook.getUnitId(), r = this._worksheet.getSheetId(), { key: o, disposableCollection: s } = le(n, this._injector.get(pe)), a = this._injector.get(K).addFloatDomToPosition({ ...n, componentKey: o, unitId: t, subUnitId: r }, e);
+    return a ? (s.add(a.dispose), {
+      id: a.id,
+      dispose: () => {
+        s.dispose(), a.dispose();
+      }
+    }) : (s.dispose(), null);
+  }
+}
+te.extend($e);