@dagrejs/dagre 1.1.0 → 1.1.2

package/mjs-lib/order/sort-subgraph.js

@@ -1,71 +0,0 @@
-import { default as barycenter } from "./barycenter.js";
-import { default as resolveConflicts } from "./resolve-conflicts.js";
-import { default as sort } from "./sort.js";
-
-export default 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 subgraphs = {};
-
-  if (bl) {
-    movable = movable.filter(w => w !== bl && w !== br);
-  }
-
-  let barycenters = barycenter(g, movable);
-  barycenters.forEach(entry => {
-    if (g.children(entry.v).length) {
-      let subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
-      subgraphs[entry.v] = subgraphResult;
-      if (subgraphResult.hasOwnProperty("barycenter")) {
-        mergeBarycenters(entry, subgraphResult);
-      }
-    }
-  });
-
-  let entries = resolveConflicts(barycenters, cg);
-  expandSubgraphs(entries, subgraphs);
-
-  let result = sort(entries, biasRight);
-
-  if (bl) {
-    result.vs = [bl, result.vs, br].flat(true);
-    if (g.predecessors(bl).length) {
-      let blPred = g.node(g.predecessors(bl)[0]),
-        brPred = g.node(g.predecessors(br)[0]);
-      if (!result.hasOwnProperty("barycenter")) {
-        result.barycenter = 0;
-        result.weight = 0;
-      }
-      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 => {
-      if (subgraphs[v]) {
-        return subgraphs[v].vs;
-      }
-      return v;
-    });
-  });
-}
-
-function mergeBarycenters(target, other) {
-  if (target.barycenter !== undefined) {
-    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;
-  }
-}

package/mjs-lib/order/sort.js

@@ -1,54 +0,0 @@
-import  * as util from "../util.js";
-
-export default function sort(entries, biasRight) {
-  let parts = util.partition(entries, entry => {
-    return entry.hasOwnProperty("barycenter");
-  });
-  let sortable = parts.lhs,
-    unsortable = parts.rhs.sort((a, b) => b.i - a.i),
-    vs = [],
-    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);
-    sum += entry.barycenter * entry.weight;
-    weight += entry.weight;
-    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
-  });
-
-  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) {
-    unsortable.pop();
-    vs.push(last.vs);
-    index++;
-  }
-  return index;
-}
-
-function compareWithBias(bias) {
-  return (entryV, entryW) => {
-    if (entryV.barycenter < entryW.barycenter) {
-      return -1;
-    } else if (entryV.barycenter > entryW.barycenter) {
-      return 1;
-    }
-
-    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
-  };
-}

package/mjs-lib/parent-dummy-chains.js

@@ -1,82 +0,0 @@
-export default function parentDummyChains(g) {
-  let postorderNums = postorder(g);
-
-  g.graph().dummyChains.forEach(v => {
-    let node = g.node(v);
-    let edgeObj = node.edgeObj;
-    let pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
-    let path = pathData.path;
-    let lca = pathData.lca;
-    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) {
-          pathIdx++;
-        }
-
-        if (pathV === lca) {
-          ascending = false;
-        }
-      }
-
-      if (!ascending) {
-        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];
-    }
-  });
-}
-
-// Find a path from v to w through the lowest common ancestor (LCA). Return the
-// full path and the LCA.
-function findPath(g, postorderNums, v, w) {
-  let vPath = [];
-  let wPath = [];
-  let low = Math.min(postorderNums[v].low, postorderNums[w].low);
-  let lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
-  let parent;
-  let lca;
-
-  // Traverse up from v to find the LCA
-  parent = v;
-  do {
-    parent = g.parent(parent);
-    vPath.push(parent);
-  } while (parent &&
-           (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
-  lca = parent;
-
-  // Traverse from w to LCA
-  parent = w;
-  while ((parent = g.parent(parent)) !== lca) {
-    wPath.push(parent);
-  }
-
-  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++ };
-  }
-  g.children().forEach(dfs);
-
-  return result;
-}

package/mjs-lib/position/bk.js

@@ -1,409 +0,0 @@
-"use strict";
-
-import { Graph as Graph } from "@dagrejs/graphlib";
-import  * as util from "../util.js";
-
-/*
- * This module provides coordinate assignment based on Brandes and Köpf, "Fast
- * and Simple Horizontal Coordinate Assignment."
- */
-
-/*
- * Marks all edges in the graph with a type-1 conflict with the "type1Conflict"
- * property. A type-1 conflict is one where a non-inner segment crosses an
- * inner segment. An inner segment is an edge with both incident nodes marked
- * with the "dummy" property.
- *
- * This algorithm scans layer by layer, starting with the second, for type-1
- * conflicts between the current layer and the previous layer. For each layer
- * it scans the nodes from left to right until it reaches one that is incident
- * on an inner segment. It then scans predecessors to determine if they have
- * edges that cross that inner segment. At the end a final scan is done for all
- * nodes on the current rank to see if they cross the last visited inner
- * segment.
- *
- * This algorithm (safely) assumes that a dummy node will only be incident on a
- * single node in the layers being scanned.
- */
-export function findType1Conflicts(g, layering) {
-  let conflicts = {};
-
-  function visitLayer(prevLayer, layer) {
-    let
-      // last visited node in the previous layer that is incident on an inner
-      // segment.
-      k0 = 0,
-      // Tracks the last node in this layer scanned for crossings with a type-1
-      // segment.
-      scanPos = 0,
-      prevLayerLength = prevLayer.length,
-      lastNode = layer[layer.length - 1];
-
-    layer.forEach((v, i) => {
-      let w = findOtherInnerSegmentNode(g, v),
-        k1 = w ? g.node(w).order : prevLayerLength;
-
-      if (w || v === lastNode) {
-        layer.slice(scanPos, i+1).forEach(scanNode => {
-          g.predecessors(scanNode).forEach(u => {
-            let uLabel = g.node(u),
-              uPos = uLabel.order;
-            if ((uPos < k0 || k1 < uPos) &&
-                !(uLabel.dummy && g.node(scanNode).dummy)) {
-              addConflict(conflicts, u, scanNode);
-            }
-          });
-        });
-        scanPos = i + 1;
-        k0 = k1;
-      }
-    });
-
-    return layer;
-  }
-
-  layering.reduce(visitLayer);
-  return conflicts;
-}
-
-export function findType2Conflicts(g, layering) {
-  let conflicts = {};
-
-  function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
-    let v;
-    util.range(southPos, southEnd).forEach(i => {
-      v = south[i];
-      if (g.node(v).dummy) {
-        g.predecessors(v).forEach(u => {
-          let uNode = g.node(u);
-          if (uNode.dummy &&
-              (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
-            addConflict(conflicts, u, v);
-          }
-        });
-      }
-    });
-  }
-
-
-  function visitLayer(north, south) {
-    let prevNorthPos = -1,
-      nextNorthPos,
-      southPos = 0;
-
-    south.forEach((v, southLookahead) => {
-      if (g.node(v).dummy === "border") {
-        let predecessors = g.predecessors(v);
-        if (predecessors.length) {
-          nextNorthPos = g.node(predecessors[0]).order;
-          scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
-          southPos = southLookahead;
-          prevNorthPos = nextNorthPos;
-        }
-      }
-      scan(south, southPos, south.length, nextNorthPos, north.length);
-    });
-
-    return south;
-  }
-
-  layering.reduce(visitLayer);
-  return conflicts;
-}
-
-function findOtherInnerSegmentNode(g, v) {
-  if (g.node(v).dummy) {
-    return g.predecessors(v).find(u => g.node(u).dummy);
-  }
-}
-
-export function addConflict(conflicts, v, w) {
-  if (v > w) {
-    let tmp = v;
-    v = w;
-    w = tmp;
-  }
-
-  let conflictsV = conflicts[v];
-  if (!conflictsV) {
-    conflicts[v] = conflictsV = {};
-  }
-  conflictsV[w] = true;
-}
-
-export function hasConflict(conflicts, v, w) {
-  if (v > w) {
-    let tmp = v;
-    v = w;
-    w = tmp;
-  }
-  return !!conflicts[v] && conflicts[v].hasOwnProperty(w);
-}
-
-/*
- * Try to align nodes into vertical "blocks" where possible. This algorithm
- * attempts to align a node with one of its median neighbors. If the edge
- * connecting a neighbor is a type-1 conflict then we ignore that possibility.
- * If a previous node has already formed a block with a node after the node
- * we're trying to form a block with, we also ignore that possibility - our
- * blocks would be split in that scenario.
- */
-export function verticalAlignment(g, layering, conflicts, neighborFn) {
-  let root = {},
-    align = {},
-    pos = {};
-
-  // We cache the position here based on the layering because the graph and
-  // layering may be out of sync. The layering matrix is manipulated to
-  // generate different extreme alignments.
-  layering.forEach(layer => {
-    layer.forEach((v, order) => {
-      root[v] = v;
-      align[v] = v;
-      pos[v] = order;
-    });
-  });
-
-  layering.forEach(layer => {
-    let prevIdx = -1;
-    layer.forEach(v => {
-      let ws = neighborFn(v);
-      if (ws.length) {
-        ws = ws.sort((a, b) => pos[a] - pos[b]);
-        let mp = (ws.length - 1) / 2;
-        for (let i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
-          let w = ws[i];
-          if (align[v] === v &&
-              prevIdx < pos[w] &&
-              !hasConflict(conflicts, v, w)) {
-            align[w] = v;
-            align[v] = root[v] = root[w];
-            prevIdx = pos[w];
-          }
-        }
-      }
-    });
-  });
-
-  return { root: root, align: align };
-}
-
-export function horizontalCompaction(g, layering, root, align, reverseSep) {
-  // This portion of the algorithm differs from BK due to a number of problems.
-  // Instead of their algorithm we construct a new block graph and do two
-  // sweeps. The first sweep places blocks with the smallest possible
-  // coordinates. The second sweep removes unused space by moving blocks to the
-  // greatest coordinates without violating separation.
-  let xs = {},
-    blockG = buildBlockGraph(g, layering, root, reverseSep),
-    borderType = reverseSep ? "borderLeft" : "borderRight";
-
-  function iterate(setXsFunc, nextNodesFunc) {
-    let stack = blockG.nodes();
-    let elem = stack.pop();
-    let visited = {};
-    while (elem) {
-      if (visited[elem]) {
-        setXsFunc(elem);
-      } else {
-        visited[elem] = true;
-        stack.push(elem);
-        stack = stack.concat(nextNodesFunc(elem));
-      }
-
-      elem = stack.pop();
-    }
-  }
-
-  // First pass, assign smallest coordinates
-  function pass1(elem) {
-    xs[elem] = blockG.inEdges(elem).reduce((acc, e) => {
-      return Math.max(acc, xs[e.v] + blockG.edge(e));
-    }, 0);
-  }
-
-  // Second pass, assign greatest coordinates
-  function pass2(elem) {
-    let min = blockG.outEdges(elem).reduce((acc, e) => {
-      return Math.min(acc, xs[e.w] - blockG.edge(e));
-    }, Number.POSITIVE_INFINITY);
-
-    let node = g.node(elem);
-    if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
-      xs[elem] = Math.max(xs[elem], min);
-    }
-  }
-
-  iterate(pass1, blockG.predecessors.bind(blockG));
-  iterate(pass2, blockG.successors.bind(blockG));
-
-  // Assign x coordinates to all nodes
-  Object.keys(align).forEach(v => xs[v] = xs[root[v]]);
-
-  return xs;
-}
-
-
-function buildBlockGraph(g, layering, root, reverseSep) {
-  let blockGraph = new Graph(),
-    graphLabel = g.graph(),
-    sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
-
-  layering.forEach(layer => {
-    let u;
-    layer.forEach(v => {
-      let vRoot = root[v];
-      blockGraph.setNode(vRoot);
-      if (u) {
-        var uRoot = root[u],
-          prevMax = blockGraph.edge(uRoot, vRoot);
-        blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
-      }
-      u = v;
-    });
-  });
-
-  return blockGraph;
-}
-
-/*
- * Returns the alignment that has the smallest width of the given alignments.
- */
-export function findSmallestWidthAlignment(g, xss) {
-  return Object.values(xss).reduce((currentMinAndXs, xs) => {
-    let max = Number.NEGATIVE_INFINITY;
-    let min = Number.POSITIVE_INFINITY;
-
-    Object.entries(xs).forEach(([v, x]) => {
-      let halfWidth = width(g, v) / 2;
-
-      max = Math.max(x + halfWidth, max);
-      min = Math.min(x - halfWidth, min);
-    });
-
-    const newMin = max - min;
-    if (newMin < currentMinAndXs[0]) {
-      currentMinAndXs = [newMin, xs];
-    }
-    return currentMinAndXs;
-  }, [Number.POSITIVE_INFINITY, null])[1];
-}
-
-/*
- * Align the coordinates of each of the layout alignments such that
- * left-biased alignments have their minimum coordinate at the same point as
- * the minimum coordinate of the smallest width alignment and right-biased
- * alignments have their maximum coordinate at the same point as the maximum
- * coordinate of the smallest width alignment.
- */
-export function alignCoordinates(xss, alignTo) {
-  let alignToVals = Object.values(alignTo),
-    alignToMin = Math.min(...alignToVals),
-    alignToMax = Math.max(...alignToVals);
-
-  ["u", "d"].forEach(vert => {
-    ["l", "r"].forEach(horiz => {
-      let alignment = vert + horiz,
-        xs = xss[alignment];
-
-      if (xs === alignTo) return;
-
-      let xsVals = Object.values(xs);
-      let delta = alignToMin - Math.min(...xsVals);
-      if (horiz !== "l") {
-        delta = alignToMax - Math.max(...xsVals);
-      }
-
-      if (delta) {
-        xss[alignment] = util.mapValues(xs, x => x + delta);
-      }
-    });
-  });
-}
-
-export function balance(xss, align) {
-  return util.mapValues(xss.ul, (num, v) => {
-    if (align) {
-      return xss[align.toLowerCase()][v];
-    } else {
-      let xs = Object.values(xss).map(xs => xs[v]).sort((a, b) => a - b);
-      return (xs[1] + xs[2]) / 2;
-    }
-  });
-}
-
-export function positionX(g) {
-  let layering = util.buildLayerMatrix(g);
-  let conflicts = Object.assign(
-    findType1Conflicts(g, layering),
-    findType2Conflicts(g, layering));
-
-  let xss = {};
-  let adjustedLayering;
-  ["u", "d"].forEach(vert => {
-    adjustedLayering = vert === "u" ? layering : Object.values(layering).reverse();
-    ["l", "r"].forEach(horiz => {
-      if (horiz === "r") {
-        adjustedLayering = adjustedLayering.map(inner => {
-          return Object.values(inner).reverse();
-        });
-      }
-
-      let neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
-      let align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
-      let xs = horizontalCompaction(g, adjustedLayering,
-        align.root, align.align, horiz === "r");
-      if (horiz === "r") {
-        xs = util.mapValues(xs, x => -x);
-      }
-      xss[vert + horiz] = xs;
-    });
-  });
-
-
-  let smallestWidth = findSmallestWidthAlignment(g, xss);
-  alignCoordinates(xss, smallestWidth);
-  return balance(xss, g.graph().align);
-}
-
-function sep(nodeSep, edgeSep, reverseSep) {
-  return (g, v, w) => {
-    let vLabel = g.node(v);
-    let wLabel = g.node(w);
-    let sum = 0;
-    let delta;
-
-    sum += vLabel.width / 2;
-    if (vLabel.hasOwnProperty("labelpos")) {
-      switch (vLabel.labelpos.toLowerCase()) {
-      case "l": delta = -vLabel.width / 2; break;
-      case "r": delta = vLabel.width / 2; break;
-      }
-    }
-    if (delta) {
-      sum += reverseSep ? delta : -delta;
-    }
-    delta = 0;
-
-    sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
-    sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
-
-    sum += wLabel.width / 2;
-    if (wLabel.hasOwnProperty("labelpos")) {
-      switch (wLabel.labelpos.toLowerCase()) {
-      case "l": delta = wLabel.width / 2; break;
-      case "r": delta = -wLabel.width / 2; break;
-      }
-    }
-    if (delta) {
-      sum += reverseSep ? delta : -delta;
-    }
-    delta = 0;
-
-    return sum;
-  };
-}
-
-function width(g, v) {
-  return g.node(v).width;
-}

package/mjs-lib/position/index.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import  * as util from "../util.js";
-import { positionX as positionX } from "./bk.js";
-
-export default function position(g) {
-  g = util.asNonCompoundGraph(g);
-
-  positionY(g);
-  Object.entries(positionX(g)).forEach(([v, x]) => g.node(v).x = x);
-}
-
-function positionY(g) {
-  let layering = util.buildLayerMatrix(g);
-  let rankSep = g.graph().ranksep;
-  let prevY = 0;
-  layering.forEach(layer => {
-    const maxHeight = layer.reduce((acc, v) => {
-      const height = g.node(v).height;
-      if (acc > height) {
-        return acc;
-      } else {
-        return height;
-      }
-    }, 0);
-    layer.forEach(v => g.node(v).y = prevY + maxHeight / 2);
-    prevY += maxHeight + rankSep;
-  });
-}
-