@dagrejs/dagre 1.1.3 → 1.1.5

package/lib/position/bk.js

@@ -152,7 +152,7 @@ function hasConflict(conflicts, v, w) {
     v = w;
     w = tmp;
   }
-  return !!conflicts[v] && conflicts[v].hasOwnProperty(w);
+  return !!conflicts[v] && Object.hasOwn(conflicts[v], w);
 }
 
 /*
@@ -313,8 +313,8 @@ function findSmallestWidthAlignment(g, xss) {
  */
 function alignCoordinates(xss, alignTo) {
   let alignToVals = Object.values(alignTo),
-    alignToMin = Math.min(...alignToVals),
-    alignToMax = Math.max(...alignToVals);
+    alignToMin = util.applyWithChunking(Math.min, alignToVals),
+    alignToMax = util.applyWithChunking(Math.max, alignToVals);
 
   ["u", "d"].forEach(vert => {
     ["l", "r"].forEach(horiz => {
@@ -324,9 +324,9 @@ function alignCoordinates(xss, alignTo) {
       if (xs === alignTo) return;
 
       let xsVals = Object.values(xs);
-      let delta = alignToMin - Math.min(...xsVals);
+      let delta = alignToMin - util.applyWithChunking(Math.min, xsVals);
       if (horiz !== "l") {
-        delta = alignToMax - Math.max(...xsVals);
+        delta = alignToMax - util.applyWithChunking(Math.max,xsVals);
       }
 
       if (delta) {
@@ -389,7 +389,7 @@ function sep(nodeSep, edgeSep, reverseSep) {
     let delta;
 
     sum += vLabel.width / 2;
-    if (vLabel.hasOwnProperty("labelpos")) {
+    if (Object.hasOwn(vLabel, "labelpos")) {
       switch (vLabel.labelpos.toLowerCase()) {
       case "l": delta = -vLabel.width / 2; break;
       case "r": delta = vLabel.width / 2; break;
@@ -404,7 +404,7 @@ function sep(nodeSep, edgeSep, reverseSep) {
     sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
 
     sum += wLabel.width / 2;
-    if (wLabel.hasOwnProperty("labelpos")) {
+    if (Object.hasOwn(wLabel, "labelpos")) {
       switch (wLabel.labelpos.toLowerCase()) {
       case "l": delta = wLabel.width / 2; break;
       case "r": delta = -wLabel.width / 2; break;

package/lib/rank/index.js

@@ -27,10 +27,16 @@ module.exports = rank;
  *       fix them up later.
  */
 function rank(g) {
+  var ranker = g.graph().ranker;
+  if (ranker instanceof Function) {
+    return ranker(g);
+  }
+
   switch(g.graph().ranker) {
   case "network-simplex": networkSimplexRanker(g); break;
   case "tight-tree": tightTreeRanker(g); break;
   case "longest-path": longestPathRanker(g); break;
+  case "none": break;
   default: networkSimplexRanker(g);
   }
 }

package/lib/rank/network-simplex.js

@@ -132,7 +132,7 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
 
   visited[v] = true;
   tree.neighbors(v).forEach(w => {
-    if (!visited.hasOwnProperty(w)) {
+    if (!Object.hasOwn(visited, w)) {
       nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
     }
   });

package/lib/rank/util.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const { applyWithChunking } = require("../util");
+
 module.exports = {
   longestPath: longestPath,
   slack: slack
@@ -31,18 +33,20 @@ function longestPath(g) {
 
   function dfs(v) {
     var label = g.node(v);
-    if (visited.hasOwnProperty(v)) {
+    if (Object.hasOwn(visited, v)) {
       return label.rank;
     }
     visited[v] = true;
 
-    var rank = Math.min(...g.outEdges(v).map(e => {
+    let outEdgesMinLens = g.outEdges(v).map(e => {
       if (e == null) {
         return Number.POSITIVE_INFINITY;
       }
 
       return dfs(e.w) - g.edge(e).minlen;
-    }));
+    });
+
+    var rank = applyWithChunking(Math.min, outEdgesMinLens);
 
     if (rank === Number.POSITIVE_INFINITY) {
       rank = 0;

package/lib/util.js

@@ -7,6 +7,7 @@ let Graph = require("@dagrejs/graphlib").Graph;
 module.exports = {
   addBorderNode,
   addDummyNode,
+  applyWithChunking,
   asNonCompoundGraph,
   buildLayerMatrix,
   intersectRect,
@@ -30,10 +31,10 @@ module.exports = {
  * Adds a dummy node to the graph and return v.
  */
 function addDummyNode(g, type, attrs, name) {
-  let v;
-  do {
+  var v = name;
+  while (g.hasNode(v)) {
     v = uniqueId(name);
-  } while (g.hasNode(v));
+  }
 
   attrs.dummy = type;
   g.setNode(v, attrs);
@@ -153,17 +154,18 @@ function buildLayerMatrix(g) {
  * rank(v) >= 0 and at least one node w has rank(w) = 0.
  */
 function normalizeRanks(g) {
-  let min = Math.min(...g.nodes().map(v => {
+  let nodeRanks = g.nodes().map(v => {
     let rank = g.node(v).rank;
     if (rank === undefined) {
       return Number.MAX_VALUE;
     }
 
     return rank;
-  }));
+  });
+  let min = applyWithChunking(Math.min, nodeRanks);
   g.nodes().forEach(v => {
     let node = g.node(v);
-    if (node.hasOwnProperty("rank")) {
+    if (Object.hasOwn(node, "rank")) {
       node.rank -= min;
     }
   });
@@ -171,7 +173,8 @@ function normalizeRanks(g) {
 
 function removeEmptyRanks(g) {
   // Ranks may not start at 0, so we need to offset them
-  let offset = Math.min(...g.nodes().map(v => g.node(v).rank));
+  let nodeRanks = g.nodes().map(v => g.node(v).rank);
+  let offset = applyWithChunking(Math.min, nodeRanks);
 
   let layers = [];
   g.nodes().forEach(v => {
@@ -205,15 +208,37 @@ function addBorderNode(g, prefix, rank, order) {
   return addDummyNode(g, "border", node, prefix);
 }
 
+function splitToChunks(array, chunkSize = CHUNKING_THRESHOLD) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    const chunk = array.slice(i, i + chunkSize);
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+
+const CHUNKING_THRESHOLD = 65535;
+
+function applyWithChunking(fn, argsArray) {
+  if(argsArray.length > CHUNKING_THRESHOLD) {
+    const chunks = splitToChunks(argsArray);
+    return fn.apply(null, chunks.map(chunk => fn.apply(null, chunk)));
+  } else {
+    return fn.apply(null, argsArray);
+  }
+}
+
 function maxRank(g) {
-  return Math.max(...g.nodes().map(v => {
+  const nodes = g.nodes();
+  const nodeRanks = nodes.map(v => {
     let rank = g.node(v).rank;
     if (rank === undefined) {
       return Number.MIN_VALUE;
     }
-
     return rank;
-  }));
+  });
+
+  return applyWithChunking(Math.max, nodeRanks);
 }
 
 /*
@@ -253,7 +278,7 @@ function notime(name, fn) {
 let idCounter = 0;
 function uniqueId(prefix) {
   var id = ++idCounter;
-  return toString(prefix) + id;
+  return prefix + ("" + id);
 }
 
 function range(start, limit, step = 1) {

package/lib/version.js

@@ -1 +1 @@
-module.exports = "1.1.3";
+module.exports = "1.1.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dagrejs/dagre",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Graph layout for JavaScript",
   "author": "Chris Pettitt <cpettitt@gmail.com>",
   "contributors": [
@@ -24,7 +24,7 @@
     "layout"
   ],
   "dependencies": {
-    "@dagrejs/graphlib": "2.2.2"
+    "@dagrejs/graphlib": "2.2.4"
   },
   "devDependencies": {
     "benchmark": "2.1.4",