@dagrejs/dagre 0.8.0 → 1.0.1

package/lib/order/cross-count.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var _ = require("../lodash");
+var zipObject = require("../util").zipObject;
 
 module.exports = crossCount;
 
@@ -32,27 +32,23 @@ 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,
-                             _.map(southLayer, function (v, i) { return i; }));
-  var southEntries = _.flatten(_.map(northLayer, function(v) {
-    return _.chain(g.outEdges(v))
-            .map(function(e) {
-              return { pos: southPos[e.w], weight: g.edge(e).weight };
-            })
-            .sortBy("pos")
-            .value();
-  }), true);
+  var southPos = zipObject(southLayer, southLayer.map((v, i) => i));
+  var 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;
   while (firstIndex < southLayer.length) firstIndex <<= 1;
   var treeSize = 2 * firstIndex - 1;
   firstIndex -= 1;
-  var tree = _.map(new Array(treeSize), function() { return 0; });
+  var tree = new Array(treeSize).fill(0);
 
   // Calculate the weighted crossings
   var cc = 0;
-  _.forEach(southEntries.forEach(function(entry) {
+  southEntries.forEach(entry => {
     var index = entry.pos + firstIndex;
     tree[index] += entry.weight;
     var weightSum = 0;
@@ -64,7 +60,7 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
       tree[index] += entry.weight;
     }
     cc += entry.weight * weightSum;
-  }));
+  });
 
   return cc;
 }

package/lib/order/index.js

@@ -1,13 +1,12 @@
 "use strict";
 
-var _ = require("../lodash"),
-    initOrder = require("./init-order"),
-    crossCount = require("./cross-count"),
-    sortSubgraph = require("./sort-subgraph"),
-    buildLayerGraph = require("./build-layer-graph"),
-    addSubgraphConstraints = require("./add-subgraph-constraints"),
-    Graph = require("../graphlib").Graph,
-    util = require("../util");
+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");
 
 module.exports = order;
 
@@ -28,14 +27,14 @@ module.exports = order;
  */
 function order(g) {
   var maxRank = util.maxRank(g),
-      downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank + 1), "inEdges"),
-      upLayerGraphs = buildLayerGraphs(g, _.range(maxRank - 1, -1, -1), "outEdges");
+    downLayerGraphs = buildLayerGraphs(g, util.range(1, maxRank + 1), "inEdges"),
+    upLayerGraphs = buildLayerGraphs(g, util.range(maxRank - 1, -1, -1), "outEdges");
 
   var layering = initOrder(g);
   assignOrder(g, layering);
 
   var bestCC = Number.POSITIVE_INFINITY,
-      best;
+    best;
 
   for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
     sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
@@ -44,7 +43,7 @@ function order(g) {
     var cc = crossCount(g, layering);
     if (cc < bestCC) {
       lastBest = 0;
-      best = _.cloneDeep(layering);
+      best = Object.assign({}, layering);
       bestCC = cc;
     }
   }
@@ -53,27 +52,21 @@ function order(g) {
 }
 
 function buildLayerGraphs(g, ranks, relationship) {
-  return _.map(ranks, function(rank) {
+  return ranks.map(function(rank) {
     return buildLayerGraph(g, rank, relationship);
   });
 }
 
 function sweepLayerGraphs(layerGraphs, biasRight) {
   var cg = new Graph();
-  _.forEach(layerGraphs, function(lg) {
+  layerGraphs.forEach(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;
-    });
+    sorted.vs.forEach((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;
-    });
-  });
+  Object.values(layering).forEach(layer => layer.forEach((v, i) => g.node(v).order = i));
 }

package/lib/order/init-order.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var _ = require("../lodash");
+var util = require("../util");
 
 module.exports = initOrder;
 
@@ -16,23 +16,21 @@ module.exports = initOrder;
  * the order of its nodes.
  */
 function initOrder(g) {
-  var visited = {},
-      simpleNodes = _.filter(g.nodes(), function(v) {
-        return !g.children(v).length;
-      }),
-      maxRank = _.max(_.map(simpleNodes, function(v) { return g.node(v).rank; })),
-      layers = _.map(_.range(maxRank + 1), function() { return []; });
+  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(() => []);
 
   function dfs(v) {
-    if (_.has(visited, v)) return;
+    if (visited[v]) return;
     visited[v] = true;
     var node = g.node(v);
     layers[node.rank].push(v);
-    _.forEach(g.successors(v), dfs);
+    g.successors(v).forEach(dfs);
   }
 
-  var orderedVs = _.sortBy(simpleNodes, function(v) { return g.node(v).rank; });
-  _.forEach(orderedVs, dfs);
+  var 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 _ = require("../lodash");
+var util = require("../util");
 
 module.exports = resolveConflicts;
 
@@ -31,7 +31,7 @@ module.exports = resolveConflicts;
  */
 function resolveConflicts(entries, cg) {
   var mappedEntries = {};
-  _.forEach(entries, function(entry, i) {
+  entries.forEach((entry, i) => {
     var tmp = mappedEntries[entry.v] = {
       indegree: 0,
       "in": [],
@@ -39,24 +39,22 @@ function resolveConflicts(entries, cg) {
       vs: [entry.v],
       i: i
     };
-    if (!_.isUndefined(entry.barycenter)) {
+    if (entry.barycenter !== undefined) {
       tmp.barycenter = entry.barycenter;
       tmp.weight = entry.weight;
     }
   });
 
-  _.forEach(cg.edges(), function(e) {
-    var entryV = mappedEntries[e.v],
-        entryW = mappedEntries[e.w];
-    if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
+  cg.edges().forEach(e => {
+    var entryV = mappedEntries[e.v];
+    var entryW = mappedEntries[e.w];
+    if (entryV !== undefined && entryW !== undefined) {
       entryW.indegree++;
       entryV.out.push(mappedEntries[e.w]);
     }
   });
 
-  var sourceSet = _.filter(mappedEntries, function(entry) {
-    return !entry.indegree;
-  });
+  var sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
 
   return doResolveConflicts(sourceSet);
 }
@@ -69,8 +67,8 @@ function doResolveConflicts(sourceSet) {
       if (uEntry.merged) {
         return;
       }
-      if (_.isUndefined(uEntry.barycenter) ||
-          _.isUndefined(vEntry.barycenter) ||
+      if (uEntry.barycenter === undefined ||
+          vEntry.barycenter === undefined ||
           uEntry.barycenter >= vEntry.barycenter) {
         mergeEntries(vEntry, uEntry);
       }
@@ -89,21 +87,18 @@ function doResolveConflicts(sourceSet) {
   while (sourceSet.length) {
     var entry = sourceSet.pop();
     entries.push(entry);
-    _.forEach(entry["in"].reverse(), handleIn(entry));
-    _.forEach(entry.out, handleOut(entry));
+    entry["in"].reverse().forEach(handleIn(entry));
+    entry.out.forEach(handleOut(entry));
   }
 
-  return _.chain(entries)
-          .filter(function(entry) { return !entry.merged; })
-          .map(function(entry) {
-            return _.pick(entry, ["vs", "i", "barycenter", "weight"]);
-          })
-          .value();
+  return entries.filter(entry => !entry.merged).map(entry => {
+    return util.pick(entry, ["vs", "i", "barycenter", "weight"]);
+  });
 }
 
 function mergeEntries(target, source) {
-  var sum = 0,
-      weight = 0;
+  var sum = 0;
+  var weight = 0;
 
   if (target.weight) {
     sum += target.barycenter * target.weight;

package/lib/order/sort-subgraph.js

@@ -1,29 +1,26 @@
-var _ = require("../lodash"),
-    barycenter = require("./barycenter"),
-    resolveConflicts = require("./resolve-conflicts"),
-    sort = require("./sort");
+var barycenter = require("./barycenter");
+var resolveConflicts = require("./resolve-conflicts");
+var sort = require("./sort");
 
 module.exports = sortSubgraph;
 
 function sortSubgraph(g, v, cg, biasRight) {
-  var movable = g.children(v),
-      node = g.node(v),
-      bl = node ? node.borderLeft : undefined,
-      br = node ? node.borderRight: undefined,
-      subgraphs = {};
+  var movable = g.children(v);
+  var node = g.node(v);
+  var bl = node ? node.borderLeft : undefined;
+  var br = node ? node.borderRight: undefined;
+  var subgraphs = {};
 
   if (bl) {
-    movable = _.filter(movable, function(w) {
-      return w !== bl && w !== br;
-    });
+    movable = movable.filter(w => w !== bl && w !== br);
   }
 
   var barycenters = barycenter(g, movable);
-  _.forEach(barycenters, function(entry) {
+  barycenters.forEach(function(entry) {
     if (g.children(entry.v).length) {
       var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
       subgraphs[entry.v] = subgraphResult;
-      if (_.has(subgraphResult, "barycenter")) {
+      if (subgraphResult.hasOwnProperty("barycenter")) {
         mergeBarycenters(entry, subgraphResult);
       }
     }
@@ -35,11 +32,11 @@ function sortSubgraph(g, v, cg, biasRight) {
   var result = sort(entries, biasRight);
 
   if (bl) {
-    result.vs = _.flatten([bl, result.vs, br], true);
+    result.vs = [bl, result.vs, br].flat(true);
     if (g.predecessors(bl).length) {
       var blPred = g.node(g.predecessors(bl)[0]),
-          brPred = g.node(g.predecessors(br)[0]);
-      if (!_.has(result, "barycenter")) {
+        brPred = g.node(g.predecessors(br)[0]);
+      if (!result.hasOwnProperty("barycenter")) {
         result.barycenter = 0;
         result.weight = 0;
       }
@@ -53,18 +50,18 @@ function sortSubgraph(g, v, cg, biasRight) {
 }
 
 function expandSubgraphs(entries, subgraphs) {
-  _.forEach(entries, function(entry) {
-    entry.vs = _.flatten(entry.vs.map(function(v) {
+  entries.forEach(function(entry) {
+    entry.vs = entry.vs.flatMap(function(v) {
       if (subgraphs[v]) {
         return subgraphs[v].vs;
       }
       return v;
-    }), true);
+    });
   });
 }
 
 function mergeBarycenters(target, other) {
-  if (!_.isUndefined(target.barycenter)) {
+  if (target.barycenter !== undefined) {
     target.barycenter = (target.barycenter * target.weight +
                          other.barycenter * other.weight) /
                         (target.weight + other.weight);

package/lib/order/sort.js

@@ -1,24 +1,23 @@
-var _ = require("../lodash"),
-    util = require("../util");
+var util = require("../util");
 
 module.exports = sort;
 
 function sort(entries, biasRight) {
   var parts = util.partition(entries, function(entry) {
-    return _.has(entry, "barycenter");
+    return entry.hasOwnProperty("barycenter");
   });
   var sortable = parts.lhs,
-      unsortable = _.sortBy(parts.rhs, function(entry) { return -entry.i; }),
-      vs = [],
-      sum = 0,
-      weight = 0,
-      vsIndex = 0;
+    unsortable = parts.rhs.sort((a, b) => b.i - a.i),
+    vs = [],
+    sum = 0,
+    weight = 0,
+    vsIndex = 0;
 
   sortable.sort(compareWithBias(!!biasRight));
 
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
 
-  _.forEach(sortable, function (entry) {
+  sortable.forEach(function (entry) {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
     sum += entry.barycenter * entry.weight;
@@ -26,7 +25,7 @@ function sort(entries, biasRight) {
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
   });
 
-  var result = { vs: _.flatten(vs, true) };
+  var result = { vs: vs.flat(true) };
   if (weight) {
     result.barycenter = sum / weight;
     result.weight = weight;
@@ -36,7 +35,7 @@ function sort(entries, biasRight) {
 
 function consumeUnsortable(vs, unsortable, index) {
   var last;
-  while (unsortable.length && (last = _.last(unsortable)).i <= index) {
+  while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= index) {
     unsortable.pop();
     vs.push(last.vs);
     index++;

package/lib/parent-dummy-chains.js

@@ -1,19 +1,17 @@
-var _ = require("./lodash");
-
 module.exports = parentDummyChains;
 
 function parentDummyChains(g) {
   var postorderNums = postorder(g);
 
-  _.forEach(g.graph().dummyChains, function(v) {
-    var node = g.node(v),
-        edgeObj = node.edgeObj,
-        pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w),
-        path = pathData.path,
-        lca = pathData.lca,
-        pathIdx = 0,
-        pathV = path[pathIdx],
-        ascending = true;
+  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;
 
     while (v !== edgeObj.w) {
       node = g.node(v);
@@ -46,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 = [],
-      wPath = [],
-      low = Math.min(postorderNums[v].low, postorderNums[w].low),
-      lim = Math.max(postorderNums[v].lim, postorderNums[w].lim),
-      parent,
-      lca;
+  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;
 
   // Traverse up from v to find the LCA
   parent = v;
@@ -72,15 +70,15 @@ function findPath(g, postorderNums, v, w) {
 }
 
 function postorder(g) {
-  var result = {},
-      lim = 0;
+  var result = {};
+  var lim = 0;
 
   function dfs(v) {
     var low = lim;
-    _.forEach(g.children(v), dfs);
+    g.children(v).forEach(dfs);
     result[v] = { low: low, lim: lim++ };
   }
-  _.forEach(g.children(), dfs);
+  g.children().forEach(dfs);
 
   return result;
 }