@qy_better_lib/hooks 0.0.15 → 0.1.1

package/lib/packages/hooks/node_modules/@antv/x6/es/registry/tool/segments.js

@@ -0,0 +1,241 @@
+import "../../../../x6-common/es/polyfill/index.js";
+import "../../../../x6-common/es/common/disposable.js";
+import "../../../../x6-common/es/common/basecoat.js";
+import { call as B } from "../../../../x6-common/es/function/function.js";
+import "../../../../x6-common/es/platform/index.js";
+import { addClass as z } from "../../../../x6-common/es/dom/class.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 R, matrixToTransformString as b } 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 "../../../../x6-geometry/es/angle.js";
+import { Point as v } from "../../../../x6-geometry/es/point.js";
+import { Line as T } from "../../../../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 { View as I } from "../../view/view.js";
+import { ToolsView as L } from "../../view/tool.js";
+import { getAnchor as S } from "./util.js";
+import C from "../../../../../lodash-es/cloneDeep.js";
+class w extends L.ToolItem {
+  constructor() {
+    super(...arguments), this.handles = [];
+  }
+  get vertices() {
+    return this.cellView.cell.getVertices();
+  }
+  update() {
+    return this.render(), this;
+  }
+  onRender() {
+    z(this.container, this.prefixClassName("edge-tool-segments")), this.resetHandles();
+    const e = this.cellView, s = [...this.vertices];
+    s.unshift(e.sourcePoint), s.push(e.targetPoint);
+    for (let t = 0, o = s.length; t < o - 1; t += 1) {
+      const i = s[t], c = s[t + 1], n = this.renderHandle(i, c, t);
+      this.stamp(n.container), this.handles.push(n);
+    }
+    return this;
+  }
+  renderHandle(e, s, t) {
+    const o = this.options.createHandle({
+      index: t,
+      graph: this.graph,
+      guard: (i) => this.guard(i),
+      attrs: this.options.attrs || {}
+    });
+    return this.options.processHandle && this.options.processHandle(o), this.updateHandle(o, e, s), this.container.appendChild(o.container), this.startHandleListening(o), o;
+  }
+  startHandleListening(e) {
+    e.on("change", this.onHandleChange, this), e.on("changing", this.onHandleChanging, this), e.on("changed", this.onHandleChanged, this);
+  }
+  stopHandleListening(e) {
+    e.off("change", this.onHandleChange, this), e.off("changing", this.onHandleChanging, this), e.off("changed", this.onHandleChanged, this);
+  }
+  resetHandles() {
+    const e = this.handles;
+    this.handles = [], e && e.forEach((s) => {
+      this.stopHandleListening(s), s.remove();
+    });
+  }
+  shiftHandleIndexes(e) {
+    const s = this.handles;
+    for (let t = 0, o = s.length; t < o; t += 1)
+      s[t].options.index += e;
+  }
+  resetAnchor(e, s) {
+    const t = this.cellView.cell, o = {
+      ui: !0,
+      toolId: this.cid
+    };
+    s ? t.prop([e, "anchor"], s, o) : t.removeProp([e, "anchor"], o);
+  }
+  snapHandle(e, s, t) {
+    const o = e.options.axis, i = e.options.index, r = this.cellView.cell.getVertices(), h = r[i - 2] || t.sourceAnchor, a = r[i + 1] || t.targetAnchor, d = this.options.snapRadius;
+    return Math.abs(s[o] - h[o]) < d ? s[o] = h[o] : Math.abs(s[o] - a[o]) < d && (s[o] = a[o]), s;
+  }
+  onHandleChanging({ handle: e, e: s }) {
+    const t = this.graph, o = this.options, i = this.cellView, c = o.anchor, n = e.options.axis, r = e.options.index - 1, h = this.getEventData(s), a = this.normalizeEvent(s), d = t.snapToGrid(a.clientX, a.clientY), l = this.snapHandle(e, d.clone(), h), p = C(this.vertices);
+    let g = p[r], u = p[r + 1];
+    const x = i.sourceView, D = i.sourceBBox;
+    let A = !1, H = !1;
+    if (g ? r === 0 ? D.containsPoint(g) ? (p.shift(), this.shiftHandleIndexes(-1), A = !0) : (g[n] = l[n], H = !0) : g[n] = l[n] : (g = i.sourceAnchor.toJSON(), g[n] = l[n], D.containsPoint(g) ? A = !0 : (p.unshift(g), this.shiftHandleIndexes(1), H = !0)), typeof c == "function" && x) {
+      if (A) {
+        const m = h.sourceAnchor.clone();
+        m[n] = l[n];
+        const P = B(c, i, m, x, i.sourceMagnet || x.container, "source", i, this);
+        this.resetAnchor("source", P);
+      }
+      H && this.resetAnchor("source", h.sourceAnchorDef);
+    }
+    const V = i.targetView, E = i.targetBBox;
+    let M = !1, y = !1;
+    if (u ? r === p.length - 2 ? E.containsPoint(u) ? (p.pop(), M = !0) : (u[n] = l[n], y = !0) : u[n] = l[n] : (u = i.targetAnchor.toJSON(), u[n] = l[n], E.containsPoint(u) ? M = !0 : (p.push(u), y = !0)), typeof c == "function" && V) {
+      if (M) {
+        const m = h.targetAnchor.clone();
+        m[n] = l[n];
+        const P = B(c, i, m, V, i.targetMagnet || V.container, "target", i, this);
+        this.resetAnchor("target", P);
+      }
+      y && this.resetAnchor("target", h.targetAnchorDef);
+    }
+    v.equalPoints(p, this.vertices) || this.cellView.cell.setVertices(p, { ui: !0, toolId: this.cid }), this.updateHandle(e, g, u, 0), o.stopPropagation || i.notifyMouseMove(a, d.x, d.y);
+  }
+  onHandleChange({ handle: e, e: s }) {
+    const t = this.options, o = this.handles, i = this.cellView, c = e.options.index;
+    if (Array.isArray(o)) {
+      for (let n = 0, r = o.length; n < r; n += 1)
+        n !== c && o[n].hide();
+      if (this.focus(), this.setEventData(s, {
+        sourceAnchor: i.sourceAnchor.clone(),
+        targetAnchor: i.targetAnchor.clone(),
+        sourceAnchorDef: C(this.cell.prop(["source", "anchor"])),
+        targetAnchorDef: C(this.cell.prop(["target", "anchor"]))
+      }), this.cell.startBatch("move-segment", { ui: !0, toolId: this.cid }), !t.stopPropagation) {
+        const n = this.normalizeEvent(s), r = this.graph.snapToGrid(n.clientX, n.clientY);
+        i.notifyMouseDown(n, r.x, r.y);
+      }
+    }
+  }
+  onHandleChanged({ e }) {
+    const s = this.options, t = this.cellView;
+    s.removeRedundancies && t.removeRedundantLinearVertices({ ui: !0, toolId: this.cid });
+    const o = this.normalizeEvent(e), i = this.graph.snapToGrid(o.clientX, o.clientY);
+    this.render(), this.blur(), this.cell.stopBatch("move-segment", { ui: !0, toolId: this.cid }), s.stopPropagation || t.notifyMouseUp(o, i.x, i.y), t.checkMouseleave(o), s.onChanged && s.onChanged({ edge: t.cell, edgeView: t });
+  }
+  updateHandle(e, s, t, o = 0) {
+    const i = this.options.precision || 0, c = Math.abs(s.x - t.x) < i, n = Math.abs(s.y - t.y) < i;
+    if (c || n) {
+      const r = new T(s, t);
+      if (r.length() < this.options.threshold)
+        e.hide();
+      else {
+        const a = r.getCenter(), d = c ? "x" : "y";
+        a[d] += o || 0;
+        const l = r.vector().vectorAngle(new v(1, 0));
+        e.updatePosition(a.x, a.y, l, this.cellView), e.show(), e.options.axis = d;
+      }
+    } else
+      e.hide();
+  }
+  onRemove() {
+    this.resetHandles();
+  }
+}
+(function(f) {
+  class e extends I {
+    constructor(t) {
+      super(), this.options = t, this.render(), this.delegateEvents({
+        mousedown: "onMouseDown",
+        touchstart: "onMouseDown"
+      });
+    }
+    render() {
+      this.container = I.createElement("rect", !0);
+      const t = this.options.attrs;
+      if (typeof t == "function") {
+        const o = f.getDefaults();
+        this.setAttrs(Object.assign(Object.assign({}, o.attrs), t(this)));
+      } else
+        this.setAttrs(t);
+      this.addClass(this.prefixClassName("edge-tool-segment"));
+    }
+    updatePosition(t, o, i, c) {
+      const n = c.getClosestPoint(new v(t, o)) || new v(t, o);
+      let r = R().translate(n.x, n.y);
+      if (n.equals({ x: t, y: o }))
+        r = r.rotate(i);
+      else {
+        let a = new T(t, o, n.x, n.y).vector().vectorAngle(new v(1, 0));
+        a !== 0 && (a += 90), r = r.rotate(a);
+      }
+      this.setAttrs({
+        transform: b(r),
+        cursor: i % 180 === 0 ? "row-resize" : "col-resize"
+      });
+    }
+    onMouseDown(t) {
+      this.options.guard(t) || (this.trigger("change", { e: t, handle: this }), t.stopPropagation(), t.preventDefault(), this.options.graph.view.undelegateEvents(), this.delegateDocumentEvents({
+        mousemove: "onMouseMove",
+        touchmove: "onMouseMove",
+        mouseup: "onMouseUp",
+        touchend: "onMouseUp",
+        touchcancel: "onMouseUp"
+      }, t.data));
+    }
+    onMouseMove(t) {
+      this.emit("changing", { e: t, handle: this });
+    }
+    onMouseUp(t) {
+      this.emit("changed", { e: t, handle: this }), this.undelegateDocumentEvents(), this.options.graph.view.delegateEvents();
+    }
+    show() {
+      this.container.style.display = "";
+    }
+    hide() {
+      this.container.style.display = "none";
+    }
+  }
+  f.Handle = e;
+})(w || (w = {}));
+(function(f) {
+  f.config({
+    name: "segments",
+    precision: 0.5,
+    threshold: 40,
+    snapRadius: 10,
+    stopPropagation: !0,
+    removeRedundancies: !0,
+    attrs: {
+      width: 20,
+      height: 8,
+      x: -10,
+      y: -4,
+      rx: 4,
+      ry: 4,
+      fill: "#333",
+      stroke: "#fff",
+      "stroke-width": 2
+    },
+    createHandle: (e) => new f.Handle(e),
+    anchor: S
+  });
+})(w || (w = {}));
+export {
+  w as Segments
+};

package/lib/packages/hooks/node_modules/@antv/x6/es/registry/tool/util.js

@@ -0,0 +1,30 @@
+import "../../../../x6-common/es/polyfill/index.js";
+import "../../../../x6-common/es/common/disposable.js";
+import "../../../../x6-common/es/common/basecoat.js";
+import { call as p } 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 "../../../../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 { ConnectionStrategy as e } from "../connection-strategy/index.js";
+function U(t, o, r, i) {
+  return p(e.presets.pinRelative, this.graph, {}, o, r, t, this.cell, i, {}).anchor;
+}
+function V(t, o) {
+  return o ? t.cell.getBBox() : t.cell.isEdge() ? t.getConnection().bbox() : t.getUnrotatedBBoxOfElement(t.container);
+}
+export {
+  U as getAnchor,
+  V as getViewBBox
+};

package/lib/packages/hooks/node_modules/@antv/x6/es/registry/tool/vertices.js

@@ -0,0 +1,248 @@
+import "../../../../x6-geometry/es/angle.js";
+import { Point as d } 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 "../../../../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 "../../../../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 { ModifierKey as g } from "../../../../x6-common/es/modifier/index.js";
+import "../../../../x6-common/es/animation/timing.js";
+import "../../../../x6-common/es/animation/interp.js";
+import { Config as m } from "../../config/index.js";
+import { View as l } from "../../view/view.js";
+import { ToolsView as v } from "../../view/tool.js";
+class c extends v.ToolItem {
+  constructor() {
+    super(...arguments), this.handles = [];
+  }
+  get vertices() {
+    return this.cellView.cell.getVertices();
+  }
+  onRender() {
+    return this.addClass(this.prefixClassName("edge-tool-vertices")), this.options.addable && this.updatePath(), this.resetHandles(), this.renderHandles(), this;
+  }
+  update() {
+    return this.vertices.length === this.handles.length ? this.updateHandles() : (this.resetHandles(), this.renderHandles()), this.options.addable && this.updatePath(), this;
+  }
+  resetHandles() {
+    const t = this.handles;
+    this.handles = [], t && t.forEach((s) => {
+      this.stopHandleListening(s), s.remove();
+    });
+  }
+  renderHandles() {
+    const t = this.vertices;
+    for (let s = 0, e = t.length; s < e; s += 1) {
+      const i = t[s], o = this.options.createHandle, n = this.options.processHandle, a = o({
+        index: s,
+        graph: this.graph,
+        guard: (r) => this.guard(r),
+        attrs: this.options.attrs || {}
+      });
+      n && n(a), a.updatePosition(i.x, i.y), this.stamp(a.container), this.container.appendChild(a.container), this.handles.push(a), this.startHandleListening(a);
+    }
+  }
+  updateHandles() {
+    const t = this.vertices;
+    for (let s = 0, e = t.length; s < e; s += 1) {
+      const i = t[s], o = this.handles[s];
+      o && o.updatePosition(i.x, i.y);
+    }
+  }
+  updatePath() {
+    const t = this.childNodes.connection;
+    t && t.setAttribute("d", this.cellView.getConnectionPathData());
+  }
+  startHandleListening(t) {
+    const s = this.cellView;
+    s.can("vertexMovable") && (t.on("change", this.onHandleChange, this), t.on("changing", this.onHandleChanging, this), t.on("changed", this.onHandleChanged, this)), s.can("vertexDeletable") && t.on("remove", this.onHandleRemove, this);
+  }
+  stopHandleListening(t) {
+    const s = this.cellView;
+    s.can("vertexMovable") && (t.off("change", this.onHandleChange, this), t.off("changing", this.onHandleChanging, this), t.off("changed", this.onHandleChanged, this)), s.can("vertexDeletable") && t.off("remove", this.onHandleRemove, this);
+  }
+  getNeighborPoints(t) {
+    const s = this.cellView, e = this.vertices, i = t > 0 ? e[t - 1] : s.sourceAnchor, o = t < e.length - 1 ? e[t + 1] : s.targetAnchor;
+    return {
+      prev: d.create(i),
+      next: d.create(o)
+    };
+  }
+  getMouseEventArgs(t) {
+    const s = this.normalizeEvent(t), { x: e, y: i } = this.graph.snapToGrid(s.clientX, s.clientY);
+    return { e: s, x: e, y: i };
+  }
+  onHandleChange({ e: t }) {
+    this.focus();
+    const s = this.cellView;
+    if (s.cell.startBatch("move-vertex", { ui: !0, toolId: this.cid }), !this.options.stopPropagation) {
+      const { e, x: i, y: o } = this.getMouseEventArgs(t);
+      this.eventData(e, { start: { x: i, y: o } }), s.notifyMouseDown(e, i, o);
+    }
+  }
+  onHandleChanging({ handle: t, e: s }) {
+    const e = this.cellView, i = t.options.index, { e: o, x: n, y: a } = this.getMouseEventArgs(s), r = { x: n, y: a };
+    this.snapVertex(r, i), e.cell.setVertexAt(i, r, { ui: !0, toolId: this.cid }), t.updatePosition(r.x, r.y), this.options.stopPropagation || e.notifyMouseMove(o, n, a);
+  }
+  stopBatch(t) {
+    this.cell.stopBatch("move-vertex", { ui: !0, toolId: this.cid }), t && this.cell.stopBatch("add-vertex", { ui: !0, toolId: this.cid });
+  }
+  onHandleChanged({ e: t }) {
+    const s = this.options, e = this.cellView;
+    if (s.addable && this.updatePath(), !s.removeRedundancies) {
+      this.stopBatch(this.eventData(t).vertexAdded);
+      return;
+    }
+    e.removeRedundantLinearVertices({
+      ui: !0,
+      toolId: this.cid
+    }) && this.render(), this.blur(), this.stopBatch(this.eventData(t).vertexAdded);
+    const { e: o, x: n, y: a } = this.getMouseEventArgs(t);
+    if (!this.options.stopPropagation) {
+      e.notifyMouseUp(o, n, a);
+      const { start: r } = this.eventData(o);
+      if (r) {
+        const { x: p, y: u } = r;
+        p === n && u === a && e.onClick(o, n, a);
+      }
+    }
+    e.checkMouseleave(o), s.onChanged && s.onChanged({ edge: e.cell, edgeView: e });
+  }
+  snapVertex(t, s) {
+    const e = this.options.snapRadius || 0;
+    if (e > 0) {
+      const i = this.getNeighborPoints(s), o = i.prev, n = i.next;
+      Math.abs(t.x - o.x) < e ? t.x = o.x : Math.abs(t.x - n.x) < e && (t.x = n.x), Math.abs(t.y - o.y) < e ? t.y = i.prev.y : Math.abs(t.y - n.y) < e && (t.y = n.y);
+    }
+  }
+  onHandleRemove({ handle: t, e: s }) {
+    if (this.options.removable) {
+      const e = t.options.index, i = this.cellView;
+      i.cell.removeVertexAt(e, { ui: !0 }), this.options.addable && this.updatePath(), i.checkMouseleave(this.normalizeEvent(s));
+    }
+  }
+  allowAddVertex(t) {
+    const s = this.guard(t), e = this.options.addable && this.cellView.can("vertexAddable"), i = this.options.modifiers ? g.isMatch(t, this.options.modifiers) : !0;
+    return !s && e && i;
+  }
+  onPathMouseDown(t) {
+    const s = this.cellView;
+    if (!this.allowAddVertex(t))
+      return;
+    t.stopPropagation(), t.preventDefault();
+    const e = this.normalizeEvent(t), i = this.graph.snapToGrid(e.clientX, e.clientY).toJSON();
+    s.cell.startBatch("add-vertex", { ui: !0, toolId: this.cid });
+    const o = s.getVertexIndex(i.x, i.y);
+    this.snapVertex(i, o), s.cell.insertVertex(i, o, {
+      ui: !0,
+      toolId: this.cid
+    }), this.render();
+    const n = this.handles[o];
+    this.eventData(e, { vertexAdded: !0 }), n.onMouseDown(e);
+  }
+  onRemove() {
+    this.resetHandles();
+  }
+}
+(function(h) {
+  class t extends l {
+    get graph() {
+      return this.options.graph;
+    }
+    constructor(e) {
+      super(), this.options = e, this.render(), this.delegateEvents({
+        mousedown: "onMouseDown",
+        touchstart: "onMouseDown",
+        dblclick: "onDoubleClick"
+      });
+    }
+    render() {
+      this.container = l.createElement("circle", !0);
+      const e = this.options.attrs;
+      if (typeof e == "function") {
+        const i = h.getDefaults();
+        this.setAttrs(Object.assign(Object.assign({}, i.attrs), e(this)));
+      } else
+        this.setAttrs(e);
+      this.addClass(this.prefixClassName("edge-tool-vertex"));
+    }
+    updatePosition(e, i) {
+      this.setAttrs({ cx: e, cy: i });
+    }
+    onMouseDown(e) {
+      this.options.guard(e) || (e.stopPropagation(), e.preventDefault(), this.graph.view.undelegateEvents(), this.delegateDocumentEvents({
+        mousemove: "onMouseMove",
+        touchmove: "onMouseMove",
+        mouseup: "onMouseUp",
+        touchend: "onMouseUp",
+        touchcancel: "onMouseUp"
+      }, e.data), this.emit("change", { e, handle: this }));
+    }
+    onMouseMove(e) {
+      this.emit("changing", { e, handle: this });
+    }
+    onMouseUp(e) {
+      this.emit("changed", { e, handle: this }), this.undelegateDocumentEvents(), this.graph.view.delegateEvents();
+    }
+    onDoubleClick(e) {
+      this.emit("remove", { e, handle: this });
+    }
+  }
+  h.Handle = t;
+})(c || (c = {}));
+(function(h) {
+  const t = m.prefix("edge-tool-vertex-path");
+  h.config({
+    name: "vertices",
+    snapRadius: 20,
+    addable: !0,
+    removable: !0,
+    removeRedundancies: !0,
+    stopPropagation: !0,
+    attrs: {
+      r: 6,
+      fill: "#333",
+      stroke: "#fff",
+      cursor: "move",
+      "stroke-width": 2
+    },
+    createHandle: (s) => new h.Handle(s),
+    markup: [
+      {
+        tagName: "path",
+        selector: "connection",
+        className: t,
+        attrs: {
+          fill: "none",
+          stroke: "transparent",
+          "stroke-width": 10,
+          cursor: "pointer"
+        }
+      }
+    ],
+    events: {
+      [`mousedown .${t}`]: "onPathMouseDown",
+      [`touchstart .${t}`]: "onPathMouseDown"
+    }
+  });
+})(c || (c = {}));
+export {
+  c as Vertices
+};

package/lib/packages/hooks/node_modules/@antv/x6/es/renderer/queueJob.js

@@ -0,0 +1,69 @@
+class d {
+  constructor() {
+    this.isFlushing = !1, this.isFlushPending = !1, this.scheduleId = 0, this.queue = [], this.frameInterval = 33, this.initialTime = Date.now();
+  }
+  queueJob(e) {
+    if (e.priority & n.PRIOR)
+      e.cb();
+    else {
+      const i = this.findInsertionIndex(e);
+      i >= 0 && this.queue.splice(i, 0, e);
+    }
+  }
+  queueFlush() {
+    !this.isFlushing && !this.isFlushPending && (this.isFlushPending = !0, this.scheduleJob());
+  }
+  queueFlushSync() {
+    !this.isFlushing && !this.isFlushPending && (this.isFlushPending = !0, this.flushJobsSync());
+  }
+  clearJobs() {
+    this.queue.length = 0, this.isFlushing = !1, this.isFlushPending = !1, this.cancelScheduleJob();
+  }
+  flushJobs() {
+    this.isFlushPending = !1, this.isFlushing = !0;
+    const e = this.getCurrentTime();
+    let i;
+    for (; (i = this.queue.shift()) && (i.cb(), !(this.getCurrentTime() - e >= this.frameInterval)); )
+      ;
+    this.isFlushing = !1, this.queue.length && this.queueFlush();
+  }
+  flushJobsSync() {
+    this.isFlushPending = !1, this.isFlushing = !0;
+    let e;
+    for (; e = this.queue.shift(); )
+      try {
+        e.cb();
+      } catch (i) {
+        console.log(i);
+      }
+    this.isFlushing = !1;
+  }
+  findInsertionIndex(e) {
+    let i = 0, h = this.queue.length, l = h - 1;
+    const u = e.priority;
+    for (; i <= l; ) {
+      const t = (l - i >> 1) + i;
+      u <= this.queue[t].priority ? i = t + 1 : (h = t, l = t - 1);
+    }
+    return h;
+  }
+  scheduleJob() {
+    "requestIdleCallback" in window ? (this.scheduleId && this.cancelScheduleJob(), this.scheduleId = window.requestIdleCallback(this.flushJobs.bind(this), {
+      timeout: 100
+    })) : (this.scheduleId && this.cancelScheduleJob(), this.scheduleId = window.setTimeout(this.flushJobs.bind(this)));
+  }
+  cancelScheduleJob() {
+    "cancelIdleCallback" in window ? (this.scheduleId && window.cancelIdleCallback(this.scheduleId), this.scheduleId = 0) : (this.scheduleId && clearTimeout(this.scheduleId), this.scheduleId = 0);
+  }
+  getCurrentTime() {
+    return typeof performance == "object" && typeof performance.now == "function" ? performance.now() : Date.now() - this.initialTime;
+  }
+}
+var n;
+(function(s) {
+  s[s.Update = 2] = "Update", s[s.RenderEdge = 4] = "RenderEdge", s[s.RenderNode = 8] = "RenderNode", s[s.PRIOR = 1048576] = "PRIOR";
+})(n || (n = {}));
+export {
+  n as JOB_PRIORITY,
+  d as JobQueue
+};

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

@@ -0,0 +1,96 @@
+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 d } 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 { Base as u } from "../graph/base.js";
+import { Cell as c } from "../model/cell.js";
+import "../model/node.js";
+import "../model/edge.js";
+import "../model/model.js";
+import "../model/collection.js";
+import { Scheduler as a } from "./scheduler.js";
+import { Util as f } from "../util/index.js";
+var p = function(s, e, i, t) {
+  var n = arguments.length, r = n < 3 ? e : t === null ? t = Object.getOwnPropertyDescriptor(e, i) : t, o;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") r = Reflect.decorate(s, e, i, t);
+  else for (var l = s.length - 1; l >= 0; l--) (o = s[l]) && (r = (n < 3 ? o(r) : n > 3 ? o(e, i, r) : o(e, i)) || r);
+  return n > 3 && r && Object.defineProperty(e, i, r), r;
+};
+class h extends u {
+  constructor() {
+    super(...arguments), this.schedule = new a(this.graph);
+  }
+  requestViewUpdate(e, i, t = {}) {
+    this.schedule.requestViewUpdate(e, i, t);
+  }
+  isViewMounted(e) {
+    return this.schedule.isViewMounted(e);
+  }
+  setRenderArea(e) {
+    this.schedule.setRenderArea(e);
+  }
+  findViewByElem(e) {
+    if (e == null)
+      return null;
+    const i = this.options.container, t = typeof e == "string" ? i.querySelector(e) : e instanceof Element ? e : e[0];
+    if (t) {
+      const n = this.graph.view.findAttr("data-cell-id", t);
+      if (n) {
+        const r = this.schedule.views;
+        if (r[n])
+          return r[n].view;
+      }
+    }
+    return null;
+  }
+  findViewByCell(e) {
+    if (e == null)
+      return null;
+    const i = c.isCell(e) ? e.id : e, t = this.schedule.views;
+    return t[i] ? t[i].view : null;
+  }
+  findViewsFromPoint(e) {
+    const i = { x: e.x, y: e.y };
+    return this.model.getCells().map((t) => this.findViewByCell(t)).filter((t) => t != null ? f.getBBox(t.container, {
+      target: this.view.stage
+    }).containsPoint(i) : !1);
+  }
+  findEdgeViewsFromPoint(e, i = 5) {
+    return this.model.getEdges().map((t) => this.findViewByCell(t)).filter((t) => {
+      if (t != null) {
+        const n = t.getClosestPoint(e);
+        if (n)
+          return n.distance(e) <= i;
+      }
+      return !1;
+    });
+  }
+  findViewsInArea(e, i = {}) {
+    const t = d.create(e);
+    return this.model.getCells().map((n) => this.findViewByCell(n)).filter((n) => {
+      if (n) {
+        if (i.nodeOnly && !n.isNodeView())
+          return !1;
+        const r = f.getBBox(n.container, {
+          target: this.view.stage
+        });
+        return r.width === 0 ? r.inflate(1, 0) : r.height === 0 && r.inflate(0, 1), i.strict ? t.containsRect(r) : t.isIntersectWithRect(r);
+      }
+      return !1;
+    });
+  }
+  dispose() {
+    this.schedule.dispose();
+  }
+}
+p([
+  u.dispose()
+], h.prototype, "dispose", null);
+export {
+  h as Renderer
+};