@dagrejs/dagre 1.1.8 → 2.0.0

package/index.d.ts

@@ -1,147 +0,0 @@
-// 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[];
-      hasNode(name: string): boolean;
-      neighbors(name: string): string[] | undefined;
-      node(id: string | Label): Node<T>;
-      nodeCount(): number;
-      nodes(): string[];
-      parent(childName: string): string | undefined;
-      predecessors(name: string): string[] | 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): string[] | 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 floydWarshall(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;
-    labelpos?: 'l' | 'c' | 'r' | undefined;
-    labeloffest?: number | undefined;
-  }
-
-  export interface LayoutConfig {
-    customOrder?: (graph: graphlib.Graph, order: (graph: graphlib.Graph, opts: configUnion) => void) => void;
-    disableOptimalOrderHeuristic?: boolean;
-  }
-
-  type configUnion = GraphLabel & NodeConfig & EdgeConfig & LayoutConfig;
-
-  export function layout(graph: graphlib.Graph, layout?: configUnion): 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;
-    rank?: number | undefined;
-    rx?: number | undefined;
-    ry?: number | undefined;
-    shape?: string | undefined;
-  };
-}

package/lib/acyclic.js

@@ -1,67 +0,0 @@
-"use strict";
-
-let greedyFAS = require("./greedy-fas");
-let uniqueId = require("./util").uniqueId;
-
-module.exports = {
-  run: run,
-  undo: undo
-};
-
-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 (Object.hasOwn(visited, v)) {
-      return;
-    }
-    visited[v] = true;
-    stack[v] = true;
-    g.outEdges(v).forEach(e => {
-      if (Object.hasOwn(stack, e.w)) {
-        fas.push(e);
-      } else {
-        dfs(e.w);
-      }
-    });
-    delete stack[v];
-  }
-
-  g.nodes().forEach(dfs);
-  return fas;
-}
-
-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/lib/add-border-segments.js

@@ -1,37 +0,0 @@
-let util = require("./util");
-
-module.exports = addBorderSegments;
-
-function addBorderSegments(g) {
-  function dfs(v) {
-    let children = g.children(v);
-    let node = g.node(v);
-    if (children.length) {
-      children.forEach(dfs);
-    }
-
-    if (Object.hasOwn(node, "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 });
-  }
-}

package/lib/coordinate-system.js

@@ -1,70 +0,0 @@
-"use strict";
-
-module.exports = {
-  adjust: adjust,
-  undo: undo
-};
-
-function adjust(g) {
-  let rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === "lr" || rankDir === "rl") {
-    swapWidthHeight(g);
-  }
-}
-
-function undo(g) {
-  let rankDir = g.graph().rankdir.toLowerCase();
-  if (rankDir === "bt" || rankDir === "rl") {
-    reverseY(g);
-  }
-
-  if (rankDir === "lr" || rankDir === "rl") {
-    swapXY(g);
-    swapWidthHeight(g);
-  }
-}
-
-function swapWidthHeight(g) {
-  g.nodes().forEach(v => swapWidthHeightOne(g.node(v)));
-  g.edges().forEach(e => swapWidthHeightOne(g.edge(e)));
-}
-
-function swapWidthHeightOne(attrs) {
-  let w = attrs.width;
-  attrs.width = attrs.height;
-  attrs.height = w;
-}
-
-function reverseY(g) {
-  g.nodes().forEach(v => reverseYOne(g.node(v)));
-
-  g.edges().forEach(e => {
-    let edge = g.edge(e);
-    edge.points.forEach(reverseYOne);
-    if (Object.hasOwn(edge, "y")) {
-      reverseYOne(edge);
-    }
-  });
-}
-
-function reverseYOne(attrs) {
-  attrs.y = -attrs.y;
-}
-
-function swapXY(g) {
-  g.nodes().forEach(v => swapXYOne(g.node(v)));
-
-  g.edges().forEach(e => {
-    let edge = g.edge(e);
-    edge.points.forEach(swapXYOne);
-    if (Object.hasOwn(edge, "x")) {
-      swapXYOne(edge);
-    }
-  });
-}
-
-function swapXYOne(attrs) {
-  let x = attrs.x;
-  attrs.x = attrs.y;
-  attrs.y = x;
-}

package/lib/data/list.js

@@ -1,58 +0,0 @@
-/*
- * Simple doubly linked list implementation derived from Cormen, et al.,
- * "Introduction to Algorithms".
- */
-
-class List {
-  constructor() {
-    let sentinel = {};
-    sentinel._next = sentinel._prev = sentinel;
-    this._sentinel = sentinel;
-  }
-
-  dequeue() {
-    let sentinel = this._sentinel;
-    let entry = sentinel._prev;
-    if (entry !== sentinel) {
-      unlink(entry);
-      return 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;
-  }
-
-  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(", ") + "]";
-  }
-}
-
-function unlink(entry) {
-  entry._prev._next = entry._next;
-  entry._next._prev = entry._prev;
-  delete entry._next;
-  delete entry._prev;
-}
-
-function filterOutLinks(k, v) {
-  if (k !== "_next" && k !== "_prev") {
-    return v;
-  }
-}
-
-module.exports = List;

package/lib/debug.js

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

package/lib/greedy-fas.js

@@ -1,124 +0,0 @@
-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
- * arc set is a set of edges that can be removed to make a graph acyclic.
- * The algorithm comes from: P. Eades, X. Lin, and W. F. Smyth, "A fast and
- * effective heuristic for the feedback arc set problem." This implementation
- * adjusts that from the paper to allow for weighted edges.
- */
-module.exports = greedyFAS;
-
-let DEFAULT_WEIGHT_FN = () => 1;
-
-function greedyFAS(g, weightFn) {
-  if (g.nodeCount() <= 1) {
-    return [];
-  }
-  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) {
-  let results = [];
-  let sources = buckets[buckets.length - 1];
-  let sinks = buckets[0];
-
-  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 (let i = buckets.length - 2; i > 0; --i) {
-        entry = buckets[i].dequeue();
-        if (entry) {
-          results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
-          break;
-        }
-      }
-    }
-  }
-
-  return results;
-}
-
-function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  let results = collectPredecessors ? [] : undefined;
-
-  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 });
-    }
-
-    uEntry.out -= weight;
-    assignBucket(buckets, zeroIdx, uEntry);
-  });
-
-  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);
-  });
-
-  g.removeNode(entry.v);
-
-  return results;
-}
-
-function buildState(g, weightFn) {
-  let fasGraph = new Graph();
-  let maxIn = 0;
-  let maxOut = 0;
-
-  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(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);
-  });
-
-  let buckets = range(maxOut + maxIn + 3).map(() => new List());
-  let zeroIdx = maxIn + 1;
-
-  fasGraph.nodes().forEach(v => {
-    assignBucket(buckets, zeroIdx, fasGraph.node(v));
-  });
-
-  return { graph: fasGraph, buckets: buckets, zeroIdx: zeroIdx };
-}
-
-function assignBucket(buckets, zeroIdx, entry) {
-  if (!entry.out) {
-    buckets[0].enqueue(entry);
-  } else if (!entry["in"]) {
-    buckets[buckets.length - 1].enqueue(entry);
-  } else {
-    buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
-  }
-}
-
-function range(limit) {
-  const range = [];
-  for (let i = 0; i < limit; i++) {
-    range.push(i);
-  }
-
-  return range;
-}