@qy_better_lib/hooks 0.0.15 → 0.1.1

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

@@ -0,0 +1,45 @@
+class c {
+  get cell() {
+    return this.view.cell;
+  }
+  constructor(t, r, i = []) {
+    this.view = t;
+    const e = {}, f = {};
+    let s = 0;
+    Object.keys(r).forEach((a) => {
+      let g = r[a];
+      Array.isArray(g) || (g = [g]), g.forEach((n) => {
+        let l = e[n];
+        l || (s += 1, l = e[n] = 1 << s), f[a] |= l;
+      });
+    });
+    let h = i;
+    if (Array.isArray(h) || (h = [h]), h.forEach((a) => {
+      e[a] || (s += 1, e[a] = 1 << s);
+    }), s > 25)
+      throw new Error("Maximum number of flags exceeded.");
+    this.flags = e, this.attrs = f, this.bootstrap = i;
+  }
+  getFlag(t) {
+    const r = this.flags;
+    return r == null ? 0 : Array.isArray(t) ? t.reduce((i, e) => i | r[e], 0) : r[t] | 0;
+  }
+  hasAction(t, r) {
+    return t & this.getFlag(r);
+  }
+  removeAction(t, r) {
+    return t ^ t & this.getFlag(r);
+  }
+  getBootstrapFlag() {
+    return this.getFlag(this.bootstrap);
+  }
+  getChangedFlag() {
+    let t = 0;
+    return this.attrs && Object.keys(this.attrs).forEach((r) => {
+      this.cell.hasChanged(r) && (t |= this.attrs[r]);
+    }), t;
+  }
+}
+export {
+  c as FlagManager
+};

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

@@ -0,0 +1,231 @@
+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 { attr as j, kebablizeAttrs as v } from "../../../x6-common/es/dom/attr.js";
+import "../../../x6-common/es/datauri/index.js";
+import "../../../x6-common/es/unit/index.js";
+import { ns as C, createElementNS as J, createElement as O, index as V, createSvgElement as z } from "../../../x6-common/es/dom/elem.js";
+import "../../../x6-common/es/dom/prefix.js";
+import { css as D } from "../../../x6-common/es/dom/css.js";
+import { Vector as $ } from "../../../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 q from "../../../../lodash-es/cloneDeep.js";
+var u;
+(function(e) {
+  function i(t) {
+    return t != null && !r(t);
+  }
+  e.isJSONMarkup = i;
+  function r(t) {
+    return t != null && typeof t == "string";
+  }
+  e.isStringMarkup = r;
+  function d(t) {
+    return t == null || r(t) ? t : q(t);
+  }
+  e.clone = d;
+  function f(t) {
+    return `${t}`.trim().replace(/[\r|\n]/g, " ").replace(/>\s+</g, "><");
+  }
+  e.sanitize = f;
+  function c(t, h = { ns: C.svg }) {
+    const a = document.createDocumentFragment(), n = {}, o = {}, p = [
+      {
+        markup: Array.isArray(t) ? t : [t],
+        parent: a,
+        ns: h.ns
+      }
+    ];
+    for (; p.length > 0; ) {
+      const l = p.pop();
+      let N = l.ns || C.svg;
+      const L = l.markup, P = l.parent;
+      L.forEach((s) => {
+        const k = s.tagName;
+        if (!k)
+          throw new TypeError("Invalid tagName");
+        s.ns && (N = s.ns);
+        const g = N ? J(k, N) : O(k), A = s.attrs;
+        A && j(g, v(A));
+        const x = s.style;
+        x && D(g, x);
+        const S = s.className;
+        S != null && g.setAttribute("class", Array.isArray(S) ? S.join(" ") : S), s.textContent && (g.textContent = s.textContent);
+        const M = s.selector;
+        if (M != null) {
+          if (o[M])
+            throw new TypeError("Selector must be unique");
+          o[M] = g;
+        }
+        if (s.groupSelector) {
+          let b = s.groupSelector;
+          Array.isArray(b) || (b = [b]), b.forEach((w) => {
+            n[w] || (n[w] = []), n[w].push(g);
+          });
+        }
+        P.appendChild(g);
+        const F = s.children;
+        Array.isArray(F) && p.push({ ns: N, markup: F, parent: g });
+      });
+    }
+    return Object.keys(n).forEach((l) => {
+      if (o[l])
+        throw new Error("Ambiguous group selector");
+      o[l] = n[l];
+    }), { fragment: a, selectors: o, groups: n };
+  }
+  e.parseJSONMarkup = c;
+  function m(t) {
+    return t instanceof SVGElement ? z("g") : O("div");
+  }
+  function y(t) {
+    if (r(t)) {
+      const o = $.createVectors(t), p = o.length;
+      if (p === 1)
+        return {
+          elem: o[0].node
+        };
+      if (p > 1) {
+        const l = m(o[0].node);
+        return o.forEach((N) => {
+          l.appendChild(N.node);
+        }), { elem: l };
+      }
+      return {};
+    }
+    const h = c(t), a = h.fragment;
+    let n = null;
+    return a.childNodes.length > 1 ? (n = m(a.firstChild), n.appendChild(a)) : n = a.firstChild, { elem: n, selectors: h.selectors };
+  }
+  e.renderMarkup = y;
+  function E(t) {
+    const h = $.createVectors(t), a = document.createDocumentFragment();
+    for (let n = 0, o = h.length; n < o; n += 1) {
+      const p = h[n].node;
+      a.appendChild(p);
+    }
+    return { fragment: a, selectors: {} };
+  }
+  e.parseLabelStringMarkup = E;
+})(u || (u = {}));
+(function(e) {
+  function i(r, d, f) {
+    if (r != null) {
+      let c;
+      const m = r.tagName.toLowerCase();
+      if (r === d)
+        return typeof f == "string" ? c = `> ${m} > ${f}` : c = `> ${m}`, c;
+      const y = r.parentNode;
+      if (y && y.childNodes.length > 1) {
+        const E = V(r) + 1;
+        c = `${m}:nth-child(${E})`;
+      } else
+        c = m;
+      return f && (c += ` > ${f}`), i(r.parentNode, d, c);
+    }
+    return f;
+  }
+  e.getSelector = i;
+})(u || (u = {}));
+(function(e) {
+  function i() {
+    return "g";
+  }
+  e.getPortContainerMarkup = i;
+  function r() {
+    return {
+      tagName: "circle",
+      selector: "circle",
+      attrs: {
+        r: 10,
+        fill: "#FFFFFF",
+        stroke: "#000000"
+      }
+    };
+  }
+  e.getPortMarkup = r;
+  function d() {
+    return {
+      tagName: "text",
+      selector: "text",
+      attrs: {
+        fill: "#000000"
+      }
+    };
+  }
+  e.getPortLabelMarkup = d;
+})(u || (u = {}));
+(function(e) {
+  function i() {
+    return [
+      {
+        tagName: "path",
+        selector: "wrap",
+        groupSelector: "lines",
+        attrs: {
+          fill: "none",
+          cursor: "pointer",
+          stroke: "transparent",
+          strokeLinecap: "round"
+        }
+      },
+      {
+        tagName: "path",
+        selector: "line",
+        groupSelector: "lines",
+        attrs: {
+          fill: "none",
+          pointerEvents: "none"
+        }
+      }
+    ];
+  }
+  e.getEdgeMarkup = i;
+})(u || (u = {}));
+(function(e) {
+  function i(r = !1) {
+    return {
+      tagName: "foreignObject",
+      selector: "fo",
+      children: [
+        {
+          ns: C.xhtml,
+          tagName: "body",
+          selector: "foBody",
+          attrs: {
+            xmlns: C.xhtml
+          },
+          style: {
+            width: "100%",
+            height: "100%",
+            background: "transparent"
+          },
+          children: r ? [] : [
+            {
+              tagName: "div",
+              selector: "foContent",
+              style: {
+                width: "100%",
+                height: "100%"
+              }
+            }
+          ]
+        }
+      ]
+    };
+  }
+  e.getForeignObjectMarkup = i;
+})(u || (u = {}));
+export {
+  u as Markup
+};