@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,72 @@
+import "../../../x6-geometry/es/angle.js";
+import { Point as s } 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 { setByPath as m } from "../../../x6-common/es/object/object.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 { Base as f } from "./base.js";
+var y = function(o, i) {
+  var r = {};
+  for (var t in o) Object.prototype.hasOwnProperty.call(o, t) && i.indexOf(t) < 0 && (r[t] = o[t]);
+  if (o != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var e = 0, t = Object.getOwnPropertySymbols(o); e < t.length; e++)
+      i.indexOf(t[e]) < 0 && Object.prototype.propertyIsEnumerable.call(o, t[e]) && (r[t[e]] = o[t[e]]);
+  return r;
+};
+class n extends f {
+  get points() {
+    return this.getPoints();
+  }
+  set points(i) {
+    this.setPoints(i);
+  }
+  getPoints() {
+    return this.getAttrByPath("body/refPoints");
+  }
+  setPoints(i, r) {
+    return i == null ? this.removePoints() : this.setAttrByPath("body/refPoints", n.pointsToString(i), r), this;
+  }
+  removePoints() {
+    return this.removeAttrByPath("body/refPoints"), this;
+  }
+}
+(function(o) {
+  function i(r) {
+    return typeof r == "string" ? r : r.map((t) => Array.isArray(t) ? t.join(",") : s.isPointLike(t) ? `${t.x}, ${t.y}` : "").join(" ");
+  }
+  o.pointsToString = i, o.config({
+    propHooks(r) {
+      const { points: t } = r, e = y(r, ["points"]);
+      if (t) {
+        const p = i(t);
+        p && m(e, "attrs/body/refPoints", p);
+      }
+      return e;
+    }
+  });
+})(n || (n = {}));
+export {
+  n as Poly
+};

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

@@ -0,0 +1,3 @@
+import { Poly as o } from "./poly.js";
+import { createShape as r } from "./util.js";
+r("polygon", {}, { parent: o });

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

@@ -0,0 +1,3 @@
+import { Poly as o } from "./poly.js";
+import { createShape as r } from "./util.js";
+r("polyline", {}, { parent: o });

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

@@ -0,0 +1,9 @@
+import { createShape as e } from "./util.js";
+e("rect", {
+  attrs: {
+    body: {
+      refWidth: "100%",
+      refHeight: "100%"
+    }
+  }
+});

package/lib/packages/hooks/node_modules/@antv/x6/es/shape/text-block.js

@@ -0,0 +1,122 @@
+import "../../../x6-common/es/polyfill/index.js";
+import "../../../x6-common/es/common/disposable.js";
+import "../../../x6-common/es/common/basecoat.js";
+import { setByPath as c } from "../../../x6-common/es/object/object.js";
+import { call as f } from "../../../x6-common/es/function/function.js";
+import { Platform as b } from "../../../x6-common/es/platform/index.js";
+import { ns as d } from "../../../x6-common/es/dom/elem.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 "../registry/grid/index.js";
+import "../registry/background/index.js";
+import "../registry/filter/index.js";
+import { Attr as g } from "../registry/attr/index.js";
+import "../registry/highlighter/index.js";
+import "../registry/port-layout/index.js";
+import "../registry/port-label-layout/index.js";
+import "../registry/tool/index.js";
+import "../registry/marker/index.js";
+import "../registry/node-anchor/index.js";
+import "../registry/edge-anchor/index.js";
+import "../registry/connection-point/index.js";
+import "../registry/router/index.js";
+import "../registry/connector/index.js";
+import "../registry/registry.js";
+import { Base as p } from "./base.js";
+var h = function(t, i) {
+  var e = {};
+  for (var r in t) Object.prototype.hasOwnProperty.call(t, r) && i.indexOf(r) < 0 && (e[r] = t[r]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var o = 0, r = Object.getOwnPropertySymbols(t); o < r.length; o++)
+      i.indexOf(r[o]) < 0 && Object.prototype.propertyIsEnumerable.call(t, r[o]) && (e[r[o]] = t[r[o]]);
+  return e;
+};
+p.define({
+  shape: "text-block",
+  markup: [
+    {
+      tagName: "rect",
+      selector: "body"
+    },
+    b.SUPPORT_FOREIGNOBJECT ? {
+      tagName: "foreignObject",
+      selector: "foreignObject",
+      children: [
+        {
+          tagName: "div",
+          ns: d.xhtml,
+          selector: "label",
+          style: {
+            width: "100%",
+            height: "100%",
+            position: "static",
+            backgroundColor: "transparent",
+            textAlign: "center",
+            margin: 0,
+            padding: "0px 5px",
+            boxSizing: "border-box",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center"
+          }
+        }
+      ]
+    } : {
+      tagName: "text",
+      selector: "label",
+      attrs: {
+        textAnchor: "middle"
+      }
+    }
+  ],
+  attrs: {
+    body: Object.assign(Object.assign({}, p.bodyAttr), { refWidth: "100%", refHeight: "100%" }),
+    foreignObject: {
+      refWidth: "100%",
+      refHeight: "100%"
+    },
+    label: {
+      style: {
+        fontSize: 14
+      }
+    }
+  },
+  propHooks(t) {
+    const { text: i } = t, e = h(t, ["text"]);
+    return i && c(e, "attrs/label/text", i), e;
+  },
+  attrHooks: {
+    text: {
+      set(t, { cell: i, view: e, refBBox: r, elem: o, attrs: m }) {
+        if (o instanceof HTMLElement)
+          o.textContent = t;
+        else {
+          const n = m.style || {}, a = { text: t, width: -5, height: "100%" }, l = Object.assign({ textVerticalAnchor: "middle" }, n), s = g.presets.textWrap;
+          return f(s.set, this, a, {
+            cell: i,
+            view: e,
+            elem: o,
+            refBBox: r,
+            attrs: l
+          }), { fill: n.color || null };
+        }
+      },
+      position(t, { refBBox: i, elem: e }) {
+        if (e instanceof SVGElement)
+          return i.getCenter();
+      }
+    }
+  }
+});

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

@@ -0,0 +1,72 @@
+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 "../../../x6-common/es/modifier/index.js";
+import "../../../x6-common/es/animation/timing.js";
+import "../../../x6-common/es/animation/interp.js";
+import { Base as p } from "./base.js";
+import f from "../../../../lodash-es/merge.js";
+var u = function(t, n) {
+  var o = {};
+  for (var r in t) Object.prototype.hasOwnProperty.call(t, r) && n.indexOf(r) < 0 && (o[r] = t[r]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var e = 0, r = Object.getOwnPropertySymbols(t); e < r.length; e++)
+      n.indexOf(r[e]) < 0 && Object.prototype.propertyIsEnumerable.call(t, r[e]) && (o[r[e]] = t[r[e]]);
+  return o;
+};
+function g(t, n = "body") {
+  return [
+    {
+      tagName: t,
+      selector: n
+    },
+    {
+      tagName: "text",
+      selector: "label"
+    }
+  ];
+}
+function A(t = "xlink:href") {
+  return (o) => {
+    const { imageUrl: r, imageWidth: e, imageHeight: a } = o, i = u(o, ["imageUrl", "imageWidth", "imageHeight"]);
+    if (r != null || e != null || a != null) {
+      const l = () => {
+        if (i.attrs) {
+          const m = i.attrs.image;
+          r != null && (m[t] = r), e != null && (m.width = e), a != null && (m.height = a), i.attrs.image = m;
+        }
+      };
+      i.attrs ? (i.attrs.image == null && (i.attrs.image = {}), l()) : (i.attrs = {
+        image: {}
+      }, l());
+    }
+    return i;
+  };
+}
+function B(t, n, o = {}) {
+  const r = {
+    constructorName: t,
+    markup: g(t, o.selector),
+    attrs: {
+      [t]: Object.assign({}, p.bodyAttr)
+    }
+  };
+  return (o.parent || p).define(f(r, n, { shape: t }));
+}
+export {
+  B as createShape,
+  A as getImageUrlHook,
+  g as getMarkup
+};

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

@@ -0,0 +1,163 @@
+const e = `.x6-graph {
+  position: relative;
+  overflow: hidden;
+  outline: none;
+  touch-action: none;
+}
+.x6-graph-background,
+.x6-graph-grid,
+.x6-graph-svg {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+}
+.x6-graph-background-stage,
+.x6-graph-grid-stage,
+.x6-graph-svg-stage {
+  user-select: none;
+}
+.x6-graph.x6-graph-pannable {
+  cursor: grab;
+  cursor: -moz-grab;
+  cursor: -webkit-grab;
+}
+.x6-graph.x6-graph-panning {
+  cursor: grabbing;
+  cursor: -moz-grabbing;
+  cursor: -webkit-grabbing;
+  user-select: none;
+}
+.x6-node {
+  cursor: move;
+  /* stylelint-disable-next-line */
+}
+.x6-node.x6-node-immovable {
+  cursor: default;
+}
+.x6-node * {
+  -webkit-user-drag: none;
+}
+.x6-node .scalable * {
+  vector-effect: non-scaling-stroke;
+}
+.x6-node [magnet='true'] {
+  cursor: crosshair;
+  transition: opacity 0.3s;
+}
+.x6-node [magnet='true']:hover {
+  opacity: 0.7;
+}
+.x6-node foreignObject {
+  display: block;
+  overflow: visible;
+  background-color: transparent;
+}
+.x6-node foreignObject > body {
+  position: static;
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  padding: 0;
+  overflow: visible;
+  background-color: transparent;
+}
+.x6-edge .source-marker,
+.x6-edge .target-marker {
+  vector-effect: non-scaling-stroke;
+}
+.x6-edge .connection {
+  stroke-linejoin: round;
+  fill: none;
+}
+.x6-edge .connection-wrap {
+  cursor: move;
+  opacity: 0;
+  fill: none;
+  stroke: #000;
+  stroke-width: 15;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+.x6-edge .connection-wrap:hover {
+  opacity: 0.4;
+  stroke-opacity: 0.4;
+}
+.x6-edge .vertices {
+  cursor: move;
+  opacity: 0;
+}
+.x6-edge .vertices .vertex {
+  fill: #1abc9c;
+}
+.x6-edge .vertices .vertex :hover {
+  fill: #34495e;
+  stroke: none;
+}
+.x6-edge .vertices .vertex-remove {
+  cursor: pointer;
+  fill: #fff;
+}
+.x6-edge .vertices .vertex-remove-area {
+  cursor: pointer;
+  opacity: 0.1;
+}
+.x6-edge .vertices .vertex-group:hover .vertex-remove-area {
+  opacity: 1;
+}
+.x6-edge .arrowheads {
+  cursor: move;
+  opacity: 0;
+}
+.x6-edge .arrowheads .arrowhead {
+  fill: #1abc9c;
+}
+.x6-edge .arrowheads .arrowhead :hover {
+  fill: #f39c12;
+  stroke: none;
+}
+.x6-edge .tools {
+  cursor: pointer;
+  opacity: 0;
+}
+.x6-edge .tools .tool-options {
+  display: none;
+}
+.x6-edge .tools .tool-remove circle {
+  fill: #f00;
+}
+.x6-edge .tools .tool-remove path {
+  fill: #fff;
+}
+.x6-edge:hover .vertices,
+.x6-edge:hover .arrowheads,
+.x6-edge:hover .tools {
+  opacity: 1;
+}
+.x6-highlight-opacity {
+  opacity: 0.3;
+}
+.x6-cell-tool-editor {
+  position: relative;
+  display: inline-block;
+  min-height: 1em;
+  margin: 0;
+  padding: 0;
+  line-height: 1;
+  white-space: normal;
+  text-align: center;
+  vertical-align: top;
+  overflow-wrap: normal;
+  outline: none;
+  transform-origin: 0 0;
+  -webkit-user-drag: none;
+}
+.x6-edge-tool-editor {
+  border: 1px solid #275fc5;
+  border-radius: 2px;
+}
+`;
+export {
+  e as content
+};

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

@@ -0,0 +1,231 @@
+import "../../../x6-geometry/es/angle.js";
+import { Point as b } from "../../../x6-geometry/es/point.js";
+import { Line as v } from "../../../x6-geometry/es/line.js";
+import { Ellipse as P } from "../../../x6-geometry/es/ellipse.js";
+import { Rectangle as u } from "../../../x6-geometry/es/rectangle.js";
+import { Path as S } from "../../../x6-geometry/es/path/path.js";
+import "../../../x6-geometry/es/util.js";
+import "../../../x6-geometry/es/curve.js";
+import { Polyline as g } from "../../../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 { createSvgElement as W, isSVGGraphicsElement as A, isHTMLElement as L } from "../../../x6-common/es/dom/elem.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import { hasClass as k } from "../../../x6-common/es/dom/class.js";
+import { getComputedStyle as N } from "../../../x6-common/es/dom/style.js";
+import "../../../x6-common/es/dom/prefix.js";
+import "../../../x6-common/es/vector/index.js";
+import { getPointsFromSvgElement as M } from "../../../x6-common/es/dom/path.js";
+import { createSVGPoint as D, createSVGTransform as y, matrixToTransformString as X } from "../../../x6-common/es/dom/matrix.js";
+import { getTransformToElement as T, scale as Y } 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 "../../../x6-common/es/modifier/index.js";
+import "../../../x6-common/es/animation/timing.js";
+import "../../../x6-common/es/animation/interp.js";
+import { normalize as j } from "../registry/marker/util.js";
+var O;
+(function(c) {
+  c.normalizeMarker = j;
+  function x(t, n) {
+    const r = D(t.x, t.y).matrixTransform(n);
+    return new b(r.x, r.y);
+  }
+  c.transformPoint = x;
+  function R(t, n) {
+    return new v(x(t.start, n), x(t.end, n));
+  }
+  c.transformLine = R;
+  function C(t, n) {
+    let r = t instanceof g ? t.points : t;
+    return Array.isArray(r) || (r = []), new g(r.map((o) => x(o, n)));
+  }
+  c.transformPolyline = C;
+  function d(t, n) {
+    const o = W("svg").createSVGPoint();
+    o.x = t.x, o.y = t.y;
+    const e = o.matrixTransform(n);
+    o.x = t.x + t.width, o.y = t.y;
+    const i = o.matrixTransform(n);
+    o.x = t.x + t.width, o.y = t.y + t.height;
+    const s = o.matrixTransform(n);
+    o.x = t.x, o.y = t.y + t.height;
+    const a = o.matrixTransform(n), f = Math.min(e.x, i.x, s.x, a.x), m = Math.max(e.x, i.x, s.x, a.x), p = Math.min(e.y, i.y, s.y, a.y), l = Math.max(e.y, i.y, s.y, a.y);
+    return new u(f, p, m - f, l - p);
+  }
+  c.transformRectangle = d;
+  function H(t, n, r) {
+    let o;
+    const e = t.ownerSVGElement;
+    if (!e)
+      return new u(0, 0, 0, 0);
+    try {
+      o = t.getBBox();
+    } catch {
+      o = {
+        x: t.clientLeft,
+        y: t.clientTop,
+        width: t.clientWidth,
+        height: t.clientHeight
+      };
+    }
+    if (n)
+      return u.create(o);
+    const i = T(t, r || e);
+    return d(o, i);
+  }
+  c.bbox = H;
+  function h(t, n = {}) {
+    let r;
+    if (!t.ownerSVGElement || !A(t)) {
+      if (L(t)) {
+        const { left: s, top: a, width: f, height: m } = w(t);
+        return new u(s, a, f, m);
+      }
+      return new u(0, 0, 0, 0);
+    }
+    let e = n.target;
+    if (!n.recursive) {
+      try {
+        r = t.getBBox();
+      } catch {
+        r = {
+          x: t.clientLeft,
+          y: t.clientTop,
+          width: t.clientWidth,
+          height: t.clientHeight
+        };
+      }
+      if (!e)
+        return u.create(r);
+      const s = T(t, e);
+      return d(r, s);
+    }
+    {
+      const s = t.childNodes, a = s.length;
+      if (a === 0)
+        return h(t, {
+          target: e
+        });
+      e || (e = t);
+      for (let f = 0; f < a; f += 1) {
+        const m = s[f];
+        let p;
+        m.childNodes.length === 0 ? p = h(m, {
+          target: e
+        }) : p = h(m, {
+          target: e,
+          recursive: !0
+        }), r ? r = r.union(p) : r = p;
+      }
+      return r;
+    }
+  }
+  c.getBBox = h;
+  function w(t) {
+    let n = 0, r = 0, o = 0, e = 0;
+    if (t) {
+      let i = t;
+      for (; i; )
+        n += i.offsetLeft, r += i.offsetTop, i = i.offsetParent, i && (n += parseInt(N(i, "borderLeft"), 10), r += parseInt(N(i, "borderTop"), 10));
+      o = t.offsetWidth, e = t.offsetHeight;
+    }
+    return {
+      left: n,
+      top: r,
+      width: o,
+      height: e
+    };
+  }
+  c.getBoundingOffsetRect = w;
+  function B(t) {
+    const n = (r) => {
+      const o = t.getAttribute(r), e = o ? parseFloat(o) : 0;
+      return Number.isNaN(e) ? 0 : e;
+    };
+    switch (t instanceof SVGElement && t.nodeName.toLowerCase()) {
+      case "rect":
+        return new u(n("x"), n("y"), n("width"), n("height"));
+      case "circle":
+        return new P(n("cx"), n("cy"), n("r"), n("r"));
+      case "ellipse":
+        return new P(n("cx"), n("cy"), n("rx"), n("ry"));
+      case "polyline": {
+        const r = M(t);
+        return new g(r);
+      }
+      case "polygon": {
+        const r = M(t);
+        return r.length > 1 && r.push(r[0]), new g(r);
+      }
+      case "path": {
+        let r = t.getAttribute("d");
+        return S.isValid(r) || (r = S.normalize(r)), S.parse(r);
+      }
+      case "line":
+        return new v(n("x1"), n("y1"), n("x2"), n("y2"));
+    }
+    return h(t);
+  }
+  c.toGeometryShape = B;
+  function z(t, n, r, o) {
+    const e = b.create(n), i = b.create(r);
+    o || (o = t instanceof SVGSVGElement ? t : t.ownerSVGElement);
+    const s = Y(t);
+    t.setAttribute("transform", "");
+    const a = h(t, {
+      target: o
+    }).scale(s.sx, s.sy), f = y();
+    f.setTranslate(-a.x - a.width / 2, -a.y - a.height / 2);
+    const m = y(), p = e.angleBetween(i, e.clone().translate(1, 0));
+    p && m.setRotate(p, 0, 0);
+    const l = y(), G = e.clone().move(i, a.width / 2);
+    l.setTranslate(2 * e.x - G.x, 2 * e.y - G.y);
+    const I = T(t, o), V = y();
+    V.setMatrix(l.matrix.multiply(m.matrix.multiply(f.matrix.multiply(I.scale(s.sx, s.sy))))), t.setAttribute("transform", X(V.matrix));
+  }
+  c.translateAndAutoOrient = z;
+  function E(t) {
+    if (t == null)
+      return null;
+    let n = t;
+    do {
+      let r = n.tagName;
+      if (typeof r != "string")
+        return null;
+      if (r = r.toUpperCase(), k(n, "x6-port"))
+        n = n.nextElementSibling;
+      else if (r === "G")
+        n = n.firstElementChild;
+      else if (r === "TITLE")
+        n = n.nextElementSibling;
+      else
+        break;
+    } while (n);
+    return n;
+  }
+  c.findShapeNode = E;
+  function F(t) {
+    const n = E(t);
+    if (!A(n)) {
+      if (L(t)) {
+        const { left: e, top: i, width: s, height: a } = w(t);
+        return new u(e, i, s, a);
+      }
+      return new u(0, 0, 0, 0);
+    }
+    return B(n).bbox() || u.create();
+  }
+  c.getBBoxV2 = F;
+})(O || (O = {}));
+export {
+  O as Util
+};