@statewalker/fsm-charts 0.2.4 → 0.2.5

package/src/dagre/position/bk.js

@@ -1,6 +1,6 @@
-import { _ } from '../../lodash-es/index.ts';
-import { Graph } from '../../graphlib/index.js';
-import * as util from '../util.js';
+import { Graph } from "../../graphlib/index.js";
+import { _ } from "../../lodash-es/index.ts";
+import * as util from "../util.js";
 
 /*
  * This module provides coordinate assignment based on Brandes and Köpf, "Fast
@@ -50,16 +50,19 @@ function findType1Conflicts(g, layering) {
       prevLayerLength = prevLayer.length,
       lastNode = _.last(layer);
 
-    _.forEach(layer, function (v, i) {
+    _.forEach(layer, (v, i) => {
       var w = findOtherInnerSegmentNode(g, v),
         k1 = w ? g.node(w).order : prevLayerLength;
 
       if (w || v === lastNode) {
-        _.forEach(layer.slice(scanPos, i + 1), function (scanNode) {
-          _.forEach(g.predecessors(scanNode), function (u) {
+        _.forEach(layer.slice(scanPos, i + 1), (scanNode) => {
+          _.forEach(g.predecessors(scanNode), (u) => {
             var uLabel = g.node(u),
               uPos = uLabel.order;
-            if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
+            if (
+              (uPos < k0 || k1 < uPos) &&
+              !(uLabel.dummy && g.node(scanNode).dummy)
+            ) {
               addConflict(conflicts, u, scanNode);
             }
           });
@@ -82,12 +85,15 @@ function findType2Conflicts(g, layering) {
 
   function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
     var v;
-    _.forEach(_.range(southPos, southEnd), function (i) {
+    _.forEach(_.range(southPos, southEnd), (i) => {
       v = south[i];
       if (g.node(v).dummy) {
-        _.forEach(g.predecessors(v), function (u) {
+        _.forEach(g.predecessors(v), (u) => {
           var uNode = g.node(u);
-          if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+          if (
+            uNode.dummy &&
+            (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)
+          ) {
             addConflict(conflicts, u, v);
           }
         });
@@ -100,8 +106,8 @@ function findType2Conflicts(g, layering) {
       nextNorthPos,
       southPos = 0;
 
-    _.forEach(south, function (v, southLookahead) {
-      if (g.node(v).dummy === 'border') {
+    _.forEach(south, (v, southLookahead) => {
+      if (g.node(v).dummy === "border") {
         var predecessors = g.predecessors(v);
         if (predecessors.length) {
           nextNorthPos = g.node(predecessors[0]).order;
@@ -123,9 +129,7 @@ function findType2Conflicts(g, layering) {
 
 function findOtherInnerSegmentNode(g, v) {
   if (g.node(v).dummy) {
-    return _.find(g.predecessors(v), function (u) {
-      return g.node(u).dummy;
-    });
+    return _.find(g.predecessors(v), (u) => g.node(u).dummy);
   }
 }
 
@@ -160,7 +164,7 @@ function hasConflict(conflicts, v, w) {
  * we're trying to form a block with, we also ignore that possibility - our
  * blocks would be split in that scenario.
  */
-function verticalAlignment(g, layering, conflicts, neighborFn) {
+function verticalAlignment(_g, layering, conflicts, neighborFn) {
   var root = {},
     align = {},
     pos = {};
@@ -168,26 +172,28 @@ function verticalAlignment(g, layering, conflicts, neighborFn) {
   // 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.
-  _.forEach(layering, function (layer) {
-    _.forEach(layer, function (v, order) {
+  _.forEach(layering, (layer) => {
+    _.forEach(layer, (v, order) => {
       root[v] = v;
       align[v] = v;
       pos[v] = order;
     });
   });
 
-  _.forEach(layering, function (layer) {
+  _.forEach(layering, (layer) => {
     var prevIdx = -1;
-    _.forEach(layer, function (v) {
+    _.forEach(layer, (v) => {
       var ws = neighborFn(v);
       if (ws.length) {
-        ws = _.sortBy(ws, function (w) {
-          return pos[w];
-        });
+        ws = _.sortBy(ws, (w) => pos[w]);
         var mp = (ws.length - 1) / 2;
         for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
           var w = ws[i];
-          if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+          if (
+            align[v] === v &&
+            prevIdx < pos[w] &&
+            !hasConflict(conflicts, v, w)
+          ) {
             align[w] = v;
             align[v] = root[v] = root[w];
             prevIdx = pos[w];
@@ -208,7 +214,7 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
   // greatest coordinates without violating separation.
   var xs = {},
     blockG = buildBlockGraph(g, layering, root, reverseSep),
-    borderType = reverseSep ? 'borderLeft' : 'borderRight';
+    borderType = reverseSep ? "borderLeft" : "borderRight";
 
   function iterate(setXsFunc, nextNodesFunc) {
     var stack = blockG.nodes();
@@ -229,16 +235,19 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
 
   // First pass, assign smallest coordinates
   function pass1(elem) {
-    xs[elem] = blockG.inEdges(elem).reduce(function (acc, e) {
-      return Math.max(acc, xs[e.v] + blockG.edge(e));
-    }, 0);
+    xs[elem] = blockG
+      .inEdges(elem)
+      .reduce((acc, e) => Math.max(acc, xs[e.v] + blockG.edge(e)), 0);
   }
 
   // Second pass, assign greatest coordinates
   function pass2(elem) {
-    var min = blockG.outEdges(elem).reduce(function (acc, e) {
-      return Math.min(acc, xs[e.w] - blockG.edge(e));
-    }, Number.POSITIVE_INFINITY);
+    var min = blockG
+      .outEdges(elem)
+      .reduce(
+        (acc, e) => Math.min(acc, xs[e.w] - blockG.edge(e)),
+        Number.POSITIVE_INFINITY,
+      );
 
     var node = g.node(elem);
     if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
@@ -250,7 +259,7 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
   iterate(pass2, blockG.successors.bind(blockG));
 
   // Assign x coordinates to all nodes
-  _.forEach(align, function (v) {
+  _.forEach(align, (v) => {
     xs[v] = xs[root[v]];
   });
 
@@ -262,15 +271,19 @@ function buildBlockGraph(g, layering, root, reverseSep) {
     graphLabel = g.graph(),
     sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
 
-  _.forEach(layering, function (layer) {
+  _.forEach(layering, (layer) => {
     var u;
-    _.forEach(layer, function (v) {
+    _.forEach(layer, (v) => {
       var 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));
+        blockGraph.setEdge(
+          uRoot,
+          vRoot,
+          Math.max(sepFn(g, v, u), prevMax || 0),
+        );
       }
       u = v;
     });
@@ -283,11 +296,11 @@ function buildBlockGraph(g, layering, root, reverseSep) {
  * Returns the alignment that has the smallest width of the given alignments.
  */
 function findSmallestWidthAlignment(g, xss) {
-  return _.minBy(_.values(xss), function (xs) {
+  return _.minBy(_.values(xss), (xs) => {
     var max = Number.NEGATIVE_INFINITY;
     var min = Number.POSITIVE_INFINITY;
 
-    _.forIn(xs, function (x, v) {
+    _.forIn(xs, (x, v) => {
       var halfWidth = width(g, v) / 2;
 
       max = Math.max(x + halfWidth, max);
@@ -310,27 +323,26 @@ function alignCoordinates(xss, alignTo) {
     alignToMin = _.min(alignToVals),
     alignToMax = _.max(alignToVals);
 
-  _.forEach(['u', 'd'], function (vert) {
-    _.forEach(['l', 'r'], function (horiz) {
+  _.forEach(["u", "d"], (vert) => {
+    _.forEach(["l", "r"], (horiz) => {
       var alignment = vert + horiz,
         xs = xss[alignment],
         delta;
       if (xs === alignTo) return;
 
       var xsVals = _.values(xs);
-      delta = horiz === 'l' ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);
+      delta =
+        horiz === "l" ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);
 
       if (delta) {
-        xss[alignment] = _.mapValues(xs, function (x) {
-          return x + delta;
-        });
+        xss[alignment] = _.mapValues(xs, (x) => x + delta);
       }
     });
   });
 }
 
 function balance(xss, align) {
-  return _.mapValues(xss.ul, function (ignore, v) {
+  return _.mapValues(xss.ul, (_ignore, v) => {
     if (align) {
       return xss[align.toLowerCase()][v];
     } else {
@@ -342,26 +354,33 @@ function balance(xss, align) {
 
 function positionX(g) {
   var layering = util.buildLayerMatrix(g);
-  var conflicts = _.merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+  var conflicts = _.merge(
+    findType1Conflicts(g, layering),
+    findType2Conflicts(g, layering),
+  );
 
   var xss = {};
   var adjustedLayering;
-  _.forEach(['u', 'd'], function (vert) {
-    adjustedLayering = vert === 'u' ? layering : _.values(layering).reverse();
-    _.forEach(['l', 'r'], function (horiz) {
-      if (horiz === 'r') {
-        adjustedLayering = _.map(adjustedLayering, function (inner) {
-          return _.values(inner).reverse();
-        });
+  _.forEach(["u", "d"], (vert) => {
+    adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
+    _.forEach(["l", "r"], (horiz) => {
+      if (horiz === "r") {
+        adjustedLayering = _.map(adjustedLayering, (inner) =>
+          _.values(inner).reverse(),
+        );
       }
 
-      var neighborFn = (vert === 'u' ? g.predecessors : g.successors).bind(g);
+      var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
       var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
-      var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === 'r');
-      if (horiz === 'r') {
-        xs = _.mapValues(xs, function (x) {
-          return -x;
-        });
+      var xs = horizontalCompaction(
+        g,
+        adjustedLayering,
+        align.root,
+        align.align,
+        horiz === "r",
+      );
+      if (horiz === "r") {
+        xs = _.mapValues(xs, (x) => -x);
       }
       xss[vert + horiz] = xs;
     });
@@ -373,19 +392,19 @@ function positionX(g) {
 }
 
 function sep(nodeSep, edgeSep, reverseSep) {
-  return function (g, v, w) {
+  return (g, v, w) => {
     var vLabel = g.node(v);
     var wLabel = g.node(w);
     var sum = 0;
     var delta;
 
     sum += vLabel.width / 2;
-    if (_.has(vLabel, 'labelpos')) {
+    if (_.has(vLabel, "labelpos")) {
       switch (vLabel.labelpos.toLowerCase()) {
-        case 'l':
+        case "l":
           delta = -vLabel.width / 2;
           break;
-        case 'r':
+        case "r":
           delta = vLabel.width / 2;
           break;
       }
@@ -399,12 +418,12 @@ function sep(nodeSep, edgeSep, reverseSep) {
     sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
 
     sum += wLabel.width / 2;
-    if (_.has(wLabel, 'labelpos')) {
+    if (_.has(wLabel, "labelpos")) {
       switch (wLabel.labelpos.toLowerCase()) {
-        case 'l':
+        case "l":
           delta = wLabel.width / 2;
           break;
-        case 'r':
+        case "r":
           delta = -wLabel.width / 2;
           break;
       }

package/src/dagre/position/index.js

@@ -1,6 +1,6 @@
-import { _ } from '../../lodash-es/index.ts';
-import * as util from '../util.js';
-import { positionX } from './bk.js';
+import { _ } from "../../lodash-es/index.ts";
+import * as util from "../util.js";
+import { positionX } from "./bk.js";
 
 export { position };
 
@@ -8,7 +8,7 @@ function position(g) {
   g = util.asNonCompoundGraph(g);
 
   positionY(g);
-  _.forOwn(positionX(g), function (x, v) {
+  _.forOwn(positionX(g), (x, v) => {
     g.node(v).x = x;
   });
 }
@@ -17,13 +17,9 @@ function positionY(g) {
   var layering = util.buildLayerMatrix(g);
   var rankSep = g.graph().ranksep;
   var prevY = 0;
-  _.forEach(layering, function (layer) {
-    var maxHeight = _.max(
-      _.map(layer, function (v) {
-        return g.node(v).height;
-      })
-    );
-    _.forEach(layer, function (v) {
+  _.forEach(layering, (layer) => {
+    var maxHeight = _.max(_.map(layer, (v) => g.node(v).height));
+    _.forEach(layer, (v) => {
       g.node(v).y = prevY + maxHeight / 2;
     });
     prevY += maxHeight + rankSep;

package/src/dagre/rank/feasible-tree.d.ts

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

package/src/dagre/rank/feasible-tree.js

@@ -1,6 +1,6 @@
-import { _ } from '../../lodash-es/index.ts';
-import { Graph } from '../../graphlib/index.js';
-import { slack } from './util.js';
+import { Graph } from "../../graphlib/index.js";
+import { _ } from "../../lodash-es/index.ts";
+import { slack } from "./util.js";
 
 export { feasibleTree };
 
@@ -53,7 +53,7 @@ function feasibleTree(g) {
  */
 function tightTree(t, g) {
   function dfs(v) {
-    _.forEach(g.nodeEdges(v), function (e) {
+    _.forEach(g.nodeEdges(v), (e) => {
       var edgeV = e.v,
         w = v === edgeV ? e.w : edgeV;
       if (!t.hasNode(w) && !slack(g, e)) {
@@ -73,7 +73,7 @@ function tightTree(t, g) {
  * it.
  */
 function findMinSlackEdge(t, g) {
-  return _.minBy(g.edges(), function (e) {
+  return _.minBy(g.edges(), (e) => {
     if (t.hasNode(e.v) !== t.hasNode(e.w)) {
       return slack(g, e);
     }
@@ -81,7 +81,7 @@ function findMinSlackEdge(t, g) {
 }
 
 function shiftRanks(t, g, delta) {
-  _.forEach(t.nodes(), function (v) {
+  _.forEach(t.nodes(), (v) => {
     g.node(v).rank += delta;
   });
 }

package/src/dagre/rank/index.js

@@ -1,6 +1,6 @@
-import { feasibleTree } from './feasible-tree.js';
-import { networkSimplex } from './network-simplex.js';
-import { longestPath } from './util.js';
+import { feasibleTree } from "./feasible-tree.js";
+import { networkSimplex } from "./network-simplex.js";
+import { longestPath } from "./util.js";
 
 export { rank };
 
@@ -25,13 +25,13 @@ export { rank };
  */
 function rank(g) {
   switch (g.graph().ranker) {
-    case 'network-simplex':
+    case "network-simplex":
       networkSimplexRanker(g);
       break;
-    case 'tight-tree':
+    case "tight-tree":
       tightTreeRanker(g);
       break;
-    case 'longest-path':
+    case "longest-path":
       longestPathRanker(g);
       break;
     default:

package/src/dagre/rank/network-simplex.d.ts

@@ -13,4 +13,3 @@ declare function calcCutValue(t: any, g: any, child: any): number;
 declare function leaveEdge(tree: any): any;
 declare function enterEdge(t: any, g: any, edge: any): any;
 declare function exchangeEdges(t: any, g: any, e: any, f: any): void;
-export {};

package/src/dagre/rank/network-simplex.js

@@ -1,8 +1,8 @@
-import { _ } from '../../lodash-es/index.ts';
-import * as alg from '../../graphlib/alg/index.js';
-import { simplify } from '../util.js';
-import { feasibleTree } from './feasible-tree.js';
-import { longestPath, slack } from './util.js';
+import * as alg from "../../graphlib/alg/index.js";
+import { _ } from "../../lodash-es/index.ts";
+import { simplify } from "../util.js";
+import { feasibleTree } from "./feasible-tree.js";
+import { longestPath, slack } from "./util.js";
 
 export { networkSimplex };
 
@@ -67,7 +67,7 @@ function networkSimplex(g) {
 function initCutValues(t, g) {
   var vs = alg.postorder(t, t.nodes());
   vs = vs.slice(0, vs.length - 1);
-  _.forEach(vs, function (v) {
+  _.forEach(vs, (v) => {
     assignCutValue(t, g, v);
   });
 }
@@ -99,7 +99,7 @@ function calcCutValue(t, g, child) {
 
   cutValue = graphEdge.weight;
 
-  _.forEach(g.nodeEdges(child), function (e) {
+  _.forEach(g.nodeEdges(child), (e) => {
     var isOutEdge = e.v === child,
       other = isOutEdge ? e.w : e.v;
 
@@ -130,7 +130,7 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
   var label = tree.node(v);
 
   visited[v] = true;
-  _.forEach(tree.neighbors(v), function (w) {
+  _.forEach(tree.neighbors(v), (w) => {
     if (!_.has(visited, w)) {
       nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
     }
@@ -149,9 +149,7 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
 }
 
 function leaveEdge(tree) {
-  return _.find(tree.edges(), function (e) {
-    return tree.edge(e).cutvalue < 0;
-  });
+  return _.find(tree.edges(), (e) => tree.edge(e).cutvalue < 0);
 }
 
 function enterEdge(t, g, edge) {
@@ -178,16 +176,14 @@ function enterEdge(t, g, edge) {
     flip = true;
   }
 
-  var candidates = _.filter(g.edges(), function (edge) {
-    return (
+  var candidates = _.filter(
+    g.edges(),
+    (edge) =>
       flip === isDescendant(t, t.node(edge.v), tailLabel) &&
-      flip !== isDescendant(t, t.node(edge.w), tailLabel)
-    );
-  });
+      flip !== isDescendant(t, t.node(edge.w), tailLabel),
+  );
 
-  return _.minBy(candidates, function (edge) {
-    return slack(g, edge);
-  });
+  return _.minBy(candidates, (edge) => slack(g, edge));
 }
 
 function exchangeEdges(t, g, e, f) {
@@ -201,12 +197,10 @@ function exchangeEdges(t, g, e, f) {
 }
 
 function updateRanks(t, g) {
-  var root = _.find(t.nodes(), function (v) {
-    return !g.node(v).parent;
-  });
+  var root = _.find(t.nodes(), (v) => !g.node(v).parent);
   var vs = alg.preorder(t, root);
   vs = vs.slice(1);
-  _.forEach(vs, function (v) {
+  _.forEach(vs, (v) => {
     var parent = t.node(v).parent,
       edge = g.edge(v, parent),
       flipped = false;
@@ -216,7 +210,8 @@ function updateRanks(t, g) {
       flipped = true;
     }
 
-    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+    g.node(v).rank =
+      g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
   });
 }
 
@@ -231,6 +226,6 @@ function isTreeEdge(tree, u, v) {
  * Returns true if the specified node is descendant of the root node per the
  * assigned low and lim attributes in the tree.
  */
-function isDescendant(tree, vLabel, rootLabel) {
+function isDescendant(_tree, vLabel, rootLabel) {
   return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
 }

package/src/dagre/rank/util.js

@@ -1,4 +1,4 @@
-import { _ } from '../../lodash-es/index.ts';
+import { _ } from "../../lodash-es/index.ts";
 
 export { longestPath, slack };
 
@@ -33,11 +33,7 @@ function longestPath(g) {
     }
     visited[v] = true;
 
-    var rank = _.min(
-      _.map(g.outEdges(v), function (e) {
-        return dfs(e.w) - g.edge(e).minlen;
-      })
-    );
+    var rank = _.min(_.map(g.outEdges(v), (e) => dfs(e.w) - g.edge(e).minlen));
 
     if (
       rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3

package/src/dagre/util.d.ts

@@ -1,11 +1,11 @@
 export function addDummyNode(g: any, type: any, attrs: any, name: any): string;
 export function simplify(g: any): Graph;
 export function asNonCompoundGraph(g: any): Graph;
-export function successorWeights(g: any): import('lodash').Dictionary<{}>;
-export function predecessorWeights(g: any): import('lodash').Dictionary<{}>;
+export function successorWeights(g: any): import("lodash").Dictionary<{}>;
+export function predecessorWeights(g: any): import("lodash").Dictionary<{}>;
 export function intersectRect(
   rect: any,
-  point: any
+  point: any,
 ): {
   x: any;
   y: any;
@@ -13,15 +13,21 @@ export function intersectRect(
 export function buildLayerMatrix(g: any): any[][];
 export function normalizeRanks(g: any): void;
 export function removeEmptyRanks(g: any): void;
-export function addBorderNode(g: any, prefix: any, rank: any, order: any, ...args: any[]): string;
+export function addBorderNode(
+  g: any,
+  prefix: any,
+  rank: any,
+  order: any,
+  ...args: any[]
+): string;
 export function maxRank(g: any): any;
 export function partition(
   collection: any,
-  fn: any
+  fn: any,
 ): {
   lhs: any[];
   rhs: any[];
 };
 export function time(name: any, fn: any): any;
 export function notime(name: any, fn: any): any;
-import { Graph } from '../graphlib/index.js';
+import { Graph } from "../graphlib/index.js";