@dagrejs/dagre 1.1.5 → 1.1.8

package/dist/dagre.js

@@ -1161,6 +1161,8 @@ module.exports = buildLayerGraph;
  *    2. Base nodes in the input graph have a rank attribute
  *    3. Subgraph nodes in the input graph has minRank and maxRank attributes
  *    4. Edges have an assigned weight
+ *    5. If `nodesWithRank` is not undefined, it must contains only the nodes
+ *       which belong to `g` and belong to `rank`.
  *
  * Post-conditions:
  *
@@ -1175,12 +1177,16 @@ module.exports = buildLayerGraph;
  *    5. The weights for copied edges are aggregated as need, since the output
  *       graph is not a multi-graph.
  */
-function buildLayerGraph(g, rank, relationship) {
+function buildLayerGraph(g, rank, relationship, nodesWithRank) {
+  if (!nodesWithRank) {
+    nodesWithRank = g.nodes();
+  }
   let root = createRootNode(g),
-    result = new Graph({ compound: true }).setGraph({ root: root })
-      .setDefaultNodeLabel(v => g.node(v));
+    result = new Graph({ compound: true })
+      .setGraph({ root: root })
+      .setDefaultNodeLabel((v) => g.node(v));
 
-  g.nodes().forEach(v => {
+  nodesWithRank.forEach((v) => {
     let node = g.node(v),
       parent = g.parent(v);
 
@@ -1346,8 +1352,38 @@ function order(g, opts) {
 }
 
 function buildLayerGraphs(g, ranks, relationship) {
-  return ranks.map(function(rank) {
-    return buildLayerGraph(g, rank, relationship);
+  // Build an index mapping from rank to the nodes with that rank.
+  // This helps to avoid a quadratic search for all nodes with the same rank as
+  // the current node.
+  const nodesByRank = new Map();
+  const addNodeToRank = (rank, node) => {
+    if (!nodesByRank.has(rank)) {
+      nodesByRank.set(rank, []);
+    }
+    nodesByRank.get(rank).push(node);
+  };
+
+  // Visit the nodes in their original order in the graph, and add each
+  // node to the ranks(s) that it belongs to.
+  for (const v of g.nodes()) {
+    const node = g.node(v);
+    if (typeof node.rank === "number") {
+      addNodeToRank(node.rank, v);
+    }
+    // If there is a range of ranks, add it to each, but skip the `node.rank` which
+    // has already had the node added.
+    if (typeof node.minRank === "number" && typeof node.maxRank === "number") {
+      for (let r = node.minRank; r <= node.maxRank; r++) {
+        if (r !== node.rank) {
+          // Don't add this node to its `node.rank` twice.
+          addNodeToRank(r, v);
+        }
+      }
+    }
+  }
+
+  return ranks.map(function (rank) {
+    return buildLayerGraph(g, rank, relationship, nodesByRank.get(rank) || []);
   });
 }
 
@@ -2996,7 +3032,7 @@ function zipObject(props, values) {
 }
 
 },{"@dagrejs/graphlib":29}],28:[function(require,module,exports){
-module.exports = "1.1.5";
+module.exports = "1.1.8";
 
 },{}],29:[function(require,module,exports){
 /**

package/dist/dagre.min.js

@@ -153,6 +153,8 @@ g.graph().nodeRankFactor=nodeSep}function dfs(g,root,nodeSep,weight,height,depth
  *    2. Base nodes in the input graph have a rank attribute
  *    3. Subgraph nodes in the input graph has minRank and maxRank attributes
  *    4. Edges have an assigned weight
+ *    5. If `nodesWithRank` is not undefined, it must contains only the nodes
+ *       which belong to `g` and belong to `rank`.
  *
  * Post-conditions:
  *
@@ -166,7 +168,7 @@ g.graph().nodeRankFactor=nodeSep}function dfs(g,root,nodeSep,weight,height,depth
  *       parameter, are added to the output graph.
  *    5. The weights for copied edges are aggregated as need, since the output
  *       graph is not a multi-graph.
- */function buildLayerGraph(g,rank,relationship){let root=createRootNode(g),result=new Graph({compound:true}).setGraph({root:root}).setDefaultNodeLabel(v=>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){result.setNode(v);result.setParent(v,parent||root);
+ */function buildLayerGraph(g,rank,relationship,nodesWithRank){if(!nodesWithRank){nodesWithRank=g.nodes()}let root=createRootNode(g),result=new Graph({compound:true}).setGraph({root:root}).setDefaultNodeLabel(v=>g.node(v));nodesWithRank.forEach(v=>{let node=g.node(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!
 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})});if(Object.hasOwn(node,"minRank")){result.setNode(v,{borderLeft:node.borderLeft[rank],borderRight:node.borderRight[rank]})}}});return result}function createRootNode(g){var v;while(g.hasNode(v=util.uniqueId("_root")));return v}},{"../util":27,"@dagrejs/graphlib":29}],14:[function(require,module,exports){"use strict";let zipObject=require("../util").zipObject;module.exports=crossCount;
 /*
@@ -207,7 +209,19 @@ let cc=0;southEntries.forEach(entry=>{let index=entry.pos+firstIndex;tree[index]
  *
  *    1. Graph nodes will have an "order" attribute based on the results of the
  *       algorithm.
- */function order(g,opts){if(opts&&typeof opts.customOrder==="function"){opts.customOrder(g,order);return}let maxRank=util.maxRank(g),downLayerGraphs=buildLayerGraphs(g,util.range(1,maxRank+1),"inEdges"),upLayerGraphs=buildLayerGraphs(g,util.range(maxRank-1,-1,-1),"outEdges");let layering=initOrder(g);assignOrder(g,layering);if(opts&&opts.disableOptimalOrderHeuristic){return}let bestCC=Number.POSITIVE_INFINITY,best;for(let i=0,lastBest=0;lastBest<4;++i,++lastBest){sweepLayerGraphs(i%2?downLayerGraphs:upLayerGraphs,i%4>=2);layering=util.buildLayerMatrix(g);let cc=crossCount(g,layering);if(cc<bestCC){lastBest=0;best=Object.assign({},layering);bestCC=cc}}assignOrder(g,best)}function buildLayerGraphs(g,ranks,relationship){return ranks.map(function(rank){return buildLayerGraph(g,rank,relationship)})}function sweepLayerGraphs(layerGraphs,biasRight){let cg=new Graph;layerGraphs.forEach(function(lg){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)})}function assignOrder(g,layering){Object.values(layering).forEach(layer=>layer.forEach((v,i)=>g.node(v).order=i))}},{"../util":27,"./add-subgraph-constraints":11,"./build-layer-graph":13,"./cross-count":14,"./init-order":16,"./sort-subgraph":18,"@dagrejs/graphlib":29}],16:[function(require,module,exports){"use strict";let util=require("../util");module.exports=initOrder;
+ */function order(g,opts){if(opts&&typeof opts.customOrder==="function"){opts.customOrder(g,order);return}let maxRank=util.maxRank(g),downLayerGraphs=buildLayerGraphs(g,util.range(1,maxRank+1),"inEdges"),upLayerGraphs=buildLayerGraphs(g,util.range(maxRank-1,-1,-1),"outEdges");let layering=initOrder(g);assignOrder(g,layering);if(opts&&opts.disableOptimalOrderHeuristic){return}let bestCC=Number.POSITIVE_INFINITY,best;for(let i=0,lastBest=0;lastBest<4;++i,++lastBest){sweepLayerGraphs(i%2?downLayerGraphs:upLayerGraphs,i%4>=2);layering=util.buildLayerMatrix(g);let cc=crossCount(g,layering);if(cc<bestCC){lastBest=0;best=Object.assign({},layering);bestCC=cc}}assignOrder(g,best)}function buildLayerGraphs(g,ranks,relationship){
+// Build an index mapping from rank to the nodes with that rank.
+// This helps to avoid a quadratic search for all nodes with the same rank as
+// the current node.
+const nodesByRank=new Map;const addNodeToRank=(rank,node)=>{if(!nodesByRank.has(rank)){nodesByRank.set(rank,[])}nodesByRank.get(rank).push(node)};
+// Visit the nodes in their original order in the graph, and add each
+// node to the ranks(s) that it belongs to.
+for(const v of g.nodes()){const node=g.node(v);if(typeof node.rank==="number"){addNodeToRank(node.rank,v)}
+// If there is a range of ranks, add it to each, but skip the `node.rank` which
+// has already had the node added.
+if(typeof node.minRank==="number"&&typeof node.maxRank==="number"){for(let r=node.minRank;r<=node.maxRank;r++){if(r!==node.rank){
+// Don't add this node to its `node.rank` twice.
+addNodeToRank(r,v)}}}}return ranks.map(function(rank){return buildLayerGraph(g,rank,relationship,nodesByRank.get(rank)||[])})}function sweepLayerGraphs(layerGraphs,biasRight){let cg=new Graph;layerGraphs.forEach(function(lg){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)})}function assignOrder(g,layering){Object.values(layering).forEach(layer=>layer.forEach((v,i)=>g.node(v).order=i))}},{"../util":27,"./add-subgraph-constraints":11,"./build-layer-graph":13,"./cross-count":14,"./init-order":16,"./sort-subgraph":18,"@dagrejs/graphlib":29}],16:[function(require,module,exports){"use strict";let util=require("../util");module.exports=initOrder;
 /*
  * Assigns an initial order value for each node by performing a DFS search
  * starting from nodes in the first rank. Nodes are assigned an order in their
@@ -495,7 +509,7 @@ let nodeRanks=g.nodes().map(v=>g.node(v).rank);let offset=applyWithChunking(Math
 /*
  * Returns a new function that wraps `fn` with a timer. The wrapper logs the
  * time it takes to execute the function.
- */function time(name,fn){let start=Date.now();try{return fn()}finally{console.log(name+" time: "+(Date.now()-start)+"ms")}}function notime(name,fn){return fn()}let idCounter=0;function uniqueId(prefix){var id=++idCounter;return prefix+(""+id)}function range(start,limit,step=1){if(limit==null){limit=start;start=0}let endCon=i=>i<limit;if(step<0){endCon=i=>limit<i}const range=[];for(let i=start;endCon(i);i+=step){range.push(i)}return range}function pick(source,keys){const dest={};for(const key of keys){if(source[key]!==undefined){dest[key]=source[key]}}return dest}function mapValues(obj,funcOrProp){let func=funcOrProp;if(typeof funcOrProp==="string"){func=val=>val[funcOrProp]}return Object.entries(obj).reduce((acc,[k,v])=>{acc[k]=func(v,k);return acc},{})}function zipObject(props,values){return props.reduce((acc,key,i)=>{acc[key]=values[i];return acc},{})}},{"@dagrejs/graphlib":29}],28:[function(require,module,exports){module.exports="1.1.5"},{}],29:[function(require,module,exports){
+ */function time(name,fn){let start=Date.now();try{return fn()}finally{console.log(name+" time: "+(Date.now()-start)+"ms")}}function notime(name,fn){return fn()}let idCounter=0;function uniqueId(prefix){var id=++idCounter;return prefix+(""+id)}function range(start,limit,step=1){if(limit==null){limit=start;start=0}let endCon=i=>i<limit;if(step<0){endCon=i=>limit<i}const range=[];for(let i=start;endCon(i);i+=step){range.push(i)}return range}function pick(source,keys){const dest={};for(const key of keys){if(source[key]!==undefined){dest[key]=source[key]}}return dest}function mapValues(obj,funcOrProp){let func=funcOrProp;if(typeof funcOrProp==="string"){func=val=>val[funcOrProp]}return Object.entries(obj).reduce((acc,[k,v])=>{acc[k]=func(v,k);return acc},{})}function zipObject(props,values){return props.reduce((acc,key,i)=>{acc[key]=values[i];return acc},{})}},{"@dagrejs/graphlib":29}],28:[function(require,module,exports){module.exports="1.1.8"},{}],29:[function(require,module,exports){
 /**
  * Copyright (c) 2014, Chris Pettitt
  * All rights reserved.

package/index.d.ts

@@ -57,7 +57,7 @@ declare module '@dagrejs/dagre' {
       function dijkstra(graph: Graph, source: string, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
       function dijkstraAll(graph: Graph, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
       function findCycles(graph: Graph): string[][];
-      function floydWarchall(graph: Graph, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
+      function floydWarshall(graph: Graph, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
       function isAcyclic(graph: Graph): boolean;
       function postorder(graph: Graph, nodeNames: string | string[]): string[];
       function preorder(graph: Graph, nodeNames: string | string[]): string[];

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

@@ -19,6 +19,8 @@ module.exports = buildLayerGraph;
  *    2. Base nodes in the input graph have a rank attribute
  *    3. Subgraph nodes in the input graph has minRank and maxRank attributes
  *    4. Edges have an assigned weight
+ *    5. If `nodesWithRank` is not undefined, it must contains only the nodes
+ *       which belong to `g` and belong to `rank`.
  *
  * Post-conditions:
  *
@@ -33,12 +35,16 @@ module.exports = buildLayerGraph;
  *    5. The weights for copied edges are aggregated as need, since the output
  *       graph is not a multi-graph.
  */
-function buildLayerGraph(g, rank, relationship) {
+function buildLayerGraph(g, rank, relationship, nodesWithRank) {
+  if (!nodesWithRank) {
+    nodesWithRank = g.nodes();
+  }
   let root = createRootNode(g),
-    result = new Graph({ compound: true }).setGraph({ root: root })
-      .setDefaultNodeLabel(v => g.node(v));
+    result = new Graph({ compound: true })
+      .setGraph({ root: root })
+      .setDefaultNodeLabel((v) => g.node(v));
 
-  g.nodes().forEach(v => {
+  nodesWithRank.forEach((v) => {
     let node = g.node(v),
       parent = g.parent(v);
 

package/lib/order/index.js

@@ -61,8 +61,38 @@ function order(g, opts) {
 }
 
 function buildLayerGraphs(g, ranks, relationship) {
-  return ranks.map(function(rank) {
-    return buildLayerGraph(g, rank, relationship);
+  // Build an index mapping from rank to the nodes with that rank.
+  // This helps to avoid a quadratic search for all nodes with the same rank as
+  // the current node.
+  const nodesByRank = new Map();
+  const addNodeToRank = (rank, node) => {
+    if (!nodesByRank.has(rank)) {
+      nodesByRank.set(rank, []);
+    }
+    nodesByRank.get(rank).push(node);
+  };
+
+  // Visit the nodes in their original order in the graph, and add each
+  // node to the ranks(s) that it belongs to.
+  for (const v of g.nodes()) {
+    const node = g.node(v);
+    if (typeof node.rank === "number") {
+      addNodeToRank(node.rank, v);
+    }
+    // If there is a range of ranks, add it to each, but skip the `node.rank` which
+    // has already had the node added.
+    if (typeof node.minRank === "number" && typeof node.maxRank === "number") {
+      for (let r = node.minRank; r <= node.maxRank; r++) {
+        if (r !== node.rank) {
+          // Don't add this node to its `node.rank` twice.
+          addNodeToRank(r, v);
+        }
+      }
+    }
+  }
+
+  return ranks.map(function (rank) {
+    return buildLayerGraph(g, rank, relationship, nodesByRank.get(rank) || []);
   });
 }
 

package/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dagrejs/dagre",
-  "version": "1.1.5",
+  "version": "1.1.8",
   "description": "Graph layout for JavaScript",
   "author": "Chris Pettitt <cpettitt@gmail.com>",
   "contributors": [