@dagrejs/dagre 1.0.2 → 1.0.4

package/lib/nesting-graph.js

@@ -1,14 +1,14 @@
-var util = require("./util");
+let util = require("./util");
 
 module.exports = {
-  run: run,
-  cleanup: cleanup
+  run,
+  cleanup,
 };
 
 /*
  * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
  * adds appropriate edges to ensure that all cluster nodes are placed between
- * these boundries, and ensures that the graph is connected.
+ * these boundaries, and ensures that the graph is connected.
  *
  * In addition we ensure, through the use of the minlen property, that nodes
  * and subgraph border nodes to not end up on the same rank.
@@ -29,10 +29,10 @@ module.exports = {
  * Graphs."
  */
 function run(g) {
-  var root = util.addDummyNode(g, "root", {}, "_root");
-  var depths = treeDepths(g);
-  var height = Math.max(...Object.values(depths)) - 1; // Note: depths is an Object not an array
-  var nodeSep = 2 * height + 1;
+  let root = util.addDummyNode(g, "root", {}, "_root");
+  let depths = treeDepths(g);
+  let height = Math.max(...Object.values(depths)) - 1; // Note: depths is an Object not an array
+  let nodeSep = 2 * height + 1;
 
   g.graph().nestingRoot = root;
 
@@ -40,12 +40,10 @@ function run(g) {
   g.edges().forEach(e => g.edge(e).minlen *= nodeSep);
 
   // Calculate a weight that is sufficient to keep subgraphs vertically compact
-  var weight = sumWeights(g) + 1;
+  let weight = sumWeights(g) + 1;
 
   // Create border nodes and link them up
-  g.children().forEach(function(child) {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-  });
+  g.children().forEach(child => dfs(g, root, nodeSep, weight, height, depths, child));
 
   // Save the multiplier for node layers for later removal of empty border
   // layers.
@@ -53,7 +51,7 @@ function run(g) {
 }
 
 function dfs(g, root, nodeSep, weight, height, depths, v) {
-  var children = g.children(v);
+  let children = g.children(v);
   if (!children.length) {
     if (v !== root) {
       g.setEdge(root, v, { weight: 0, minlen: nodeSep });
@@ -61,23 +59,23 @@ function dfs(g, root, nodeSep, weight, height, depths, v) {
     return;
   }
 
-  var top = util.addBorderNode(g, "_bt");
-  var bottom = util.addBorderNode(g, "_bb");
-  var label = g.node(v);
+  let top = util.addBorderNode(g, "_bt");
+  let bottom = util.addBorderNode(g, "_bb");
+  let label = g.node(v);
 
   g.setParent(top, v);
   label.borderTop = top;
   g.setParent(bottom, v);
   label.borderBottom = bottom;
 
-  children.forEach(function(child) {
+  children.forEach(child => {
     dfs(g, root, nodeSep, weight, height, depths, child);
 
-    var childNode = g.node(child);
-    var childTop = childNode.borderTop ? childNode.borderTop : child;
-    var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
-    var thisWeight = childNode.borderTop ? weight : 2 * weight;
-    var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+    let childNode = g.node(child);
+    let childTop = childNode.borderTop ? childNode.borderTop : child;
+    let childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+    let thisWeight = childNode.borderTop ? weight : 2 * weight;
+    let minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
 
     g.setEdge(top, childTop, {
       weight: thisWeight,

package/lib/normalize.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var util = require("./util");
+let util = require("./util");
 
 module.exports = {
   run: run,
@@ -29,19 +29,19 @@ function run(g) {
 }
 
 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;
+  let v = e.v;
+  let vRank = g.node(v).rank;
+  let w = e.w;
+  let wRank = g.node(w).rank;
+  let name = e.name;
+  let edgeLabel = g.edge(e);
+  let labelRank = edgeLabel.labelRank;
 
   if (wRank === vRank + 1) return;
 
   g.removeEdge(e);
 
-  var dummy, attrs, i;
+  let dummy, attrs, i;
   for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
     edgeLabel.points = [];
     attrs = {
@@ -67,10 +67,10 @@ function normalizeEdge(g, e) {
 }
 
 function undo(g) {
-  g.graph().dummyChains.forEach(function(v) {
-    var node = g.node(v);
-    var origLabel = node.edgeLabel;
-    var w;
+  g.graph().dummyChains.forEach(v => {
+    let node = g.node(v);
+    let origLabel = node.edgeLabel;
+    let w;
     g.setEdge(node.edgeObj, origLabel);
     while (node.dummy) {
       w = g.successors(v)[0];

package/lib/order/add-subgraph-constraints.js

@@ -1,11 +1,11 @@
 module.exports = addSubgraphConstraints;
 
 function addSubgraphConstraints(g, cg, vs) {
-  var prev = {},
+  let prev = {},
     rootPrev;
 
-  vs.forEach(function(v) {
-    var child = g.parent(v),
+  vs.forEach(v => {
+    let child = g.parent(v),
       parent,
       prevChild;
     while (child) {

package/lib/order/barycenter.js

@@ -2,12 +2,12 @@ module.exports = barycenter;
 
 function barycenter(g, movable = []) {
   return movable.map(v => {
-    var inV = g.inEdges(v);
+    let inV = g.inEdges(v);
     if (!inV.length) {
       return { v: v };
     } else {
-      var result = inV.reduce((acc, e) => {
-        var edge = g.edge(e),
+      let result = inV.reduce((acc, e) => {
+        let edge = g.edge(e),
           nodeU = g.node(e.v);
         return {
           sum: acc.sum + (edge.weight * nodeU.order),

package/lib/order/build-layer-graph.js

@@ -1,5 +1,5 @@
-var Graph = require("@dagrejs/graphlib").Graph;
-var util = require("../util");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
 
 module.exports = buildLayerGraph;
 
@@ -34,12 +34,12 @@ module.exports = buildLayerGraph;
  *       graph is not a multi-graph.
  */
 function buildLayerGraph(g, rank, relationship) {
-  var root = createRootNode(g),
+  let root = createRootNode(g),
     result = new Graph({ compound: true }).setGraph({ root: root })
-      .setDefaultNodeLabel(function(v) { return g.node(v); });
+      .setDefaultNodeLabel(v => g.node(v));
 
-  g.nodes().forEach(function(v) {
-    var node = g.node(v),
+  g.nodes().forEach(v => {
+    let node = g.node(v),
       parent = g.parent(v);
 
     if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
@@ -47,8 +47,8 @@ function buildLayerGraph(g, rank, relationship) {
       result.setParent(v, parent || root);
 
       // This assumes we have only short edges!
-      g[relationship](v).forEach(function(e) {
-        var u = e.v === v ? e.w : e.v,
+      g[relationship](v).forEach(e => {
+        let u = e.v === v ? e.w : e.v,
           edge = result.edge(u, v),
           weight = edge !== undefined ? edge.weight : 0;
         result.setEdge(u, v, { weight: g.edge(e).weight + weight });

package/lib/order/cross-count.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var zipObject = require("../util").zipObject;
+let zipObject = require("../util").zipObject;
 
 module.exports = crossCount;
 
@@ -21,8 +21,8 @@ module.exports = crossCount;
  * This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
  */
 function crossCount(g, layering) {
-  var cc = 0;
-  for (var i = 1; i < layering.length; ++i) {
+  let cc = 0;
+  for (let i = 1; i < layering.length; ++i) {
     cc += twoLayerCrossCount(g, layering[i-1], layering[i]);
   }
   return cc;
@@ -32,26 +32,26 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
   // Sort all of the edges between the north and south layers by their position
   // in the north layer and then the south. Map these edges to the position of
   // their head in the south layer.
-  var southPos = zipObject(southLayer, southLayer.map((v, i) => i));
-  var southEntries = northLayer.flatMap(v => {
+  let southPos = zipObject(southLayer, southLayer.map((v, i) => i));
+  let southEntries = northLayer.flatMap(v => {
     return g.outEdges(v).map(e => {
       return { pos: southPos[e.w], weight: g.edge(e).weight };
     }).sort((a, b) => a.pos - b.pos);
   });
 
   // Build the accumulator tree
-  var firstIndex = 1;
+  let firstIndex = 1;
   while (firstIndex < southLayer.length) firstIndex <<= 1;
-  var treeSize = 2 * firstIndex - 1;
+  let treeSize = 2 * firstIndex - 1;
   firstIndex -= 1;
-  var tree = new Array(treeSize).fill(0);
+  let tree = new Array(treeSize).fill(0);
 
   // Calculate the weighted crossings
-  var cc = 0;
+  let cc = 0;
   southEntries.forEach(entry => {
-    var index = entry.pos + firstIndex;
+    let index = entry.pos + firstIndex;
     tree[index] += entry.weight;
-    var weightSum = 0;
+    let weightSum = 0;
     while (index > 0) {
       if (index % 2) {
         weightSum += tree[index + 1];

package/lib/order/index.js

@@ -1,12 +1,12 @@
 "use strict";
 
-var initOrder = require("./init-order");
-var crossCount = require("./cross-count");
-var sortSubgraph = require("./sort-subgraph");
-var buildLayerGraph = require("./build-layer-graph");
-var addSubgraphConstraints = require("./add-subgraph-constraints");
-var Graph = require("@dagrejs/graphlib").Graph;
-var util = require("../util");
+let initOrder = require("./init-order");
+let crossCount = require("./cross-count");
+let sortSubgraph = require("./sort-subgraph");
+let buildLayerGraph = require("./build-layer-graph");
+let addSubgraphConstraints = require("./add-subgraph-constraints");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
 
 module.exports = order;
 
@@ -26,21 +26,21 @@ module.exports = order;
  *       algorithm.
  */
 function order(g) {
-  var maxRank = util.maxRank(g),
+  let maxRank = util.maxRank(g),
     downLayerGraphs = buildLayerGraphs(g, util.range(1, maxRank + 1), "inEdges"),
     upLayerGraphs = buildLayerGraphs(g, util.range(maxRank - 1, -1, -1), "outEdges");
 
-  var layering = initOrder(g);
+  let layering = initOrder(g);
   assignOrder(g, layering);
 
-  var bestCC = Number.POSITIVE_INFINITY,
+  let bestCC = Number.POSITIVE_INFINITY,
     best;
 
-  for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+  for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
     sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
 
     layering = util.buildLayerMatrix(g);
-    var cc = crossCount(g, layering);
+    let cc = crossCount(g, layering);
     if (cc < bestCC) {
       lastBest = 0;
       best = Object.assign({}, layering);
@@ -58,10 +58,10 @@ function buildLayerGraphs(g, ranks, relationship) {
 }
 
 function sweepLayerGraphs(layerGraphs, biasRight) {
-  var cg = new Graph();
+  let cg = new Graph();
   layerGraphs.forEach(function(lg) {
-    var root = lg.graph().root;
-    var sorted = sortSubgraph(lg, root, cg, biasRight);
+    let root = lg.graph().root;
+    let sorted = sortSubgraph(lg, root, cg, biasRight);
     sorted.vs.forEach((v, i) => lg.node(v).order = i);
     addSubgraphConstraints(lg, cg, sorted.vs);
   });

package/lib/order/init-order.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var util = require("../util");
+let util = require("../util");
 
 module.exports = initOrder;
 
@@ -16,20 +16,20 @@ module.exports = initOrder;
  * the order of its nodes.
  */
 function initOrder(g) {
-  var visited = {};
-  var simpleNodes = g.nodes().filter(v => !g.children(v).length);
-  var maxRank = Math.max(...simpleNodes.map(v => g.node(v).rank));
-  var layers = util.range(maxRank + 1).map(() => []);
+  let visited = {};
+  let simpleNodes = g.nodes().filter(v => !g.children(v).length);
+  let maxRank = Math.max(...simpleNodes.map(v => g.node(v).rank));
+  let layers = util.range(maxRank + 1).map(() => []);
 
   function dfs(v) {
     if (visited[v]) return;
     visited[v] = true;
-    var node = g.node(v);
+    let node = g.node(v);
     layers[node.rank].push(v);
     g.successors(v).forEach(dfs);
   }
 
-  var orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
+  let orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
   orderedVs.forEach(dfs);
 
   return layers;

package/lib/order/resolve-conflicts.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var util = require("../util");
+let util = require("../util");
 
 module.exports = resolveConflicts;
 
@@ -30,9 +30,9 @@ module.exports = resolveConflicts;
  *    elements in `vs`.
  */
 function resolveConflicts(entries, cg) {
-  var mappedEntries = {};
+  let mappedEntries = {};
   entries.forEach((entry, i) => {
-    var tmp = mappedEntries[entry.v] = {
+    let tmp = mappedEntries[entry.v] = {
       indegree: 0,
       "in": [],
       out: [],
@@ -46,24 +46,24 @@ function resolveConflicts(entries, cg) {
   });
 
   cg.edges().forEach(e => {
-    var entryV = mappedEntries[e.v];
-    var entryW = mappedEntries[e.w];
+    let entryV = mappedEntries[e.v];
+    let entryW = mappedEntries[e.w];
     if (entryV !== undefined && entryW !== undefined) {
       entryW.indegree++;
       entryV.out.push(mappedEntries[e.w]);
     }
   });
 
-  var sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
+  let sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
 
   return doResolveConflicts(sourceSet);
 }
 
 function doResolveConflicts(sourceSet) {
-  var entries = [];
+  let entries = [];
 
   function handleIn(vEntry) {
-    return function(uEntry) {
+    return uEntry => {
       if (uEntry.merged) {
         return;
       }
@@ -76,7 +76,7 @@ function doResolveConflicts(sourceSet) {
   }
 
   function handleOut(vEntry) {
-    return function(wEntry) {
+    return wEntry => {
       wEntry["in"].push(vEntry);
       if (--wEntry.indegree === 0) {
         sourceSet.push(wEntry);
@@ -85,7 +85,7 @@ function doResolveConflicts(sourceSet) {
   }
 
   while (sourceSet.length) {
-    var entry = sourceSet.pop();
+    let entry = sourceSet.pop();
     entries.push(entry);
     entry["in"].reverse().forEach(handleIn(entry));
     entry.out.forEach(handleOut(entry));
@@ -97,8 +97,8 @@ function doResolveConflicts(sourceSet) {
 }
 
 function mergeEntries(target, source) {
-  var sum = 0;
-  var weight = 0;
+  let sum = 0;
+  let weight = 0;
 
   if (target.weight) {
     sum += target.barycenter * target.weight;

package/lib/order/sort-subgraph.js

@@ -1,24 +1,24 @@
-var barycenter = require("./barycenter");
-var resolveConflicts = require("./resolve-conflicts");
-var sort = require("./sort");
+let barycenter = require("./barycenter");
+let resolveConflicts = require("./resolve-conflicts");
+let sort = require("./sort");
 
 module.exports = sortSubgraph;
 
 function sortSubgraph(g, v, cg, biasRight) {
-  var movable = g.children(v);
-  var node = g.node(v);
-  var bl = node ? node.borderLeft : undefined;
-  var br = node ? node.borderRight: undefined;
-  var subgraphs = {};
+  let movable = g.children(v);
+  let node = g.node(v);
+  let bl = node ? node.borderLeft : undefined;
+  let br = node ? node.borderRight: undefined;
+  let subgraphs = {};
 
   if (bl) {
     movable = movable.filter(w => w !== bl && w !== br);
   }
 
-  var barycenters = barycenter(g, movable);
-  barycenters.forEach(function(entry) {
+  let barycenters = barycenter(g, movable);
+  barycenters.forEach(entry => {
     if (g.children(entry.v).length) {
-      var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+      let subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
       subgraphs[entry.v] = subgraphResult;
       if (subgraphResult.hasOwnProperty("barycenter")) {
         mergeBarycenters(entry, subgraphResult);
@@ -26,15 +26,15 @@ function sortSubgraph(g, v, cg, biasRight) {
     }
   });
 
-  var entries = resolveConflicts(barycenters, cg);
+  let entries = resolveConflicts(barycenters, cg);
   expandSubgraphs(entries, subgraphs);
 
-  var result = sort(entries, biasRight);
+  let result = sort(entries, biasRight);
 
   if (bl) {
     result.vs = [bl, result.vs, br].flat(true);
     if (g.predecessors(bl).length) {
-      var blPred = g.node(g.predecessors(bl)[0]),
+      let blPred = g.node(g.predecessors(bl)[0]),
         brPred = g.node(g.predecessors(br)[0]);
       if (!result.hasOwnProperty("barycenter")) {
         result.barycenter = 0;
@@ -50,8 +50,8 @@ function sortSubgraph(g, v, cg, biasRight) {
 }
 
 function expandSubgraphs(entries, subgraphs) {
-  entries.forEach(function(entry) {
-    entry.vs = entry.vs.flatMap(function(v) {
+  entries.forEach(entry => {
+    entry.vs = entry.vs.flatMap(v => {
       if (subgraphs[v]) {
         return subgraphs[v].vs;
       }

package/lib/order/sort.js

@@ -1,12 +1,12 @@
-var util = require("../util");
+let util = require("../util");
 
 module.exports = sort;
 
 function sort(entries, biasRight) {
-  var parts = util.partition(entries, function(entry) {
+  let parts = util.partition(entries, entry => {
     return entry.hasOwnProperty("barycenter");
   });
-  var sortable = parts.lhs,
+  let sortable = parts.lhs,
     unsortable = parts.rhs.sort((a, b) => b.i - a.i),
     vs = [],
     sum = 0,
@@ -17,7 +17,7 @@ function sort(entries, biasRight) {
 
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
 
-  sortable.forEach(function (entry) {
+  sortable.forEach(entry => {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
     sum += entry.barycenter * entry.weight;
@@ -25,7 +25,7 @@ function sort(entries, biasRight) {
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
   });
 
-  var result = { vs: vs.flat(true) };
+  let result = { vs: vs.flat(true) };
   if (weight) {
     result.barycenter = sum / weight;
     result.weight = weight;
@@ -34,7 +34,7 @@ function sort(entries, biasRight) {
 }
 
 function consumeUnsortable(vs, unsortable, index) {
-  var last;
+  let last;
   while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= index) {
     unsortable.pop();
     vs.push(last.vs);
@@ -44,7 +44,7 @@ function consumeUnsortable(vs, unsortable, index) {
 }
 
 function compareWithBias(bias) {
-  return function(entryV, entryW) {
+  return (entryV, entryW) => {
     if (entryV.barycenter < entryW.barycenter) {
       return -1;
     } else if (entryV.barycenter > entryW.barycenter) {

package/lib/parent-dummy-chains.js

@@ -1,17 +1,17 @@
 module.exports = parentDummyChains;
 
 function parentDummyChains(g) {
-  var postorderNums = postorder(g);
+  let postorderNums = postorder(g);
 
-  g.graph().dummyChains.forEach(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;
+  g.graph().dummyChains.forEach(v => {
+    let node = g.node(v);
+    let edgeObj = node.edgeObj;
+    let pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+    let path = pathData.path;
+    let lca = pathData.lca;
+    let pathIdx = 0;
+    let pathV = path[pathIdx];
+    let ascending = true;
 
     while (v !== edgeObj.w) {
       node = g.node(v);
@@ -44,12 +44,12 @@ function parentDummyChains(g) {
 // Find a path from v to w through the lowest common ancestor (LCA). Return the
 // full path and the LCA.
 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;
+  let vPath = [];
+  let wPath = [];
+  let low = Math.min(postorderNums[v].low, postorderNums[w].low);
+  let lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+  let parent;
+  let lca;
 
   // Traverse up from v to find the LCA
   parent = v;
@@ -70,11 +70,11 @@ function findPath(g, postorderNums, v, w) {
 }
 
 function postorder(g) {
-  var result = {};
-  var lim = 0;
+  let result = {};
+  let lim = 0;
 
   function dfs(v) {
-    var low = lim;
+    let low = lim;
     g.children(v).forEach(dfs);
     result[v] = { low: low, lim: lim++ };
   }