@dagrejs/dagre 1.0.2 → 1.1.0

package/lib/rank/network-simplex.js

@@ -1,14 +1,16 @@
 "use strict";
 
-var feasibleTree = require("./feasible-tree");
-var slack = require("./util").slack;
-var initRank = require("./util").longestPath;
-var preorder = require("@dagrejs/graphlib").alg.preorder;
-var postorder = require("@dagrejs/graphlib").alg.postorder;
-var simplify = require("../util").simplify;
-
-module.exports = networkSimplex;
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = networkSimplex;
+var _feasibleTree = _interopRequireDefault(require("./feasible-tree.js"));
+var _util = require("./util.js");
+var _graphlib = require("@dagrejs/graphlib");
+var _util2 = require("../util.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var preorder = _graphlib.alg.preorder;
+var postorder = _graphlib.alg.postorder;
 // Expose some internals for testing purposes
 networkSimplex.initLowLimValues = initLowLimValues;
 networkSimplex.initCutValues = initCutValues;
@@ -51,14 +53,13 @@ networkSimplex.exchangeEdges = exchangeEdges;
  * structure of the overall algorithm.
  */
 function networkSimplex(g) {
-  g = simplify(g);
-  initRank(g);
-  var t = feasibleTree(g);
+  g = (0, _util2.simplify)(g);
+  (0, _util.longestPath)(g);
+  var t = (0, _feasibleTree.default)(g);
   initLowLimValues(t);
   initCutValues(t, g);
-
   var e, f;
-  while ((e = leaveEdge(t))) {
+  while (e = leaveEdge(t)) {
     f = enterEdge(t, g, e);
     exchangeEdges(t, g, e, f);
   }
@@ -72,7 +73,6 @@ function initCutValues(t, g) {
   vs = vs.slice(0, vs.length - 1);
   vs.forEach(v => assignCutValue(t, g, v));
 }
-
 function assignCutValue(t, g, child) {
   var childLab = t.node(child);
   var parent = childLab.parent;
@@ -92,22 +92,17 @@ function calcCutValue(t, g, child) {
   var graphEdge = g.edge(child, parent);
   // The accumulated cut value for the edge between this node and its parent
   var cutValue = 0;
-
   if (!graphEdge) {
     childIsTail = false;
     graphEdge = g.edge(parent, child);
   }
-
   cutValue = graphEdge.weight;
-
-  g.nodeEdges(child).forEach(function(e) {
+  g.nodeEdges(child).forEach(e => {
     var isOutEdge = e.v === child,
       other = isOutEdge ? e.w : e.v;
-
     if (other !== parent) {
       var pointsToHead = isOutEdge === childIsTail,
         otherWeight = g.edge(e).weight;
-
       cutValue += pointsToHead ? otherWeight : -otherWeight;
       if (isTreeEdge(t, child, other)) {
         var otherCutValue = t.edge(child, other).cutvalue;
@@ -115,28 +110,23 @@ function calcCutValue(t, g, child) {
       }
     }
   });
-
   return cutValue;
 }
-
 function initLowLimValues(tree, root) {
   if (arguments.length < 2) {
     root = tree.nodes()[0];
   }
   dfsAssignLowLim(tree, {}, 1, root);
 }
-
 function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
   var low = nextLim;
   var label = tree.node(v);
-
   visited[v] = true;
-  tree.neighbors(v).forEach(function(w) {
+  tree.neighbors(v).forEach(w => {
     if (!visited.hasOwnProperty(w)) {
       nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
     }
   });
-
   label.low = low;
   label.lim = nextLim++;
   if (parent) {
@@ -145,14 +135,11 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
     // TODO should be able to remove this when we incrementally update low lim
     delete label.parent;
   }
-
   return nextLim;
 }
-
 function leaveEdge(tree) {
   return tree.edges().find(e => tree.edge(e).cutvalue < 0);
 }
-
 function enterEdge(t, g, edge) {
   var v = edge.v;
   var w = edge.w;
@@ -164,7 +151,6 @@ function enterEdge(t, g, edge) {
     v = edge.w;
     w = edge.v;
   }
-
   var vLabel = t.node(v);
   var wLabel = t.node(w);
   var tailLabel = vLabel;
@@ -176,21 +162,16 @@ function enterEdge(t, g, edge) {
     tailLabel = wLabel;
     flip = true;
   }
-
-  var candidates = g.edges().filter(function(edge) {
-    return flip === isDescendant(t, t.node(edge.v), tailLabel) &&
-           flip !== isDescendant(t, t.node(edge.w), tailLabel);
+  var candidates = g.edges().filter(edge => {
+    return flip === isDescendant(t, t.node(edge.v), tailLabel) && flip !== isDescendant(t, t.node(edge.w), tailLabel);
   });
-
   return candidates.reduce((acc, edge) => {
-    if (slack(g, edge) < slack(g, acc)) {
+    if ((0, _util.slack)(g, edge) < (0, _util.slack)(g, acc)) {
       return edge;
     }
-
     return acc;
   });
 }
-
 function exchangeEdges(t, g, e, f) {
   var v = e.v;
   var w = e.w;
@@ -200,21 +181,18 @@ function exchangeEdges(t, g, e, f) {
   initCutValues(t, g);
   updateRanks(t, g);
 }
-
 function updateRanks(t, g) {
   var root = t.nodes().find(v => !g.node(v).parent);
   var vs = preorder(t, root);
   vs = vs.slice(1);
-  vs.forEach(function(v) {
+  vs.forEach(v => {
     var parent = t.node(v).parent,
       edge = g.edge(v, parent),
       flipped = false;
-
     if (!edge) {
       edge = g.edge(parent, v);
       flipped = true;
     }
-
     g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
   });
 }
@@ -233,3 +211,4 @@ function isTreeEdge(tree, u, v) {
 function isDescendant(tree, vLabel, rootLabel) {
   return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
 }
+module.exports = exports.default;

package/lib/rank/util.js

@@ -1,10 +1,5 @@
 "use strict";
 
-module.exports = {
-  longestPath: longestPath,
-  slack: slack
-};
-
 /*
  * Initializes ranks for the input graph using the longest path algorithm. This
  * algorithm scales well and is fast in practice, it yields rather poor
@@ -26,31 +21,30 @@ module.exports = {
  *
  *    1. Each node will be assign an (unnormalized) "rank" property.
  */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.longestPath = longestPath;
+exports.slack = slack;
 function longestPath(g) {
   var visited = {};
-
   function dfs(v) {
     var label = g.node(v);
     if (visited.hasOwnProperty(v)) {
       return label.rank;
     }
     visited[v] = true;
-
     var rank = Math.min(...g.outEdges(v).map(e => {
       if (e == null) {
         return Number.POSITIVE_INFINITY;
       }
-
       return dfs(e.w) - g.edge(e).minlen;
     }));
-
     if (rank === Number.POSITIVE_INFINITY) {
       rank = 0;
     }
-
-    return (label.rank = rank);
+    return label.rank = rank;
   }
-
   g.sources().forEach(dfs);
 }
 

package/lib/util.js

@@ -2,39 +2,37 @@
 
 "use strict";
 
-var Graph = require("@dagrejs/graphlib").Graph;
-
-module.exports = {
-  addBorderNode,
-  addDummyNode,
-  asNonCompoundGraph,
-  buildLayerMatrix,
-  intersectRect,
-  mapValues,
-  maxRank,
-  normalizeRanks,
-  notime,
-  partition,
-  pick,
-  predecessorWeights,
-  range,
-  removeEmptyRanks,
-  simplify,
-  successorWeights,
-  time,
-  uniqueId,
-  zipObject,
-};
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addBorderNode = addBorderNode;
+exports.addDummyNode = addDummyNode;
+exports.asNonCompoundGraph = asNonCompoundGraph;
+exports.buildLayerMatrix = buildLayerMatrix;
+exports.intersectRect = intersectRect;
+exports.mapValues = mapValues;
+exports.maxRank = maxRank;
+exports.normalizeRanks = normalizeRanks;
+exports.notime = notime;
+exports.partition = partition;
+exports.pick = pick;
+exports.predecessorWeights = predecessorWeights;
+exports.range = range;
+exports.removeEmptyRanks = removeEmptyRanks;
+exports.simplify = simplify;
+exports.successorWeights = successorWeights;
+exports.time = time;
+exports.uniqueId = uniqueId;
+exports.zipObject = zipObject;
+var _graphlib = require("@dagrejs/graphlib");
 /*
  * Adds a dummy node to the graph and return v.
  */
 function addDummyNode(g, type, attrs, name) {
-  var v;
+  let v;
   do {
     v = uniqueId(name);
   } while (g.hasNode(v));
-
   attrs.dummy = type;
   g.setNode(v, attrs);
   return v;
@@ -45,11 +43,14 @@ function addDummyNode(g, type, attrs, name) {
  * associated with multi-edges.
  */
 function simplify(g) {
-  var simplified = new Graph().setGraph(g.graph());
+  let simplified = new _graphlib.Graph().setGraph(g.graph());
   g.nodes().forEach(v => simplified.setNode(v, g.node(v)));
   g.edges().forEach(e => {
-    var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
-    var label = g.edge(e);
+    let simpleLabel = simplified.edge(e.v, e.w) || {
+      weight: 0,
+      minlen: 1
+    };
+    let label = g.edge(e);
     simplified.setEdge(e.v, e.w, {
       weight: simpleLabel.weight + label.weight,
       minlen: Math.max(simpleLabel.minlen, label.minlen)
@@ -57,9 +58,10 @@ function simplify(g) {
   });
   return simplified;
 }
-
 function asNonCompoundGraph(g) {
-  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+  let simplified = new _graphlib.Graph({
+    multigraph: g.isMultigraph()
+  }).setGraph(g.graph());
   g.nodes().forEach(v => {
     if (!g.children(v).length) {
       simplified.setNode(v, g.node(v));
@@ -70,10 +72,9 @@ function asNonCompoundGraph(g) {
   });
   return simplified;
 }
-
 function successorWeights(g) {
-  var weightMap = g.nodes().map(v => {
-    var sucs = {};
+  let weightMap = g.nodes().map(v => {
+    let sucs = {};
     g.outEdges(v).forEach(e => {
       sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
     });
@@ -81,10 +82,9 @@ function successorWeights(g) {
   });
   return zipObject(g.nodes(), weightMap);
 }
-
 function predecessorWeights(g) {
-  var weightMap = g.nodes().map(v => {
-    var preds = {};
+  let weightMap = g.nodes().map(v => {
+    let preds = {};
     g.inEdges(v).forEach(e => {
       preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
     });
@@ -98,21 +98,19 @@ function predecessorWeights(g) {
  * ({x, y, width, height}) if it were pointing at the rectangle's center.
  */
 function intersectRect(rect, point) {
-  var x = rect.x;
-  var y = rect.y;
+  let x = rect.x;
+  let y = rect.y;
 
   // Rectangle intersection algorithm from:
   // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
-  var dx = point.x - x;
-  var dy = point.y - y;
-  var w = rect.width / 2;
-  var h = rect.height / 2;
-
+  let dx = point.x - x;
+  let dy = point.y - y;
+  let w = rect.width / 2;
+  let h = rect.height / 2;
   if (!dx && !dy) {
     throw new Error("Not possible to find intersection inside of the rectangle");
   }
-
-  var sx, sy;
+  let sx, sy;
   if (Math.abs(dy) * w > Math.abs(dx) * h) {
     // Intersection is top or bottom of rect.
     if (dy < 0) {
@@ -128,8 +126,10 @@ function intersectRect(rect, point) {
     sx = w;
     sy = w * dy / dx;
   }
-
-  return { x: x + sx, y: y + sy };
+  return {
+    x: x + sx,
+    y: y + sy
+  };
 }
 
 /*
@@ -137,10 +137,10 @@ function intersectRect(rect, point) {
  * function will produce a matrix with the ids of each node.
  */
 function buildLayerMatrix(g) {
-  var layering = range(maxRank(g) + 1).map(() => []);
+  let layering = range(maxRank(g) + 1).map(() => []);
   g.nodes().forEach(v => {
-    var node = g.node(v);
-    var rank = node.rank;
+    let node = g.node(v);
+    let rank = node.rank;
     if (rank !== undefined) {
       layering[rank][node.order] = v;
     }
@@ -153,37 +153,33 @@ function buildLayerMatrix(g) {
  * rank(v) >= 0 and at least one node w has rank(w) = 0.
  */
 function normalizeRanks(g) {
-  var min = Math.min(...g.nodes().map(v => {
-    var rank = g.node(v).rank;
+  let min = Math.min(...g.nodes().map(v => {
+    let rank = g.node(v).rank;
     if (rank === undefined) {
       return Number.MAX_VALUE;
     }
-
     return rank;
   }));
   g.nodes().forEach(v => {
-    var node = g.node(v);
+    let node = g.node(v);
     if (node.hasOwnProperty("rank")) {
       node.rank -= min;
     }
   });
 }
-
 function removeEmptyRanks(g) {
   // Ranks may not start at 0, so we need to offset them
-  var offset = Math.min(...g.nodes().map(v => g.node(v).rank));
-
-  var layers = [];
+  let offset = Math.min(...g.nodes().map(v => g.node(v).rank));
+  let layers = [];
   g.nodes().forEach(v => {
-    var rank = g.node(v).rank - offset;
+    let rank = g.node(v).rank - offset;
     if (!layers[rank]) {
       layers[rank] = [];
     }
     layers[rank].push(v);
   });
-
-  var delta = 0;
-  var nodeRankFactor = g.graph().nodeRankFactor;
+  let delta = 0;
+  let nodeRankFactor = g.graph().nodeRankFactor;
   Array.from(layers).forEach((vs, i) => {
     if (vs === undefined && i % nodeRankFactor !== 0) {
       --delta;
@@ -192,9 +188,8 @@ function removeEmptyRanks(g) {
     }
   });
 }
-
 function addBorderNode(g, prefix, rank, order) {
-  var node = {
+  let node = {
     width: 0,
     height: 0
   };
@@ -204,14 +199,12 @@ function addBorderNode(g, prefix, rank, order) {
   }
   return addDummyNode(g, "border", node, prefix);
 }
-
 function maxRank(g) {
   return Math.max(...g.nodes().map(v => {
-    var rank = g.node(v).rank;
+    let rank = g.node(v).rank;
     if (rank === undefined) {
       return Number.MIN_VALUE;
     }
-
     return rank;
   }));
 }
@@ -222,7 +215,10 @@ function maxRank(g) {
  * into `rhs.
  */
 function partition(collection, fn) {
-  var result = { lhs: [], rhs: [] };
+  let result = {
+    lhs: [],
+    rhs: []
+  };
   collection.forEach(value => {
     if (fn(value)) {
       result.lhs.push(value);
@@ -238,43 +234,36 @@ function partition(collection, fn) {
  * time it takes to execute the function.
  */
 function time(name, fn) {
-  var start = Date.now();
+  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 toString(prefix) + id;
 }
-
 function range(start, limit, step = 1) {
   if (limit == null) {
     limit = start;
     start = 0;
   }
-
-  let endCon = (i) => i < limit;
+  let endCon = i => i < limit;
   if (step < 0) {
-    endCon = (i) => limit < i;
+    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) {
@@ -282,22 +271,18 @@ function pick(source, keys) {
       dest[key] = source[key];
     }
   }
-
   return dest;
 }
-
 function mapValues(obj, funcOrProp) {
   let func = funcOrProp;
   if (typeof funcOrProp === 'string') {
-    func = (val) => val[funcOrProp];
+    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];

package/lib/version.js

@@ -1 +1,8 @@
-module.exports = "1.0.2";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = "1.1.0";
+module.exports = exports.default;

package/mjs-lib/acyclic.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import { default as greedyFAS } from "./greedy-fas.js";
+import { uniqueId as uniqueId } from "./util.js";
+
+export function run(g) {
+  let fas = (g.graph().acyclicer === "greedy"
+    ? greedyFAS(g, weightFn(g))
+    : dfsFAS(g));
+  fas.forEach(e => {
+    let label = g.edge(e);
+    g.removeEdge(e);
+    label.forwardName = e.name;
+    label.reversed = true;
+    g.setEdge(e.w, e.v, label, uniqueId("rev"));
+  });
+
+  function weightFn(g) {
+    return e => {
+      return g.edge(e).weight;
+    };
+  }
+}
+
+function dfsFAS(g) {
+  let fas = [];
+  let stack = {};
+  let visited = {};
+
+  function dfs(v) {
+    if (visited.hasOwnProperty(v)) {
+      return;
+    }
+    visited[v] = true;
+    stack[v] = true;
+    g.outEdges(v).forEach(e => {
+      if (stack.hasOwnProperty(e.w)) {
+        fas.push(e);
+      } else {
+        dfs(e.w);
+      }
+    });
+    delete stack[v];
+  }
+
+  g.nodes().forEach(dfs);
+  return fas;
+}
+
+export function undo(g) {
+  g.edges().forEach(e => {
+    let label = g.edge(e);
+    if (label.reversed) {
+      g.removeEdge(e);
+
+      let forwardName = label.forwardName;
+      delete label.reversed;
+      delete label.forwardName;
+      g.setEdge(e.w, e.v, label, forwardName);
+    }
+  });
+}

package/mjs-lib/add-border-segments.js

@@ -0,0 +1,35 @@
+import  * as util from "./util.js";
+
+export default function addBorderSegments(g) {
+  function dfs(v) {
+    let children = g.children(v);
+    let node = g.node(v);
+    if (children.length) {
+      children.forEach(dfs);
+    }
+
+    if (node.hasOwnProperty("minRank")) {
+      node.borderLeft = [];
+      node.borderRight = [];
+      for (let rank = node.minRank, maxRank = node.maxRank + 1;
+        rank < maxRank;
+        ++rank) {
+        addBorderNode(g, "borderLeft", "_bl", v, node, rank);
+        addBorderNode(g, "borderRight", "_br", v, node, rank);
+      }
+    }
+  }
+
+  g.children().forEach(dfs);
+}
+
+function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
+  let label = { width: 0, height: 0, rank: rank, borderType: prop };
+  let prev = sgNode[prop][rank - 1];
+  let curr = util.addDummyNode(g, "border", label, prefix);
+  sgNode[prop][rank] = curr;
+  g.setParent(curr, sg);
+  if (prev) {
+    g.setEdge(prev, curr, { weight: 1 });
+  }
+}