@dagrejs/dagre 0.7.5 → 1.0.0

package/lib/position/bk.js

@@ -1,8 +1,7 @@
 "use strict";
 
-var _ = require("../lodash"),
-    Graph = require("../graphlib").Graph,
-    util = require("../util");
+var Graph = require("@dagrejs/graphlib").Graph;
+var util = require("../util");
 
 /*
  * This module provides coordinate assignment based on Brandes and Köpf, "Fast
@@ -51,17 +50,17 @@ function findType1Conflicts(g, layering) {
       // segment.
       scanPos = 0,
       prevLayerLength = prevLayer.length,
-      lastNode = _.last(layer);
+      lastNode = layer[layer.length - 1];
 
-    _.each(layer, function(v, i) {
+    layer.forEach(function(v, i) {
       var w = findOtherInnerSegmentNode(g, v),
-          k1 = w ? g.node(w).order : prevLayerLength;
+        k1 = w ? g.node(w).order : prevLayerLength;
 
       if (w || v === lastNode) {
-        _.each(layer.slice(scanPos, i +1), function(scanNode) {
-          _.each(g.predecessors(scanNode), function(u) {
+        layer.slice(scanPos, i+1).forEach(function(scanNode) {
+          g.predecessors(scanNode).forEach(function(u) {
             var uLabel = g.node(u),
-                uPos = uLabel.order;
+              uPos = uLabel.order;
             if ((uPos < k0 || k1 < uPos) &&
                 !(uLabel.dummy && g.node(scanNode).dummy)) {
               addConflict(conflicts, u, scanNode);
@@ -76,7 +75,7 @@ function findType1Conflicts(g, layering) {
     return layer;
   }
 
-  _.reduce(layering, visitLayer);
+  layering.reduce(visitLayer);
   return conflicts;
 }
 
@@ -85,10 +84,10 @@ function findType2Conflicts(g, layering) {
 
   function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
     var v;
-    _.each(_.range(southPos, southEnd), function(i) {
+    util.range(southPos, southEnd).forEach(function(i) {
       v = south[i];
       if (g.node(v).dummy) {
-        _.each(g.predecessors(v), function(u) {
+        g.predecessors(v).forEach(function(u) {
           var uNode = g.node(u);
           if (uNode.dummy &&
               (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
@@ -102,10 +101,10 @@ function findType2Conflicts(g, layering) {
 
   function visitLayer(north, south) {
     var prevNorthPos = -1,
-        nextNorthPos,
-        southPos = 0;
+      nextNorthPos,
+      southPos = 0;
 
-    _.each(south, function(v, southLookahead) {
+    south.forEach(function(v, southLookahead) {
       if (g.node(v).dummy === "border") {
         var predecessors = g.predecessors(v);
         if (predecessors.length) {
@@ -121,15 +120,13 @@ function findType2Conflicts(g, layering) {
     return south;
   }
 
-  _.reduce(layering, visitLayer);
+  layering.reduce(visitLayer);
   return conflicts;
 }
 
 function findOtherInnerSegmentNode(g, v) {
   if (g.node(v).dummy) {
-    return _.find(g.predecessors(v), function(u) {
-      return g.node(u).dummy;
-    });
+    return g.predecessors(v).find(u => g.node(u).dummy);
   }
 }
 
@@ -153,7 +150,7 @@ function hasConflict(conflicts, v, w) {
     v = w;
     w = tmp;
   }
-  return _.has(conflicts[v], w);
+  return !!conflicts[v] && conflicts[v].hasOwnProperty(w);
 }
 
 /*
@@ -166,26 +163,26 @@ function hasConflict(conflicts, v, w) {
  */
 function verticalAlignment(g, layering, conflicts, neighborFn) {
   var root = {},
-      align = {},
-      pos = {};
+    align = {},
+    pos = {};
 
   // We cache the position here based on the layering because the graph and
   // layering may be out of sync. The layering matrix is manipulated to
   // generate different extreme alignments.
-  _.each(layering, function(layer) {
-    _.each(layer, function(v, order) {
+  layering.forEach(function(layer) {
+    layer.forEach(function(v, order) {
       root[v] = v;
       align[v] = v;
       pos[v] = order;
     });
   });
 
-  _.each(layering, function(layer) {
+  layering.forEach(function(layer) {
     var prevIdx = -1;
-    _.each(layer, function(v) {
+    layer.forEach(function(v) {
       var ws = neighborFn(v);
       if (ws.length) {
-        ws = _.sortBy(ws, function(w) { return pos[w]; });
+        ws = ws.sort((a, b) => pos[a] - pos[b]);
         var mp = (ws.length - 1) / 2;
         for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
           var w = ws[i];
@@ -211,41 +208,50 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
   // coordinates. The second sweep removes unused space by moving blocks to the
   // greatest coordinates without violating separation.
   var xs = {},
-      blockG = buildBlockGraph(g, layering, root, reverseSep);
-
-  // First pass, assign smallest coordinates via DFS
-  var visited = {};
-  function pass1(v) {
-    if (!_.has(visited, v)) {
-      visited[v] = true;
-      xs[v] = _.reduce(blockG.inEdges(v), function(max, e) {
-        pass1(e.v);
-        return Math.max(max, xs[e.v] + blockG.edge(e));
-      }, 0);
+    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();
     }
   }
-  _.each(blockG.nodes(), pass1);
-
-  var borderType = reverseSep ? "borderLeft" : "borderRight";
-  function pass2(v) {
-    if (visited[v] !== 2) {
-      visited[v]++;
-      var node = g.node(v);
-      var min = _.reduce(blockG.outEdges(v), function(min, e) {
-        pass2(e.w);
-        return Math.min(min, xs[e.w] - blockG.edge(e));
-      }, Number.POSITIVE_INFINITY);
-      if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
-        xs[v] = Math.max(xs[v], min);
-      }
+
+  // First pass, assign smallest coordinates
+  function pass1(elem) {
+    xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {
+      return Math.max(acc, xs[e.v] + blockG.edge(e));
+    }, 0);
+  }
+
+  // Second pass, assign greatest coordinates
+  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);
     }
   }
-  _.each(blockG.nodes(), pass2);
+
+  iterate(pass1, blockG.predecessors.bind(blockG));
+  iterate(pass2, blockG.successors.bind(blockG));
 
   // Assign x coordinates to all nodes
-  _.each(align, function(v) {
-    xs[v] = xs[root[v]];
-  });
+  Object.keys(align).forEach(v => xs[v] = xs[root[v]]);
 
   return xs;
 }
@@ -253,17 +259,17 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
 
 function buildBlockGraph(g, layering, root, reverseSep) {
   var blockGraph = new Graph(),
-      graphLabel = g.graph(),
-      sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+    graphLabel = g.graph(),
+    sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
 
-  _.each(layering, function(layer) {
+  layering.forEach(function(layer) {
     var u;
-    _.each(layer, function(v) {
+    layer.forEach(function(v) {
       var vRoot = root[v];
       blockGraph.setNode(vRoot);
       if (u) {
         var uRoot = root[u],
-            prevMax = blockGraph.edge(uRoot, vRoot);
+          prevMax = blockGraph.edge(uRoot, vRoot);
         blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
       }
       u = v;
@@ -277,11 +283,23 @@ function buildBlockGraph(g, layering, root, reverseSep) {
  * Returns the alignment that has the smallest width of the given alignments.
  */
 function findSmallestWidthAlignment(g, xss) {
-  return _.min(xss, function(xs) {
-    var min = _.min(xs, function(x, v) { return x - width(g, v) / 2; }),
-        max = _.max(xs, function(x, v) { return x + width(g, v) / 2; });
-    return max - min;
-  });
+  return Object.values(xss).reduce((currentMinAndXs, xs) => {
+    var max = Number.NEGATIVE_INFINITY;
+    var min = Number.POSITIVE_INFINITY;
+
+    Object.entries(xs).forEach(([v, x]) => {
+      var halfWidth = width(g, v) / 2;
+
+      max = Math.max(x + halfWidth, max);
+      min = Math.min(x - halfWidth, min);
+    });
+
+    const newMin = max - min;
+    if (newMin < currentMinAndXs[0]) {
+      currentMinAndXs = [newMin, xs];
+    }
+    return currentMinAndXs;
+  }, [Number.POSITIVE_INFINITY, null])[1];
 }
 
 /*
@@ -292,64 +310,70 @@ function findSmallestWidthAlignment(g, xss) {
  * coordinate of the smallest width alignment.
  */
 function alignCoordinates(xss, alignTo) {
-  var alignToMin = _.min(alignTo),
-      alignToMax = _.max(alignTo);
+  var alignToVals = Object.values(alignTo),
+    alignToMin = Math.min(...alignToVals),
+    alignToMax = Math.max(...alignToVals);
 
-  _.each(["u", "d"], function(vert) {
-    _.each(["l", "r"], function(horiz) {
+  ["u", "d"].forEach(function(vert) {
+    ["l", "r"].forEach(function(horiz) {
       var alignment = vert + horiz,
-          xs = xss[alignment],
-          delta;
+        xs = xss[alignment];
+
       if (xs === alignTo) return;
 
-      delta = horiz === "l" ? alignToMin - _.min(xs) : alignToMax - _.max(xs);
+      var xsVals = Object.values(xs);
+      let delta = alignToMin - Math.min(...xsVals);
+      if (horiz !== "l") {
+        delta = alignToMax - Math.max(...xsVals);
+      }
 
       if (delta) {
-        xss[alignment] = _.mapValues(xs, function(x) { return x + delta; });
+        xss[alignment] = util.mapValues(xs, x => x + delta);
       }
     });
   });
 }
 
 function balance(xss, align) {
-  return _.mapValues(xss.ul, function(ignore, v) {
+  return util.mapValues(xss.ul, function(num, v) {
     if (align) {
       return xss[align.toLowerCase()][v];
     } else {
-      var xs = _.sortBy(_.pluck(xss, v));
+      var xs = Object.values(xss).map(xs => xs[v]).sort((a, b) => a - b);
       return (xs[1] + xs[2]) / 2;
     }
   });
 }
 
 function positionX(g) {
-  var layering = util.buildLayerMatrix(g),
-      conflicts = _.merge(findType1Conflicts(g, layering),
-                          findType2Conflicts(g, layering));
-
-  var xss = {},
-      adjustedLayering;
-  _.each(["u", "d"], function(vert) {
-    adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
-    _.each(["l", "r"], function(horiz) {
+  var layering = util.buildLayerMatrix(g);
+  var conflicts = Object.assign(
+    findType1Conflicts(g, layering),
+    findType2Conflicts(g, layering));
+
+  var xss = {};
+  var adjustedLayering;
+  ["u", "d"].forEach(function(vert) {
+    adjustedLayering = vert === "u" ? layering : Object.values(layering).reverse();
+    ["l", "r"].forEach(function(horiz) {
       if (horiz === "r") {
-        adjustedLayering = _.map(adjustedLayering, function(inner) {
-          return _.values(inner).reverse();
+        adjustedLayering = adjustedLayering.map(inner => {
+          return Object.values(inner).reverse();
         });
       }
 
-      var neighborFn = _.bind(vert === "u" ? g.predecessors : g.successors, g);
+      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");
+        align.root, align.align, horiz === "r");
       if (horiz === "r") {
-        xs = _.mapValues(xs, function(x) { return -x; });
+        xs = util.mapValues(xs, x => -x);
       }
       xss[vert + horiz] = xs;
     });
   });
 
+
   var smallestWidth = findSmallestWidthAlignment(g, xss);
   alignCoordinates(xss, smallestWidth);
   return balance(xss, g.graph().align);
@@ -357,16 +381,16 @@ function positionX(g) {
 
 function sep(nodeSep, edgeSep, reverseSep) {
   return function(g, v, w) {
-    var vLabel = g.node(v),
-        wLabel = g.node(w),
-        sum = 0,
-        delta;
+    var vLabel = g.node(v);
+    var wLabel = g.node(w);
+    var sum = 0;
+    var delta;
 
     sum += vLabel.width / 2;
-    if (_.has(vLabel, "labelpos")) {
+    if (vLabel.hasOwnProperty("labelpos")) {
       switch (vLabel.labelpos.toLowerCase()) {
-        case "l": delta = -vLabel.width / 2; break;
-        case "r": delta = vLabel.width / 2; break;
+      case "l": delta = -vLabel.width / 2; break;
+      case "r": delta = vLabel.width / 2; break;
       }
     }
     if (delta) {
@@ -378,10 +402,10 @@ function sep(nodeSep, edgeSep, reverseSep) {
     sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
 
     sum += wLabel.width / 2;
-    if (_.has(wLabel, "labelpos")) {
+    if (wLabel.hasOwnProperty("labelpos")) {
       switch (wLabel.labelpos.toLowerCase()) {
-        case "l": delta = wLabel.width / 2; break;
-        case "r": delta = -wLabel.width / 2; break;
+      case "l": delta = wLabel.width / 2; break;
+      case "r": delta = -wLabel.width / 2; break;
       }
     }
     if (delta) {

package/lib/position/index.js

@@ -1,8 +1,7 @@
 "use strict";
 
-var _ = require("../lodash"),
-    util = require("../util"),
-    positionX = require("./bk").positionX;
+var util = require("../util");
+var positionX = require("./bk").positionX;
 
 module.exports = position;
 
@@ -10,20 +9,23 @@ function position(g) {
   g = util.asNonCompoundGraph(g);
 
   positionY(g);
-  _.each(positionX(g), function(x, v) {
-    g.node(v).x = x;
-  });
+  Object.entries(positionX(g)).forEach(([v, x]) => g.node(v).x = x);
 }
 
 function positionY(g) {
-  var layering = util.buildLayerMatrix(g),
-      rankSep = g.graph().ranksep,
-      prevY = 0;
-  _.each(layering, function(layer) {
-    var maxHeight = _.max(_.map(layer, function(v) { return g.node(v).height; }));
-    _.each(layer, function(v) {
-      g.node(v).y = prevY + maxHeight / 2;
-    });
+  var layering = util.buildLayerMatrix(g);
+  var rankSep = g.graph().ranksep;
+  var prevY = 0;
+  layering.forEach(function(layer) {
+    const maxHeight = layer.reduce((acc, v) => {
+      const height = g.node(v).height;
+      if (acc > height) {
+        return acc;
+      } else {
+        return height;
+      }
+    }, 0);
+    layer.forEach(v => g.node(v).y = prevY + maxHeight / 2);
     prevY += maxHeight + rankSep;
   });
 }

package/lib/rank/feasible-tree.js

@@ -1,8 +1,7 @@
 "use strict";
 
-var _ = require("../lodash"),
-    Graph = require("../graphlib").Graph,
-    slack = require("./util").slack;
+var Graph = require("@dagrejs/graphlib").Graph;
+var slack = require("./util").slack;
 
 module.exports = feasibleTree;
 
@@ -35,8 +34,8 @@ function feasibleTree(g) {
   var t = new Graph({ directed: false });
 
   // Choose arbitrary node from which to start our tree
-  var start = g.nodes()[0],
-      size = g.nodeCount();
+  var start = g.nodes()[0];
+  var size = g.nodeCount();
   t.setNode(start, {});
 
   var edge, delta;
@@ -55,9 +54,9 @@ function feasibleTree(g) {
  */
 function tightTree(t, g) {
   function dfs(v) {
-    _.each(g.nodeEdges(v), function(e) {
+    g.nodeEdges(v).forEach(function(e) {
       var edgeV = e.v,
-          w = (v === edgeV) ? e.w : edgeV;
+        w = (v === edgeV) ? e.w : edgeV;
       if (!t.hasNode(w) && !slack(g, e)) {
         t.setNode(w, {});
         t.setEdge(v, w, {});
@@ -66,7 +65,7 @@ function tightTree(t, g) {
     });
   }
 
-  _.each(t.nodes(), dfs);
+  t.nodes().forEach(dfs);
   return t.nodeCount();
 }
 
@@ -75,15 +74,22 @@ function tightTree(t, g) {
  * it.
  */
 function findMinSlackEdge(t, g) {
-  return _.min(g.edges(), function(e) {
-    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
-      return slack(g, e);
+  const edges = g.edges();
+
+  return edges.reduce((acc, edge) => {
+    let edgeSlack = Number.POSITIVE_INFINITY;
+    if (t.hasNode(edge.v) !== t.hasNode(edge.w)) {
+      edgeSlack = slack(g, edge);
+    }
+
+    if (edgeSlack < acc[0]) {
+      return [edgeSlack, edge];
     }
-  });
+
+    return acc;
+  }, [Number.POSITIVE_INFINITY, null])[1];
 }
 
 function shiftRanks(t, g, delta) {
-  _.each(t.nodes(), function(v) {
-    g.node(v).rank += delta;
-  });
+  t.nodes().forEach(v => g.node(v).rank += delta);
 }

package/lib/rank/index.js

@@ -1,9 +1,9 @@
 "use strict";
 
-var rankUtil = require("./util"),
-    longestPath = rankUtil.longestPath,
-    feasibleTree = require("./feasible-tree"),
-    networkSimplex = require("./network-simplex");
+var rankUtil = require("./util");
+var longestPath = rankUtil.longestPath;
+var feasibleTree = require("./feasible-tree");
+var networkSimplex = require("./network-simplex");
 
 module.exports = rank;
 
@@ -28,10 +28,10 @@ module.exports = rank;
  */
 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);
+  case "network-simplex": networkSimplexRanker(g); break;
+  case "tight-tree": tightTreeRanker(g); break;
+  case "longest-path": longestPathRanker(g); break;
+  default: networkSimplexRanker(g);
   }
 }