@dagrejs/dagre 1.1.0 → 1.1.1

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

@@ -1,13 +1,8 @@
-"use strict";
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
+
+module.exports = buildLayerGraph;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = buildLayerGraph;
-var _graphlib = require("@dagrejs/graphlib");
-var util = _interopRequireWildcard(require("../util.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /*
  * Constructs a graph that can be used to sort a layer of nodes. The graph will
  * contain all base and subgraph nodes from the request layer in their original
@@ -40,14 +35,13 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 function buildLayerGraph(g, rank, relationship) {
   let root = createRootNode(g),
-    result = new _graphlib.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 => {
     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);
@@ -57,10 +51,9 @@ function buildLayerGraph(g, rank, relationship) {
         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
-        });
+        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
       });
+
       if (node.hasOwnProperty("minRank")) {
         result.setNode(v, {
           borderLeft: node.borderLeft[rank],
@@ -69,11 +62,12 @@ function buildLayerGraph(g, rank, relationship) {
       }
     }
   });
+
   return result;
 }
+
 function createRootNode(g) {
   var v;
-  while (g.hasNode(v = util.uniqueId("_root")));
+  while (g.hasNode((v = util.uniqueId("_root"))));
   return v;
 }
-module.exports = exports.default;

package/lib/order/cross-count.js

@@ -1,10 +1,9 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = crossCount;
-var _util = require("../util.js");
+let zipObject = require("../util").zipObject;
+
+module.exports = crossCount;
+
 /*
  * A function that takes a layering (an array of layers, each with an array of
  * ordererd nodes) and a graph and returns a weighted crossing count.
@@ -24,21 +23,19 @@ var _util = require("../util.js");
 function crossCount(g, layering) {
   let cc = 0;
   for (let i = 1; i < layering.length; ++i) {
-    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+    cc += twoLayerCrossCount(g, layering[i-1], layering[i]);
   }
   return cc;
 }
+
 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.
-  let southPos = (0, _util.zipObject)(southLayer, southLayer.map((v, i) => i));
+  let southPos = zipObject(southLayer, southLayer.map((v, i) => i));
   let southEntries = northLayer.flatMap(v => {
     return g.outEdges(v).map(e => {
-      return {
-        pos: southPos[e.w],
-        weight: g.edge(e).weight
-      };
+      return { pos: southPos[e.w], weight: g.edge(e).weight };
     }).sort((a, b) => a.pos - b.pos);
   });
 
@@ -59,11 +56,11 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
       if (index % 2) {
         weightSum += tree[index + 1];
       }
-      index = index - 1 >> 1;
+      index = (index - 1) >> 1;
       tree[index] += entry.weight;
     }
     cc += entry.weight * weightSum;
   });
+
   return cc;
 }
-module.exports = exports.default;

package/lib/order/index.js

@@ -1,19 +1,15 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = order;
-var _initOrder = _interopRequireDefault(require("./init-order.js"));
-var _crossCount = _interopRequireDefault(require("./cross-count.js"));
-var _sortSubgraph = _interopRequireDefault(require("./sort-subgraph.js"));
-var _buildLayerGraph = _interopRequireDefault(require("./build-layer-graph.js"));
-var _addSubgraphConstraints = _interopRequireDefault(require("./add-subgraph-constraints.js"));
-var _graphlib = require("@dagrejs/graphlib");
-var util = _interopRequireWildcard(require("../util.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let initOrder = require("./init-order");
+let crossCount = require("./cross-count");
+let sortSubgraph = require("./sort-subgraph");
+let buildLayerGraph = require("./build-layer-graph");
+let addSubgraphConstraints = require("./add-subgraph-constraints");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
+
+module.exports = order;
+
 /*
  * Applies heuristics to minimize edge crossings in the graph and sets the best
  * order solution as an order attribute on each node.
@@ -39,7 +35,7 @@ function order(g, opts) {
     downLayerGraphs = buildLayerGraphs(g, util.range(1, maxRank + 1), "inEdges"),
     upLayerGraphs = buildLayerGraphs(g, util.range(maxRank - 1, -1, -1), "outEdges");
 
-  let layering = (0, _initOrder.default)(g);
+  let layering = initOrder(g);
   assignOrder(g, layering);
 
   if (opts && opts.disableOptimalOrderHeuristic) {
@@ -51,31 +47,35 @@ function order(g, opts) {
 
   for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
     sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+
     layering = util.buildLayerMatrix(g);
-    let cc = (0, _crossCount.default)(g, layering);
+    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 (0, _buildLayerGraph.default)(g, rank, relationship);
+  return ranks.map(function(rank) {
+    return buildLayerGraph(g, rank, relationship);
   });
 }
+
 function sweepLayerGraphs(layerGraphs, biasRight) {
-  let cg = new _graphlib.Graph();
-  layerGraphs.forEach(function (lg) {
+  let cg = new Graph();
+  layerGraphs.forEach(function(lg) {
     let root = lg.graph().root;
-    let sorted = (0, _sortSubgraph.default)(lg, root, cg, biasRight);
+    let sorted = sortSubgraph(lg, root, cg, biasRight);
     sorted.vs.forEach((v, i) => lg.node(v).order = i);
-    (0, _addSubgraphConstraints.default)(lg, cg, sorted.vs);
+    addSubgraphConstraints(lg, cg, sorted.vs);
   });
 }
+
 function assignOrder(g, layering) {
   Object.values(layering).forEach(layer => layer.forEach((v, i) => g.node(v).order = i));
 }
-module.exports = exports.default;

package/lib/order/init-order.js

@@ -1,12 +1,9 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = initOrder;
-var util = _interopRequireWildcard(require("../util.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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
@@ -23,6 +20,7 @@ function initOrder(g) {
   let simpleNodes = g.nodes().filter(v => !g.children(v).length);
   let maxRank = Math.max(...simpleNodes.map(v => g.node(v).rank));
   let layers = util.range(maxRank + 1).map(() => []);
+
   function dfs(v) {
     if (visited[v]) return;
     visited[v] = true;
@@ -30,8 +28,9 @@ function initOrder(g) {
     layers[node.rank].push(v);
     g.successors(v).forEach(dfs);
   }
+
   let orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
   orderedVs.forEach(dfs);
+
   return layers;
 }
-module.exports = exports.default;

package/lib/order/resolve-conflicts.js

@@ -1,12 +1,9 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = resolveConflicts;
-var util = _interopRequireWildcard(require("../util.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+let util = require("../util");
+
+module.exports = resolveConflicts;
+
 /*
  * Given a list of entries of the form {v, barycenter, weight} and a
  * constraint graph this function will resolve any conflicts between the
@@ -47,6 +44,7 @@ function resolveConflicts(entries, cg) {
       tmp.weight = entry.weight;
     }
   });
+
   cg.edges().forEach(e => {
     let entryV = mappedEntries[e.v];
     let entryW = mappedEntries[e.w];
@@ -55,21 +53,28 @@ function resolveConflicts(entries, cg) {
       entryV.out.push(mappedEntries[e.w]);
     }
   });
+
   let sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
+
   return doResolveConflicts(sourceSet);
 }
+
 function doResolveConflicts(sourceSet) {
   let entries = [];
+
   function handleIn(vEntry) {
     return uEntry => {
       if (uEntry.merged) {
         return;
       }
-      if (uEntry.barycenter === undefined || vEntry.barycenter === undefined || uEntry.barycenter >= vEntry.barycenter) {
+      if (uEntry.barycenter === undefined ||
+          vEntry.barycenter === undefined ||
+          uEntry.barycenter >= vEntry.barycenter) {
         mergeEntries(vEntry, uEntry);
       }
     };
   }
+
   function handleOut(vEntry) {
     return wEntry => {
       wEntry["in"].push(vEntry);
@@ -78,31 +83,36 @@ function doResolveConflicts(sourceSet) {
       }
     };
   }
+
   while (sourceSet.length) {
     let entry = sourceSet.pop();
     entries.push(entry);
     entry["in"].reverse().forEach(handleIn(entry));
     entry.out.forEach(handleOut(entry));
   }
+
   return entries.filter(entry => !entry.merged).map(entry => {
     return util.pick(entry, ["vs", "i", "barycenter", "weight"]);
   });
 }
+
 function mergeEntries(target, source) {
   let sum = 0;
   let weight = 0;
+
   if (target.weight) {
     sum += target.barycenter * target.weight;
     weight += target.weight;
   }
+
   if (source.weight) {
     sum += source.barycenter * source.weight;
     weight += source.weight;
   }
+
   target.vs = source.vs.concat(target.vs);
   target.barycenter = sum / weight;
   target.weight = weight;
   target.i = Math.min(source.i, target.i);
   source.merged = true;
 }
-module.exports = exports.default;

package/lib/order/sort-subgraph.js

@@ -1,23 +1,21 @@
-"use strict";
+let barycenter = require("./barycenter");
+let resolveConflicts = require("./resolve-conflicts");
+let sort = require("./sort");
+
+module.exports = sortSubgraph;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = sortSubgraph;
-var _barycenter = _interopRequireDefault(require("./barycenter.js"));
-var _resolveConflicts = _interopRequireDefault(require("./resolve-conflicts.js"));
-var _sort = _interopRequireDefault(require("./sort.js"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function sortSubgraph(g, v, cg, biasRight) {
   let movable = g.children(v);
   let node = g.node(v);
   let bl = node ? node.borderLeft : undefined;
-  let br = node ? node.borderRight : undefined;
+  let br = node ? node.borderRight: undefined;
   let subgraphs = {};
+
   if (bl) {
     movable = movable.filter(w => w !== bl && w !== br);
   }
-  let barycenters = (0, _barycenter.default)(g, movable);
+
+  let barycenters = barycenter(g, movable);
   barycenters.forEach(entry => {
     if (g.children(entry.v).length) {
       let subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
@@ -27,9 +25,12 @@ function sortSubgraph(g, v, cg, biasRight) {
       }
     }
   });
-  let entries = (0, _resolveConflicts.default)(barycenters, cg);
+
+  let entries = resolveConflicts(barycenters, cg);
   expandSubgraphs(entries, subgraphs);
-  let result = (0, _sort.default)(entries, biasRight);
+
+  let result = sort(entries, biasRight);
+
   if (bl) {
     result.vs = [bl, result.vs, br].flat(true);
     if (g.predecessors(bl).length) {
@@ -39,12 +40,15 @@ function sortSubgraph(g, v, cg, biasRight) {
         result.barycenter = 0;
         result.weight = 0;
       }
-      result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+      result.barycenter = (result.barycenter * result.weight +
+                           blPred.order + brPred.order) / (result.weight + 2);
       result.weight += 2;
     }
   }
+
   return result;
 }
+
 function expandSubgraphs(entries, subgraphs) {
   entries.forEach(entry => {
     entry.vs = entry.vs.flatMap(v => {
@@ -55,13 +59,15 @@ function expandSubgraphs(entries, subgraphs) {
     });
   });
 }
+
 function mergeBarycenters(target, other) {
   if (target.barycenter !== undefined) {
-    target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
+    target.barycenter = (target.barycenter * target.weight +
+                         other.barycenter * other.weight) /
+                        (target.weight + other.weight);
     target.weight += other.weight;
   } else {
     target.barycenter = other.barycenter;
     target.weight = other.weight;
   }
 }
-module.exports = exports.default;

package/lib/order/sort.js

@@ -1,12 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = sort;
-var util = _interopRequireWildcard(require("../util.js"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+let util = require("../util");
+
+module.exports = sort;
+
 function sort(entries, biasRight) {
   let parts = util.partition(entries, entry => {
     return entry.hasOwnProperty("barycenter");
@@ -17,8 +12,11 @@ function sort(entries, biasRight) {
     sum = 0,
     weight = 0,
     vsIndex = 0;
+
   sortable.sort(compareWithBias(!!biasRight));
+
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+
   sortable.forEach(entry => {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
@@ -26,15 +24,15 @@ function sort(entries, biasRight) {
     weight += entry.weight;
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
   });
-  let result = {
-    vs: vs.flat(true)
-  };
+
+  let result = { vs: vs.flat(true) };
   if (weight) {
     result.barycenter = sum / weight;
     result.weight = weight;
   }
   return result;
 }
+
 function consumeUnsortable(vs, unsortable, index) {
   let last;
   while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= index) {
@@ -44,6 +42,7 @@ function consumeUnsortable(vs, unsortable, index) {
   }
   return index;
 }
+
 function compareWithBias(bias) {
   return (entryV, entryW) => {
     if (entryV.barycenter < entryW.barycenter) {
@@ -51,7 +50,7 @@ function compareWithBias(bias) {
     } else if (entryV.barycenter > entryW.barycenter) {
       return 1;
     }
+
     return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
   };
 }
-module.exports = exports.default;

package/lib/parent-dummy-chains.js

@@ -1,11 +1,8 @@
-"use strict";
+module.exports = parentDummyChains;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parentDummyChains;
 function parentDummyChains(g) {
   let postorderNums = postorder(g);
+
   g.graph().dummyChains.forEach(v => {
     let node = g.node(v);
     let edgeObj = node.edgeObj;
@@ -15,22 +12,29 @@ function parentDummyChains(g) {
     let pathIdx = 0;
     let pathV = path[pathIdx];
     let ascending = true;
+
     while (v !== edgeObj.w) {
       node = g.node(v);
+
       if (ascending) {
-        while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+        while ((pathV = path[pathIdx]) !== lca &&
+               g.node(pathV).maxRank < node.rank) {
           pathIdx++;
         }
+
         if (pathV === lca) {
           ascending = false;
         }
       }
+
       if (!ascending) {
-        while (pathIdx < path.length - 1 && g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
+        while (pathIdx < path.length - 1 &&
+               g.node(pathV = path[pathIdx + 1]).minRank <= node.rank) {
           pathIdx++;
         }
         pathV = path[pathIdx];
       }
+
       g.setParent(v, pathV);
       v = g.successors(v)[0];
     }
@@ -52,7 +56,8 @@ function findPath(g, postorderNums, v, w) {
   do {
     parent = g.parent(parent);
     vPath.push(parent);
-  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+  } while (parent &&
+           (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
   lca = parent;
 
   // Traverse from w to LCA
@@ -60,23 +65,20 @@ function findPath(g, postorderNums, v, w) {
   while ((parent = g.parent(parent)) !== lca) {
     wPath.push(parent);
   }
-  return {
-    path: vPath.concat(wPath.reverse()),
-    lca: lca
-  };
+
+  return { path: vPath.concat(wPath.reverse()), lca: lca };
 }
+
 function postorder(g) {
   let result = {};
   let lim = 0;
+
   function dfs(v) {
     let low = lim;
     g.children(v).forEach(dfs);
-    result[v] = {
-      low: low,
-      lim: lim++
-    };
+    result[v] = { low: low, lim: lim++ };
   }
   g.children().forEach(dfs);
+
   return result;
 }
-module.exports = exports.default;