@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/normalize.mjs

@@ -0,0 +1,69 @@
+import * as _ from "lodash-es";
+import { addDummyNode } from "./util.mjs";
+function run(g) {
+  g.graph().dummyChains = [];
+  _.forEach(g.edges(), function(edge) {
+    normalizeEdge(g, edge);
+  });
+}
+function normalizeEdge(g, e) {
+  var v = e.v;
+  var vRank = g.node(v).rank;
+  var w = e.w;
+  var wRank = g.node(w).rank;
+  var name = e.name;
+  var edgeLabel = g.edge(e);
+  var labelRank = edgeLabel.labelRank;
+  if (wRank === vRank + 1) return;
+  g.removeEdge(e);
+  var attrs = void 0;
+  var dummy, i;
+  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+    edgeLabel.points = [];
+    attrs = {
+      width: 0,
+      height: 0,
+      edgeLabel,
+      edgeObj: e,
+      rank: vRank
+    };
+    dummy = addDummyNode(g, "edge", attrs, "_d");
+    if (vRank === labelRank) {
+      attrs.width = edgeLabel.width;
+      attrs.height = edgeLabel.height;
+      attrs.dummy = "edge-label";
+      attrs.labelpos = edgeLabel.labelpos;
+    }
+    g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
+    if (i === 0) {
+      g.graph().dummyChains.push(dummy);
+    }
+    v = dummy;
+  }
+  g.setEdge(v, w, { weight: edgeLabel.weight }, name);
+}
+function undo(g) {
+  _.forEach(g.graph().dummyChains, function(v) {
+    var node = g.node(v);
+    var origLabel = node.edgeLabel;
+    var w;
+    g.setEdge(node.edgeObj, origLabel);
+    while (node.dummy) {
+      w = g.successors(v)[0];
+      g.removeNode(v);
+      origLabel.points.push({ x: node.x, y: node.y });
+      if (node.dummy === "edge-label") {
+        origLabel.x = node.x;
+        origLabel.y = node.y;
+        origLabel.width = node.width;
+        origLabel.height = node.height;
+      }
+      v = w;
+      node = g.node(v);
+    }
+  });
+}
+export {
+  run,
+  undo
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/add-subgraph-constraints.mjs

@@ -0,0 +1,25 @@
+import * as _ from "lodash-es";
+function addSubgraphConstraints(g, cg, vs) {
+  var prev = {}, rootPrev;
+  _.forEach(vs, function(v) {
+    var child = g.parent(v), parent, prevChild;
+    while (child) {
+      parent = g.parent(child);
+      if (parent) {
+        prevChild = prev[parent];
+        prev[parent] = child;
+      } else {
+        prevChild = rootPrev;
+        rootPrev = child;
+      }
+      if (prevChild && prevChild !== child) {
+        cg.setEdge(prevChild, child);
+        return;
+      }
+      child = parent;
+    }
+  });
+}
+export {
+  addSubgraphConstraints
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/barycenter.mjs

@@ -0,0 +1,29 @@
+import * as _ from "lodash-es";
+function barycenter(g, movable) {
+  return _.map(movable, function(v) {
+    var inV = g.inEdges(v);
+    if (!inV.length) {
+      return { v };
+    } else {
+      var result = _.reduce(
+        inV,
+        function(acc, e) {
+          var edge = g.edge(e), nodeU = g.node(e.v);
+          return {
+            sum: acc.sum + edge.weight * nodeU.order,
+            weight: acc.weight + edge.weight
+          };
+        },
+        { sum: 0, weight: 0 }
+      );
+      return {
+        v,
+        barycenter: result.sum / result.weight,
+        weight: result.weight
+      };
+    }
+  });
+}
+export {
+  barycenter
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.mjs

@@ -0,0 +1,33 @@
+import * as _ from "lodash-es";
+import { Graph } from "../../graphlib/graph.mjs";
+function buildLayerGraph(g, rank, relationship) {
+  var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel(function(v) {
+    return g.node(v);
+  });
+  _.forEach(g.nodes(), function(v) {
+    var node = g.node(v), parent = g.parent(v);
+    if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
+      result.setNode(v);
+      result.setParent(v, parent || root);
+      _.forEach(g[relationship](v), function(e) {
+        var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !_.isUndefined(edge) ? edge.weight : 0;
+        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+      });
+      if (Object.prototype.hasOwnProperty.call(node, "minRank")) {
+        result.setNode(v, {
+          borderLeft: node.borderLeft[rank],
+          borderRight: node.borderRight[rank]
+        });
+      }
+    }
+  });
+  return result;
+}
+function createRootNode(g) {
+  var v;
+  while (g.hasNode(v = _.uniqueId("_root"))) ;
+  return v;
+}
+export {
+  buildLayerGraph
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/cross-count.mjs

@@ -0,0 +1,54 @@
+import * as _ from "lodash-es";
+function crossCount(g, layering) {
+  var cc = 0;
+  for (var i = 1; i < layering.length; ++i) {
+    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+  }
+  return cc;
+}
+function twoLayerCrossCount(g, northLayer, southLayer) {
+  var southPos = _.zipObject(
+    southLayer,
+    _.map(southLayer, function(v, i) {
+      return i;
+    })
+  );
+  var southEntries = _.flatten(
+    _.map(northLayer, function(v) {
+      return _.sortBy(
+        _.map(g.outEdges(v), function(e) {
+          return { pos: southPos[e.w], weight: g.edge(e).weight };
+        }),
+        "pos"
+      );
+    })
+  );
+  var firstIndex = 1;
+  while (firstIndex < southLayer.length) firstIndex <<= 1;
+  var treeSize = 2 * firstIndex - 1;
+  firstIndex -= 1;
+  var tree = _.map(new Array(treeSize), function() {
+    return 0;
+  });
+  var cc = 0;
+  _.forEach(
+    // @ts-expect-error
+    southEntries.forEach(function(entry) {
+      var index = entry.pos + firstIndex;
+      tree[index] += entry.weight;
+      var weightSum = 0;
+      while (index > 0) {
+        if (index % 2) {
+          weightSum += tree[index + 1];
+        }
+        index = index - 1 >> 1;
+        tree[index] += entry.weight;
+      }
+      cc += entry.weight * weightSum;
+    })
+  );
+  return cc;
+}
+export {
+  crossCount
+};

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

@@ -0,0 +1,51 @@
+import * as _ from "lodash-es";
+import { Graph } from "../../graphlib/graph.mjs";
+import { maxRank, buildLayerMatrix } from "../util.mjs";
+import { addSubgraphConstraints } from "./add-subgraph-constraints.mjs";
+import { buildLayerGraph } from "./build-layer-graph.mjs";
+import { crossCount } from "./cross-count.mjs";
+import { initOrder } from "./init-order.mjs";
+import { sortSubgraph } from "./sort-subgraph.mjs";
+function order(g) {
+  var maxRank$1 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank$1 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g, _.range(maxRank$1 - 1, -1, -1), "outEdges");
+  var layering = initOrder(g);
+  assignOrder(g, layering);
+  var bestCC = Number.POSITIVE_INFINITY, best;
+  for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+    sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+    layering = buildLayerMatrix(g);
+    var cc = crossCount(g, layering);
+    if (cc < bestCC) {
+      lastBest = 0;
+      best = _.cloneDeep(layering);
+      bestCC = cc;
+    }
+  }
+  assignOrder(g, best);
+}
+function buildLayerGraphs(g, ranks, relationship) {
+  return _.map(ranks, function(rank) {
+    return buildLayerGraph(g, rank, relationship);
+  });
+}
+function sweepLayerGraphs(layerGraphs, biasRight) {
+  var cg = new Graph();
+  _.forEach(layerGraphs, function(lg) {
+    var root = lg.graph().root;
+    var sorted = sortSubgraph(lg, root, cg, biasRight);
+    _.forEach(sorted.vs, function(v, i) {
+      lg.node(v).order = i;
+    });
+    addSubgraphConstraints(lg, cg, sorted.vs);
+  });
+}
+function assignOrder(g, layering) {
+  _.forEach(layering, function(layer) {
+    _.forEach(layer, function(v, i) {
+      g.node(v).order = i;
+    });
+  });
+}
+export {
+  order
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/init-order.mjs

@@ -0,0 +1,30 @@
+import * as _ from "lodash-es";
+function initOrder(g) {
+  var visited = {};
+  var simpleNodes = _.filter(g.nodes(), function(v) {
+    return !g.children(v).length;
+  });
+  var maxRank = _.max(
+    _.map(simpleNodes, function(v) {
+      return g.node(v).rank;
+    })
+  );
+  var layers = _.map(_.range(maxRank + 1), function() {
+    return [];
+  });
+  function dfs(v) {
+    if (_.has(visited, v)) return;
+    visited[v] = true;
+    var node = g.node(v);
+    layers[node.rank].push(v);
+    _.forEach(g.successors(v), dfs);
+  }
+  var orderedVs = _.sortBy(simpleNodes, function(v) {
+    return g.node(v).rank;
+  });
+  _.forEach(orderedVs, dfs);
+  return layers;
+}
+export {
+  initOrder
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.mjs

@@ -0,0 +1,84 @@
+import * as _ from "lodash-es";
+function resolveConflicts(entries, cg) {
+  var mappedEntries = {};
+  _.forEach(entries, function(entry, i) {
+    var tmp = mappedEntries[entry.v] = {
+      indegree: 0,
+      in: [],
+      out: [],
+      vs: [entry.v],
+      i
+    };
+    if (!_.isUndefined(entry.barycenter)) {
+      tmp.barycenter = entry.barycenter;
+      tmp.weight = entry.weight;
+    }
+  });
+  _.forEach(cg.edges(), function(e) {
+    var entryV = mappedEntries[e.v];
+    var entryW = mappedEntries[e.w];
+    if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
+      entryW.indegree++;
+      entryV.out.push(mappedEntries[e.w]);
+    }
+  });
+  var sourceSet = _.filter(mappedEntries, function(entry) {
+    return !entry.indegree;
+  });
+  return doResolveConflicts(sourceSet);
+}
+function doResolveConflicts(sourceSet) {
+  var entries = [];
+  function handleIn(vEntry) {
+    return function(uEntry) {
+      if (uEntry.merged) {
+        return;
+      }
+      if (_.isUndefined(uEntry.barycenter) || _.isUndefined(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) {
+        mergeEntries(vEntry, uEntry);
+      }
+    };
+  }
+  function handleOut(vEntry) {
+    return function(wEntry) {
+      wEntry["in"].push(vEntry);
+      if (--wEntry.indegree === 0) {
+        sourceSet.push(wEntry);
+      }
+    };
+  }
+  while (sourceSet.length) {
+    var entry = sourceSet.pop();
+    entries.push(entry);
+    _.forEach(entry["in"].reverse(), handleIn(entry));
+    _.forEach(entry.out, handleOut(entry));
+  }
+  return _.map(
+    _.filter(entries, function(entry2) {
+      return !entry2.merged;
+    }),
+    function(entry2) {
+      return _.pick(entry2, ["vs", "i", "barycenter", "weight"]);
+    }
+  );
+}
+function mergeEntries(target, source) {
+  var sum = 0;
+  var weight = 0;
+  if (target.weight) {
+    sum += target.barycenter * target.weight;
+    weight += target.weight;
+  }
+  if (source.weight) {
+    sum += source.barycenter * source.weight;
+    weight += source.weight;
+  }
+  target.vs = source.vs.concat(target.vs);
+  target.barycenter = sum / weight;
+  target.weight = weight;
+  target.i = Math.min(source.i, target.i);
+  source.merged = true;
+}
+export {
+  resolveConflicts
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.mjs

@@ -0,0 +1,66 @@
+import * as _ from "lodash-es";
+import { barycenter } from "./barycenter.mjs";
+import { resolveConflicts } from "./resolve-conflicts.mjs";
+import { sort } from "./sort.mjs";
+function sortSubgraph(g, v, cg, biasRight) {
+  var movable = g.children(v);
+  var node = g.node(v);
+  var bl = node ? node.borderLeft : void 0;
+  var br = node ? node.borderRight : void 0;
+  var subgraphs = {};
+  if (bl) {
+    movable = _.filter(movable, function(w) {
+      return w !== bl && w !== br;
+    });
+  }
+  var barycenters = barycenter(g, movable);
+  _.forEach(barycenters, function(entry) {
+    if (g.children(entry.v).length) {
+      var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+      subgraphs[entry.v] = subgraphResult;
+      if (Object.prototype.hasOwnProperty.call(subgraphResult, "barycenter")) {
+        mergeBarycenters(entry, subgraphResult);
+      }
+    }
+  });
+  var entries = resolveConflicts(barycenters, cg);
+  expandSubgraphs(entries, subgraphs);
+  var result = sort(entries, biasRight);
+  if (bl) {
+    result.vs = _.flatten([bl, result.vs, br]);
+    if (g.predecessors(bl).length) {
+      var blPred = g.node(g.predecessors(bl)[0]), brPred = g.node(g.predecessors(br)[0]);
+      if (!Object.prototype.hasOwnProperty.call(result, "barycenter")) {
+        result.barycenter = 0;
+        result.weight = 0;
+      }
+      result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+      result.weight += 2;
+    }
+  }
+  return result;
+}
+function expandSubgraphs(entries, subgraphs) {
+  _.forEach(entries, function(entry) {
+    entry.vs = _.flatten(
+      entry.vs.map(function(v) {
+        if (subgraphs[v]) {
+          return subgraphs[v].vs;
+        }
+        return v;
+      })
+    );
+  });
+}
+function mergeBarycenters(target, other) {
+  if (!_.isUndefined(target.barycenter)) {
+    target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
+    target.weight += other.weight;
+  } else {
+    target.barycenter = other.barycenter;
+    target.weight = other.weight;
+  }
+}
+export {
+  sortSubgraph
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/order/sort.mjs

@@ -0,0 +1,47 @@
+import * as _ from "lodash-es";
+import { partition } from "../util.mjs";
+function sort(entries, biasRight) {
+  var parts = partition(entries, function(entry) {
+    return Object.prototype.hasOwnProperty.call(entry, "barycenter");
+  });
+  var sortable = parts.lhs, unsortable = _.sortBy(parts.rhs, function(entry) {
+    return -entry.i;
+  }), vs = [], sum = 0, weight = 0, vsIndex = 0;
+  sortable.sort(compareWithBias(!!biasRight));
+  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+  _.forEach(sortable, function(entry) {
+    vsIndex += entry.vs.length;
+    vs.push(entry.vs);
+    sum += entry.barycenter * entry.weight;
+    weight += entry.weight;
+    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+  });
+  var result = { vs: _.flatten(vs) };
+  if (weight) {
+    result.barycenter = sum / weight;
+    result.weight = weight;
+  }
+  return result;
+}
+function consumeUnsortable(vs, unsortable, index) {
+  var last;
+  while (unsortable.length && (last = _.last(unsortable)).i <= index) {
+    unsortable.pop();
+    vs.push(last.vs);
+    index++;
+  }
+  return index;
+}
+function compareWithBias(bias) {
+  return function(entryV, entryW) {
+    if (entryV.barycenter < entryW.barycenter) {
+      return -1;
+    } else if (entryV.barycenter > entryW.barycenter) {
+      return 1;
+    }
+    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
+  };
+}
+export {
+  sort
+};

package/dist/node_modules/.pnpm/dagre-d3-es@7.0.11/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.mjs

@@ -0,0 +1,66 @@
+import * as _ from "lodash-es";
+function parentDummyChains(g) {
+  var postorderNums = postorder(g);
+  _.forEach(g.graph().dummyChains, function(v) {
+    var node = g.node(v);
+    var edgeObj = node.edgeObj;
+    var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+    var path = pathData.path;
+    var lca = pathData.lca;
+    var pathIdx = 0;
+    var pathV = path[pathIdx];
+    var ascending = true;
+    while (v !== edgeObj.w) {
+      node = g.node(v);
+      if (ascending) {
+        while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+          pathIdx++;
+        }
+        if (pathV === lca) {
+          ascending = false;
+        }
+      }
+      if (!ascending) {
+        while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
+          pathIdx++;
+        }
+        pathV = path[pathIdx];
+      }
+      g.setParent(v, pathV);
+      v = g.successors(v)[0];
+    }
+  });
+}
+function findPath(g, postorderNums, v, w) {
+  var vPath = [];
+  var wPath = [];
+  var low = Math.min(postorderNums[v].low, postorderNums[w].low);
+  var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+  var parent;
+  var lca;
+  parent = v;
+  do {
+    parent = g.parent(parent);
+    vPath.push(parent);
+  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+  lca = parent;
+  parent = w;
+  while ((parent = g.parent(parent)) !== lca) {
+    wPath.push(parent);
+  }
+  return { path: vPath.concat(wPath.reverse()), lca };
+}
+function postorder(g) {
+  var result = {};
+  var lim = 0;
+  function dfs(v) {
+    var low = lim;
+    _.forEach(g.children(v), dfs);
+    result[v] = { low, lim: lim++ };
+  }
+  _.forEach(g.children(), dfs);
+  return result;
+}
+export {
+  parentDummyChains
+};