@dagrejs/dagre 1.1.5 → 2.0.0

package/lib/rank/network-simplex.js

@@ -1,235 +0,0 @@
-"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;
-
-// Expose some internals for testing purposes
-networkSimplex.initLowLimValues = initLowLimValues;
-networkSimplex.initCutValues = initCutValues;
-networkSimplex.calcCutValue = calcCutValue;
-networkSimplex.leaveEdge = leaveEdge;
-networkSimplex.enterEdge = enterEdge;
-networkSimplex.exchangeEdges = exchangeEdges;
-
-/*
- * The network simplex algorithm assigns ranks to each node in the input graph
- * and iteratively improves the ranking to reduce the length of edges.
- *
- * Preconditions:
- *
- *    1. The input graph must be a DAG.
- *    2. All nodes in the graph must have an object value.
- *    3. All edges in the graph must have "minlen" and "weight" attributes.
- *
- * Postconditions:
- *
- *    1. All nodes in the graph will have an assigned "rank" attribute that has
- *       been optimized by the network simplex algorithm. Ranks start at 0.
- *
- *
- * A rough sketch of the algorithm is as follows:
- *
- *    1. Assign initial ranks to each node. We use the longest path algorithm,
- *       which assigns ranks to the lowest position possible. In general this
- *       leads to very wide bottom ranks and unnecessarily long edges.
- *    2. Construct a feasible tight tree. A tight tree is one such that all
- *       edges in the tree have no slack (difference between length of edge
- *       and minlen for the edge). This by itself greatly improves the assigned
- *       rankings by shorting edges.
- *    3. Iteratively find edges that have negative cut values. Generally a
- *       negative cut value indicates that the edge could be removed and a new
- *       tree edge could be added to produce a more compact graph.
- *
- * Much of the algorithms here are derived from Gansner, et al., "A Technique
- * for Drawing Directed Graphs." The structure of the file roughly follows the
- * structure of the overall algorithm.
- */
-function networkSimplex(g) {
-  g = simplify(g);
-  initRank(g);
-  var t = feasibleTree(g);
-  initLowLimValues(t);
-  initCutValues(t, g);
-
-  var e, f;
-  while ((e = leaveEdge(t))) {
-    f = enterEdge(t, g, e);
-    exchangeEdges(t, g, e, f);
-  }
-}
-
-/*
- * Initializes cut values for all edges in the tree.
- */
-function initCutValues(t, g) {
-  var vs = postorder(t, t.nodes());
-  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;
-  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
-}
-
-/*
- * Given the tight tree, its graph, and a child in the graph calculate and
- * return the cut value for the edge between the child and its parent.
- */
-function calcCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  // True if the child is on the tail end of the edge in the directed graph
-  var childIsTail = true;
-  // The graph's view of the tree edge we're inspecting
-  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(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;
-        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
-      }
-    }
-  });
-
-  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(w => {
-    if (!Object.hasOwn(visited, w)) {
-      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
-    }
-  });
-
-  label.low = low;
-  label.lim = nextLim++;
-  if (parent) {
-    label.parent = parent;
-  } else {
-    // 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;
-
-  // For the rest of this function we assume that v is the tail and w is the
-  // head, so if we don't have this edge in the graph we should flip it to
-  // match the correct orientation.
-  if (!g.hasEdge(v, w)) {
-    v = edge.w;
-    w = edge.v;
-  }
-
-  var vLabel = t.node(v);
-  var wLabel = t.node(w);
-  var tailLabel = vLabel;
-  var flip = false;
-
-  // If the root is in the tail of the edge then we need to flip the logic that
-  // checks for the head and tail nodes in the candidates function below.
-  if (vLabel.lim > wLabel.lim) {
-    tailLabel = wLabel;
-    flip = true;
-  }
-
-  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)) {
-      return edge;
-    }
-
-    return acc;
-  });
-}
-
-function exchangeEdges(t, g, e, f) {
-  var v = e.v;
-  var w = e.w;
-  t.removeEdge(v, w);
-  t.setEdge(f.v, f.w, {});
-  initLowLimValues(t);
-  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(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);
-  });
-}
-
-/*
- * Returns true if the edge is in the tree.
- */
-function isTreeEdge(tree, u, v) {
-  return tree.hasEdge(u, v);
-}
-
-/*
- * Returns true if the specified node is descendant of the root node per the
- * assigned low and lim attributes in the tree.
- */
-function isDescendant(tree, vLabel, rootLabel) {
-  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
-}

package/lib/rank/util.js

@@ -1,67 +0,0 @@
-"use strict";
-
-const { applyWithChunking } = require("../util");
-
-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
- * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom
- * ranks wide and leaving edges longer than necessary. However, due to its
- * speed, this algorithm is good for getting an initial ranking that can be fed
- * into other algorithms.
- *
- * This algorithm does not normalize layers because it will be used by other
- * algorithms in most cases. If using this algorithm directly, be sure to
- * run normalize at the end.
- *
- * Pre-conditions:
- *
- *    1. Input graph is a DAG.
- *    2. Input graph node labels can be assigned properties.
- *
- * Post-conditions:
- *
- *    1. Each node will be assign an (unnormalized) "rank" property.
- */
-function longestPath(g) {
-  var visited = {};
-
-  function dfs(v) {
-    var label = g.node(v);
-    if (Object.hasOwn(visited, v)) {
-      return label.rank;
-    }
-    visited[v] = true;
-
-    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;
-    }
-
-    return (label.rank = rank);
-  }
-
-  g.sources().forEach(dfs);
-}
-
-/*
- * Returns the amount of slack for the given edge. The slack is defined as the
- * difference between the length of the edge and its minimum length.
- */
-function slack(g, e) {
-  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
-}

package/lib/util.js

@@ -1,331 +0,0 @@
-/* eslint "no-console": off */
-
-"use strict";
-
-let Graph = require("@dagrejs/graphlib").Graph;
-
-module.exports = {
-  addBorderNode,
-  addDummyNode,
-  applyWithChunking,
-  asNonCompoundGraph,
-  buildLayerMatrix,
-  intersectRect,
-  mapValues,
-  maxRank,
-  normalizeRanks,
-  notime,
-  partition,
-  pick,
-  predecessorWeights,
-  range,
-  removeEmptyRanks,
-  simplify,
-  successorWeights,
-  time,
-  uniqueId,
-  zipObject,
-};
-
-/*
- * Adds a dummy node to the graph and return v.
- */
-function addDummyNode(g, type, attrs, name) {
-  var v = name;
-  while (g.hasNode(v)) {
-    v = uniqueId(name);
-  }
-
-  attrs.dummy = type;
-  g.setNode(v, attrs);
-  return v;
-}
-
-/*
- * Returns a new graph with only simple edges. Handles aggregation of data
- * associated with multi-edges.
- */
-function simplify(g) {
-  let simplified = new Graph().setGraph(g.graph());
-  g.nodes().forEach(v => simplified.setNode(v, g.node(v)));
-  g.edges().forEach(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)
-    });
-  });
-  return simplified;
-}
-
-function asNonCompoundGraph(g) {
-  let simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
-  g.nodes().forEach(v => {
-    if (!g.children(v).length) {
-      simplified.setNode(v, g.node(v));
-    }
-  });
-  g.edges().forEach(e => {
-    simplified.setEdge(e, g.edge(e));
-  });
-  return simplified;
-}
-
-function successorWeights(g) {
-  let weightMap = g.nodes().map(v => {
-    let sucs = {};
-    g.outEdges(v).forEach(e => {
-      sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
-    });
-    return sucs;
-  });
-  return zipObject(g.nodes(), weightMap);
-}
-
-function predecessorWeights(g) {
-  let weightMap = g.nodes().map(v => {
-    let preds = {};
-    g.inEdges(v).forEach(e => {
-      preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
-    });
-    return preds;
-  });
-  return zipObject(g.nodes(), weightMap);
-}
-
-/*
- * Finds where a line starting at point ({x, y}) would intersect a rectangle
- * ({x, y, width, height}) if it were pointing at the rectangle's center.
- */
-function intersectRect(rect, point) {
-  let x = rect.x;
-  let y = rect.y;
-
-  // Rectangle intersection algorithm from:
-  // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
-  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");
-  }
-
-  let sx, sy;
-  if (Math.abs(dy) * w > Math.abs(dx) * h) {
-    // Intersection is top or bottom of rect.
-    if (dy < 0) {
-      h = -h;
-    }
-    sx = h * dx / dy;
-    sy = h;
-  } else {
-    // Intersection is left or right of rect.
-    if (dx < 0) {
-      w = -w;
-    }
-    sx = w;
-    sy = w * dy / dx;
-  }
-
-  return { x: x + sx, y: y + sy };
-}
-
-/*
- * Given a DAG with each node assigned "rank" and "order" properties, this
- * function will produce a matrix with the ids of each node.
- */
-function buildLayerMatrix(g) {
-  let layering = range(maxRank(g) + 1).map(() => []);
-  g.nodes().forEach(v => {
-    let node = g.node(v);
-    let rank = node.rank;
-    if (rank !== undefined) {
-      layering[rank][node.order] = v;
-    }
-  });
-  return layering;
-}
-
-/*
- * Adjusts the ranks for all nodes in the graph such that all nodes v have
- * rank(v) >= 0 and at least one node w has rank(w) = 0.
- */
-function normalizeRanks(g) {
-  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 (Object.hasOwn(node, "rank")) {
-      node.rank -= min;
-    }
-  });
-}
-
-function removeEmptyRanks(g) {
-  // Ranks may not start at 0, so we need to offset them
-  let nodeRanks = g.nodes().map(v => g.node(v).rank);
-  let offset = applyWithChunking(Math.min, nodeRanks);
-
-  let layers = [];
-  g.nodes().forEach(v => {
-    let rank = g.node(v).rank - offset;
-    if (!layers[rank]) {
-      layers[rank] = [];
-    }
-    layers[rank].push(v);
-  });
-
-  let delta = 0;
-  let nodeRankFactor = g.graph().nodeRankFactor;
-  Array.from(layers).forEach((vs, i) => {
-    if (vs === undefined && i % nodeRankFactor !== 0) {
-      --delta;
-    } else if (vs !== undefined && delta) {
-      vs.forEach(v => g.node(v).rank += delta);
-    }
-  });
-}
-
-function addBorderNode(g, prefix, rank, order) {
-  let node = {
-    width: 0,
-    height: 0
-  };
-  if (arguments.length >= 4) {
-    node.rank = rank;
-    node.order = 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) {
-  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);
-}
-
-/*
- * Partition a collection into two groups: `lhs` and `rhs`. If the supplied
- * function returns true for an entry it goes into `lhs`. Otherwise it goes
- * into `rhs.
- */
-function partition(collection, fn) {
-  let result = { lhs: [], rhs: [] };
-  collection.forEach(value => {
-    if (fn(value)) {
-      result.lhs.push(value);
-    } else {
-      result.rhs.push(value);
-    }
-  });
-  return result;
-}
-
-/*
- * 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;
-  }, {});
-}

package/lib/version.js

@@ -1 +0,0 @@
-module.exports = "1.1.5";