@dagrejs/dagre 1.1.0 → 1.1.2

package/mjs-lib/nesting-graph.js

@@ -1,120 +0,0 @@
-import * as util from "./util.js";
-
-/*
- * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
- * adds appropriate edges to ensure that all cluster nodes are placed between
- * these boundaries, and ensures that the graph is connected.
- *
- * In addition we ensure, through the use of the minlen property, that nodes
- * and subgraph border nodes to not end up on the same rank.
- *
- * Preconditions:
- *
- *    1. Input graph is a DAG
- *    2. Nodes in the input graph has a minlen attribute
- *
- * Postconditions:
- *
- *    1. Input graph is connected.
- *    2. Dummy nodes are added for the tops and bottoms of subgraphs.
- *    3. The minlen attribute for nodes is adjusted to ensure nodes do not
- *       get placed on the same rank as subgraph border nodes.
- *
- * The nesting graph idea comes from Sander, "Layout of Compound Directed
- * Graphs."
- */
-export function run(g) {
-  let root = util.addDummyNode(g, "root", {}, "_root");
-  let depths = treeDepths(g);
-  let height = Math.max(...Object.values(depths)) - 1; // Note: depths is an Object not an array
-  let nodeSep = 2 * height + 1;
-
-  g.graph().nestingRoot = root;
-
-  // Multiply minlen by nodeSep to align nodes on non-border ranks.
-  g.edges().forEach(e => g.edge(e).minlen *= nodeSep);
-
-  // Calculate a weight that is sufficient to keep subgraphs vertically compact
-  let weight = sumWeights(g) + 1;
-
-  // Create border nodes and link them up
-  g.children().forEach(child => dfs(g, root, nodeSep, weight, height, depths, child));
-
-  // Save the multiplier for node layers for later removal of empty border
-  // layers.
-  g.graph().nodeRankFactor = nodeSep;
-}
-
-function dfs(g, root, nodeSep, weight, height, depths, v) {
-  let children = g.children(v);
-  if (!children.length) {
-    if (v !== root) {
-      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
-    }
-    return;
-  }
-
-  let top = util.addBorderNode(g, "_bt");
-  let bottom = util.addBorderNode(g, "_bb");
-  let label = g.node(v);
-
-  g.setParent(top, v);
-  label.borderTop = top;
-  g.setParent(bottom, v);
-  label.borderBottom = bottom;
-
-  children.forEach(child => {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-
-    let childNode = g.node(child);
-    let childTop = childNode.borderTop ? childNode.borderTop : child;
-    let childBottom = childNode.borderBottom ? childNode.borderBottom : child;
-    let thisWeight = childNode.borderTop ? weight : 2 * weight;
-    let minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
-
-    g.setEdge(top, childTop, {
-      weight: thisWeight,
-      minlen: minlen,
-      nestingEdge: true
-    });
-
-    g.setEdge(childBottom, bottom, {
-      weight: thisWeight,
-      minlen: minlen,
-      nestingEdge: true
-    });
-  });
-
-  if (!g.parent(v)) {
-    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
-  }
-}
-
-function treeDepths(g) {
-  var depths = {};
-  function dfs(v, depth) {
-    var children = g.children(v);
-    if (children && children.length) {
-      children.forEach(child => dfs(child, depth + 1));
-    }
-    depths[v] = depth;
-  }
-  g.children().forEach(v => dfs(v, 1));
-  return depths;
-}
-
-function sumWeights(g) {
-  return g.edges().reduce((acc, e) => acc + g.edge(e).weight, 0);
-}
-
-export function cleanup(g) {
-  var graphLabel = g.graph();
-  g.removeNode(graphLabel.nestingRoot);
-  delete graphLabel.nestingRoot;
-  g.edges().forEach(e => {
-    var edge = g.edge(e);
-    if (edge.nestingEdge) {
-      g.removeEdge(e);
-    }
-  });
-}

package/mjs-lib/normalize.js

@@ -1,84 +0,0 @@
-"use strict";
-
-import * as util from "./util.js";
-
-/*
- * Breaks any long edges in the graph into short segments that span 1 layer
- * each. This operation is undoable with the denormalize function.
- *
- * Pre-conditions:
- *
- *    1. The input graph is a DAG.
- *    2. Each node in the graph has a "rank" property.
- *
- * Post-condition:
- *
- *    1. All edges in the graph have a length of 1.
- *    2. Dummy nodes are added where edges have been split into segments.
- *    3. The graph is augmented with a "dummyChains" attribute which contains
- *       the first dummy in each chain of dummy nodes produced.
- */
-export function run(g) {
-  g.graph().dummyChains = [];
-  g.edges().forEach(edge => normalizeEdge(g, edge));
-}
-
-function normalizeEdge(g, e) {
-  let v = e.v;
-  let vRank = g.node(v).rank;
-  let w = e.w;
-  let wRank = g.node(w).rank;
-  let name = e.name;
-  let edgeLabel = g.edge(e);
-  let labelRank = edgeLabel.labelRank;
-
-  if (wRank === vRank + 1) return;
-
-  g.removeEdge(e);
-
-  let dummy, attrs, i;
-  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
-    edgeLabel.points = [];
-    attrs = {
-      width: 0, height: 0,
-      edgeLabel: edgeLabel, edgeObj: e,
-      rank: vRank
-    };
-    dummy = util.addDummyNode(g, "edge", attrs, "_d");
-    if (vRank === labelRank) {
-      attrs.width = edgeLabel.width;
-      attrs.height = edgeLabel.height;
-      attrs.dummy = "edge-label";
-      attrs.labelpos = edgeLabel.labelpos;
-    }
-    g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
-    if (i === 0) {
-      g.graph().dummyChains.push(dummy);
-    }
-    v = dummy;
-  }
-
-  g.setEdge(v, w, { weight: edgeLabel.weight }, name);
-}
-
-export function undo(g) {
-  g.graph().dummyChains.forEach(v => {
-    let node = g.node(v);
-    let origLabel = node.edgeLabel;
-    let w;
-    g.setEdge(node.edgeObj, origLabel);
-    while (node.dummy) {
-      w = g.successors(v)[0];
-      g.removeNode(v);
-      origLabel.points.push({ x: node.x, y: node.y });
-      if (node.dummy === "edge-label") {
-        origLabel.x = node.x;
-        origLabel.y = node.y;
-        origLabel.width = node.width;
-        origLabel.height = node.height;
-      }
-      v = w;
-      node = g.node(v);
-    }
-  });
-}

package/mjs-lib/order/add-subgraph-constraints.js

@@ -1,49 +0,0 @@
-export default function addSubgraphConstraints(g, cg, vs) {
-  let prev = {},
-    rootPrev;
-
-  vs.forEach(v => {
-    let child = g.parent(v),
-      parent,
-      prevChild;
-    while (child) {
-      parent = g.parent(child);
-      if (parent) {
-        prevChild = prev[parent];
-        prev[parent] = child;
-      } else {
-        prevChild = rootPrev;
-        rootPrev = child;
-      }
-      if (prevChild && prevChild !== child) {
-        cg.setEdge(prevChild, child);
-        return;
-      }
-      child = parent;
-    }
-  });
-
-  /*
-  function dfs(v) {
-    var children = v ? g.children(v) : g.children();
-    if (children.length) {
-      var min = Number.POSITIVE_INFINITY,
-          subgraphs = [];
-      children.forEach(function(child) {
-        var childMin = dfs(child);
-        if (g.children(child).length) {
-          subgraphs.push({ v: child, order: childMin });
-        }
-        min = Math.min(min, childMin);
-      });
-      _.sortBy(subgraphs, "order").reduce(function(prev, curr) {
-        cg.setEdge(prev.v, curr.v);
-        return curr;
-      });
-      return min;
-    }
-    return g.node(v).order;
-  }
-  dfs(undefined);
-  */
-}

package/mjs-lib/order/barycenter.js

@@ -1,24 +0,0 @@
-export default function barycenter(g, movable = []) {
-  return movable.map(v => {
-    let inV = g.inEdges(v);
-    if (!inV.length) {
-      return { v: v };
-    } else {
-      let result = inV.reduce((acc, e) => {
-        let edge = g.edge(e),
-          nodeU = g.node(e.v);
-        return {
-          sum: acc.sum + (edge.weight * nodeU.order),
-          weight: acc.weight + edge.weight
-        };
-      }, { sum: 0, weight: 0 });
-
-      return {
-        v: v,
-        barycenter: result.sum / result.weight,
-        weight: result.weight
-      };
-    }
-  });
-}
-

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

@@ -1,71 +0,0 @@
-import { Graph as Graph } from "@dagrejs/graphlib";
-import  * as util from "../util.js";
-
-/*
- * 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
- * hierarchy and any edges that are incident on these nodes and are of the type
- * requested by the "relationship" parameter.
- *
- * Nodes from the requested rank that do not have parents are assigned a root
- * node in the output graph, which is set in the root graph attribute. This
- * makes it easy to walk the hierarchy of movable nodes during ordering.
- *
- * Pre-conditions:
- *
- *    1. Input graph is a DAG
- *    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
- *
- * Post-conditions:
- *
- *    1. Output graph has all nodes in the movable rank with preserved
- *       hierarchy.
- *    2. Root nodes in the movable layer are made children of the node
- *       indicated by the root attribute of the graph.
- *    3. Non-movable nodes incident on movable nodes, selected by the
- *       relationship parameter, are included in the graph (without hierarchy).
- *    4. Edges incident on movable nodes, selected by the relationship
- *       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.
- */
-export default 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);
-
-      // 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 (node.hasOwnProperty("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;
-}

package/mjs-lib/order/cross-count.js

@@ -1,64 +0,0 @@
-"use strict";
-
-import { zipObject as zipObject } from "../util.js";
-
-/*
- * 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.
- *
- * Pre-conditions:
- *
- *    1. Input graph must be simple (not a multigraph), directed, and include
- *       only simple edges.
- *    2. Edges in the input graph must have assigned weights.
- *
- * Post-conditions:
- *
- *    1. The graph and layering matrix are left unchanged.
- *
- * This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
- */
-export default function crossCount(g, layering) {
-  let cc = 0;
-  for (let i = 1; i < layering.length; ++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 = 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 };
-    }).sort((a, b) => a.pos - b.pos);
-  });
-
-  // Build the accumulator tree
-  let firstIndex = 1;
-  while (firstIndex < southLayer.length) firstIndex <<= 1;
-  let treeSize = 2 * firstIndex - 1;
-  firstIndex -= 1;
-  let tree = new Array(treeSize).fill(0);
-
-  // Calculate the weighted crossings
-  let cc = 0;
-  southEntries.forEach(entry => {
-    let index = entry.pos + firstIndex;
-    tree[index] += entry.weight;
-    let weightSum = 0;
-    while (index > 0) {
-      if (index % 2) {
-        weightSum += tree[index + 1];
-      }
-      index = (index - 1) >> 1;
-      tree[index] += entry.weight;
-    }
-    cc += entry.weight * weightSum;
-  });
-
-  return cc;
-}

package/mjs-lib/order/index.js

@@ -1,70 +0,0 @@
-"use strict";
-
-import { default as initOrder } from "./init-order.js";
-import { default as crossCount } from "./cross-count.js";
-import { default as sortSubgraph } from "./sort-subgraph.js";
-import { default as buildLayerGraph } from "./build-layer-graph.js";
-import { default as addSubgraphConstraints } from "./add-subgraph-constraints.js";
-import { Graph as Graph } from "@dagrejs/graphlib";
-import  * as util from "../util.js";
-
-/*
- * Applies heuristics to minimize edge crossings in the graph and sets the best
- * order solution as an order attribute on each node.
- *
- * Pre-conditions:
- *
- *    1. Graph must be DAG
- *    2. Graph nodes must be objects with a "rank" attribute
- *    3. Graph edges must have the "weight" attribute
- *
- * Post-conditions:
- *
- *    1. Graph nodes will have an "order" attribute based on the results of the
- *       algorithm.
- */
-export default function order(g) {
-  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);
-
-  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));
-}

package/mjs-lib/order/init-order.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import  * as util from "../util.js";
-
-/*
- * 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
- * rank as they are first visited.
- *
- * This approach comes from Gansner, et al., "A Technique for Drawing Directed
- * Graphs."
- *
- * Returns a layering matrix with an array per layer and each layer sorted by
- * the order of its nodes.
- */
-export default function initOrder(g) {
-  let visited = {};
-  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;
-    let node = g.node(v);
-    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;
-}

package/mjs-lib/order/resolve-conflicts.js

@@ -1,116 +0,0 @@
-"use strict";
-
-import  * as util from "../util.js";
-
-/*
- * Given a list of entries of the form {v, barycenter, weight} and a
- * constraint graph this function will resolve any conflicts between the
- * constraint graph and the barycenters for the entries. If the barycenters for
- * an entry would violate a constraint in the constraint graph then we coalesce
- * the nodes in the conflict into a new node that respects the contraint and
- * aggregates barycenter and weight information.
- *
- * This implementation is based on the description in Forster, "A Fast and
- * Simple Hueristic for Constrained Two-Level Crossing Reduction," thought it
- * differs in some specific details.
- *
- * Pre-conditions:
- *
- *    1. Each entry has the form {v, barycenter, weight}, or if the node has
- *       no barycenter, then {v}.
- *
- * Returns:
- *
- *    A new list of entries of the form {vs, i, barycenter, weight}. The list
- *    `vs` may either be a singleton or it may be an aggregation of nodes
- *    ordered such that they do not violate constraints from the constraint
- *    graph. The property `i` is the lowest original index of any of the
- *    elements in `vs`.
- */
-export default function resolveConflicts(entries, cg) {
-  let mappedEntries = {};
-  entries.forEach((entry, i) => {
-    let tmp = mappedEntries[entry.v] = {
-      indegree: 0,
-      "in": [],
-      out: [],
-      vs: [entry.v],
-      i: i
-    };
-    if (entry.barycenter !== undefined) {
-      tmp.barycenter = entry.barycenter;
-      tmp.weight = entry.weight;
-    }
-  });
-
-  cg.edges().forEach(e => {
-    let entryV = mappedEntries[e.v];
-    let entryW = mappedEntries[e.w];
-    if (entryV !== undefined && entryW !== undefined) {
-      entryW.indegree++;
-      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) {
-        mergeEntries(vEntry, uEntry);
-      }
-    };
-  }
-
-  function handleOut(vEntry) {
-    return wEntry => {
-      wEntry["in"].push(vEntry);
-      if (--wEntry.indegree === 0) {
-        sourceSet.push(wEntry);
-      }
-    };
-  }
-
-  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;
-}