@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/@antv/x6/es/view/attr.js

@@ -0,0 +1,209 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { kebabCase as D } from "../../../x6-common/es/string/format.js";
+import { call as x } from "../../../x6-common/es/function/function.js";
+import "../../../x6-common/es/platform/index.js";
+import { CASE_SENSITIVE_ATTR as E, attr as R } from "../../../x6-common/es/dom/attr.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import { contains as N } from "../../../x6-common/es/dom/elem.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import { transformStringToMatrix as O, matrixToTransformString as S } from "../../../x6-common/es/dom/matrix.js";
+import "../../../x6-common/es/dom/event/hook.js";
+import "../../../x6-common/es/dom/event/main.js";
+import "../../../x6-common/es/dom/event/object.js";
+import "../../../x6-common/es/size-sensor/index.js";
+import "../../../x6-common/es/algorithm/priorityqueue.js";
+import "../../../x6-common/es/algorithm/dijkstra.js";
+import "../../../x6-common/es/color/index.js";
+import { Dictionary as j } from "../../../x6-common/es/dictionary/dictionary.js";
+import "../../../x6-common/es/modifier/index.js";
+import "../../../x6-common/es/animation/timing.js";
+import "../../../x6-common/es/animation/interp.js";
+import "../../../x6-geometry/es/angle.js";
+import { Point as y } from "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import "../../../x6-geometry/es/rectangle.js";
+import "../../../x6-geometry/es/path/path.js";
+import "../../../x6-geometry/es/util.js";
+import "../../../x6-geometry/es/curve.js";
+import "../../../x6-geometry/es/polyline.js";
+import { Attr as T } from "../registry/attr/index.js";
+import { View as k } from "./view.js";
+import { Util as A } from "../util/index.js";
+import I from "../../../../lodash-es/isPlainObject.js";
+import C from "../../../../lodash-es/sortedIndex.js";
+import M from "../../../../lodash-es/merge.js";
+class At {
+  constructor(t) {
+    this.view = t;
+  }
+  get cell() {
+    return this.view.cell;
+  }
+  getDefinition(t) {
+    return this.cell.getAttrDefinition(t);
+  }
+  processAttrs(t, r) {
+    let o, h, m, d;
+    const p = [];
+    return Object.keys(r).forEach((s) => {
+      const a = r[s], e = this.getDefinition(s), c = x(T.isValidDefinition, this.view, e, a, {
+        elem: t,
+        attrs: r,
+        cell: this.cell,
+        view: this.view
+      });
+      if (e && c)
+        typeof e == "string" ? (o == null && (o = {}), o[e] = a) : a !== null && p.push({ name: s, definition: e });
+      else {
+        o == null && (o = {});
+        const i = E.includes(s) ? s : D(s);
+        o[i] = a;
+      }
+    }), p.forEach(({ name: s, definition: a }) => {
+      const e = r[s];
+      typeof a.set == "function" && (h == null && (h = {}), h[s] = e), typeof a.offset == "function" && (m == null && (m = {}), m[s] = e), typeof a.position == "function" && (d == null && (d = {}), d[s] = e);
+    }), {
+      raw: r,
+      normal: o,
+      set: h,
+      offset: m,
+      position: d
+    };
+  }
+  mergeProcessedAttrs(t, r) {
+    t.set = Object.assign(Object.assign({}, t.set), r.set), t.position = Object.assign(Object.assign({}, t.position), r.position), t.offset = Object.assign(Object.assign({}, t.offset), r.offset);
+    const o = t.normal && t.normal.transform;
+    o != null && r.normal && (r.normal.transform = o), t.normal = r.normal;
+  }
+  findAttrs(t, r, o, h) {
+    const m = [], d = new j();
+    return Object.keys(t).forEach((p) => {
+      const s = t[p];
+      if (!I(s))
+        return;
+      const { isCSSSelector: a, elems: e } = k.find(p, r, h);
+      o[p] = e;
+      for (let c = 0, i = e.length; c < i; c += 1) {
+        const n = e[c], v = h && h[p] === n, f = d.get(n);
+        if (f) {
+          f.array || (m.push(n), f.array = !0, f.attrs = [f.attrs], f.priority = [f.priority]);
+          const l = f.attrs, u = f.priority;
+          if (v)
+            l.unshift(s), u.unshift(-1);
+          else {
+            const g = C(u, a ? -1 : i);
+            l.splice(g, 0, s), u.splice(g, 0, i);
+          }
+        } else
+          d.set(n, {
+            elem: n,
+            attrs: s,
+            priority: v ? -1 : i,
+            array: !1
+          });
+      }
+    }), m.forEach((p) => {
+      const s = d.get(p), a = s.attrs;
+      s.attrs = a.reduceRight((e, c) => M(e, c), {});
+    }), d;
+  }
+  updateRelativeAttrs(t, r, o) {
+    const h = r.raw || {};
+    let m = r.normal || {};
+    const d = r.set, p = r.position, s = r.offset, a = () => ({
+      elem: t,
+      cell: this.cell,
+      view: this.view,
+      attrs: h,
+      refBBox: o.clone()
+    });
+    if (d != null && Object.keys(d).forEach((l) => {
+      const u = d[l], g = this.getDefinition(l);
+      if (g != null) {
+        const b = x(g.set, this.view, u, a());
+        typeof b == "object" ? m = Object.assign(Object.assign({}, m), b) : b != null && (m[l] = b);
+      }
+    }), t instanceof HTMLElement) {
+      this.view.setAttrs(m, t);
+      return;
+    }
+    const e = m.transform, c = e ? `${e}` : null, i = O(c), n = new y(i.e, i.f);
+    e && (delete m.transform, i.e = 0, i.f = 0);
+    let v = !1;
+    p != null && Object.keys(p).forEach((l) => {
+      const u = p[l], g = this.getDefinition(l);
+      if (g != null) {
+        const b = x(g.position, this.view, u, a());
+        b != null && (v = !0, n.translate(y.create(b)));
+      }
+    }), this.view.setAttrs(m, t);
+    let f = !1;
+    if (s != null) {
+      const l = this.view.getBoundingRectOfElement(t);
+      if (l.width > 0 && l.height > 0) {
+        const u = A.transformRectangle(l, i);
+        Object.keys(s).forEach((g) => {
+          const b = s[g], w = this.getDefinition(g);
+          if (w != null) {
+            const B = x(w.offset, this.view, b, {
+              elem: t,
+              cell: this.cell,
+              view: this.view,
+              attrs: h,
+              refBBox: u
+            });
+            B != null && (f = !0, n.translate(y.create(B)));
+          }
+        });
+      }
+    }
+    (e != null || v || f) && (n.round(1), i.e = n.x, i.f = n.y, t.setAttribute("transform", S(i)));
+  }
+  update(t, r, o) {
+    const h = {}, m = this.findAttrs(o.attrs || r, t, h, o.selectors), d = o.attrs ? this.findAttrs(r, t, h, o.selectors) : m, p = [];
+    m.each((e) => {
+      const c = e.elem, i = e.attrs, n = this.processAttrs(c, i);
+      if (n.set == null && n.position == null && n.offset == null)
+        this.view.setAttrs(n.normal, c);
+      else {
+        const v = d.get(c), f = v ? v.attrs : null, l = f && i.ref == null ? f.ref : i.ref;
+        let u;
+        if (l) {
+          if (u = (h[l] || this.view.find(l, t, o.selectors))[0], !u)
+            throw new Error(`"${l}" reference does not exist.`);
+        } else
+          u = null;
+        const g = {
+          node: c,
+          refNode: u,
+          attributes: f,
+          processedAttributes: n
+        }, b = p.findIndex((w) => w.refNode === c);
+        b > -1 ? p.splice(b, 0, g) : p.push(g);
+      }
+    });
+    const s = new j();
+    let a;
+    p.forEach((e) => {
+      const c = e.node, i = e.refNode;
+      let n;
+      const v = i != null && o.rotatableNode != null && N(o.rotatableNode, i);
+      if (i && (n = s.get(i)), !n) {
+        const u = v ? o.rotatableNode : t;
+        n = i ? A.getBBox(i, { target: u }) : o.rootBBox, i && s.set(i, n);
+      }
+      let f;
+      o.attrs && e.attributes ? (f = this.processAttrs(c, e.attributes), this.mergeProcessedAttrs(f, e.processedAttributes)) : f = e.processedAttributes;
+      let l = n;
+      v && o.rotatableNode != null && !o.rotatableNode.contains(c) && (a || (a = O(R(o.rotatableNode, "transform"))), l = A.transformRectangle(n, a)), this.updateRelativeAttrs(c, f, l);
+    });
+  }
+}
+export {
+  At as AttrManager
+};

package/lib/packages/hooks/node_modules/@antv/x6/es/view/cache.js

@@ -0,0 +1,56 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import "../../../x6-common/es/platform/index.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import { createSVGMatrix as o } from "../../../x6-common/es/dom/matrix.js";
+import { getTransformToParentElement as a } from "../../../x6-common/es/dom/transform.js";
+import "../../../x6-common/es/dom/event/hook.js";
+import "../../../x6-common/es/dom/event/main.js";
+import "../../../x6-common/es/dom/event/object.js";
+import "../../../x6-common/es/size-sensor/index.js";
+import "../../../x6-common/es/algorithm/priorityqueue.js";
+import "../../../x6-common/es/algorithm/dijkstra.js";
+import "../../../x6-common/es/color/index.js";
+import { Dictionary as m } from "../../../x6-common/es/dictionary/dictionary.js";
+import "../../../x6-common/es/modifier/index.js";
+import "../../../x6-common/es/animation/timing.js";
+import "../../../x6-common/es/animation/interp.js";
+import { Util as i } from "../util/index.js";
+class V {
+  constructor(t) {
+    this.view = t, this.clean();
+  }
+  clean() {
+    this.elemCache && this.elemCache.dispose(), this.elemCache = new m(), this.pathCache = {};
+  }
+  get(t) {
+    return this.elemCache.has(t) || this.elemCache.set(t, {}), this.elemCache.get(t);
+  }
+  getData(t) {
+    const e = this.get(t);
+    return e.data || (e.data = {}), e.data;
+  }
+  getMatrix(t) {
+    const e = this.get(t);
+    if (e.matrix == null) {
+      const r = this.view.container;
+      e.matrix = a(t, r);
+    }
+    return o(e.matrix);
+  }
+  getShape(t) {
+    const e = this.get(t);
+    return e.shape == null && (e.shape = i.toGeometryShape(t)), e.shape.clone();
+  }
+  getBoundingRect(t) {
+    const e = this.get(t);
+    return e.boundingRect == null && (e.boundingRect = i.getBBoxV2(t)), e.boundingRect.clone();
+  }
+}
+export {
+  V as Cache
+};

package/lib/packages/hooks/node_modules/@antv/x6/es/view/cell.js

@@ -0,0 +1,434 @@
+import "../../../x6-geometry/es/angle.js";
+import "../../../x6-geometry/es/point.js";
+import "../../../x6-geometry/es/line.js";
+import "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as M } from "../../../x6-geometry/es/rectangle.js";
+import "../../../x6-geometry/es/path/path.js";
+import "../../../x6-geometry/es/util.js";
+import "../../../x6-geometry/es/curve.js";
+import "../../../x6-geometry/es/polyline.js";
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { call as f } from "../../../x6-common/es/function/function.js";
+import "../../../x6-common/es/platform/index.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import { createSVGMatrix as p } from "../../../x6-common/es/dom/matrix.js";
+import "../../../x6-common/es/dom/event/hook.js";
+import "../../../x6-common/es/dom/event/main.js";
+import "../../../x6-common/es/dom/event/object.js";
+import "../../../x6-common/es/size-sensor/index.js";
+import "../../../x6-common/es/algorithm/priorityqueue.js";
+import "../../../x6-common/es/algorithm/dijkstra.js";
+import "../../../x6-common/es/color/index.js";
+import "../../../x6-common/es/modifier/index.js";
+import "../../../x6-common/es/animation/timing.js";
+import "../../../x6-common/es/animation/interp.js";
+import { Registry as b } from "../registry/registry.js";
+import { View as m } from "./view.js";
+import { Cache as O } from "./cache.js";
+import { Markup as w } from "./markup.js";
+import { ToolsView as d } from "./tool.js";
+import { AttrManager as v } from "./attr.js";
+import { FlagManager as E } from "./flag.js";
+import { Util as y } from "../util/index.js";
+import A from "../../../../lodash-es/cloneDeep.js";
+import x from "../../../../lodash-es/merge.js";
+import C from "../../../../lodash-es/uniq.js";
+var S = function(n, t, e, i) {
+  var o = arguments.length, s = o < 3 ? t : i === null ? i = Object.getOwnPropertyDescriptor(t, e) : i, r;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") s = Reflect.decorate(n, t, e, i);
+  else for (var c = n.length - 1; c >= 0; c--) (r = n[c]) && (s = (o < 3 ? r(s) : o > 3 ? r(t, e, s) : r(t, e)) || s);
+  return o > 3 && s && Object.defineProperty(t, e, s), s;
+}, T = function(n, t) {
+  var e = {};
+  for (var i in n) Object.prototype.hasOwnProperty.call(n, i) && t.indexOf(i) < 0 && (e[i] = n[i]);
+  if (n != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var o = 0, i = Object.getOwnPropertySymbols(n); o < i.length; o++)
+      t.indexOf(i[o]) < 0 && Object.prototype.propertyIsEnumerable.call(n, i[o]) && (e[i[o]] = n[i[o]]);
+  return e;
+};
+class h extends m {
+  static getDefaults() {
+    return this.defaults;
+  }
+  static config(t) {
+    this.defaults = this.getOptions(t);
+  }
+  static getOptions(t) {
+    const e = (l, a) => a != null ? C([
+      ...Array.isArray(l) ? l : [l],
+      ...Array.isArray(a) ? a : [a]
+    ]) : Array.isArray(l) ? [...l] : [l], i = A(this.getDefaults()), { bootstrap: o, actions: s, events: r, documentEvents: c } = t, g = T(t, ["bootstrap", "actions", "events", "documentEvents"]);
+    return o && (i.bootstrap = e(i.bootstrap, o)), s && Object.entries(s).forEach(([l, a]) => {
+      const u = i.actions[l];
+      a && u ? i.actions[l] = e(u, a) : a && (i.actions[l] = e(a));
+    }), r && (i.events = Object.assign(Object.assign({}, i.events), r)), t.documentEvents && (i.documentEvents = Object.assign(Object.assign({}, i.documentEvents), c)), x(i, g);
+  }
+  get [Symbol.toStringTag]() {
+    return h.toStringTag;
+  }
+  constructor(t, e = {}) {
+    super(), this.cell = t, this.options = this.ensureOptions(e), this.graph = this.options.graph, this.attr = new v(this), this.flag = new E(this, this.options.actions, this.options.bootstrap), this.cache = new O(this), this.setContainer(this.ensureContainer()), this.setup(), this.init();
+  }
+  init() {
+  }
+  onRemove() {
+    this.removeTools();
+  }
+  get priority() {
+    return this.options.priority;
+  }
+  get rootSelector() {
+    return this.options.rootSelector;
+  }
+  getConstructor() {
+    return this.constructor;
+  }
+  ensureOptions(t) {
+    return this.getConstructor().getOptions(t);
+  }
+  getContainerTagName() {
+    return this.options.isSvgElement ? "g" : "div";
+  }
+  getContainerStyle() {
+  }
+  getContainerAttrs() {
+    return {
+      "data-cell-id": this.cell.id,
+      "data-shape": this.cell.shape
+    };
+  }
+  getContainerClassName() {
+    return this.prefixClassName("cell");
+  }
+  ensureContainer() {
+    return m.createElement(this.getContainerTagName(), this.options.isSvgElement);
+  }
+  setContainer(t) {
+    if (this.container !== t) {
+      this.undelegateEvents(), this.container = t, this.options.events != null && this.delegateEvents(this.options.events);
+      const e = this.getContainerAttrs();
+      e != null && this.setAttrs(e, t);
+      const i = this.getContainerStyle();
+      i != null && this.setStyle(i, t);
+      const o = this.getContainerClassName();
+      o != null && this.addClass(o, t);
+    }
+    return this;
+  }
+  isNodeView() {
+    return !1;
+  }
+  isEdgeView() {
+    return !1;
+  }
+  render() {
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  confirmUpdate(t, e = {}) {
+    return 0;
+  }
+  getBootstrapFlag() {
+    return this.flag.getBootstrapFlag();
+  }
+  getFlag(t) {
+    return this.flag.getFlag(t);
+  }
+  hasAction(t, e) {
+    return this.flag.hasAction(t, e);
+  }
+  removeAction(t, e) {
+    return this.flag.removeAction(t, e);
+  }
+  handleAction(t, e, i, o) {
+    if (this.hasAction(t, e)) {
+      i();
+      const s = [e];
+      return o && (typeof o == "string" ? s.push(o) : s.push(...o)), this.removeAction(t, s);
+    }
+    return t;
+  }
+  setup() {
+    this.cell.on("changed", this.onCellChanged, this);
+  }
+  onCellChanged({ options: t }) {
+    this.onAttrsChange(t);
+  }
+  onAttrsChange(t) {
+    let e = this.flag.getChangedFlag();
+    t.updated || !e || (t.dirty && this.hasAction(e, "update") && (e |= this.getFlag("render")), t.toolId && (t.async = !1), this.graph != null && this.graph.renderer.requestViewUpdate(this, e, t));
+  }
+  parseJSONMarkup(t, e) {
+    const i = w.parseJSONMarkup(t), o = i.selectors, s = this.rootSelector;
+    if (e && s) {
+      if (o[s])
+        throw new Error("Invalid root selector");
+      o[s] = e;
+    }
+    return i;
+  }
+  can(t) {
+    let e = this.graph.options.interacting;
+    if (typeof e == "function" && (e = f(e, this.graph, this)), typeof e == "object") {
+      let i = e[t];
+      return typeof i == "function" && (i = f(i, this.graph, this)), i !== !1;
+    }
+    return typeof e == "boolean" ? e : !1;
+  }
+  cleanCache() {
+    return this.cache.clean(), this;
+  }
+  getCache(t) {
+    return this.cache.get(t);
+  }
+  getDataOfElement(t) {
+    return this.cache.getData(t);
+  }
+  getMatrixOfElement(t) {
+    return this.cache.getMatrix(t);
+  }
+  getShapeOfElement(t) {
+    return this.cache.getShape(t);
+  }
+  getBoundingRectOfElement(t) {
+    return this.cache.getBoundingRect(t);
+  }
+  getBBoxOfElement(t) {
+    const e = this.getBoundingRectOfElement(t), i = this.getMatrixOfElement(t), o = this.getRootRotatedMatrix(), s = this.getRootTranslatedMatrix();
+    return y.transformRectangle(e, s.multiply(o).multiply(i));
+  }
+  getUnrotatedBBoxOfElement(t) {
+    const e = this.getBoundingRectOfElement(t), i = this.getMatrixOfElement(t), o = this.getRootTranslatedMatrix();
+    return y.transformRectangle(e, o.multiply(i));
+  }
+  getBBox(t = {}) {
+    let e;
+    if (t.useCellGeometry) {
+      const i = this.cell, o = i.isNode() ? i.getAngle() : 0;
+      e = i.getBBox().bbox(o);
+    } else
+      e = this.getBBoxOfElement(this.container);
+    return this.graph.coord.localToGraphRect(e);
+  }
+  getRootTranslatedMatrix() {
+    const t = this.cell, e = t.isNode() ? t.getPosition() : { x: 0, y: 0 };
+    return p().translate(e.x, e.y);
+  }
+  getRootRotatedMatrix() {
+    let t = p();
+    const e = this.cell, i = e.isNode() ? e.getAngle() : 0;
+    if (i) {
+      const o = e.getBBox(), s = o.width / 2, r = o.height / 2;
+      t = t.translate(s, r).rotate(i).translate(-s, -r);
+    }
+    return t;
+  }
+  findMagnet(t = this.container) {
+    return this.findByAttr("magnet", t);
+  }
+  updateAttrs(t, e, i = {}) {
+    i.rootBBox == null && (i.rootBBox = new M()), i.selectors == null && (i.selectors = this.selectors), this.attr.update(t, e, i);
+  }
+  isEdgeElement(t) {
+    return this.cell.isEdge() && (t == null || t === this.container);
+  }
+  // #region highlight
+  prepareHighlight(t, e = {}) {
+    const i = t || this.container;
+    return e.partial = i === this.container, i;
+  }
+  highlight(t, e = {}) {
+    const i = this.prepareHighlight(t, e);
+    return this.notify("cell:highlight", {
+      magnet: i,
+      options: e,
+      view: this,
+      cell: this.cell
+    }), this.isEdgeView() ? this.notify("edge:highlight", {
+      magnet: i,
+      options: e,
+      view: this,
+      edge: this.cell,
+      cell: this.cell
+    }) : this.isNodeView() && this.notify("node:highlight", {
+      magnet: i,
+      options: e,
+      view: this,
+      node: this.cell,
+      cell: this.cell
+    }), this;
+  }
+  unhighlight(t, e = {}) {
+    const i = this.prepareHighlight(t, e);
+    return this.notify("cell:unhighlight", {
+      magnet: i,
+      options: e,
+      view: this,
+      cell: this.cell
+    }), this.isNodeView() ? this.notify("node:unhighlight", {
+      magnet: i,
+      options: e,
+      view: this,
+      node: this.cell,
+      cell: this.cell
+    }) : this.isEdgeView() && this.notify("edge:unhighlight", {
+      magnet: i,
+      options: e,
+      view: this,
+      edge: this.cell,
+      cell: this.cell
+    }), this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  notifyUnhighlight(t, e) {
+  }
+  // #endregion
+  getEdgeTerminal(t, e, i, o, s) {
+    const r = this.cell, c = this.findAttr("port", t), g = t.getAttribute("data-selector"), l = { cell: r.id };
+    return g != null && (l.magnet = g), c != null ? (l.port = c, r.isNode() && !r.hasPort(c) && g == null && (l.selector = this.getSelector(t))) : g == null && this.container !== t && (l.selector = this.getSelector(t)), l;
+  }
+  getMagnetFromEdgeTerminal(t) {
+    const e = this.cell, i = this.container, o = t.port;
+    let s = t.magnet, r;
+    return o != null && e.isNode() && e.hasPort(o) ? r = this.findPortElem(o, s) || i : (s || (s = t.selector), !s && o != null && (s = `[port="${o}"]`), r = this.findOne(s, i, this.selectors)), r;
+  }
+  hasTools(t) {
+    const e = this.tools;
+    return e == null ? !1 : t == null ? !0 : e.name === t;
+  }
+  addTools(t) {
+    if (this.removeTools(), t) {
+      if (!this.can("toolsAddable"))
+        return this;
+      const e = d.isToolsView(t) ? t : new d(t);
+      this.tools = e, e.config({ view: this }), e.mount();
+    }
+    return this;
+  }
+  updateTools(t = {}) {
+    return this.tools && this.tools.update(t), this;
+  }
+  removeTools() {
+    return this.tools && (this.tools.remove(), this.tools = null), this;
+  }
+  hideTools() {
+    return this.tools && this.tools.hide(), this;
+  }
+  showTools() {
+    return this.tools && this.tools.show(), this;
+  }
+  renderTools() {
+    const t = this.cell.getTools();
+    return this.addTools(t), this;
+  }
+  notify(t, e) {
+    return this.trigger(t, e), this.graph.trigger(t, e), this;
+  }
+  getEventArgs(t, e, i) {
+    const o = this, s = o.cell;
+    return e == null || i == null ? { e: t, view: o, cell: s } : { e: t, x: e, y: i, view: o, cell: s };
+  }
+  onClick(t, e, i) {
+    this.notify("cell:click", this.getEventArgs(t, e, i));
+  }
+  onDblClick(t, e, i) {
+    this.notify("cell:dblclick", this.getEventArgs(t, e, i));
+  }
+  onContextMenu(t, e, i) {
+    this.notify("cell:contextmenu", this.getEventArgs(t, e, i));
+  }
+  onMouseDown(t, e, i) {
+    this.cell.model && (this.cachedModelForMouseEvent = this.cell.model, this.cachedModelForMouseEvent.startBatch("mouse")), this.notify("cell:mousedown", this.getEventArgs(t, e, i));
+  }
+  onMouseUp(t, e, i) {
+    this.notify("cell:mouseup", this.getEventArgs(t, e, i)), this.cachedModelForMouseEvent && (this.cachedModelForMouseEvent.stopBatch("mouse", { cell: this.cell }), this.cachedModelForMouseEvent = null);
+  }
+  onMouseMove(t, e, i) {
+    this.notify("cell:mousemove", this.getEventArgs(t, e, i));
+  }
+  onMouseOver(t) {
+    this.notify("cell:mouseover", this.getEventArgs(t));
+  }
+  onMouseOut(t) {
+    this.notify("cell:mouseout", this.getEventArgs(t));
+  }
+  onMouseEnter(t) {
+    this.notify("cell:mouseenter", this.getEventArgs(t));
+  }
+  onMouseLeave(t) {
+    this.notify("cell:mouseleave", this.getEventArgs(t));
+  }
+  onMouseWheel(t, e, i, o) {
+    this.notify("cell:mousewheel", Object.assign({ delta: o }, this.getEventArgs(t, e, i)));
+  }
+  onCustomEvent(t, e, i, o) {
+    this.notify("cell:customevent", Object.assign({ name: e }, this.getEventArgs(t, i, o))), this.notify(e, Object.assign({}, this.getEventArgs(t, i, o)));
+  }
+  onMagnetMouseDown(t, e, i, o) {
+  }
+  onMagnetDblClick(t, e, i, o) {
+  }
+  onMagnetContextMenu(t, e, i, o) {
+  }
+  onLabelMouseDown(t, e, i) {
+  }
+  checkMouseleave(t) {
+    const e = this.getEventTarget(t, { fromPoint: !0 }), i = this.graph.findViewByElem(e);
+    i !== this && (this.onMouseLeave(t), i && i.onMouseEnter(t));
+  }
+  dispose() {
+    this.cell.off("changed", this.onCellChanged, this);
+  }
+}
+h.defaults = {
+  isSvgElement: !0,
+  rootSelector: "root",
+  priority: 0,
+  bootstrap: [],
+  actions: {}
+};
+S([
+  h.dispose()
+], h.prototype, "dispose", null);
+(function(n) {
+  n.Flag = E, n.Attr = v;
+})(h || (h = {}));
+(function(n) {
+  n.toStringTag = `X6.${n.name}`;
+  function t(e) {
+    if (e == null)
+      return !1;
+    if (e instanceof n)
+      return !0;
+    const i = e[Symbol.toStringTag], o = e;
+    return (i == null || i === n.toStringTag) && typeof o.isNodeView == "function" && typeof o.isEdgeView == "function" && typeof o.confirmUpdate == "function";
+  }
+  n.isCellView = t;
+})(h || (h = {}));
+(function(n) {
+  function t(i) {
+    return function(o) {
+      o.config({ priority: i });
+    };
+  }
+  n.priority = t;
+  function e(i) {
+    return function(o) {
+      o.config({ bootstrap: i });
+    };
+  }
+  n.bootstrap = e;
+})(h || (h = {}));
+(function(n) {
+  n.registry = b.create({
+    type: "view"
+  });
+})(h || (h = {}));
+export {
+  h as CellView
+};