@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/position/bk.mjs

@@ -0,0 +1,296 @@
+import * as _ from "lodash-es";
+import { Graph } from "../../graphlib/graph.mjs";
+import { buildLayerMatrix } from "../util.mjs";
+function findType1Conflicts(g, layering) {
+  var conflicts = {};
+  function visitLayer(prevLayer, layer) {
+    var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = _.last(layer);
+    _.forEach(layer, function(v, i) {
+      var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
+      if (w || v === lastNode) {
+        _.forEach(layer.slice(scanPos, i + 1), function(scanNode) {
+          _.forEach(g.predecessors(scanNode), function(u) {
+            var uLabel = g.node(u), uPos = uLabel.order;
+            if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
+              addConflict(conflicts, u, scanNode);
+            }
+          });
+        });
+        scanPos = i + 1;
+        k0 = k1;
+      }
+    });
+    return layer;
+  }
+  _.reduce(layering, visitLayer);
+  return conflicts;
+}
+function findType2Conflicts(g, layering) {
+  var conflicts = {};
+  function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+    var v;
+    _.forEach(_.range(southPos, southEnd), function(i) {
+      v = south[i];
+      if (g.node(v).dummy) {
+        _.forEach(g.predecessors(v), function(u) {
+          var uNode = g.node(u);
+          if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+            addConflict(conflicts, u, v);
+          }
+        });
+      }
+    });
+  }
+  function visitLayer(north, south) {
+    var prevNorthPos = -1, nextNorthPos, southPos = 0;
+    _.forEach(south, function(v, southLookahead) {
+      if (g.node(v).dummy === "border") {
+        var predecessors = g.predecessors(v);
+        if (predecessors.length) {
+          nextNorthPos = g.node(predecessors[0]).order;
+          scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
+          southPos = southLookahead;
+          prevNorthPos = nextNorthPos;
+        }
+      }
+      scan(south, southPos, south.length, nextNorthPos, north.length);
+    });
+    return south;
+  }
+  _.reduce(layering, visitLayer);
+  return conflicts;
+}
+function findOtherInnerSegmentNode(g, v) {
+  if (g.node(v).dummy) {
+    return _.find(g.predecessors(v), function(u) {
+      return g.node(u).dummy;
+    });
+  }
+}
+function addConflict(conflicts, v, w) {
+  if (v > w) {
+    var tmp = v;
+    v = w;
+    w = tmp;
+  }
+  var conflictsV = conflicts[v];
+  if (!conflictsV) {
+    conflicts[v] = conflictsV = {};
+  }
+  conflictsV[w] = true;
+}
+function hasConflict(conflicts, v, w) {
+  if (v > w) {
+    var tmp = v;
+    v = w;
+    w = tmp;
+  }
+  return !!conflicts[v] && Object.prototype.hasOwnProperty.call(conflicts[v], w);
+}
+function verticalAlignment(g, layering, conflicts, neighborFn) {
+  var root = {}, align = {}, pos = {};
+  _.forEach(layering, function(layer) {
+    _.forEach(layer, function(v, order) {
+      root[v] = v;
+      align[v] = v;
+      pos[v] = order;
+    });
+  });
+  _.forEach(layering, function(layer) {
+    var prevIdx = -1;
+    _.forEach(layer, function(v) {
+      var ws = neighborFn(v);
+      if (ws.length) {
+        ws = _.sortBy(ws, function(w2) {
+          return pos[w2];
+        });
+        var mp = (ws.length - 1) / 2;
+        for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+          var w = ws[i];
+          if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+            align[w] = v;
+            align[v] = root[v] = root[w];
+            prevIdx = pos[w];
+          }
+        }
+      }
+    });
+  });
+  return { root, align };
+}
+function horizontalCompaction(g, layering, root, align, reverseSep) {
+  var xs = {}, blockG = buildBlockGraph(g, layering, root, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight";
+  function iterate(setXsFunc, nextNodesFunc) {
+    var stack = blockG.nodes();
+    var elem = stack.pop();
+    var visited = {};
+    while (elem) {
+      if (visited[elem]) {
+        setXsFunc(elem);
+      } else {
+        visited[elem] = true;
+        stack.push(elem);
+        stack = stack.concat(nextNodesFunc(elem));
+      }
+      elem = stack.pop();
+    }
+  }
+  function pass1(elem) {
+    xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {
+      return Math.max(acc, xs[e.v] + blockG.edge(e));
+    }, 0);
+  }
+  function pass2(elem) {
+    var min = blockG.outEdges(elem).reduce(function(acc, e) {
+      return Math.min(acc, xs[e.w] - blockG.edge(e));
+    }, Number.POSITIVE_INFINITY);
+    var node = g.node(elem);
+    if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
+      xs[elem] = Math.max(xs[elem], min);
+    }
+  }
+  iterate(pass1, blockG.predecessors.bind(blockG));
+  iterate(pass2, blockG.successors.bind(blockG));
+  _.forEach(align, function(v) {
+    xs[v] = xs[root[v]];
+  });
+  return xs;
+}
+function buildBlockGraph(g, layering, root, reverseSep) {
+  var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+  _.forEach(layering, function(layer) {
+    var u;
+    _.forEach(layer, function(v) {
+      var vRoot = root[v];
+      blockGraph.setNode(vRoot);
+      if (u) {
+        var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
+        blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
+      }
+      u = v;
+    });
+  });
+  return blockGraph;
+}
+function findSmallestWidthAlignment(g, xss) {
+  return _.minBy(_.values(xss), function(xs) {
+    var max = Number.NEGATIVE_INFINITY;
+    var min = Number.POSITIVE_INFINITY;
+    _.forIn(xs, function(x, v) {
+      var halfWidth = width(g, v) / 2;
+      max = Math.max(x + halfWidth, max);
+      min = Math.min(x - halfWidth, min);
+    });
+    return max - min;
+  });
+}
+function alignCoordinates(xss, alignTo) {
+  var alignToVals = _.values(alignTo), alignToMin = _.min(alignToVals), alignToMax = _.max(alignToVals);
+  _.forEach(["u", "d"], function(vert) {
+    _.forEach(["l", "r"], function(horiz) {
+      var alignment = vert + horiz, xs = xss[alignment], delta;
+      if (xs === alignTo) return;
+      var xsVals = _.values(xs);
+      delta = horiz === "l" ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);
+      if (delta) {
+        xss[alignment] = _.mapValues(xs, function(x) {
+          return x + delta;
+        });
+      }
+    });
+  });
+}
+function balance(xss, align) {
+  return _.mapValues(xss.ul, function(ignore, v) {
+    if (align) {
+      return xss[align.toLowerCase()][v];
+    } else {
+      var xs = _.sortBy(_.map(xss, v));
+      return (xs[1] + xs[2]) / 2;
+    }
+  });
+}
+function positionX(g) {
+  var layering = buildLayerMatrix(g);
+  var conflicts = _.merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+  var xss = {};
+  var adjustedLayering;
+  _.forEach(["u", "d"], function(vert) {
+    adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
+    _.forEach(["l", "r"], function(horiz) {
+      if (horiz === "r") {
+        adjustedLayering = _.map(adjustedLayering, function(inner) {
+          return _.values(inner).reverse();
+        });
+      }
+      var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
+      var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+      var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === "r");
+      if (horiz === "r") {
+        xs = _.mapValues(xs, function(x) {
+          return -x;
+        });
+      }
+      xss[vert + horiz] = xs;
+    });
+  });
+  var smallestWidth = findSmallestWidthAlignment(g, xss);
+  alignCoordinates(xss, smallestWidth);
+  return balance(xss, g.graph().align);
+}
+function sep(nodeSep, edgeSep, reverseSep) {
+  return function(g, v, w) {
+    var vLabel = g.node(v);
+    var wLabel = g.node(w);
+    var sum = 0;
+    var delta;
+    sum += vLabel.width / 2;
+    if (Object.prototype.hasOwnProperty.call(vLabel, "labelpos")) {
+      switch (vLabel.labelpos.toLowerCase()) {
+        case "l":
+          delta = -vLabel.width / 2;
+          break;
+        case "r":
+          delta = vLabel.width / 2;
+          break;
+      }
+    }
+    if (delta) {
+      sum += reverseSep ? delta : -delta;
+    }
+    delta = 0;
+    sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
+    sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
+    sum += wLabel.width / 2;
+    if (Object.prototype.hasOwnProperty.call(wLabel, "labelpos")) {
+      switch (wLabel.labelpos.toLowerCase()) {
+        case "l":
+          delta = wLabel.width / 2;
+          break;
+        case "r":
+          delta = -wLabel.width / 2;
+          break;
+      }
+    }
+    if (delta) {
+      sum += reverseSep ? delta : -delta;
+    }
+    delta = 0;
+    return sum;
+  };
+}
+function width(g, v) {
+  return g.node(v).width;
+}
+export {
+  addConflict,
+  alignCoordinates,
+  balance,
+  findSmallestWidthAlignment,
+  findType1Conflicts,
+  findType2Conflicts,
+  hasConflict,
+  horizontalCompaction,
+  positionX,
+  verticalAlignment
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/position/index.mjs

@@ -0,0 +1,29 @@
+import * as _ from "lodash-es";
+import { asNonCompoundGraph, buildLayerMatrix } from "../util.mjs";
+import { positionX } from "./bk.mjs";
+function position(g) {
+  g = asNonCompoundGraph(g);
+  positionY(g);
+  _.forOwn(positionX(g), function(x, v) {
+    g.node(v).x = x;
+  });
+}
+function positionY(g) {
+  var layering = buildLayerMatrix(g);
+  var rankSep = g.graph().ranksep;
+  var prevY = 0;
+  _.forEach(layering, function(layer) {
+    var maxHeight = _.max(
+      _.map(layer, function(v) {
+        return g.node(v).height;
+      })
+    );
+    _.forEach(layer, function(v) {
+      g.node(v).y = prevY + maxHeight / 2;
+    });
+    prevY += maxHeight + rankSep;
+  });
+}
+export {
+  position
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.mjs

@@ -0,0 +1,45 @@
+import * as _ from "lodash-es";
+import { Graph } from "../../graphlib/graph.mjs";
+import { slack } from "./util.mjs";
+function feasibleTree(g) {
+  var t = new Graph({ directed: false });
+  var start = g.nodes()[0];
+  var size = g.nodeCount();
+  t.setNode(start, {});
+  var edge, delta;
+  while (tightTree(t, g) < size) {
+    edge = findMinSlackEdge(t, g);
+    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+    shiftRanks(t, g, delta);
+  }
+  return t;
+}
+function tightTree(t, g) {
+  function dfs(v) {
+    _.forEach(g.nodeEdges(v), function(e) {
+      var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
+      if (!t.hasNode(w) && !slack(g, e)) {
+        t.setNode(w, {});
+        t.setEdge(v, w, {});
+        dfs(w);
+      }
+    });
+  }
+  _.forEach(t.nodes(), dfs);
+  return t.nodeCount();
+}
+function findMinSlackEdge(t, g) {
+  return _.minBy(g.edges(), function(e) {
+    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
+      return slack(g, e);
+    }
+  });
+}
+function shiftRanks(t, g, delta) {
+  _.forEach(t.nodes(), function(v) {
+    g.node(v).rank += delta;
+  });
+}
+export {
+  feasibleTree
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/rank/index.mjs

@@ -0,0 +1,29 @@
+import { feasibleTree } from "./feasible-tree.mjs";
+import { networkSimplex } from "./network-simplex.mjs";
+import { longestPath } from "./util.mjs";
+function rank(g) {
+  switch (g.graph().ranker) {
+    case "network-simplex":
+      networkSimplexRanker(g);
+      break;
+    case "tight-tree":
+      tightTreeRanker(g);
+      break;
+    case "longest-path":
+      longestPathRanker(g);
+      break;
+    default:
+      networkSimplexRanker(g);
+  }
+}
+var longestPathRanker = longestPath;
+function tightTreeRanker(g) {
+  longestPath(g);
+  feasibleTree(g);
+}
+function networkSimplexRanker(g) {
+  networkSimplex(g);
+}
+export {
+  rank
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.mjs

@@ -0,0 +1,148 @@
+import * as _ from "lodash-es";
+import "../../graphlib/alg/dijkstra.mjs";
+import "../../graphlib/alg/floyd-warshall.mjs";
+import "../../graphlib/alg/topsort.mjs";
+import { postorder } from "../../graphlib/alg/postorder.mjs";
+import { preorder } from "../../graphlib/alg/preorder.mjs";
+import "../../graphlib/graph.mjs";
+import { simplify } from "../util.mjs";
+import { feasibleTree } from "./feasible-tree.mjs";
+import { longestPath, slack } from "./util.mjs";
+networkSimplex.initLowLimValues = initLowLimValues;
+networkSimplex.initCutValues = initCutValues;
+networkSimplex.calcCutValue = calcCutValue;
+networkSimplex.leaveEdge = leaveEdge;
+networkSimplex.enterEdge = enterEdge;
+networkSimplex.exchangeEdges = exchangeEdges;
+function networkSimplex(g) {
+  g = simplify(g);
+  longestPath(g);
+  var t = feasibleTree(g);
+  initLowLimValues(t);
+  initCutValues(t, g);
+  var e, f;
+  while (e = leaveEdge(t)) {
+    f = enterEdge(t, g, e);
+    exchangeEdges(t, g, e, f);
+  }
+}
+function initCutValues(t, g) {
+  var vs = postorder(t, t.nodes());
+  vs = vs.slice(0, vs.length - 1);
+  _.forEach(vs, function(v) {
+    assignCutValue(t, g, v);
+  });
+}
+function assignCutValue(t, g, child) {
+  var childLab = t.node(child);
+  var parent = childLab.parent;
+  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+}
+function calcCutValue(t, g, child) {
+  var childLab = t.node(child);
+  var parent = childLab.parent;
+  var childIsTail = true;
+  var graphEdge = g.edge(child, parent);
+  var cutValue = 0;
+  if (!graphEdge) {
+    childIsTail = false;
+    graphEdge = g.edge(parent, child);
+  }
+  cutValue = graphEdge.weight;
+  _.forEach(g.nodeEdges(child), function(e) {
+    var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
+    if (other !== parent) {
+      var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
+      cutValue += pointsToHead ? otherWeight : -otherWeight;
+      if (isTreeEdge(t, child, other)) {
+        var otherCutValue = t.edge(child, other).cutvalue;
+        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+      }
+    }
+  });
+  return cutValue;
+}
+function initLowLimValues(tree, root) {
+  if (arguments.length < 2) {
+    root = tree.nodes()[0];
+  }
+  dfsAssignLowLim(tree, {}, 1, root);
+}
+function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+  var low = nextLim;
+  var label = tree.node(v);
+  visited[v] = true;
+  _.forEach(tree.neighbors(v), function(w) {
+    if (!Object.prototype.hasOwnProperty.call(visited, w)) {
+      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+    }
+  });
+  label.low = low;
+  label.lim = nextLim++;
+  if (parent) {
+    label.parent = parent;
+  } else {
+    delete label.parent;
+  }
+  return nextLim;
+}
+function leaveEdge(tree) {
+  return _.find(tree.edges(), function(e) {
+    return tree.edge(e).cutvalue < 0;
+  });
+}
+function enterEdge(t, g, edge) {
+  var v = edge.v;
+  var w = edge.w;
+  if (!g.hasEdge(v, w)) {
+    v = edge.w;
+    w = edge.v;
+  }
+  var vLabel = t.node(v);
+  var wLabel = t.node(w);
+  var tailLabel = vLabel;
+  var flip = false;
+  if (vLabel.lim > wLabel.lim) {
+    tailLabel = wLabel;
+    flip = true;
+  }
+  var candidates = _.filter(g.edges(), function(edge2) {
+    return flip === isDescendant(t, t.node(edge2.v), tailLabel) && flip !== isDescendant(t, t.node(edge2.w), tailLabel);
+  });
+  return _.minBy(candidates, function(edge2) {
+    return slack(g, edge2);
+  });
+}
+function exchangeEdges(t, g, e, f) {
+  var v = e.v;
+  var w = e.w;
+  t.removeEdge(v, w);
+  t.setEdge(f.v, f.w, {});
+  initLowLimValues(t);
+  initCutValues(t, g);
+  updateRanks(t, g);
+}
+function updateRanks(t, g) {
+  var root = _.find(t.nodes(), function(v) {
+    return !g.node(v).parent;
+  });
+  var vs = preorder(t, root);
+  vs = vs.slice(1);
+  _.forEach(vs, function(v) {
+    var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
+    if (!edge) {
+      edge = g.edge(parent, v);
+      flipped = true;
+    }
+    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+  });
+}
+function isTreeEdge(tree, u, v) {
+  return tree.hasEdge(u, v);
+}
+function isDescendant(tree, vLabel, rootLabel) {
+  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
+}
+export {
+  networkSimplex
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/rank/util.mjs

@@ -0,0 +1,30 @@
+import * as _ from "lodash-es";
+function longestPath(g) {
+  var visited = {};
+  function dfs(v) {
+    var label = g.node(v);
+    if (Object.prototype.hasOwnProperty.call(visited, v)) {
+      return label.rank;
+    }
+    visited[v] = true;
+    var rank = _.min(
+      _.map(g.outEdges(v), function(e) {
+        return dfs(e.w) - g.edge(e).minlen;
+      })
+    );
+    if (rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+    rank === void 0 || // return value of _.map([]) for Lodash 4
+    rank === null) {
+      rank = 0;
+    }
+    return label.rank = rank;
+  }
+  _.forEach(g.sources(), dfs);
+}
+function slack(g, e) {
+  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+}
+export {
+  longestPath,
+  slack
+};