@statewalker/fsm-charts 0.0.1

package/src/dagre/acyclic.js

@@ -0,0 +1,60 @@
+import { _ } from '../lodash-es/index.ts';
+import { greedyFAS } from './greedy-fas.js';
+
+export { run, undo };
+
+function run(g) {
+  var fas = g.graph().acyclicer === 'greedy' ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+  _.forEach(fas, function (e) {
+    var 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 function (e) {
+      return g.edge(e).weight;
+    };
+  }
+}
+
+function dfsFAS(g) {
+  var fas = [];
+  var stack = {};
+  var visited = {};
+
+  function dfs(v) {
+    if (_.has(visited, v)) {
+      return;
+    }
+    visited[v] = true;
+    stack[v] = true;
+    _.forEach(g.outEdges(v), function (e) {
+      if (_.has(stack, e.w)) {
+        fas.push(e);
+      } else {
+        dfs(e.w);
+      }
+    });
+    delete stack[v];
+  }
+
+  _.forEach(g.nodes(), dfs);
+  return fas;
+}
+
+function undo(g) {
+  _.forEach(g.edges(), function (e) {
+    var label = g.edge(e);
+    if (label.reversed) {
+      g.removeEdge(e);
+
+      var forwardName = label.forwardName;
+      delete label.reversed;
+      delete label.forwardName;
+      g.setEdge(e.w, e.v, label, forwardName);
+    }
+  });
+}

package/src/dagre/add-border-segments.d.ts

@@ -0,0 +1 @@
+export function addBorderSegments(g: any): void;

package/src/dagre/add-border-segments.js

@@ -0,0 +1,36 @@
+import { _ } from '../lodash-es/index.ts';
+import * as util from './util.js';
+
+export { addBorderSegments };
+
+function addBorderSegments(g) {
+  function dfs(v) {
+    var children = g.children(v);
+    var node = g.node(v);
+    if (children.length) {
+      _.forEach(children, dfs);
+    }
+
+    if (_.has(node, 'minRank')) {
+      node.borderLeft = [];
+      node.borderRight = [];
+      for (var rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
+        addBorderNode(g, 'borderLeft', '_bl', v, node, rank);
+        addBorderNode(g, 'borderRight', '_br', v, node, rank);
+      }
+    }
+  }
+
+  _.forEach(g.children(), dfs);
+}
+
+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);
+  sgNode[prop][rank] = curr;
+  g.setParent(curr, sg);
+  if (prev) {
+    g.setEdge(prev, curr, { weight: 1 });
+  }
+}

package/src/dagre/coordinate-system.d.ts

@@ -0,0 +1,2 @@
+export function adjust(g: any): void;
+export function undo(g: any): void;

package/src/dagre/coordinate-system.js

@@ -0,0 +1,75 @@
+import { _ } from '../lodash-es/index.ts';
+
+export { adjust, undo };
+
+function adjust(g) {
+  var rankDir = g.graph().rankdir.toLowerCase();
+  if (rankDir === 'lr' || rankDir === 'rl') {
+    swapWidthHeight(g);
+  }
+}
+
+function undo(g) {
+  var rankDir = g.graph().rankdir.toLowerCase();
+  if (rankDir === 'bt' || rankDir === 'rl') {
+    reverseY(g);
+  }
+
+  if (rankDir === 'lr' || rankDir === 'rl') {
+    swapXY(g);
+    swapWidthHeight(g);
+  }
+}
+
+function swapWidthHeight(g) {
+  _.forEach(g.nodes(), function (v) {
+    swapWidthHeightOne(g.node(v));
+  });
+  _.forEach(g.edges(), function (e) {
+    swapWidthHeightOne(g.edge(e));
+  });
+}
+
+function swapWidthHeightOne(attrs) {
+  var w = attrs.width;
+  attrs.width = attrs.height;
+  attrs.height = w;
+}
+
+function reverseY(g) {
+  _.forEach(g.nodes(), function (v) {
+    reverseYOne(g.node(v));
+  });
+
+  _.forEach(g.edges(), function (e) {
+    var edge = g.edge(e);
+    _.forEach(edge.points, reverseYOne);
+    if (_.has(edge, 'y')) {
+      reverseYOne(edge);
+    }
+  });
+}
+
+function reverseYOne(attrs) {
+  attrs.y = -attrs.y;
+}
+
+function swapXY(g) {
+  _.forEach(g.nodes(), function (v) {
+    swapXYOne(g.node(v));
+  });
+
+  _.forEach(g.edges(), function (e) {
+    var edge = g.edge(e);
+    _.forEach(edge.points, swapXYOne);
+    if (_.has(edge, 'x')) {
+      swapXYOne(edge);
+    }
+  });
+}
+
+function swapXYOne(attrs) {
+  var x = attrs.x;
+  attrs.x = attrs.y;
+  attrs.y = x;
+}

package/src/dagre/data/list.d.ts

@@ -0,0 +1,12 @@
+export class List {
+  _sentinel: {
+    _next: any;
+    _prev: any;
+  };
+  dequeue(): {
+    _next: any;
+    _prev: any;
+  };
+  enqueue(entry: any): void;
+  toString(): string;
+}

package/src/dagre/data/list.js

@@ -0,0 +1,55 @@
+/*
+ * Simple doubly linked list implementation derived from Cormen, et al.,
+ * "Introduction to Algorithms".
+ */
+
+export { List };
+
+class List {
+  constructor() {
+    var sentinel = {};
+    sentinel._next = sentinel._prev = sentinel;
+    this._sentinel = sentinel;
+  }
+  dequeue() {
+    var sentinel = this._sentinel;
+    var entry = sentinel._prev;
+    if (entry !== sentinel) {
+      unlink(entry);
+      return entry;
+    }
+  }
+  enqueue(entry) {
+    var 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() {
+    var strs = [];
+    var sentinel = this._sentinel;
+    var 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;
+  }
+}

package/src/dagre/debug.d.ts

@@ -0,0 +1,2 @@
+export function debugOrdering(g: any): Graph;
+import { Graph } from '../graphlib/index.js';

package/src/dagre/debug.js

@@ -0,0 +1,32 @@
+import { _ } from '../lodash-es/index.ts';
+import { Graph } from '../graphlib/index.js';
+import * as util from './util.js';
+
+export { debugOrdering };
+
+/* istanbul ignore next */
+function debugOrdering(g) {
+  var layerMatrix = util.buildLayerMatrix(g);
+
+  var h = new Graph({ compound: true, multigraph: true }).setGraph({});
+
+  _.forEach(g.nodes(), function (v) {
+    h.setNode(v, { label: v });
+    h.setParent(v, 'layer' + g.node(v).rank);
+  });
+
+  _.forEach(g.edges(), function (e) {
+    h.setEdge(e.v, e.w, {}, e.name);
+  });
+
+  _.forEach(layerMatrix, function (layer, i) {
+    var layerV = 'layer' + i;
+    h.setNode(layerV, { rank: 'same' });
+    _.reduce(layer, function (u, v) {
+      h.setEdge(u, v, { style: 'invis' });
+      return v;
+    });
+  });
+
+  return h;
+}

package/src/dagre/greedy-fas.d.ts

@@ -0,0 +1 @@
+export function greedyFAS(g: any, weightFn: any): any[];

package/src/dagre/greedy-fas.js

@@ -0,0 +1,126 @@
+import { _ } from '../lodash-es/index.ts';
+import { Graph } from '../graphlib/index.js';
+import { List } from './data/list.js';
+
+/*
+ * 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.
+ */
+export { greedyFAS };
+
+var DEFAULT_WEIGHT_FN = _.constant(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);
+
+  // Expand multi-edges
+  return _.flatten(
+    _.map(results, function (e) {
+      return g.outEdges(e.v, e.w);
+    })
+  );
+}
+
+function doGreedyFAS(g, buckets, zeroIdx) {
+  var results = [];
+  var sources = buckets[buckets.length - 1];
+  var sinks = buckets[0];
+
+  var 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) {
+        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) {
+  var results = collectPredecessors ? [] : undefined;
+
+  _.forEach(g.inEdges(entry.v), function (edge) {
+    var weight = g.edge(edge);
+    var uEntry = g.node(edge.v);
+
+    if (collectPredecessors) {
+      results.push({ v: edge.v, w: edge.w });
+    }
+
+    uEntry.out -= weight;
+    assignBucket(buckets, zeroIdx, uEntry);
+  });
+
+  _.forEach(g.outEdges(entry.v), function (edge) {
+    var weight = g.edge(edge);
+    var w = edge.w;
+    var wEntry = g.node(w);
+    wEntry['in'] -= weight;
+    assignBucket(buckets, zeroIdx, wEntry);
+  });
+
+  g.removeNode(entry.v);
+
+  return results;
+}
+
+function buildState(g, weightFn) {
+  var fasGraph = new Graph();
+  var maxIn = 0;
+  var maxOut = 0;
+
+  _.forEach(g.nodes(), function (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.
+  _.forEach(g.edges(), function (e) {
+    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
+    var weight = weightFn(e);
+    var 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(function () {
+    return new List();
+  });
+  var zeroIdx = maxIn + 1;
+
+  _.forEach(fasGraph.nodes(), function (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);
+  }
+}

package/src/dagre/index.d.ts

@@ -0,0 +1,5 @@
+import * as acyclic from './acyclic.js';
+import * as normalize from './normalize.js';
+import { rank } from './rank/index.js';
+import { layout } from './layout.js';
+export { acyclic, normalize, rank, layout };

package/src/dagre/index.js

@@ -0,0 +1,6 @@
+import * as acyclic from './acyclic.js';
+import { layout } from './layout.js';
+import * as normalize from './normalize.js';
+import { rank } from './rank/index.js';
+
+export { acyclic, normalize, rank, layout };

package/src/dagre/layout.d.ts

@@ -0,0 +1 @@
+export function layout(g: any, opts: any): void;