@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/position/bk.js

@@ -0,0 +1,201 @@
+import { DagreGraph as I } from "../graph.js";
+import { minBy as M } from "../util.js";
+const k = (e, d) => {
+  const c = {}, i = (r, a) => {
+    let s = 0, n = 0;
+    const t = r.length, o = a == null ? void 0 : a[(a == null ? void 0 : a.length) - 1];
+    return a == null || a.forEach((u, f) => {
+      var h;
+      const v = O(e, u), l = v ? e.getNode(v.id).data.order : t;
+      (v || u === o) && ((h = a.slice(n, f + 1)) === null || h === void 0 || h.forEach((b) => {
+        var m;
+        (m = e.getPredecessors(b)) === null || m === void 0 || m.forEach((g) => {
+          var N;
+          const p = e.getNode(g.id), w = p.data.order;
+          (w < s || l < w) && !(p.data.dummy && (!((N = e.getNode(b)) === null || N === void 0) && N.data.dummy)) && E(c, g.id, b);
+        });
+      }), n = f + 1, s = l);
+    }), a;
+  };
+  return d != null && d.length && d.reduce(i), c;
+}, C = (e, d) => {
+  const c = {};
+  function i(n, t, o, u, f) {
+    var h, v;
+    let l;
+    for (let b = t; b < o; b++)
+      l = n[b], !((h = e.getNode(l)) === null || h === void 0) && h.data.dummy && ((v = e.getPredecessors(l)) === null || v === void 0 || v.forEach((m) => {
+        const g = e.getNode(m.id);
+        g.data.dummy && (g.data.order < u || g.data.order > f) && E(c, m.id, l);
+      }));
+  }
+  function r(n) {
+    return JSON.stringify(n.slice(1));
+  }
+  function a(n, t) {
+    const o = r(n);
+    t.get(o) || (i(...n), t.set(o, !0));
+  }
+  const s = (n, t) => {
+    let o = -1, u, f = 0;
+    const h = /* @__PURE__ */ new Map();
+    return t == null || t.forEach((v, l) => {
+      var b;
+      if (((b = e.getNode(v)) === null || b === void 0 ? void 0 : b.data.dummy) === "border") {
+        const m = e.getPredecessors(v) || [];
+        m.length && (u = e.getNode(m[0].id).data.order, a([t, f, l, o, u], h), f = l, o = u);
+      }
+      a([t, f, t.length, u, n.length], h);
+    }), t;
+  };
+  return d != null && d.length && d.reduce(s), c;
+}, O = (e, d) => {
+  var c, i;
+  if (!((c = e.getNode(d)) === null || c === void 0) && c.data.dummy)
+    return (i = e.getPredecessors(d)) === null || i === void 0 ? void 0 : i.find((r) => e.getNode(r.id).data.dummy);
+}, E = (e, d, c) => {
+  let i = d, r = c;
+  if (i > r) {
+    const s = i;
+    i = r, r = s;
+  }
+  let a = e[i];
+  a || (e[i] = a = {}), a[r] = !0;
+}, P = (e, d, c) => {
+  let i = d, r = c;
+  if (i > r) {
+    const a = d;
+    i = r, r = a;
+  }
+  return !!e[i];
+}, V = (e, d, c, i) => {
+  const r = {}, a = {}, s = {};
+  return d == null || d.forEach((n) => {
+    n == null || n.forEach((t, o) => {
+      r[t] = t, a[t] = t, s[t] = o;
+    });
+  }), d == null || d.forEach((n) => {
+    let t = -1;
+    n == null || n.forEach((o) => {
+      let u = i(o).map((f) => f.id);
+      if (u.length) {
+        u = u.sort((h, v) => s[h] - s[v]);
+        const f = (u.length - 1) / 2;
+        for (let h = Math.floor(f), v = Math.ceil(f); h <= v; ++h) {
+          const l = u[h];
+          a[o] === o && t < s[l] && !P(c, o, l) && (a[l] = o, a[o] = r[o] = r[l], t = s[l]);
+        }
+      }
+    });
+  }), { root: r, align: a };
+}, R = (e, d, c, i, r, a, s) => {
+  var n;
+  const t = {}, o = T(e, d, c, r, a, s), u = s ? "borderLeft" : "borderRight", f = (l, b) => {
+    let m = o.getAllNodes(), g = m.pop();
+    const N = {};
+    for (; g; )
+      N[g.id] ? l(g.id) : (N[g.id] = !0, m.push(g), m = m.concat(b(g.id))), g = m.pop();
+  }, h = (l) => {
+    t[l] = (o.getRelatedEdges(l, "in") || []).reduce((b, m) => Math.max(b, (t[m.source] || 0) + m.data.weight), 0);
+  }, v = (l) => {
+    const b = (o.getRelatedEdges(l, "out") || []).reduce((g, N) => Math.min(g, (t[N.target] || 0) - N.data.weight), Number.POSITIVE_INFINITY), m = e.getNode(l);
+    b !== Number.POSITIVE_INFINITY && m.data.borderType !== u && (t[l] = Math.max(t[l], b));
+  };
+  return f(h, o.getPredecessors.bind(o)), f(v, o.getSuccessors.bind(o)), (n = Object.values(i)) === null || n === void 0 || n.forEach((l) => {
+    t[l] = t[c[l]];
+  }), t;
+}, T = (e, d, c, i, r, a) => {
+  const s = new I(), n = _(i, r, a);
+  return d == null || d.forEach((t) => {
+    let o;
+    t == null || t.forEach((u) => {
+      const f = c[u];
+      if (s.hasNode(f) || s.addNode({
+        id: f,
+        data: {}
+      }), o) {
+        const h = c[o], v = s.getRelatedEdges(h, "out").find((l) => l.target === f);
+        v ? s.updateEdgeData(v.id, Object.assign(Object.assign({}, v.data), { weight: Math.max(n(e, u, o), v.data.weight || 0) })) : s.addEdge({
+          id: `e${Math.random()}`,
+          source: h,
+          target: f,
+          data: {
+            weight: Math.max(n(e, u, o), 0)
+          }
+        });
+      }
+      o = u;
+    });
+  }), s;
+}, F = (e, d) => M(Object.values(d), (c) => {
+  var i;
+  let r = Number.NEGATIVE_INFINITY, a = Number.POSITIVE_INFINITY;
+  return (i = Object.keys(c)) === null || i === void 0 || i.forEach((s) => {
+    const n = c[s], t = x(e, s) / 2;
+    r = Math.max(n + t, r), a = Math.min(n - t, a);
+  }), r - a;
+});
+function G(e, d) {
+  const c = Object.values(d), i = Math.min(...c), r = Math.max(...c);
+  ["u", "d"].forEach((a) => {
+    ["l", "r"].forEach((s) => {
+      const n = a + s, t = e[n];
+      let o;
+      if (t === d)
+        return;
+      const u = Object.values(t);
+      o = s === "l" ? i - Math.min(...u) : r - Math.max(...u), o && (e[n] = {}, Object.keys(t).forEach((f) => {
+        e[n][f] = t[f] + o;
+      }));
+    });
+  });
+}
+const A = (e, d) => {
+  const c = {};
+  return Object.keys(e.ul).forEach((i) => {
+    if (d)
+      c[i] = e[d.toLowerCase()][i];
+    else {
+      const r = Object.values(e).map((a) => a[i]);
+      c[i] = (r[0] + r[1]) / 2;
+    }
+  }), c;
+}, _ = (e, d, c) => (i, r, a) => {
+  const s = i.getNode(r), n = i.getNode(a);
+  let t = 0, o = 0;
+  if (t += s.data.width / 2, s.data.hasOwnProperty("labelpos"))
+    switch ((s.data.labelpos || "").toLowerCase()) {
+      case "l":
+        o = -s.data.width / 2;
+        break;
+      case "r":
+        o = s.data.width / 2;
+        break;
+    }
+  if (o && (t += c ? o : -o), o = 0, t += (s.data.dummy ? d : e) / 2, t += (n.data.dummy ? d : e) / 2, t += n.data.width / 2, n.data.labelpos)
+    switch ((n.data.labelpos || "").toLowerCase()) {
+      case "l":
+        o = n.data.width / 2;
+        break;
+      case "r":
+        o = -n.data.width / 2;
+        break;
+    }
+  return o && (t += c ? o : -o), o = 0, t;
+}, x = (e, d) => e.getNode(d).data.width || 0;
+export {
+  E as addConflict,
+  G as alignCoordinates,
+  A as balance,
+  T as buildBlockGraph,
+  O as findOtherInnerSegmentNode,
+  F as findSmallestWidthAlignment,
+  k as findType1Conflicts,
+  C as findType2Conflicts,
+  P as hasConflict,
+  R as horizontalCompaction,
+  _ as sep,
+  V as verticalAlignment,
+  x as width
+};
+//# sourceMappingURL=bk.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/position/bk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bk.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/position/bk.js"],"sourcesContent":["import { DagreGraph } from '../graph.js';\nimport { minBy } from '../util.js';\n\nconst findType1Conflicts = (g, layering) => {\n    const conflicts = {};\n    const visitLayer = (prevLayer, layer) => {\n        // last visited node in the previous layer that is incident on an inner\n        // segment.\n        let k0 = 0;\n        // Tracks the last node in this layer scanned for crossings with a type-1\n        // segment.\n        let scanPos = 0;\n        const prevLayerLength = prevLayer.length;\n        const lastNode = layer === null || layer === void 0 ? void 0 : layer[(layer === null || layer === void 0 ? void 0 : layer.length) - 1];\n        layer === null || layer === void 0 ? void 0 : layer.forEach((v, i) => {\n            var _a;\n            const w = findOtherInnerSegmentNode(g, v);\n            const k1 = w ? g.getNode(w.id).data.order : prevLayerLength;\n            if (w || v === lastNode) {\n                (_a = layer.slice(scanPos, i + 1)) === null || _a === void 0 ? void 0 : _a.forEach((scanNode) => {\n                    var _a;\n                    (_a = g.getPredecessors(scanNode)) === null || _a === void 0 ? void 0 : _a.forEach((u) => {\n                        var _a;\n                        const uLabel = g.getNode(u.id);\n                        const uPos = uLabel.data.order;\n                        if ((uPos < k0 || k1 < uPos) &&\n                            !(uLabel.data.dummy && ((_a = g.getNode(scanNode)) === null || _a === void 0 ? void 0 : _a.data.dummy))) {\n                            addConflict(conflicts, u.id, scanNode);\n                        }\n                    });\n                });\n                scanPos = i + 1;\n                k0 = k1;\n            }\n        });\n        return layer;\n    };\n    if (layering === null || layering === void 0 ? void 0 : layering.length) {\n        layering.reduce(visitLayer);\n    }\n    return conflicts;\n};\nconst findType2Conflicts = (g, layering) => {\n    const conflicts = {};\n    function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {\n        var _a, _b;\n        let v;\n        for (let i = southPos; i < southEnd; i++) {\n            v = south[i];\n            if ((_a = g.getNode(v)) === null || _a === void 0 ? void 0 : _a.data.dummy) {\n                (_b = g.getPredecessors(v)) === null || _b === void 0 ? void 0 : _b.forEach((u) => {\n                    const uNode = g.getNode(u.id);\n                    if (uNode.data.dummy &&\n                        (uNode.data.order < prevNorthBorder ||\n                            uNode.data.order > nextNorthBorder)) {\n                        addConflict(conflicts, u.id, v);\n                    }\n                });\n            }\n        }\n    }\n    function getScannedKey(params) {\n        // south数组可能很大，不适合做key\n        return JSON.stringify(params.slice(1));\n    }\n    function scanIfNeeded(params, scanCache) {\n        const cacheKey = getScannedKey(params);\n        if (scanCache.get(cacheKey))\n            return;\n        scan(...params);\n        scanCache.set(cacheKey, true);\n    }\n    const visitLayer = (north, south) => {\n        let prevNorthPos = -1;\n        let nextNorthPos;\n        let southPos = 0;\n        const scanned = new Map();\n        south === null || south === void 0 ? void 0 : south.forEach((v, southLookahead) => {\n            var _a;\n            if (((_a = g.getNode(v)) === null || _a === void 0 ? void 0 : _a.data.dummy) === 'border') {\n                const predecessors = g.getPredecessors(v) || [];\n                if (predecessors.length) {\n                    nextNorthPos = g.getNode(predecessors[0].id).data.order;\n                    scanIfNeeded([south, southPos, southLookahead, prevNorthPos, nextNorthPos], scanned);\n                    southPos = southLookahead;\n                    prevNorthPos = nextNorthPos;\n                }\n            }\n            scanIfNeeded([south, southPos, south.length, nextNorthPos, north.length], scanned);\n        });\n        return south;\n    };\n    if (layering === null || layering === void 0 ? void 0 : layering.length) {\n        layering.reduce(visitLayer);\n    }\n    return conflicts;\n};\nconst findOtherInnerSegmentNode = (g, v) => {\n    var _a, _b;\n    if ((_a = g.getNode(v)) === null || _a === void 0 ? void 0 : _a.data.dummy) {\n        return (_b = g.getPredecessors(v)) === null || _b === void 0 ? void 0 : _b.find((u) => g.getNode(u.id).data.dummy);\n    }\n};\nconst addConflict = (conflicts, v, w) => {\n    let vv = v;\n    let ww = w;\n    if (vv > ww) {\n        const tmp = vv;\n        vv = ww;\n        ww = tmp;\n    }\n    let conflictsV = conflicts[vv];\n    if (!conflictsV) {\n        conflicts[vv] = conflictsV = {};\n    }\n    conflictsV[ww] = true;\n};\nconst hasConflict = (conflicts, v, w) => {\n    let vv = v;\n    let ww = w;\n    if (vv > ww) {\n        const tmp = v;\n        vv = ww;\n        ww = tmp;\n    }\n    return !!conflicts[vv];\n};\n/*\n * Try to align nodes into vertical \"blocks\" where possible. This algorithm\n * attempts to align a node with one of its median neighbors. If the edge\n * connecting a neighbor is a type-1 conflict then we ignore that possibility.\n * If a previous node has already formed a block with a node after the node\n * we're trying to form a block with, we also ignore that possibility - our\n * blocks would be split in that scenario.\n */\nconst verticalAlignment = (g, layering, conflicts, neighborFn) => {\n    const root = {};\n    const align = {};\n    const pos = {};\n    // We cache the position here based on the layering because the graph and\n    // layering may be out of sync. The layering matrix is manipulated to\n    // generate different extreme alignments.\n    layering === null || layering === void 0 ? void 0 : layering.forEach((layer) => {\n        layer === null || layer === void 0 ? void 0 : layer.forEach((v, order) => {\n            root[v] = v;\n            align[v] = v;\n            pos[v] = order;\n        });\n    });\n    layering === null || layering === void 0 ? void 0 : layering.forEach((layer) => {\n        let prevIdx = -1;\n        layer === null || layer === void 0 ? void 0 : layer.forEach((v) => {\n            let ws = neighborFn(v).map((n) => n.id);\n            if (ws.length) {\n                ws = ws.sort((a, b) => pos[a] - pos[b]);\n                const mp = (ws.length - 1) / 2;\n                for (let i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {\n                    const w = ws[i];\n                    if (align[v] === v &&\n                        prevIdx < pos[w] &&\n                        !hasConflict(conflicts, v, w)) {\n                        align[w] = v;\n                        align[v] = root[v] = root[w];\n                        prevIdx = pos[w];\n                    }\n                }\n            }\n        });\n    });\n    return { root, align };\n};\nconst horizontalCompaction = (g, layering, root, align, nodesep, edgesep, reverseSep) => {\n    var _a;\n    // This portion of the algorithm differs from BK due to a number of problems.\n    // Instead of their algorithm we construct a new block graph and do two\n    // sweeps. The first sweep places blocks with the smallest possible\n    // coordinates. The second sweep removes unused space by moving blocks to the\n    // greatest coordinates without violating separation.\n    const xs = {};\n    const blockG = buildBlockGraph(g, layering, root, nodesep, edgesep, reverseSep);\n    const borderType = reverseSep ? 'borderLeft' : 'borderRight';\n    const iterate = (setXsFunc, nextNodesFunc) => {\n        let stack = blockG.getAllNodes();\n        let elem = stack.pop();\n        const visited = {};\n        while (elem) {\n            if (visited[elem.id]) {\n                setXsFunc(elem.id);\n            }\n            else {\n                visited[elem.id] = true;\n                stack.push(elem);\n                stack = stack.concat(nextNodesFunc(elem.id));\n            }\n            elem = stack.pop();\n        }\n    };\n    // First pass, assign smallest coordinates\n    const pass1 = (elem) => {\n        xs[elem] = (blockG.getRelatedEdges(elem, 'in') || []).reduce((acc, e) => {\n            return Math.max(acc, (xs[e.source] || 0) + e.data.weight);\n        }, 0);\n    };\n    // Second pass, assign greatest coordinates\n    const pass2 = (elem) => {\n        const min = (blockG.getRelatedEdges(elem, 'out') || []).reduce((acc, e) => {\n            return Math.min(acc, (xs[e.target] || 0) - e.data.weight);\n        }, Number.POSITIVE_INFINITY);\n        const node = g.getNode(elem);\n        if (min !== Number.POSITIVE_INFINITY &&\n            node.data.borderType !== borderType) {\n            xs[elem] = Math.max(xs[elem], min);\n        }\n    };\n    iterate(pass1, blockG.getPredecessors.bind(blockG));\n    iterate(pass2, blockG.getSuccessors.bind(blockG));\n    // Assign x coordinates to all nodes\n    (_a = Object.values(align)) === null || _a === void 0 ? void 0 : _a.forEach((v) => {\n        xs[v] = xs[root[v]];\n    });\n    return xs;\n};\nconst buildBlockGraph = (g, layering, root, nodesep, edgesep, reverseSep) => {\n    const blockGraph = new DagreGraph();\n    const sepFn = sep(nodesep, edgesep, reverseSep);\n    layering === null || layering === void 0 ? void 0 : layering.forEach((layer) => {\n        let u;\n        layer === null || layer === void 0 ? void 0 : layer.forEach((v) => {\n            const vRoot = root[v];\n            if (!blockGraph.hasNode(vRoot)) {\n                blockGraph.addNode({\n                    id: vRoot,\n                    data: {},\n                });\n            }\n            if (u) {\n                const uRoot = root[u];\n                const edge = blockGraph\n                    .getRelatedEdges(uRoot, 'out')\n                    .find((edge) => edge.target === vRoot);\n                if (!edge) {\n                    blockGraph.addEdge({\n                        id: `e${Math.random()}`,\n                        source: uRoot,\n                        target: vRoot,\n                        data: {\n                            weight: Math.max(sepFn(g, v, u), 0),\n                        },\n                    });\n                }\n                else {\n                    blockGraph.updateEdgeData(edge.id, Object.assign(Object.assign({}, edge.data), { weight: Math.max(sepFn(g, v, u), edge.data.weight || 0) }));\n                }\n            }\n            u = v;\n        });\n    });\n    return blockGraph;\n};\n/*\n * Returns the alignment that has the smallest width of the given alignments.\n */\nconst findSmallestWidthAlignment = (g, xss) => {\n    return minBy(Object.values(xss), (xs) => {\n        var _a;\n        let max = Number.NEGATIVE_INFINITY;\n        let min = Number.POSITIVE_INFINITY;\n        (_a = Object.keys(xs)) === null || _a === void 0 ? void 0 : _a.forEach((v) => {\n            const x = xs[v];\n            const halfWidth = width(g, v) / 2;\n            max = Math.max(x + halfWidth, max);\n            min = Math.min(x - halfWidth, min);\n        });\n        return max - min;\n    });\n};\n/*\n * Align the coordinates of each of the layout alignments such that\n * left-biased alignments have their minimum coordinate at the same point as\n * the minimum coordinate of the smallest width alignment and right-biased\n * alignments have their maximum coordinate at the same point as the maximum\n * coordinate of the smallest width alignment.\n */\nfunction alignCoordinates(xss, alignTo) {\n    const alignToVals = Object.values(alignTo);\n    const alignToMin = Math.min(...alignToVals);\n    const alignToMax = Math.max(...alignToVals);\n    ['u', 'd'].forEach((vert) => {\n        ['l', 'r'].forEach((horiz) => {\n            const alignment = vert + horiz;\n            const xs = xss[alignment];\n            let delta;\n            if (xs === alignTo)\n                return;\n            const xsVals = Object.values(xs);\n            delta =\n                horiz === 'l'\n                    ? alignToMin - Math.min(...xsVals)\n                    : alignToMax - Math.max(...xsVals);\n            if (delta) {\n                xss[alignment] = {};\n                Object.keys(xs).forEach((key) => {\n                    xss[alignment][key] = xs[key] + delta;\n                });\n            }\n        });\n    });\n}\nconst balance = (xss, align) => {\n    const result = {};\n    Object.keys(xss.ul).forEach((key) => {\n        if (align) {\n            result[key] = xss[align.toLowerCase()][key];\n        }\n        else {\n            const values = Object.values(xss).map((x) => x[key]);\n            result[key] = (values[0] + values[1]) / 2; // (ur + ul) / 2\n        }\n    });\n    return result;\n};\nconst sep = (nodeSep, edgeSep, reverseSep) => {\n    return (g, v, w) => {\n        const vLabel = g.getNode(v);\n        const wLabel = g.getNode(w);\n        let sum = 0;\n        let delta = 0;\n        sum += vLabel.data.width / 2;\n        if (vLabel.data.hasOwnProperty('labelpos')) {\n            switch ((vLabel.data.labelpos || '').toLowerCase()) {\n                case 'l':\n                    delta = -vLabel.data.width / 2;\n                    break;\n                case 'r':\n                    delta = vLabel.data.width / 2;\n                    break;\n            }\n        }\n        if (delta) {\n            sum += reverseSep ? delta : -delta;\n        }\n        delta = 0;\n        sum += (vLabel.data.dummy ? edgeSep : nodeSep) / 2;\n        sum += (wLabel.data.dummy ? edgeSep : nodeSep) / 2;\n        sum += wLabel.data.width / 2;\n        if (wLabel.data.labelpos) {\n            switch ((wLabel.data.labelpos || '').toLowerCase()) {\n                case 'l':\n                    delta = wLabel.data.width / 2;\n                    break;\n                case 'r':\n                    delta = -wLabel.data.width / 2;\n                    break;\n            }\n        }\n        if (delta) {\n            sum += reverseSep ? delta : -delta;\n        }\n        delta = 0;\n        return sum;\n    };\n};\nconst width = (g, v) => g.getNode(v).data.width || 0;\n\nexport { addConflict, alignCoordinates, balance, buildBlockGraph, findOtherInnerSegmentNode, findSmallestWidthAlignment, findType1Conflicts, findType2Conflicts, hasConflict, horizontalCompaction, sep, verticalAlignment, width };\n//# sourceMappingURL=bk.js.map\n"],"names":["findType1Conflicts","g","layering","conflicts","visitLayer","prevLayer","layer","k0","scanPos","prevLayerLength","lastNode","v","i","_a","w","findOtherInnerSegmentNode","k1","scanNode","u","uLabel","uPos","addConflict","findType2Conflicts","scan","south","southPos","southEnd","prevNorthBorder","nextNorthBorder","_b","uNode","getScannedKey","params","scanIfNeeded","scanCache","cacheKey","north","prevNorthPos","nextNorthPos","scanned","southLookahead","predecessors","vv","ww","tmp","conflictsV","hasConflict","verticalAlignment","neighborFn","root","align","pos","order","prevIdx","ws","n","a","b","mp","il","horizontalCompaction","nodesep","edgesep","reverseSep","xs","blockG","buildBlockGraph","borderType","iterate","setXsFunc","nextNodesFunc","stack","elem","visited","pass1","acc","e","pass2","min","node","blockGraph","DagreGraph","sepFn","sep","vRoot","uRoot","edge","findSmallestWidthAlignment","xss","minBy","max","x","halfWidth","width","alignCoordinates","alignTo","alignToVals","alignToMin","alignToMax","vert","horiz","alignment","delta","xsVals","key","balance","result","values","nodeSep","edgeSep","vLabel","wLabel","sum"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/position/index.js

@@ -0,0 +1,36 @@
+import { asNonCompoundGraph as v, buildLayerMatrix as g } from "../util.js";
+import { findType1Conflicts as b, findType2Conflicts as x, verticalAlignment as j, horizontalCompaction as E, findSmallestWidthAlignment as C, alignCoordinates as O, balance as y } from "./bk.js";
+const N = (o, c) => {
+  const { ranksep: s = 0 } = c || {}, n = g(o);
+  let i = 0;
+  n == null || n.forEach((t) => {
+    const p = t.map((e) => o.getNode(e).data.height), a = Math.max(...p, 0);
+    t == null || t.forEach((e) => {
+      o.getNode(e).data.y = i + a / 2;
+    }), i += a + s;
+  });
+}, A = (o, c) => {
+  const { align: s, nodesep: n = 0, edgesep: i = 0 } = c || {}, t = g(o), p = Object.assign(b(o, t), x(o, t)), a = {};
+  let e = [];
+  ["u", "d"].forEach((f) => {
+    e = f === "u" ? t : Object.values(t).reverse(), ["l", "r"].forEach((r) => {
+      r === "r" && (e = e.map((d) => Object.values(d).reverse()));
+      const u = (f === "u" ? o.getPredecessors : o.getSuccessors).bind(o), m = j(o, e, p, u), l = E(o, e, m.root, m.align, n, i, r === "r");
+      r === "r" && Object.keys(l).forEach((d) => l[d] = -l[d]), a[f + r] = l;
+    });
+  });
+  const h = C(o, a);
+  return h && O(a, h), y(a, s);
+}, M = (o, c) => {
+  var s;
+  const n = v(o);
+  N(n, c);
+  const i = A(n, c);
+  (s = Object.keys(i)) === null || s === void 0 || s.forEach((t) => {
+    n.getNode(t).data.x = i[t];
+  });
+};
+export {
+  M as position
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/position/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/position/index.js"],"sourcesContent":["import { asNonCompoundGraph, buildLayerMatrix } from '../util.js';\nimport { findType1Conflicts, findType2Conflicts, verticalAlignment, horizontalCompaction, findSmallestWidthAlignment, alignCoordinates, balance } from './bk.js';\n\nconst positionY = (g, options) => {\n    const { ranksep = 0 } = options || {};\n    const layering = buildLayerMatrix(g);\n    let prevY = 0;\n    layering === null || layering === void 0 ? void 0 : layering.forEach((layer) => {\n        const heights = layer.map((v) => g.getNode(v).data.height);\n        const maxHeight = Math.max(...heights, 0);\n        layer === null || layer === void 0 ? void 0 : layer.forEach((v) => {\n            g.getNode(v).data.y = prevY + maxHeight / 2;\n        });\n        prevY += maxHeight + ranksep;\n    });\n};\nconst positionX = (g, options) => {\n    const { align: graphAlign, nodesep = 0, edgesep = 0 } = options || {};\n    const layering = buildLayerMatrix(g);\n    const conflicts = Object.assign(findType1Conflicts(g, layering), findType2Conflicts(g, layering));\n    const xss = {};\n    let adjustedLayering = [];\n    ['u', 'd'].forEach((vert) => {\n        adjustedLayering =\n            vert === 'u' ? layering : Object.values(layering).reverse();\n        ['l', 'r'].forEach((horiz) => {\n            if (horiz === 'r') {\n                adjustedLayering = adjustedLayering.map((inner) => Object.values(inner).reverse());\n            }\n            const neighborFn = (vert === 'u' ? g.getPredecessors : g.getSuccessors).bind(g);\n            const align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);\n            const xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, nodesep, edgesep, horiz === 'r');\n            if (horiz === 'r') {\n                Object.keys(xs).forEach((xsKey) => (xs[xsKey] = -xs[xsKey]));\n            }\n            xss[vert + horiz] = xs;\n        });\n    });\n    const smallestWidth = findSmallestWidthAlignment(g, xss);\n    smallestWidth && alignCoordinates(xss, smallestWidth);\n    return balance(xss, graphAlign);\n};\nconst position = (g, options) => {\n    var _a;\n    const ng = asNonCompoundGraph(g);\n    positionY(ng, options);\n    const xs = positionX(ng, options);\n    (_a = Object.keys(xs)) === null || _a === void 0 ? void 0 : _a.forEach((key) => {\n        ng.getNode(key).data.x = xs[key];\n    });\n};\n\nexport { position };\n//# sourceMappingURL=index.js.map\n"],"names":["positionY","g","options","ranksep","layering","buildLayerMatrix","prevY","layer","heights","v","maxHeight","positionX","graphAlign","nodesep","edgesep","conflicts","findType1Conflicts","findType2Conflicts","xss","adjustedLayering","vert","horiz","inner","neighborFn","align","verticalAlignment","xs","horizontalCompaction","xsKey","smallestWidth","findSmallestWidthAlignment","alignCoordinates","balance","position","_a","ng","asNonCompoundGraph","key"],"mappings":";;AAGA,MAAMA,IAAY,CAACC,GAAGC,MAAY;AAC9B,QAAM,EAAE,SAAAC,IAAU,EAAC,IAAKD,KAAW,CAAA,GAC7BE,IAAWC,EAAiBJ,CAAC;AACnC,MAAIK,IAAQ;AACZ,EAAAF,KAAa,QAAuCA,EAAS,QAAQ,CAACG,MAAU;AAC5E,UAAMC,IAAUD,EAAM,IAAI,CAACE,MAAMR,EAAE,QAAQQ,CAAC,EAAE,KAAK,MAAM,GACnDC,IAAY,KAAK,IAAI,GAAGF,GAAS,CAAC;AACxC,IAAAD,KAAU,QAAoCA,EAAM,QAAQ,CAACE,MAAM;AAC/D,MAAAR,EAAE,QAAQQ,CAAC,EAAE,KAAK,IAAIH,IAAQI,IAAY;AAAA,IAC9C,CAAC,GACDJ,KAASI,IAAYP;AAAA,EACzB,CAAC;AACL,GACMQ,IAAY,CAACV,GAAGC,MAAY;AAC9B,QAAM,EAAE,OAAOU,GAAY,SAAAC,IAAU,GAAG,SAAAC,IAAU,MAAMZ,KAAW,CAAA,GAC7DE,IAAWC,EAAiBJ,CAAC,GAC7Bc,IAAY,OAAO,OAAOC,EAAmBf,GAAGG,CAAQ,GAAGa,EAAmBhB,GAAGG,CAAQ,CAAC,GAC1Fc,IAAM,CAAA;AACZ,MAAIC,IAAmB,CAAA;AACvB,GAAC,KAAK,GAAG,EAAE,QAAQ,CAACC,MAAS;AACzB,IAAAD,IACIC,MAAS,MAAMhB,IAAW,OAAO,OAAOA,CAAQ,EAAE,QAAO,GAC7D,CAAC,KAAK,GAAG,EAAE,QAAQ,CAACiB,MAAU;AAC1B,MAAIA,MAAU,QACVF,IAAmBA,EAAiB,IAAI,CAACG,MAAU,OAAO,OAAOA,CAAK,EAAE,SAAS;AAErF,YAAMC,KAAcH,MAAS,MAAMnB,EAAE,kBAAkBA,EAAE,eAAe,KAAKA,CAAC,GACxEuB,IAAQC,EAAkBxB,GAAGkB,GAAkBJ,GAAWQ,CAAU,GACpEG,IAAKC,EAAqB1B,GAAGkB,GAAkBK,EAAM,MAAMA,EAAM,OAAOX,GAASC,GAASO,MAAU,GAAG;AAC7G,MAAIA,MAAU,OACV,OAAO,KAAKK,CAAE,EAAE,QAAQ,CAACE,MAAWF,EAAGE,CAAK,IAAI,CAACF,EAAGE,CAAK,CAAE,GAE/DV,EAAIE,IAAOC,CAAK,IAAIK;AAAA,IACxB,CAAC;AAAA,EACL,CAAC;AACD,QAAMG,IAAgBC,EAA2B7B,GAAGiB,CAAG;AACvD,SAAAW,KAAiBE,EAAiBb,GAAKW,CAAa,GAC7CG,EAAQd,GAAKN,CAAU;AAClC,GACMqB,IAAW,CAAChC,GAAGC,MAAY;AAC7B,MAAIgC;AACJ,QAAMC,IAAKC,EAAmBnC,CAAC;AAC/B,EAAAD,EAAUmC,GAAIjC,CAAO;AACrB,QAAMwB,IAAKf,EAAUwB,GAAIjC,CAAO;AAChC,GAACgC,IAAK,OAAO,KAAKR,CAAE,OAAO,QAAQQ,MAAO,UAAkBA,EAAG,QAAQ,CAACG,MAAQ;AAC5E,IAAAF,EAAG,QAAQE,CAAG,EAAE,KAAK,IAAIX,EAAGW,CAAG;AAAA,EACnC,CAAC;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/feasible-tree.js

@@ -0,0 +1,63 @@
+import { DagreGraph as i } from "../graph.js";
+import { minBy as N } from "../util.js";
+import { slack as n } from "./util.js";
+const m = (e) => {
+  const t = new i({
+    tree: []
+  }), a = e.getAllNodes()[0], o = e.getAllNodes().length;
+  t.addNode(a);
+  let d, r;
+  for (; f(t, e) < o; )
+    d = c(t, e), r = t.hasNode(d.source) ? n(e, d) : -n(e, d), h(t, e, r);
+  return t;
+}, f = (e, t) => {
+  const a = (o) => {
+    t.getRelatedEdges(o, "both").forEach((d) => {
+      const r = d.source, s = o === r ? d.target : r;
+      !e.hasNode(s) && !n(t, d) && (e.addNode({
+        id: s,
+        data: {}
+      }), e.addEdge({
+        id: d.id,
+        source: o,
+        target: s,
+        data: {}
+      }), a(s));
+    });
+  };
+  return e.getAllNodes().forEach((o) => a(o.id)), e.getAllNodes().length;
+}, k = (e) => {
+  const t = new i({ tree: [] }), a = e.getAllNodes()[0], o = e.getAllNodes().length;
+  t.addNode(a);
+  let d, r;
+  for (; g(t, e) < o; )
+    d = c(t, e), r = t.hasNode(d.source) ? n(e, d) : -n(e, d), h(t, e, r);
+  return t;
+}, g = (e, t) => {
+  const a = (o) => {
+    var d;
+    (d = t.getRelatedEdges(o, "both")) === null || d === void 0 || d.forEach((r) => {
+      const s = r.source, l = o === s ? r.target : s;
+      !e.hasNode(l) && (t.getNode(l).data.layer !== void 0 || !n(t, r)) && (e.addNode({
+        id: l,
+        data: {}
+      }), e.addEdge({
+        id: r.id,
+        source: o,
+        target: l,
+        data: {}
+      }), a(l));
+    });
+  };
+  return e.getAllNodes().forEach((o) => a(o.id)), e.getAllNodes().length;
+}, c = (e, t) => N(t.getAllEdges(), (a) => e.hasNode(a.source) !== e.hasNode(a.target) ? n(t, a) : 1 / 0), h = (e, t, a) => {
+  e.getAllNodes().forEach((o) => {
+    const d = t.getNode(o.id);
+    d.data.rank || (d.data.rank = 0), d.data.rank += a;
+  });
+};
+export {
+  m as feasibleTree,
+  k as feasibleTreeWithLayer
+};
+//# sourceMappingURL=feasible-tree.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/feasible-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feasible-tree.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/feasible-tree.js"],"sourcesContent":["import { DagreGraph } from '../graph.js';\nimport { minBy } from '../util.js';\nimport { slack } from './util.js';\n\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nconst feasibleTree = (g) => {\n    const t = new DagreGraph({\n        tree: [],\n    });\n    // Choose arbitrary node from which to start our tree\n    const start = g.getAllNodes()[0];\n    const size = g.getAllNodes().length;\n    t.addNode(start);\n    let edge;\n    let delta;\n    while (tightTree(t, g) < size) {\n        edge = findMinSlackEdge(t, g);\n        delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);\n        shiftRanks(t, g, delta);\n    }\n    return t;\n};\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nconst tightTree = (t, g) => {\n    const dfs = (v) => {\n        g.getRelatedEdges(v, 'both').forEach((e) => {\n            const edgeV = e.source;\n            const w = v === edgeV ? e.target : edgeV;\n            if (!t.hasNode(w) && !slack(g, e)) {\n                t.addNode({\n                    id: w,\n                    data: {},\n                });\n                t.addEdge({\n                    id: e.id,\n                    source: v,\n                    target: w,\n                    data: {},\n                });\n                dfs(w);\n            }\n        });\n    };\n    t.getAllNodes().forEach((n) => dfs(n.id));\n    return t.getAllNodes().length;\n};\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nconst feasibleTreeWithLayer = (g) => {\n    const t = new DagreGraph({ tree: [] });\n    // Choose arbitrary node from which to start our tree\n    const start = g.getAllNodes()[0];\n    const size = g.getAllNodes().length;\n    t.addNode(start);\n    let edge;\n    let delta;\n    while (tightTreeWithLayer(t, g) < size) {\n        edge = findMinSlackEdge(t, g);\n        delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);\n        shiftRanks(t, g, delta);\n    }\n    return t;\n};\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nconst tightTreeWithLayer = (t, g) => {\n    const dfs = (v) => {\n        var _a;\n        (_a = g.getRelatedEdges(v, 'both')) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n            const edgeV = e.source;\n            const w = v === edgeV ? e.target : edgeV;\n            // 对于指定layer的，直接加入tight-tree，不参与调整\n            if (!t.hasNode(w) &&\n                (g.getNode(w).data.layer !== undefined || !slack(g, e))) {\n                t.addNode({\n                    id: w,\n                    data: {},\n                });\n                t.addEdge({\n                    id: e.id,\n                    source: v,\n                    target: w,\n                    data: {},\n                });\n                dfs(w);\n            }\n        });\n    };\n    t.getAllNodes().forEach((n) => dfs(n.id));\n    return t.getAllNodes().length;\n};\n/*\n * Finds the edge with the smallest slack that is incident on tree and returns\n * it.\n */\nconst findMinSlackEdge = (t, g) => {\n    return minBy(g.getAllEdges(), (e) => {\n        if (t.hasNode(e.source) !== t.hasNode(e.target)) {\n            return slack(g, e);\n        }\n        return Infinity;\n    });\n};\nconst shiftRanks = (t, g, delta) => {\n    t.getAllNodes().forEach((tn) => {\n        const v = g.getNode(tn.id);\n        if (!v.data.rank)\n            v.data.rank = 0;\n        v.data.rank += delta;\n    });\n};\n\nexport { feasibleTree, feasibleTreeWithLayer };\n//# sourceMappingURL=feasible-tree.js.map\n"],"names":["feasibleTree","g","DagreGraph","start","size","edge","delta","tightTree","findMinSlackEdge","slack","shiftRanks","t","dfs","v","e","edgeV","w","n","feasibleTreeWithLayer","tightTreeWithLayer","_a","minBy","tn"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js

@@ -0,0 +1,27 @@
+import { feasibleTreeWithLayer as a } from "./feasible-tree.js";
+import { networkSimplex as o } from "./network-simplex.js";
+import { longestPathWithLayer as n, longestPath as s } from "./util.js";
+const c = (e, r) => {
+  switch (r) {
+    case "network-simplex":
+      k(e);
+      break;
+    case "tight-tree":
+      t(e);
+      break;
+    case "longest-path":
+      i(e);
+      break;
+    // default: networkSimplexRanker(g);
+    default:
+      t(e);
+  }
+}, i = s, t = (e) => {
+  n(e), a(e);
+}, k = (e) => {
+  o(e);
+};
+export {
+  c as rank
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js"],"sourcesContent":["import { feasibleTreeWithLayer } from './feasible-tree.js';\nimport { networkSimplex } from './network-simplex.js';\nimport { longestPathWithLayer, longestPath } from './util.js';\n\n/*\n * Assigns a rank to each node in the input graph that respects the \"minlen\"\n * constraint specified on edges between nodes.\n *\n * This basic structure is derived from Gansner, et al., \"A Technique for\n * Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a connected DAG\n *    2. Graph nodes must be objects\n *    3. Graph edges must have \"weight\" and \"minlen\" attributes\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have a \"rank\" attribute based on the results of the\n *       algorithm. Ranks can start at any index (including negative), we'll\n *       fix them up later.\n */\nconst rank = (g, ranker) => {\n    switch (ranker) {\n        case 'network-simplex':\n            networkSimplexRanker(g);\n            break;\n        case 'tight-tree':\n            tightTreeRanker(g);\n            break;\n        case 'longest-path':\n            longestPathRanker(g);\n            break;\n        // default: networkSimplexRanker(g);\n        default:\n            tightTreeRanker(g);\n    }\n};\n// A fast and simple ranker, but results are far from optimal.\nconst longestPathRanker = longestPath;\nconst tightTreeRanker = (g) => {\n    longestPathWithLayer(g);\n    feasibleTreeWithLayer(g);\n};\nconst networkSimplexRanker = (g) => {\n    networkSimplex(g);\n};\n\nexport { rank };\n//# sourceMappingURL=index.js.map\n"],"names":["rank","g","ranker","networkSimplexRanker","tightTreeRanker","longestPathRanker","longestPath","longestPathWithLayer","feasibleTreeWithLayer","networkSimplex"],"mappings":";;;AAuBK,MAACA,IAAO,CAACC,GAAGC,MAAW;AACxB,UAAQA,GAAM;AAAA,IACV,KAAK;AACD,MAAAC,EAAqBF,CAAC;AACtB;AAAA,IACJ,KAAK;AACD,MAAAG,EAAgBH,CAAC;AACjB;AAAA,IACJ,KAAK;AACD,MAAAI,EAAkBJ,CAAC;AACnB;AAAA;AAAA,IAEJ;AACI,MAAAG,EAAgBH,CAAC;AAAA,EAC7B;AACA,GAEMI,IAAoBC,GACpBF,IAAkB,CAACH,MAAM;AAC3B,EAAAM,EAAqBN,CAAC,GACtBO,EAAsBP,CAAC;AAC3B,GACME,IAAuB,CAACF,MAAM;AAChC,EAAAQ,EAAeR,CAAC;AACpB;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js

@@ -0,0 +1,77 @@
+import { simplify as R, dfs as h, minBy as w } from "../util.js";
+import { feasibleTree as L } from "./feasible-tree.js";
+import { longestPath as v, slack as A } from "./util.js";
+const I = (t) => {
+  const a = R(t);
+  v(a);
+  const e = L(a);
+  N(e), m(e, a);
+  let o, d;
+  for (; o = x(e); )
+    d = C(e, a, o), T(e, a, o, d);
+}, m = (t, a) => {
+  let e = h(t, t.getAllNodes(), "post");
+  e = e.slice(0, (e == null ? void 0 : e.length) - 1), e.forEach((o) => {
+    V(t, a, o);
+  });
+}, V = (t, a, e) => {
+  const d = t.getNode(e).data.parent, n = t.getRelatedEdges(e, "both").find((r) => r.target === d || r.source === d);
+  n.data.cutvalue = k(t, a, e);
+}, k = (t, a, e) => {
+  const d = t.getNode(e).data.parent;
+  let n = !0, r = a.getRelatedEdges(e, "out").find((s) => s.target === d), l = 0;
+  return r || (n = !1, r = a.getRelatedEdges(d, "out").find((s) => s.target === e)), l = r.data.weight, a.getRelatedEdges(e, "both").forEach((s) => {
+    const g = s.source === e, i = g ? s.target : s.source;
+    if (i !== d) {
+      const c = g === n, u = s.data.weight;
+      if (l += c ? u : -u, $(t, e, i)) {
+        const f = t.getRelatedEdges(e, "both").find((E) => E.source === i || E.target === i).data.cutvalue;
+        l += c ? -f : f;
+      }
+    }
+  }), l;
+}, N = (t, a = t.getAllNodes()[0].id) => {
+  b(t, {}, 1, a);
+}, b = (t, a, e, o, d) => {
+  var n;
+  const r = e;
+  let l = e;
+  const s = t.getNode(o);
+  return a[o] = !0, (n = t.getNeighbors(o)) === null || n === void 0 || n.forEach((g) => {
+    a[g.id] || (l = b(t, a, l, g.id, o));
+  }), s.data.low = r, s.data.lim = l++, d ? s.data.parent = d : delete s.data.parent, l;
+}, x = (t) => t.getAllEdges().find((a) => a.data.cutvalue < 0), C = (t, a, e) => {
+  let o = e.source, d = e.target;
+  a.getRelatedEdges(o, "out").find((i) => i.target === d) || (o = e.target, d = e.source);
+  const n = t.getNode(o), r = t.getNode(d);
+  let l = n, s = !1;
+  n.data.lim > r.data.lim && (l = r, s = !0);
+  const g = a.getAllEdges().filter((i) => s === p(t.getNode(i.source), l) && s !== p(t.getNode(i.target), l));
+  return w(g, (i) => A(a, i));
+}, T = (t, a, e, o) => {
+  const d = t.getRelatedEdges(e.source, "both").find((n) => n.source === e.target || n.target === e.target);
+  d && t.removeEdge(d.id), t.addEdge({
+    id: `e${Math.random()}`,
+    source: o.source,
+    target: o.target,
+    data: {}
+  }), N(t), m(t, a), y(t, a);
+}, y = (t, a) => {
+  const e = t.getAllNodes().find((d) => !d.data.parent);
+  let o = h(t, e, "pre");
+  o = o.slice(1), o.forEach((d) => {
+    const n = t.getNode(d).data.parent;
+    let r = a.getRelatedEdges(d, "out").find((s) => s.target === n), l = !1;
+    !r && a.hasNode(n) && (r = a.getRelatedEdges(n, "out").find((s) => s.target === d), l = !0), a.getNode(d).data.rank = (a.hasNode(n) && a.getNode(n).data.rank || 0) + (l ? r == null ? void 0 : r.data.minlen : -(r == null ? void 0 : r.data.minlen));
+  });
+}, $ = (t, a, e) => t.getRelatedEdges(a, "both").find((o) => o.source === e || o.target === e), p = (t, a) => a.data.low <= t.data.lim && t.data.lim <= a.data.lim;
+export {
+  k as calcCutValue,
+  C as enterEdge,
+  T as exchangeEdges,
+  m as initCutValues,
+  N as initLowLimValues,
+  x as leaveEdge,
+  I as networkSimplex
+};
+//# sourceMappingURL=network-simplex.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js"],"sourcesContent":["import { simplify, dfs, minBy } from '../util.js';\nimport { feasibleTree } from './feasible-tree.js';\nimport { longestPath, slack } from './util.js';\n\n/*\n * The network simplex algorithm assigns ranks to each node in the input graph\n * and iteratively improves the ranking to reduce the length of edges.\n *\n * Preconditions:\n *\n *    1. The input graph must be a DAG.\n *    2. All nodes in the graph must have an object value.\n *    3. All edges in the graph must have \"minlen\" and \"weight\" attributes.\n *\n * Postconditions:\n *\n *    1. All nodes in the graph will have an assigned \"rank\" attribute that has\n *       been optimized by the network simplex algorithm. Ranks start at 0.\n *\n *\n * A rough sketch of the algorithm is as follows:\n *\n *    1. Assign initial ranks to each node. We use the longest path algorithm,\n *       which assigns ranks to the lowest position possible. In general this\n *       leads to very wide bottom ranks and unnecessarily long edges.\n *    2. Construct a feasible tight tree. A tight tree is one such that all\n *       edges in the tree have no slack (difference between length of edge\n *       and minlen for the edge). This by itself greatly improves the assigned\n *       rankings by shorting edges.\n *    3. Iteratively find edges that have negative cut values. Generally a\n *       negative cut value indicates that the edge could be removed and a new\n *       tree edge could be added to produce a more compact graph.\n *\n * Much of the algorithms here are derived from Gansner, et al., \"A Technique\n * for Drawing Directed Graphs.\" The structure of the file roughly follows the\n * structure of the overall algorithm.\n */\nconst networkSimplex = (og) => {\n    const g = simplify(og);\n    longestPath(g);\n    const t = feasibleTree(g);\n    initLowLimValues(t);\n    initCutValues(t, g);\n    let e;\n    let f;\n    while ((e = leaveEdge(t))) {\n        f = enterEdge(t, g, e);\n        exchangeEdges(t, g, e, f);\n    }\n};\n/*\n * Initializes cut values for all edges in the tree.\n */\nconst initCutValues = (t, g) => {\n    let vs = dfs(t, t.getAllNodes(), 'post');\n    vs = vs.slice(0, (vs === null || vs === void 0 ? void 0 : vs.length) - 1);\n    vs.forEach((v) => {\n        assignCutValue(t, g, v);\n    });\n};\nconst assignCutValue = (t, g, child) => {\n    const childLab = t.getNode(child);\n    const parent = childLab.data.parent;\n    // FIXME: use undirected edge?\n    const edge = t\n        .getRelatedEdges(child, 'both')\n        .find((e) => e.target === parent || e.source === parent);\n    edge.data.cutvalue = calcCutValue(t, g, child);\n};\n/*\n * Given the tight tree, its graph, and a child in the graph calculate and\n * return the cut value for the edge between the child and its parent.\n */\nconst calcCutValue = (t, g, child) => {\n    const childLab = t.getNode(child);\n    const parent = childLab.data.parent;\n    // True if the child is on the tail end of the edge in the directed graph\n    let childIsTail = true;\n    // The graph's view of the tree edge we're inspecting\n    let graphEdge = g\n        .getRelatedEdges(child, 'out')\n        .find((e) => e.target === parent);\n    // The accumulated cut value for the edge between this node and its parent\n    let cutValue = 0;\n    if (!graphEdge) {\n        childIsTail = false;\n        graphEdge = g\n            .getRelatedEdges(parent, 'out')\n            .find((e) => e.target === child);\n    }\n    cutValue = graphEdge.data.weight;\n    g.getRelatedEdges(child, 'both').forEach((e) => {\n        const isOutEdge = e.source === child;\n        const other = isOutEdge ? e.target : e.source;\n        if (other !== parent) {\n            const pointsToHead = isOutEdge === childIsTail;\n            const otherWeight = e.data.weight;\n            cutValue += pointsToHead ? otherWeight : -otherWeight;\n            if (isTreeEdge(t, child, other)) {\n                // FIXME: use undirected edge?\n                const otherCutValue = t\n                    .getRelatedEdges(child, 'both')\n                    .find((e) => e.source === other || e.target === other).data\n                    .cutvalue;\n                cutValue += pointsToHead ? -otherCutValue : otherCutValue;\n            }\n        }\n    });\n    return cutValue;\n};\nconst initLowLimValues = (tree, root = tree.getAllNodes()[0].id) => {\n    dfsAssignLowLim(tree, {}, 1, root);\n};\nconst dfsAssignLowLim = (tree, visited, nextLim, v, parent) => {\n    var _a;\n    const low = nextLim;\n    let useNextLim = nextLim;\n    const label = tree.getNode(v);\n    visited[v] = true;\n    (_a = tree.getNeighbors(v)) === null || _a === void 0 ? void 0 : _a.forEach((w) => {\n        if (!visited[w.id]) {\n            useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);\n        }\n    });\n    label.data.low = low;\n    label.data.lim = useNextLim++;\n    if (parent) {\n        label.data.parent = parent;\n    }\n    else {\n        // TODO should be able to remove this when we incrementally update low lim\n        delete label.data.parent;\n    }\n    return useNextLim;\n};\nconst leaveEdge = (tree) => {\n    return tree.getAllEdges().find((e) => {\n        return e.data.cutvalue < 0;\n    });\n};\nconst enterEdge = (t, g, edge) => {\n    let v = edge.source;\n    let w = edge.target;\n    // For the rest of this function we assume that v is the tail and w is the\n    // head, so if we don't have this edge in the graph we should flip it to\n    // match the correct orientation.\n    if (!g.getRelatedEdges(v, 'out').find((e) => e.target === w)) {\n        v = edge.target;\n        w = edge.source;\n    }\n    const vLabel = t.getNode(v);\n    const wLabel = t.getNode(w);\n    let tailLabel = vLabel;\n    let flip = false;\n    // If the root is in the tail of the edge then we need to flip the logic that\n    // checks for the head and tail nodes in the candidates function below.\n    if (vLabel.data.lim > wLabel.data.lim) {\n        tailLabel = wLabel;\n        flip = true;\n    }\n    const candidates = g.getAllEdges().filter((edge) => {\n        return (flip === isDescendant(t.getNode(edge.source), tailLabel) &&\n            flip !== isDescendant(t.getNode(edge.target), tailLabel));\n    });\n    return minBy(candidates, (edge) => {\n        return slack(g, edge);\n    });\n};\n/**\n *\n * @param t\n * @param g\n * @param e edge to remove\n * @param f edge to add\n */\nconst exchangeEdges = (t, g, e, f) => {\n    // FIXME: use undirected edge?\n    const existed = t\n        .getRelatedEdges(e.source, 'both')\n        .find((edge) => edge.source === e.target || edge.target === e.target);\n    if (existed) {\n        t.removeEdge(existed.id);\n    }\n    t.addEdge({\n        id: `e${Math.random()}`,\n        source: f.source,\n        target: f.target,\n        data: {},\n    });\n    initLowLimValues(t);\n    initCutValues(t, g);\n    updateRanks(t, g);\n};\nconst updateRanks = (t, g) => {\n    const root = t.getAllNodes().find((v) => {\n        return !v.data.parent;\n    });\n    let vs = dfs(t, root, 'pre');\n    vs = vs.slice(1);\n    vs.forEach((v) => {\n        const parent = t.getNode(v).data.parent;\n        let edge = g.getRelatedEdges(v, 'out').find((e) => e.target === parent);\n        // let edge = g.edgeFromArgs(v, parent);\n        let flipped = false;\n        if (!edge && g.hasNode(parent)) {\n            // edge = g.edgeFromArgs(parent, v)!;\n            edge = g.getRelatedEdges(parent, 'out').find((e) => e.target === v);\n            flipped = true;\n        }\n        g.getNode(v).data.rank =\n            ((g.hasNode(parent) && g.getNode(parent).data.rank) || 0) +\n                (flipped ? edge === null || edge === void 0 ? void 0 : edge.data.minlen : -(edge === null || edge === void 0 ? void 0 : edge.data.minlen));\n    });\n};\n/*\n * Returns true if the edge is in the tree.\n */\nconst isTreeEdge = (tree, u, v) => {\n    // FIXME: use undirected edge?\n    return tree\n        .getRelatedEdges(u, 'both')\n        .find((e) => e.source === v || e.target === v);\n};\n/*\n * Returns true if the specified node is descendant of the root node per the\n * assigned low and lim attributes in the tree.\n */\nconst isDescendant = (vLabel, rootLabel) => {\n    return (rootLabel.data.low <= vLabel.data.lim &&\n        vLabel.data.lim <= rootLabel.data.lim);\n};\n\nexport { calcCutValue, enterEdge, exchangeEdges, initCutValues, initLowLimValues, leaveEdge, networkSimplex };\n//# sourceMappingURL=network-simplex.js.map\n"],"names":["networkSimplex","og","g","simplify","longestPath","t","feasibleTree","initLowLimValues","initCutValues","e","f","leaveEdge","enterEdge","exchangeEdges","vs","dfs","v","assignCutValue","child","parent","edge","calcCutValue","childIsTail","graphEdge","cutValue","isOutEdge","other","pointsToHead","otherWeight","isTreeEdge","otherCutValue","tree","root","dfsAssignLowLim","visited","nextLim","_a","low","useNextLim","label","w","vLabel","wLabel","tailLabel","flip","candidates","isDescendant","minBy","slack","existed","updateRanks","flipped","u","rootLabel"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/util.js

@@ -0,0 +1,54 @@
+const g = (a) => {
+  const i = {}, o = (d) => {
+    var s;
+    const f = a.getNode(d);
+    if (!f)
+      return 0;
+    if (i[d])
+      return f.data.rank;
+    i[d] = !0;
+    let t;
+    return (s = a.getRelatedEdges(d, "out")) === null || s === void 0 || s.forEach((n) => {
+      const l = o(n.target), e = n.data.minlen, r = l - e;
+      r && (t === void 0 || r < t) && (t = r);
+    }), t || (t = 0), f.data.rank = t, t;
+  };
+  a.getAllNodes().filter((d) => a.getRelatedEdges(d.id, "in").length === 0).forEach((d) => o(d.id));
+}, N = (a) => {
+  const i = {};
+  let o;
+  const d = (t) => {
+    var n;
+    const l = a.getNode(t);
+    if (!l)
+      return 0;
+    if (i[t])
+      return l.data.rank;
+    i[t] = !0;
+    let e;
+    return (n = a.getRelatedEdges(t, "out")) === null || n === void 0 || n.forEach((r) => {
+      const c = d(r.target), k = r.data.minlen, u = c - k;
+      u && (e === void 0 || u < e) && (e = u);
+    }), e || (e = 0), (o === void 0 || e < o) && (o = e), l.data.rank = e, e;
+  };
+  a.getAllNodes().filter((t) => a.getRelatedEdges(t.id, "in").length === 0).forEach((t) => {
+    t && d(t.id);
+  }), o === void 0 && (o = 0);
+  const s = {}, f = (t, n) => {
+    var l;
+    const e = a.getNode(t), r = isNaN(e.data.layer) ? n : e.data.layer;
+    (e.data.rank === void 0 || e.data.rank < r) && (e.data.rank = r), !s[t] && (s[t] = !0, (l = a.getRelatedEdges(t, "out")) === null || l === void 0 || l.forEach((c) => {
+      f(c.target, r + c.data.minlen);
+    }));
+  };
+  a.getAllNodes().forEach((t) => {
+    const n = t.data;
+    n && (isNaN(n.layer) ? n.rank -= o : f(t.id, n.layer));
+  });
+}, h = (a, i) => a.getNode(i.target).data.rank - a.getNode(i.source).data.rank - i.data.minlen;
+export {
+  g as longestPath,
+  N as longestPathWithLayer,
+  h as slack
+};
+//# sourceMappingURL=util.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/util.js"],"sourcesContent":["/*\n * Initializes ranks for the input graph using the longest path algorithm. This\n * algorithm scales well and is fast in practice, it yields rather poor\n * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom\n * ranks wide and leaving edges longer than necessary. However, due to its\n * speed, this algorithm is good for getting an initial ranking that can be fed\n * into other algorithms.\n *\n * This algorithm does not normalize layers because it will be used by other\n * algorithms in most cases. If using this algorithm directly, be sure to\n * run normalize at the end.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG.\n *    2. Input graph node labels can be assigned properties.\n *\n * Post-conditions:\n *\n *    1. Each node will be assign an (unnormalized) \"rank\" property.\n */\nconst longestPath = (g) => {\n    const visited = {};\n    const dfs = (v) => {\n        var _a;\n        const label = g.getNode(v);\n        if (!label)\n            return 0;\n        if (visited[v]) {\n            return label.data.rank;\n        }\n        visited[v] = true;\n        let rank;\n        (_a = g.getRelatedEdges(v, 'out')) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n            const wRank = dfs(e.target);\n            const minLen = e.data.minlen;\n            const r = wRank - minLen;\n            if (r) {\n                if (rank === undefined || r < rank) {\n                    rank = r;\n                }\n            }\n        });\n        if (!rank) {\n            rank = 0;\n        }\n        label.data.rank = rank;\n        return rank;\n    };\n    g.getAllNodes()\n        .filter((n) => g.getRelatedEdges(n.id, 'in').length === 0)\n        .forEach((source) => dfs(source.id));\n};\nconst longestPathWithLayer = (g) => {\n    // 用longest path，找出最深的点\n    const visited = {};\n    let minRank;\n    const dfs = (v) => {\n        var _a;\n        const label = g.getNode(v);\n        if (!label)\n            return 0;\n        if (visited[v]) {\n            return label.data.rank;\n        }\n        visited[v] = true;\n        let rank;\n        (_a = g.getRelatedEdges(v, 'out')) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n            const wRank = dfs(e.target);\n            const minLen = e.data.minlen;\n            const r = wRank - minLen;\n            if (r) {\n                if (rank === undefined || r < rank) {\n                    rank = r;\n                }\n            }\n        });\n        if (!rank) {\n            rank = 0;\n        }\n        if (minRank === undefined || rank < minRank) {\n            minRank = rank;\n        }\n        label.data.rank = rank;\n        return rank;\n    };\n    g.getAllNodes()\n        .filter((n) => g.getRelatedEdges(n.id, 'in').length === 0)\n        .forEach((source) => {\n        if (source)\n            dfs(source.id);\n    });\n    if (minRank === undefined) {\n        minRank = 0;\n    }\n    // minRank += 1; // NOTE: 最小的层级是dummy root，+1\n    // forward一遍，赋值层级\n    const forwardVisited = {};\n    const dfsForward = (v, nextRank) => {\n        var _a;\n        const label = g.getNode(v);\n        const currRank = !isNaN(label.data.layer) ? label.data.layer : nextRank;\n        // 没有指定，取最大值\n        if (label.data.rank === undefined || label.data.rank < currRank) {\n            label.data.rank = currRank;\n        }\n        if (forwardVisited[v])\n            return;\n        forwardVisited[v] = true;\n        // DFS遍历子节点\n        (_a = g.getRelatedEdges(v, 'out')) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n            dfsForward(e.target, currRank + e.data.minlen);\n        });\n    };\n    // 指定层级的，更新下游\n    g.getAllNodes().forEach((n) => {\n        const label = n.data;\n        if (!label)\n            return;\n        if (!isNaN(label.layer)) {\n            dfsForward(n.id, label.layer); // 默认的dummy root所在层的rank是-1\n        }\n        else {\n            label.rank -= minRank;\n        }\n    });\n};\n/*\n * Returns the amount of slack for the given edge. The slack is defined as the\n * difference between the length of the edge and its minimum length.\n */\nconst slack = (g, e) => {\n    return (g.getNode(e.target).data.rank -\n        g.getNode(e.source).data.rank -\n        e.data.minlen);\n};\n\nexport { longestPath, longestPathWithLayer, slack };\n//# sourceMappingURL=util.js.map\n"],"names":["longestPath","g","visited","dfs","v","_a","label","rank","e","wRank","minLen","n","source","longestPathWithLayer","minRank","r","forwardVisited","dfsForward","nextRank","currRank","slack"],"mappings":"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","x_google_ignoreList":[0]}