@dagrejs/dagre 1.0.1 → 1.0.4

package/index.d.ts

@@ -0,0 +1,139 @@
+// Type definitions for dagre 1.0.1
+// Project: https://github.com/dagrejs/dagre
+// Definitions by: Qinfeng Chen <https://github.com/qinfchen>
+//                 Pete Vilter <https://github.com/vilterp>
+//                 David Newell <https://github.com/rustedgrail>
+//                 Graham Lea <https://github.com/GrahamLea>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module '@dagrejs/dagre' {
+  export namespace graphlib {
+    class Graph<T = {}> {
+      constructor(opt?: { directed?: boolean | undefined; multigraph?: boolean | undefined; compound?: boolean | undefined });
+
+      graph(): GraphLabel;
+      isDirected(): boolean;
+      isMultigraph(): boolean;
+      setGraph(label: GraphLabel): Graph<T>;
+
+      edge(edgeObj: Edge): GraphEdge;
+      edge(outNodeName: string, inNodeName: string, name?: string): GraphEdge;
+      edgeCount(): number;
+      edges(): Edge[];
+      hasEdge(edgeObj: Edge): boolean;
+      hasEdge(outNodeName: string, inNodeName: string, name?: string): boolean;
+      inEdges(inNodeName: string, outNodeName?: string): Edge[] | undefined;
+      outEdges(outNodeName: string, inNodeName?: string): Edge[] | undefined;
+      removeEdge(outNodeName: string, inNodeName: string, name?: string): Graph<T>;
+      setDefaultEdgeLabel(callback: string | ((v: string, w: string, name?: string) => string | Label)): Graph<T>;
+      setEdge(params: Edge, value?: string | { [key: string]: any }): Graph<T>;
+      setEdge(sourceId: string, targetId: string, value?: string | Label, name?: string): Graph<T>;
+
+      children(parentName: string): string | undefined;
+      hasNode(name: string): boolean;
+      neighbors(name: string): Array<Node<T>> | undefined;
+      node(id: string | Label): Node<T>;
+      nodeCount(): number;
+      nodes(): string[];
+      parent(childName: string): string | undefined;
+      predecessors(name: string): Array<Node<T>> | undefined;
+      removeNode(name: string): Graph<T>;
+      filterNodes(callback: (nodeId: string) => boolean): Graph<T>;
+      setDefaultNodeLabel(callback: string | ((nodeId: string) => string | Label)): Graph<T>;
+      setNode(name: string, label: string | Label): Graph<T>;
+      setParent(childName: string, parentName: string): void;
+      sinks(): Array<Node<T>>;
+      sources(): Array<Node<T>>;
+      successors(name: string): Array<Node<T>> | undefined;
+    }
+
+    namespace json {
+      function read(graph: any): Graph;
+      function write(graph: Graph): any;
+    }
+
+    namespace alg {
+      function components(graph: Graph): string[][];
+      function dijkstra(graph: Graph, source: string, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
+      function dijkstraAll(graph: Graph, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
+      function findCycles(graph: Graph): string[][];
+      function floydWarchall(graph: Graph, weightFn?: WeightFn, edgeFn?: EdgeFn): any;
+      function isAcyclic(graph: Graph): boolean;
+      function postorder(graph: Graph, nodeNames: string | string[]): string[];
+      function preorder(graph: Graph, nodeNames: string | string[]): string[];
+      function prim<T>(graph: Graph<T>, weightFn?: WeightFn): Graph<T>;
+      function tarjam(graph: Graph): string[][];
+      function topsort(graph: Graph): string[];
+    }
+  }
+
+  export interface Label {
+    label?: string;
+    width?: number;
+    height?: number;
+    minRank?: number;
+    maxRank?: number;
+    borderLeft?: string[];
+    borderRight?: string[];
+    [key: string]: any;
+  }
+  export type WeightFn = (edge: Edge) => number;
+  export type EdgeFn = (outNodeName: string) => GraphEdge[];
+
+  export interface GraphLabel {
+    width?: number | undefined;
+    height?: number | undefined;
+    compound?: boolean | undefined;
+    rankdir?: string | undefined;
+    align?: string | undefined;
+    nodesep?: number | undefined;
+    edgesep?: number | undefined;
+    ranksep?: number | undefined;
+    marginx?: number | undefined;
+    marginy?: number | undefined;
+    acyclicer?: string | undefined;
+    ranker?: string | undefined;
+  }
+
+  export interface NodeConfig {
+    width?: number | undefined;
+    height?: number | undefined;
+  }
+
+  export interface EdgeConfig {
+    minlen?: number | undefined;
+    weight?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    lablepos?: 'l' | 'c' | 'r' | undefined;
+    labeloffest?: number | undefined;
+  }
+
+  export function layout(graph: graphlib.Graph, layout?: GraphLabel & NodeConfig & EdgeConfig): void;
+
+  export interface Edge {
+    v: string;
+    w: string;
+    name?: string | undefined;
+  }
+
+  export interface GraphEdge {
+    points: Array<{ x: number; y: number }>;
+    [key: string]: any;
+  }
+
+  export type Node<T = {}> = T & {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    class?: string | undefined;
+    label?: string | undefined;
+    padding?: number | undefined;
+    paddingX?: number | undefined;
+    paddingY?: number | undefined;
+    rx?: number | undefined;
+    ry?: number | undefined;
+    shape?: string | undefined;
+  };
+}

package/lib/acyclic.js

@@ -1,7 +1,7 @@
 "use strict";
 
-var greedyFAS = require("./greedy-fas");
-var uniqueId = require("./util").uniqueId;
+let greedyFAS = require("./greedy-fas");
+let uniqueId = require("./util").uniqueId;
 
 module.exports = {
   run: run,
@@ -9,11 +9,11 @@ module.exports = {
 };
 
 function run(g) {
-  var fas = (g.graph().acyclicer === "greedy"
+  let fas = (g.graph().acyclicer === "greedy"
     ? greedyFAS(g, weightFn(g))
     : dfsFAS(g));
-  fas.forEach(function(e) {
-    var label = g.edge(e);
+  fas.forEach(e => {
+    let label = g.edge(e);
     g.removeEdge(e);
     label.forwardName = e.name;
     label.reversed = true;
@@ -21,16 +21,16 @@ function run(g) {
   });
 
   function weightFn(g) {
-    return function(e) {
+    return e => {
       return g.edge(e).weight;
     };
   }
 }
 
 function dfsFAS(g) {
-  var fas = [];
-  var stack = {};
-  var visited = {};
+  let fas = [];
+  let stack = {};
+  let visited = {};
 
   function dfs(v) {
     if (visited.hasOwnProperty(v)) {
@@ -38,7 +38,7 @@ function dfsFAS(g) {
     }
     visited[v] = true;
     stack[v] = true;
-    g.outEdges(v).forEach(function(e) {
+    g.outEdges(v).forEach(e => {
       if (stack.hasOwnProperty(e.w)) {
         fas.push(e);
       } else {
@@ -53,12 +53,12 @@ function dfsFAS(g) {
 }
 
 function undo(g) {
-  g.edges().forEach(function(e) {
-    var label = g.edge(e);
+  g.edges().forEach(e => {
+    let label = g.edge(e);
     if (label.reversed) {
       g.removeEdge(e);
 
-      var forwardName = label.forwardName;
+      let forwardName = label.forwardName;
       delete label.reversed;
       delete label.forwardName;
       g.setEdge(e.w, e.v, label, forwardName);

package/lib/add-border-segments.js

@@ -1,11 +1,11 @@
-var util = require("./util");
+let util = require("./util");
 
 module.exports = addBorderSegments;
 
 function addBorderSegments(g) {
   function dfs(v) {
-    var children = g.children(v);
-    var node = g.node(v);
+    let children = g.children(v);
+    let node = g.node(v);
     if (children.length) {
       children.forEach(dfs);
     }
@@ -13,7 +13,7 @@ function addBorderSegments(g) {
     if (node.hasOwnProperty("minRank")) {
       node.borderLeft = [];
       node.borderRight = [];
-      for (var rank = node.minRank, maxRank = node.maxRank + 1;
+      for (let rank = node.minRank, maxRank = node.maxRank + 1;
         rank < maxRank;
         ++rank) {
         addBorderNode(g, "borderLeft", "_bl", v, node, rank);
@@ -26,9 +26,9 @@ function addBorderSegments(g) {
 }
 
 function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
-  var label = { width: 0, height: 0, rank: rank, borderType: prop };
-  var prev = sgNode[prop][rank - 1];
-  var curr = util.addDummyNode(g, "border", label, prefix);
+  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) {

package/lib/coordinate-system.js

@@ -6,14 +6,14 @@ module.exports = {
 };
 
 function adjust(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
+  let rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "lr" || rankDir === "rl") {
     swapWidthHeight(g);
   }
 }
 
 function undo(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
+  let rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "bt" || rankDir === "rl") {
     reverseY(g);
   }
@@ -30,7 +30,7 @@ function swapWidthHeight(g) {
 }
 
 function swapWidthHeightOne(attrs) {
-  var w = attrs.width;
+  let w = attrs.width;
   attrs.width = attrs.height;
   attrs.height = w;
 }
@@ -38,8 +38,8 @@ function swapWidthHeightOne(attrs) {
 function reverseY(g) {
   g.nodes().forEach(v => reverseYOne(g.node(v)));
 
-  g.edges().forEach(function(e) {
-    var edge = g.edge(e);
+  g.edges().forEach(e => {
+    let edge = g.edge(e);
     edge.points.forEach(reverseYOne);
     if (edge.hasOwnProperty("y")) {
       reverseYOne(edge);
@@ -54,8 +54,8 @@ function reverseYOne(attrs) {
 function swapXY(g) {
   g.nodes().forEach(v => swapXYOne(g.node(v)));
 
-  g.edges().forEach(function(e) {
-    var edge = g.edge(e);
+  g.edges().forEach(e => {
+    let edge = g.edge(e);
     edge.points.forEach(swapXYOne);
     if (edge.hasOwnProperty("x")) {
       swapXYOne(edge);
@@ -64,7 +64,7 @@ function swapXY(g) {
 }
 
 function swapXYOne(attrs) {
-  var x = attrs.x;
+  let x = attrs.x;
   attrs.x = attrs.y;
   attrs.y = x;
 }

package/lib/data/list.js

@@ -3,44 +3,44 @@
  * "Introduction to Algorithms".
  */
 
-module.exports = List;
-
-function List() {
-  var sentinel = {};
-  sentinel._next = sentinel._prev = sentinel;
-  this._sentinel = sentinel;
-}
+class List {
+  constructor() {
+    let sentinel = {};
+    sentinel._next = sentinel._prev = sentinel;
+    this._sentinel = sentinel;
+  }
 
-List.prototype.dequeue = function() {
-  var sentinel = this._sentinel;
-  var entry = sentinel._prev;
-  if (entry !== sentinel) {
-    unlink(entry);
-    return entry;
+  dequeue() {
+    let sentinel = this._sentinel;
+    let entry = sentinel._prev;
+    if (entry !== sentinel) {
+      unlink(entry);
+      return entry;
+    }
   }
-};
 
-List.prototype.enqueue = function(entry) {
-  var sentinel = this._sentinel;
-  if (entry._prev && entry._next) {
-    unlink(entry);
+  enqueue(entry) {
+    let sentinel = this._sentinel;
+    if (entry._prev && entry._next) {
+      unlink(entry);
+    }
+    entry._next = sentinel._next;
+    sentinel._next._prev = entry;
+    sentinel._next = entry;
+    entry._prev = sentinel;
   }
-  entry._next = sentinel._next;
-  sentinel._next._prev = entry;
-  sentinel._next = entry;
-  entry._prev = sentinel;
-};
 
-List.prototype.toString = function() {
-  var strs = [];
-  var sentinel = this._sentinel;
-  var curr = sentinel._prev;
-  while (curr !== sentinel) {
-    strs.push(JSON.stringify(curr, filterOutLinks));
-    curr = curr._prev;
+  toString() {
+    let strs = [];
+    let sentinel = this._sentinel;
+    let curr = sentinel._prev;
+    while (curr !== sentinel) {
+      strs.push(JSON.stringify(curr, filterOutLinks));
+      curr = curr._prev;
+    }
+    return "[" + strs.join(", ") + "]";
   }
-  return "[" + strs.join(", ") + "]";
-};
+}
 
 function unlink(entry) {
   entry._prev._next = entry._next;
@@ -54,3 +54,5 @@ function filterOutLinks(k, v) {
     return v;
   }
 }
+
+module.exports = List;

package/lib/debug.js

@@ -1,5 +1,5 @@
-var util = require("./util");
-var Graph = require("@dagrejs/graphlib").Graph;
+let util = require("./util");
+let Graph = require("@dagrejs/graphlib").Graph;
 
 module.exports = {
   debugOrdering: debugOrdering
@@ -7,23 +7,21 @@ module.exports = {
 
 /* istanbul ignore next */
 function debugOrdering(g) {
-  var layerMatrix = util.buildLayerMatrix(g);
+  let layerMatrix = util.buildLayerMatrix(g);
 
-  var h = new Graph({ compound: true, multigraph: true }).setGraph({});
+  let h = new Graph({ compound: true, multigraph: true }).setGraph({});
 
-  g.nodes().forEach(function(v) {
+  g.nodes().forEach(v => {
     h.setNode(v, { label: v });
     h.setParent(v, "layer" + g.node(v).rank);
   });
 
-  g.edges().forEach(function(e) {
-    h.setEdge(e.v, e.w, {}, e.name);
-  });
+  g.edges().forEach(e => h.setEdge(e.v, e.w, {}, e.name));
 
-  layerMatrix.forEach(function(layer, i) {
-    var layerV = "layer" + i;
+  layerMatrix.forEach((layer, i) => {
+    let layerV = "layer" + i;
     h.setNode(layerV, { rank: "same" });
-    layer.reduce(function(u, v) {
+    layer.reduce((u, v) => {
       h.setEdge(u, v, { style: "invis" });
       return v;
     });

package/lib/greedy-fas.js

@@ -1,5 +1,5 @@
-var Graph = require("@dagrejs/graphlib").Graph;
-var List = require("./data/list");
+let Graph = require("@dagrejs/graphlib").Graph;
+let List = require("./data/list");
 
 /*
  * A greedy heuristic for finding a feedback arc set for a graph. A feedback
@@ -10,30 +10,30 @@ var List = require("./data/list");
  */
 module.exports = greedyFAS;
 
-var DEFAULT_WEIGHT_FN = () => 1;
+let DEFAULT_WEIGHT_FN = () => 1;
 
 function greedyFAS(g, weightFn) {
   if (g.nodeCount() <= 1) {
     return [];
   }
-  var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
-  var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+  let state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+  let results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
 
   // Expand multi-edges
   return results.flatMap(e => g.outEdges(e.v, e.w));
 }
 
 function doGreedyFAS(g, buckets, zeroIdx) {
-  var results = [];
-  var sources = buckets[buckets.length - 1];
-  var sinks = buckets[0];
+  let results = [];
+  let sources = buckets[buckets.length - 1];
+  let sinks = buckets[0];
 
-  var entry;
+  let entry;
   while (g.nodeCount()) {
     while ((entry = sinks.dequeue()))   { removeNode(g, buckets, zeroIdx, entry); }
     while ((entry = sources.dequeue())) { removeNode(g, buckets, zeroIdx, entry); }
     if (g.nodeCount()) {
-      for (var i = buckets.length - 2; i > 0; --i) {
+      for (let i = buckets.length - 2; i > 0; --i) {
         entry = buckets[i].dequeue();
         if (entry) {
           results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
@@ -47,11 +47,11 @@ function doGreedyFAS(g, buckets, zeroIdx) {
 }
 
 function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  var results = collectPredecessors ? [] : undefined;
+  let results = collectPredecessors ? [] : undefined;
 
-  g.inEdges(entry.v).forEach(function(edge) {
-    var weight = g.edge(edge);
-    var uEntry = g.node(edge.v);
+  g.inEdges(entry.v).forEach(edge => {
+    let weight = g.edge(edge);
+    let uEntry = g.node(edge.v);
 
     if (collectPredecessors) {
       results.push({ v: edge.v, w: edge.w });
@@ -61,10 +61,10 @@ function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
     assignBucket(buckets, zeroIdx, uEntry);
   });
 
-  g.outEdges(entry.v).forEach(function(edge) {
-    var weight = g.edge(edge);
-    var w = edge.w;
-    var wEntry = g.node(w);
+  g.outEdges(entry.v).forEach(edge => {
+    let weight = g.edge(edge);
+    let w = edge.w;
+    let wEntry = g.node(w);
     wEntry["in"] -= weight;
     assignBucket(buckets, zeroIdx, wEntry);
   });
@@ -75,29 +75,29 @@ function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
 }
 
 function buildState(g, weightFn) {
-  var fasGraph = new Graph();
-  var maxIn = 0;
-  var maxOut = 0;
+  let fasGraph = new Graph();
+  let maxIn = 0;
+  let maxOut = 0;
 
-  g.nodes().forEach(function(v) {
+  g.nodes().forEach(v => {
     fasGraph.setNode(v, { v: v, "in": 0, out: 0 });
   });
 
   // Aggregate weights on nodes, but also sum the weights across multi-edges
   // into a single edge for the fasGraph.
-  g.edges().forEach(function(e) {
-    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    var weight = weightFn(e);
-    var edgeWeight = prevWeight + weight;
+  g.edges().forEach(e => {
+    let prevWeight = fasGraph.edge(e.v, e.w) || 0;
+    let weight = weightFn(e);
+    let edgeWeight = prevWeight + weight;
     fasGraph.setEdge(e.v, e.w, edgeWeight);
     maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
     maxIn  = Math.max(maxIn,  fasGraph.node(e.w)["in"]  += weight);
   });
 
-  var buckets = range(maxOut + maxIn + 3).map(() => new List());
-  var zeroIdx = maxIn + 1;
+  let buckets = range(maxOut + maxIn + 3).map(() => new List());
+  let zeroIdx = maxIn + 1;
 
-  fasGraph.nodes().forEach(function(v) {
+  fasGraph.nodes().forEach(v => {
     assignBucket(buckets, zeroIdx, fasGraph.node(v));
   });