@dagrejs/dagre 0.8.0 → 1.0.0

package/lib/layout.js

@@ -1,27 +1,26 @@
 "use strict";
 
-var _ = require("./lodash"),
-    acyclic = require("./acyclic"),
-    normalize = require("./normalize"),
-    rank = require("./rank"),
-    normalizeRanks = require("./util").normalizeRanks,
-    parentDummyChains = require("./parent-dummy-chains"),
-    removeEmptyRanks = require("./util").removeEmptyRanks,
-    nestingGraph = require("./nesting-graph"),
-    addBorderSegments = require("./add-border-segments"),
-    coordinateSystem = require("./coordinate-system"),
-    order = require("./order"),
-    position = require("./position"),
-    util = require("./util"),
-    Graph = require("./graphlib").Graph;
+var acyclic = require("./acyclic");
+var normalize = require("./normalize");
+var rank = require("./rank");
+var normalizeRanks = require("./util").normalizeRanks;
+var parentDummyChains = require("./parent-dummy-chains");
+var removeEmptyRanks = require("./util").removeEmptyRanks;
+var nestingGraph = require("./nesting-graph");
+var addBorderSegments = require("./add-border-segments");
+var coordinateSystem = require("./coordinate-system");
+var order = require("./order");
+var position = require("./position");
+var util = require("./util");
+var Graph = require("@dagrejs/graphlib").Graph;
 
 module.exports = layout;
 
 function layout(g, opts) {
   var time = opts && opts.debugTiming ? util.time : util.notime;
   time("layout", function() {
-    var layoutGraph = time("  buildLayoutGraph",
-                               function() { return buildLayoutGraph(g); });
+    var layoutGraph =
+      time("  buildLayoutGraph", function() { return buildLayoutGraph(g); });
     time("  runLayout",        function() { runLayout(layoutGraph, time); });
     time("  updateInputGraph", function() { updateInputGraph(g, layoutGraph); });
   });
@@ -64,13 +63,14 @@ function runLayout(g, time) {
  * attributes can influence layout.
  */
 function updateInputGraph(inputGraph, layoutGraph) {
-  _.forEach(inputGraph.nodes(), function(v) {
-    var inputLabel = inputGraph.node(v),
-        layoutLabel = layoutGraph.node(v);
+  inputGraph.nodes().forEach(v => {
+    var inputLabel = inputGraph.node(v);
+    var layoutLabel = layoutGraph.node(v);
 
     if (inputLabel) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
+      inputLabel.rank = layoutLabel.rank;
 
       if (layoutGraph.children(v).length) {
         inputLabel.width = layoutLabel.width;
@@ -79,12 +79,12 @@ function updateInputGraph(inputGraph, layoutGraph) {
     }
   });
 
-  _.forEach(inputGraph.edges(), function(e) {
-    var inputLabel = inputGraph.edge(e),
-        layoutLabel = layoutGraph.edge(e);
+  inputGraph.edges().forEach(e => {
+    var inputLabel = inputGraph.edge(e);
+    var layoutLabel = layoutGraph.edge(e);
 
     inputLabel.points = layoutLabel.points;
-    if (_.has(layoutLabel, "x")) {
+    if (layoutLabel.hasOwnProperty("x")) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
     }
@@ -94,17 +94,17 @@ function updateInputGraph(inputGraph, layoutGraph) {
   inputGraph.graph().height = layoutGraph.graph().height;
 }
 
-var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"],
-    graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" },
-    graphAttrs = ["acyclicer", "ranker", "rankdir", "align"],
-    nodeNumAttrs = ["width", "height"],
-    nodeDefaults = { width: 0, height: 0 },
-    edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"],
-    edgeDefaults = {
-      minlen: 1, weight: 1, width: 0, height: 0,
-      labeloffset: 10, labelpos: "r"
-    },
-    edgeAttrs = ["labelpos"];
+var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
+var graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
+var nodeNumAttrs = ["width", "height"];
+var nodeDefaults = { width: 0, height: 0 };
+var edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
+var edgeDefaults = {
+  minlen: 1, weight: 1, width: 0, height: 0,
+  labeloffset: 10, labelpos: "r"
+};
+var edgeAttrs = ["labelpos"];
 
 /*
  * Constructs a new graph from the input graph, which can be used for layout.
@@ -113,26 +113,33 @@ var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"],
  * attributes can influence layout.
  */
 function buildLayoutGraph(inputGraph) {
-  var g = new Graph({ multigraph: true, compound: true }),
-      graph = canonicalize(inputGraph.graph());
+  var g = new Graph({ multigraph: true, compound: true });
+  var graph = canonicalize(inputGraph.graph());
 
-  g.setGraph(_.merge({},
+  g.setGraph(Object.assign({},
     graphDefaults,
     selectNumberAttrs(graph, graphNumAttrs),
-    _.pick(graph, graphAttrs)));
+    util.pick(graph, graphAttrs)));
 
-  _.forEach(inputGraph.nodes(), function(v) {
+  inputGraph.nodes().forEach(v => {
     var node = canonicalize(inputGraph.node(v));
-    g.setNode(v, _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+    const newNode = selectNumberAttrs(node, nodeNumAttrs);
+    Object.keys(nodeDefaults).forEach(k => {
+      if (newNode[k] === undefined) {
+        newNode[k] = nodeDefaults[k];
+      }
+    });
+
+    g.setNode(v, newNode);
     g.setParent(v, inputGraph.parent(v));
   });
 
-  _.forEach(inputGraph.edges(), function(e) {
+  inputGraph.edges().forEach(e => {
     var edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(e, _.merge({},
+    g.setEdge(e, Object.assign({},
       edgeDefaults,
       selectNumberAttrs(edge, edgeNumAttrs),
-      _.pick(edge, edgeAttrs)));
+      util.pick(edge, edgeAttrs)));
   });
 
   return g;
@@ -149,7 +156,7 @@ function buildLayoutGraph(inputGraph) {
 function makeSpaceForEdgeLabels(g) {
   var graph = g.graph();
   graph.ranksep /= 2;
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     var edge = g.edge(e);
     edge.minlen *= 2;
     if (edge.labelpos.toLowerCase() !== "c") {
@@ -169,12 +176,12 @@ function makeSpaceForEdgeLabels(g) {
  * label's position.
  */
 function injectEdgeLabelProxies(g) {
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     var edge = g.edge(e);
     if (edge.width && edge.height) {
-      var v = g.node(e.v),
-          w = g.node(e.w),
-          label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
+      var v = g.node(e.v);
+      var w = g.node(e.w);
+      var label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
       util.addDummyNode(g, "edge-proxy", label, "_ep");
     }
   });
@@ -182,19 +189,19 @@ function injectEdgeLabelProxies(g) {
 
 function assignRankMinMax(g) {
   var maxRank = 0;
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(v => {
     var node = g.node(v);
     if (node.borderTop) {
       node.minRank = g.node(node.borderTop).rank;
       node.maxRank = g.node(node.borderBottom).rank;
-      maxRank = _.max(maxRank, node.maxRank);
+      maxRank = Math.max(maxRank, node.maxRank);
     }
   });
   g.graph().maxRank = maxRank;
 }
 
 function removeEdgeLabelProxies(g) {
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(v => {
     var node = g.node(v);
     if (node.dummy === "edge-proxy") {
       g.edge(node.e).labelRank = node.rank;
@@ -204,29 +211,29 @@ function removeEdgeLabelProxies(g) {
 }
 
 function translateGraph(g) {
-  var minX = Number.POSITIVE_INFINITY,
-      maxX = 0,
-      minY = Number.POSITIVE_INFINITY,
-      maxY = 0,
-      graphLabel = g.graph(),
-      marginX = graphLabel.marginx || 0,
-      marginY = graphLabel.marginy || 0;
+  var minX = Number.POSITIVE_INFINITY;
+  var maxX = 0;
+  var minY = Number.POSITIVE_INFINITY;
+  var maxY = 0;
+  var graphLabel = g.graph();
+  var marginX = graphLabel.marginx || 0;
+  var marginY = graphLabel.marginy || 0;
 
   function getExtremes(attrs) {
-    var x = attrs.x,
-        y = attrs.y,
-        w = attrs.width,
-        h = attrs.height;
+    var x = attrs.x;
+    var y = attrs.y;
+    var w = attrs.width;
+    var h = attrs.height;
     minX = Math.min(minX, x - w / 2);
     maxX = Math.max(maxX, x + w / 2);
     minY = Math.min(minY, y - h / 2);
     maxY = Math.max(maxY, y + h / 2);
   }
 
-  _.forEach(g.nodes(), function(v) { getExtremes(g.node(v)); });
-  _.forEach(g.edges(), function(e) {
+  g.nodes().forEach(v => getExtremes(g.node(v)));
+  g.edges().forEach(e => {
     var edge = g.edge(e);
-    if (_.has(edge, "x")) {
+    if (edge.hasOwnProperty("x")) {
       getExtremes(edge);
     }
   });
@@ -234,20 +241,20 @@ function translateGraph(g) {
   minX -= marginX;
   minY -= marginY;
 
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(v => {
     var node = g.node(v);
     node.x -= minX;
     node.y -= minY;
   });
 
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     var edge = g.edge(e);
-    _.forEach(edge.points, function(p) {
+    edge.points.forEach(p => {
       p.x -= minX;
       p.y -= minY;
     });
-    if (_.has(edge, "x")) { edge.x -= minX; }
-    if (_.has(edge, "y")) { edge.y -= minY; }
+    if (edge.hasOwnProperty("x")) { edge.x -= minX; }
+    if (edge.hasOwnProperty("y")) { edge.y -= minY; }
   });
 
   graphLabel.width = maxX - minX + marginX;
@@ -255,11 +262,11 @@ function translateGraph(g) {
 }
 
 function assignNodeIntersects(g) {
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e),
-        nodeV = g.node(e.v),
-        nodeW = g.node(e.w),
-        p1, p2;
+  g.edges().forEach(e => {
+    var edge = g.edge(e);
+    var nodeV = g.node(e.v);
+    var nodeW = g.node(e.w);
+    var p1, p2;
     if (!edge.points) {
       edge.points = [];
       p1 = nodeW;
@@ -274,22 +281,22 @@ function assignNodeIntersects(g) {
 }
 
 function fixupEdgeLabelCoords(g) {
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     var edge = g.edge(e);
-    if (_.has(edge, "x")) {
+    if (edge.hasOwnProperty("x")) {
       if (edge.labelpos === "l" || edge.labelpos === "r") {
         edge.width -= edge.labeloffset;
       }
       switch (edge.labelpos) {
-        case "l": edge.x -= edge.width / 2 + edge.labeloffset; break;
-        case "r": edge.x += edge.width / 2 + edge.labeloffset; break;
+      case "l": edge.x -= edge.width / 2 + edge.labeloffset; break;
+      case "r": edge.x += edge.width / 2 + edge.labeloffset; break;
       }
     }
   });
 }
 
 function reversePointsForReversedEdges(g) {
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     var edge = g.edge(e);
     if (edge.reversed) {
       edge.points.reverse();
@@ -298,13 +305,13 @@ function reversePointsForReversedEdges(g) {
 }
 
 function removeBorderNodes(g) {
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(v => {
     if (g.children(v).length) {
-      var node = g.node(v),
-          t = g.node(node.borderTop),
-          b = g.node(node.borderBottom),
-          l = g.node(_.last(node.borderLeft)),
-          r = g.node(_.last(node.borderRight));
+      var node = g.node(v);
+      var t = g.node(node.borderTop);
+      var b = g.node(node.borderBottom);
+      var l = g.node(node.borderLeft[node.borderLeft.length - 1]);
+      var r = g.node(node.borderRight[node.borderRight.length - 1]);
 
       node.width = Math.abs(r.x - l.x);
       node.height = Math.abs(b.y - t.y);
@@ -313,7 +320,7 @@ function removeBorderNodes(g) {
     }
   });
 
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(v => {
     if (g.node(v).dummy === "border") {
       g.removeNode(v);
     }
@@ -321,7 +328,7 @@ function removeBorderNodes(g) {
 }
 
 function removeSelfEdges(g) {
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     if (e.v === e.w) {
       var node = g.node(e.v);
       if (!node.selfEdges) {
@@ -335,12 +342,12 @@ function removeSelfEdges(g) {
 
 function insertSelfEdges(g) {
   var layers = util.buildLayerMatrix(g);
-  _.forEach(layers, function(layer) {
+  layers.forEach(layer => {
     var orderShift = 0;
-    _.forEach(layer, function(v, i) {
+    layer.forEach((v, i) => {
       var node = g.node(v);
       node.order = i + orderShift;
-      _.forEach(node.selfEdges, function(selfEdge) {
+      (node.selfEdges || []).forEach(selfEdge => {
         util.addDummyNode(g, "selfedge", {
           width: selfEdge.label.width,
           height: selfEdge.label.height,
@@ -356,14 +363,14 @@ function insertSelfEdges(g) {
 }
 
 function positionSelfEdges(g) {
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(v => {
     var node = g.node(v);
     if (node.dummy === "selfedge") {
-      var selfNode = g.node(node.e.v),
-          x = selfNode.x + selfNode.width / 2,
-          y = selfNode.y,
-          dx = node.x - x,
-          dy = selfNode.height / 2;
+      var selfNode = g.node(node.e.v);
+      var x = selfNode.x + selfNode.width / 2;
+      var y = selfNode.y;
+      var dx = node.x - x;
+      var dy = selfNode.height / 2;
       g.setEdge(node.e, node.label);
       g.removeNode(v);
       node.label.points = [
@@ -380,13 +387,19 @@ function positionSelfEdges(g) {
 }
 
 function selectNumberAttrs(obj, attrs) {
-  return _.mapValues(_.pick(obj, attrs), Number);
+  return util.mapValues(util.pick(obj, attrs), Number);
 }
 
 function canonicalize(attrs) {
   var newAttrs = {};
-  _.forEach(attrs, function(v, k) {
-    newAttrs[k.toLowerCase()] = v;
-  });
+  if (attrs) {
+    Object.entries(attrs).forEach(([k, v]) => {
+      if (typeof k === "string") {
+        k = k.toLowerCase();
+      }
+
+      newAttrs[k] = v;
+    });
+  }
   return newAttrs;
 }

package/lib/nesting-graph.js

@@ -1,5 +1,4 @@
-var _ = require("./lodash"),
-    util = require("./util");
+var util = require("./util");
 
 module.exports = {
   run: run,
@@ -32,19 +31,19 @@ module.exports = {
 function run(g) {
   var root = util.addDummyNode(g, "root", {}, "_root");
   var depths = treeDepths(g);
-  var height = _.max(_.values(depths)) - 1; // Note: depths is an Object not an array
+  var height = Math.max(...Object.values(depths)) - 1; // Note: depths is an Object not an array
   var nodeSep = 2 * height + 1;
 
   g.graph().nestingRoot = root;
 
   // Multiply minlen by nodeSep to align nodes on non-border ranks.
-  _.forEach(g.edges(), function(e) { g.edge(e).minlen *= nodeSep; });
+  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;
 
   // Create border nodes and link them up
-  _.forEach(g.children(), function(child) {
+  g.children().forEach(function(child) {
     dfs(g, root, nodeSep, weight, height, depths, child);
   });
 
@@ -62,23 +61,23 @@ function dfs(g, root, nodeSep, weight, height, depths, v) {
     return;
   }
 
-  var top = util.addBorderNode(g, "_bt"),
-      bottom = util.addBorderNode(g, "_bb"),
-      label = g.node(v);
+  var top = util.addBorderNode(g, "_bt");
+  var bottom = util.addBorderNode(g, "_bb");
+  var label = g.node(v);
 
   g.setParent(top, v);
   label.borderTop = top;
   g.setParent(bottom, v);
   label.borderBottom = bottom;
 
-  _.forEach(children, function(child) {
+  children.forEach(function(child) {
     dfs(g, root, nodeSep, weight, height, depths, child);
 
-    var childNode = g.node(child),
-        childTop = childNode.borderTop ? childNode.borderTop : child,
-        childBottom = childNode.borderBottom ? childNode.borderBottom : child,
-        thisWeight = childNode.borderTop ? weight : 2 * weight,
-        minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+    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;
 
     g.setEdge(top, childTop, {
       weight: thisWeight,
@@ -103,27 +102,23 @@ function treeDepths(g) {
   function dfs(v, depth) {
     var children = g.children(v);
     if (children && children.length) {
-      _.forEach(children, function(child) {
-        dfs(child, depth + 1);
-      });
+      children.forEach(child => dfs(child, depth + 1));
     }
     depths[v] = depth;
   }
-  _.forEach(g.children(), function(v) { dfs(v, 1); });
+  g.children().forEach(v => dfs(v, 1));
   return depths;
 }
 
 function sumWeights(g) {
-  return _.reduce(g.edges(), function(acc, e) {
-    return acc + g.edge(e).weight;
-  }, 0);
+  return g.edges().reduce((acc, e) => acc + g.edge(e).weight, 0);
 }
 
 function cleanup(g) {
   var graphLabel = g.graph();
   g.removeNode(graphLabel.nestingRoot);
   delete graphLabel.nestingRoot;
-  _.forEach(g.edges(), function(e) {
+  g.edges().forEach(e => {
     var edge = g.edge(e);
     if (edge.nestingEdge) {
       g.removeEdge(e);

package/lib/normalize.js

@@ -1,7 +1,6 @@
 "use strict";
 
-var _ = require("./lodash"),
-    util = require("./util");
+var util = require("./util");
 
 module.exports = {
   run: run,
@@ -26,17 +25,17 @@ module.exports = {
  */
 function run(g) {
   g.graph().dummyChains = [];
-  _.forEach(g.edges(), function(edge) { normalizeEdge(g, edge); });
+  g.edges().forEach(edge => normalizeEdge(g, edge));
 }
 
 function normalizeEdge(g, e) {
-  var v = e.v,
-      vRank = g.node(v).rank,
-      w = e.w,
-      wRank = g.node(w).rank,
-      name = e.name,
-      edgeLabel = g.edge(e),
-      labelRank = edgeLabel.labelRank;
+  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;
 
@@ -68,10 +67,10 @@ function normalizeEdge(g, e) {
 }
 
 function undo(g) {
-  _.forEach(g.graph().dummyChains, function(v) {
-    var node = g.node(v),
-        origLabel = node.edgeLabel,
-        w;
+  g.graph().dummyChains.forEach(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];

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

@@ -1,15 +1,13 @@
-var _ = require("../lodash");
-
 module.exports = addSubgraphConstraints;
 
 function addSubgraphConstraints(g, cg, vs) {
   var prev = {},
-      rootPrev;
+    rootPrev;
 
-  _.forEach(vs, function(v) {
+  vs.forEach(function(v) {
     var child = g.parent(v),
-        parent,
-        prevChild;
+      parent,
+      prevChild;
     while (child) {
       parent = g.parent(child);
       if (parent) {
@@ -33,14 +31,14 @@ function addSubgraphConstraints(g, cg, vs) {
     if (children.length) {
       var min = Number.POSITIVE_INFINITY,
           subgraphs = [];
-      _.each(children, function(child) {
+      children.forEach(function(child) {
         var childMin = dfs(child);
         if (g.children(child).length) {
           subgraphs.push({ v: child, order: childMin });
         }
         min = Math.min(min, childMin);
       });
-      _.reduce(_.sortBy(subgraphs, "order"), function(prev, curr) {
+      _.sortBy(subgraphs, "order").reduce(function(prev, curr) {
         cg.setEdge(prev.v, curr.v);
         return curr;
       });

package/lib/order/barycenter.js

@@ -1,16 +1,14 @@
-var _ = require("../lodash");
-
 module.exports = barycenter;
 
-function barycenter(g, movable) {
-  return _.map(movable, function(v) {
+function barycenter(g, movable = []) {
+  return movable.map(v => {
     var inV = g.inEdges(v);
     if (!inV.length) {
       return { v: v };
     } else {
-      var result = _.reduce(inV, function(acc, e) {
+      var result = inV.reduce((acc, e) => {
         var edge = g.edge(e),
-            nodeU = g.node(e.v);
+          nodeU = g.node(e.v);
         return {
           sum: acc.sum + (edge.weight * nodeU.order),
           weight: acc.weight + edge.weight

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

@@ -1,5 +1,5 @@
-var _ = require("../lodash"),
-    Graph = require("../graphlib").Graph;
+var Graph = require("@dagrejs/graphlib").Graph;
+var util = require("../util");
 
 module.exports = buildLayerGraph;
 
@@ -35,26 +35,26 @@ module.exports = buildLayerGraph;
  */
 function buildLayerGraph(g, rank, relationship) {
   var root = createRootNode(g),
-      result = new Graph({ compound: true }).setGraph({ root: root })
-                  .setDefaultNodeLabel(function(v) { return g.node(v); });
+    result = new Graph({ compound: true }).setGraph({ root: root })
+      .setDefaultNodeLabel(function(v) { return g.node(v); });
 
-  _.forEach(g.nodes(), function(v) {
+  g.nodes().forEach(function(v) {
     var node = g.node(v),
-        parent = g.parent(v);
+      parent = g.parent(v);
 
     if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
       result.setNode(v);
       result.setParent(v, parent || root);
 
       // This assumes we have only short edges!
-      _.forEach(g[relationship](v), function(e) {
+      g[relationship](v).forEach(function(e) {
         var u = e.v === v ? e.w : e.v,
-            edge = result.edge(u, v),
-            weight = !_.isUndefined(edge) ? edge.weight : 0;
+          edge = result.edge(u, v),
+          weight = edge !== undefined ? edge.weight : 0;
         result.setEdge(u, v, { weight: g.edge(e).weight + weight });
       });
 
-      if (_.has(node, "minRank")) {
+      if (node.hasOwnProperty("minRank")) {
         result.setNode(v, {
           borderLeft: node.borderLeft[rank],
           borderRight: node.borderRight[rank]
@@ -68,6 +68,6 @@ function buildLayerGraph(g, rank, relationship) {
 
 function createRootNode(g) {
   var v;
-  while (g.hasNode((v = _.uniqueId("_root"))));
+  while (g.hasNode((v = util.uniqueId("_root"))));
   return v;
 }