@statewalker/fsm-charts 0.2.4 → 0.2.6

package/src/dagre/order/build-layer-graph.js

@@ -1,5 +1,5 @@
-import { _ } from '../../lodash-es/index.ts';
-import { Graph } from '../../graphlib/index.js';
+import { Graph } from "../../graphlib/index.js";
+import { _ } from "../../lodash-es/index.ts";
 
 export { buildLayerGraph };
 
@@ -37,11 +37,9 @@ function buildLayerGraph(g, rank, relationship) {
   var root = createRootNode(g),
     result = new Graph({ compound: true })
       .setGraph({ root: root })
-      .setDefaultNodeLabel(function (v) {
-        return g.node(v);
-      });
+      .setDefaultNodeLabel((v) => g.node(v));
 
-  _.forEach(g.nodes(), function (v) {
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v),
       parent = g.parent(v);
 
@@ -50,14 +48,14 @@ function buildLayerGraph(g, rank, relationship) {
       result.setParent(v, parent || root);
 
       // This assumes we have only short edges!
-      _.forEach(g[relationship](v), function (e) {
+      _.forEach(g[relationship](v), (e) => {
         var u = e.v === v ? e.w : e.v,
           edge = result.edge(u, v),
           weight = !_.isUndefined(edge) ? edge.weight : 0;
         result.setEdge(u, v, { weight: g.edge(e).weight + weight });
       });
 
-      if (_.has(node, 'minRank')) {
+      if (_.has(node, "minRank")) {
         result.setNode(v, {
           borderLeft: node.borderLeft[rank],
           borderRight: node.borderRight[rank],
@@ -71,6 +69,6 @@ function buildLayerGraph(g, rank, relationship) {
 
 function createRootNode(g) {
   var v;
-  while (g.hasNode((v = _.uniqueId('_root'))));
+  while (g.hasNode((v = _.uniqueId("_root"))));
   return v;
 }

package/src/dagre/order/cross-count.js

@@ -1,4 +1,4 @@
-import { _ } from '../../lodash-es/index.ts';
+import { _ } from "../../lodash-es/index.ts";
 
 export { crossCount };
 
@@ -32,19 +32,18 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
   // their head in the south layer.
   var southPos = _.zipObject(
     southLayer,
-    _.map(southLayer, function (v, i) {
-      return i;
-    })
+    _.map(southLayer, (_v, i) => i),
   );
   var southEntries = _.flatten(
-    _.map(northLayer, function (v) {
-      return _.sortBy(
-        _.map(g.outEdges(v), function (e) {
-          return { pos: southPos[e.w], weight: g.edge(e).weight };
-        }),
-        'pos'
-      );
-    })
+    _.map(northLayer, (v) =>
+      _.sortBy(
+        _.map(g.outEdges(v), (e) => ({
+          pos: southPos[e.w],
+          weight: g.edge(e).weight,
+        })),
+        "pos",
+      ),
+    ),
   );
 
   // Build the accumulator tree
@@ -52,15 +51,13 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
   while (firstIndex < southLayer.length) firstIndex <<= 1;
   var treeSize = 2 * firstIndex - 1;
   firstIndex -= 1;
-  var tree = _.map(new Array(treeSize), function () {
-    return 0;
-  });
+  var tree = _.map(new Array(treeSize), () => 0);
 
   // Calculate the weighted crossings
   var cc = 0;
   _.forEach(
     // @ts-expect-error
-    southEntries.forEach(function (entry) {
+    southEntries.forEach((entry) => {
       var index = entry.pos + firstIndex;
       tree[index] += entry.weight;
       var weightSum = 0;
@@ -75,7 +72,7 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
         tree[index] += entry.weight;
       }
       cc += entry.weight * weightSum;
-    })
+    }),
   );
 
   return cc;

package/src/dagre/order/index.js

@@ -1,11 +1,11 @@
-import { _ } from '../../lodash-es/index.ts';
-import { Graph } from '../../graphlib/index.js';
-import * as util from '../util.js';
-import { addSubgraphConstraints } from './add-subgraph-constraints.js';
-import { buildLayerGraph } from './build-layer-graph.js';
-import { crossCount } from './cross-count.js';
-import { initOrder } from './init-order.js';
-import { sortSubgraph } from './sort-subgraph.js';
+import { Graph } from "../../graphlib/index.js";
+import { _ } from "../../lodash-es/index.ts";
+import * as util from "../util.js";
+import { addSubgraphConstraints } from "./add-subgraph-constraints.js";
+import { buildLayerGraph } from "./build-layer-graph.js";
+import { crossCount } from "./cross-count.js";
+import { initOrder } from "./init-order.js";
+import { sortSubgraph } from "./sort-subgraph.js";
 
 export { order };
 
@@ -26,8 +26,12 @@ export { order };
  */
 function order(g) {
   var maxRank = util.maxRank(g),
-    downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank + 1), 'inEdges'),
-    upLayerGraphs = buildLayerGraphs(g, _.range(maxRank - 1, -1, -1), 'outEdges');
+    downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank + 1), "inEdges"),
+    upLayerGraphs = buildLayerGraphs(
+      g,
+      _.range(maxRank - 1, -1, -1),
+      "outEdges",
+    );
 
   var layering = initOrder(g);
   assignOrder(g, layering);
@@ -51,17 +55,15 @@ function order(g) {
 }
 
 function buildLayerGraphs(g, ranks, relationship) {
-  return _.map(ranks, function (rank) {
-    return buildLayerGraph(g, rank, relationship);
-  });
+  return _.map(ranks, (rank) => buildLayerGraph(g, rank, relationship));
 }
 
 function sweepLayerGraphs(layerGraphs, biasRight) {
   var cg = new Graph();
-  _.forEach(layerGraphs, function (lg) {
+  _.forEach(layerGraphs, (lg) => {
     var root = lg.graph().root;
     var sorted = sortSubgraph(lg, root, cg, biasRight);
-    _.forEach(sorted.vs, function (v, i) {
+    _.forEach(sorted.vs, (v, i) => {
       lg.node(v).order = i;
     });
     addSubgraphConstraints(lg, cg, sorted.vs);
@@ -69,8 +71,8 @@ function sweepLayerGraphs(layerGraphs, biasRight) {
 }
 
 function assignOrder(g, layering) {
-  _.forEach(layering, function (layer) {
-    _.forEach(layer, function (v, i) {
+  _.forEach(layering, (layer) => {
+    _.forEach(layer, (v, i) => {
       g.node(v).order = i;
     });
   });

package/src/dagre/order/init-order.js

@@ -1,4 +1,4 @@
-import { _ } from '../../lodash-es/index.ts';
+import { _ } from "../../lodash-es/index.ts";
 
 export { initOrder };
 
@@ -15,17 +15,9 @@ export { initOrder };
  */
 function initOrder(g) {
   var visited = {};
-  var simpleNodes = _.filter(g.nodes(), function (v) {
-    return !g.children(v).length;
-  });
-  var maxRank = _.max(
-    _.map(simpleNodes, function (v) {
-      return g.node(v).rank;
-    })
-  );
-  var layers = _.map(_.range(maxRank + 1), function () {
-    return [];
-  });
+  var simpleNodes = _.filter(g.nodes(), (v) => !g.children(v).length);
+  var maxRank = _.max(_.map(simpleNodes, (v) => g.node(v).rank));
+  var layers = _.map(_.range(maxRank + 1), () => []);
 
   function dfs(v) {
     if (_.has(visited, v)) return;
@@ -35,9 +27,7 @@ function initOrder(g) {
     _.forEach(g.successors(v), dfs);
   }
 
-  var orderedVs = _.sortBy(simpleNodes, function (v) {
-    return g.node(v).rank;
-  });
+  var orderedVs = _.sortBy(simpleNodes, (v) => g.node(v).rank);
   _.forEach(orderedVs, dfs);
 
   return layers;

package/src/dagre/order/resolve-conflicts.js

@@ -1,4 +1,4 @@
-import { _ } from '../../lodash-es/index.ts';
+import { _ } from "../../lodash-es/index.ts";
 
 export { resolveConflicts };
 
@@ -29,7 +29,7 @@ export { resolveConflicts };
  */
 function resolveConflicts(entries, cg) {
   var mappedEntries = {};
-  _.forEach(entries, function (entry, i) {
+  _.forEach(entries, (entry, i) => {
     var tmp = (mappedEntries[entry.v] = {
       indegree: 0,
       in: [],
@@ -45,7 +45,7 @@ function resolveConflicts(entries, cg) {
     }
   });
 
-  _.forEach(cg.edges(), function (e) {
+  _.forEach(cg.edges(), (e) => {
     var entryV = mappedEntries[e.v];
     var entryW = mappedEntries[e.w];
     if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
@@ -54,7 +54,7 @@ function resolveConflicts(entries, cg) {
     }
   });
 
-  var sourceSet = _.filter(mappedEntries, function (entry) {
+  var sourceSet = _.filter(mappedEntries, (entry) => {
     // @ts-expect-error
     return !entry.indegree;
   });
@@ -66,7 +66,7 @@ function doResolveConflicts(sourceSet) {
   var entries = [];
 
   function handleIn(vEntry) {
-    return function (uEntry) {
+    return (uEntry) => {
       if (uEntry.merged) {
         return;
       }
@@ -81,8 +81,8 @@ function doResolveConflicts(sourceSet) {
   }
 
   function handleOut(vEntry) {
-    return function (wEntry) {
-      wEntry['in'].push(vEntry);
+    return (wEntry) => {
+      wEntry.in.push(vEntry);
       if (--wEntry.indegree === 0) {
         sourceSet.push(wEntry);
       }
@@ -92,17 +92,13 @@ function doResolveConflicts(sourceSet) {
   while (sourceSet.length) {
     var entry = sourceSet.pop();
     entries.push(entry);
-    _.forEach(entry['in'].reverse(), handleIn(entry));
+    _.forEach(entry.in.reverse(), handleIn(entry));
     _.forEach(entry.out, handleOut(entry));
   }
 
   return _.map(
-    _.filter(entries, function (entry) {
-      return !entry.merged;
-    }),
-    function (entry) {
-      return _.pick(entry, ['vs', 'i', 'barycenter', 'weight']);
-    }
+    _.filter(entries, (entry) => !entry.merged),
+    (entry) => _.pick(entry, ["vs", "i", "barycenter", "weight"]),
   );
 }
 

package/src/dagre/order/sort-subgraph.d.ts

@@ -2,7 +2,7 @@ export function sortSubgraph(
   g: any,
   v: any,
   cg: any,
-  biasRight: any
+  biasRight: any,
 ): {
   vs: any[];
 };

package/src/dagre/order/sort-subgraph.js

@@ -1,7 +1,7 @@
-import { _ } from '../../lodash-es/index.ts';
-import { barycenter } from './barycenter.js';
-import { resolveConflicts } from './resolve-conflicts.js';
-import { sort } from './sort.js';
+import { _ } from "../../lodash-es/index.ts";
+import { barycenter } from "./barycenter.js";
+import { resolveConflicts } from "./resolve-conflicts.js";
+import { sort } from "./sort.js";
 
 export { sortSubgraph };
 
@@ -13,17 +13,15 @@ function sortSubgraph(g, v, cg, biasRight) {
   var subgraphs = {};
 
   if (bl) {
-    movable = _.filter(movable, function (w) {
-      return w !== bl && w !== br;
-    });
+    movable = _.filter(movable, (w) => w !== bl && w !== br);
   }
 
   var barycenters = barycenter(g, movable);
-  _.forEach(barycenters, function (entry) {
+  _.forEach(barycenters, (entry) => {
     if (g.children(entry.v).length) {
       var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
       subgraphs[entry.v] = subgraphResult;
-      if (_.has(subgraphResult, 'barycenter')) {
+      if (_.has(subgraphResult, "barycenter")) {
         mergeBarycenters(entry, subgraphResult);
       }
     }
@@ -39,12 +37,13 @@ function sortSubgraph(g, v, cg, biasRight) {
     if (g.predecessors(bl).length) {
       var blPred = g.node(g.predecessors(bl)[0]),
         brPred = g.node(g.predecessors(br)[0]);
-      if (!_.has(result, 'barycenter')) {
+      if (!_.has(result, "barycenter")) {
         result.barycenter = 0;
         result.weight = 0;
       }
       result.barycenter =
-        (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+        (result.barycenter * result.weight + blPred.order + brPred.order) /
+        (result.weight + 2);
       result.weight += 2;
     }
   }
@@ -53,14 +52,14 @@ function sortSubgraph(g, v, cg, biasRight) {
 }
 
 function expandSubgraphs(entries, subgraphs) {
-  _.forEach(entries, function (entry) {
+  _.forEach(entries, (entry) => {
     entry.vs = _.flatten(
-      entry.vs.map(function (v) {
+      entry.vs.map((v) => {
         if (subgraphs[v]) {
           return subgraphs[v].vs;
         }
         return v;
-      })
+      }),
     );
   });
 }

package/src/dagre/order/sort.d.ts

@@ -1,6 +1,6 @@
 export function sort(
   entries: any,
-  biasRight: any
+  biasRight: any,
 ): {
   vs: any[];
 };

package/src/dagre/order/sort.js

@@ -1,16 +1,12 @@
-import { _ } from '../../lodash-es/index.ts';
-import * as util from '../util.js';
+import { _ } from "../../lodash-es/index.ts";
+import * as util from "../util.js";
 
 export { sort };
 
 function sort(entries, biasRight) {
-  var parts = util.partition(entries, function (entry) {
-    return _.has(entry, 'barycenter');
-  });
+  var parts = util.partition(entries, (entry) => _.has(entry, "barycenter"));
   var sortable = parts.lhs,
-    unsortable = _.sortBy(parts.rhs, function (entry) {
-      return -entry.i;
-    }),
+    unsortable = _.sortBy(parts.rhs, (entry) => -entry.i),
     vs = [],
     sum = 0,
     weight = 0,
@@ -20,7 +16,7 @@ function sort(entries, biasRight) {
 
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
 
-  _.forEach(sortable, function (entry) {
+  _.forEach(sortable, (entry) => {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
     sum += entry.barycenter * entry.weight;
@@ -47,7 +43,7 @@ function consumeUnsortable(vs, unsortable, index) {
 }
 
 function compareWithBias(bias) {
-  return function (entryV, entryW) {
+  return (entryV, entryW) => {
     if (entryV.barycenter < entryW.barycenter) {
       return -1;
     } else if (entryV.barycenter > entryW.barycenter) {

package/src/dagre/parent-dummy-chains.js

@@ -1,11 +1,11 @@
-import { _ } from '../lodash-es/index.ts';
+import { _ } from "../lodash-es/index.ts";
 
 export { parentDummyChains };
 
 function parentDummyChains(g) {
   var postorderNums = postorder(g);
 
-  _.forEach(g.graph().dummyChains, function (v) {
+  _.forEach(g.graph().dummyChains, (v) => {
     var node = g.node(v);
     var edgeObj = node.edgeObj;
     var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
@@ -19,7 +19,10 @@ function parentDummyChains(g) {
       node = g.node(v);
 
       if (ascending) {
-        while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+        while (
+          (pathV = path[pathIdx]) !== lca &&
+          g.node(pathV).maxRank < node.rank
+        ) {
           pathIdx++;
         }
 
@@ -59,7 +62,10 @@ function findPath(g, postorderNums, v, w) {
   do {
     parent = g.parent(parent);
     vPath.push(parent);
-  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+  } while (
+    parent &&
+    (postorderNums[parent].low > low || lim > postorderNums[parent].lim)
+  );
   lca = parent;
 
   // Traverse from w to LCA

package/src/dagre/position/bk.d.ts

@@ -9,7 +9,7 @@ export function verticalAlignment(
   g: any,
   layering: any,
   conflicts: any,
-  neighborFn: any
+  neighborFn: any,
 ): {
   root: {};
   align: {};
@@ -19,13 +19,13 @@ export function horizontalCompaction(
   layering: any,
   root: any,
   align: any,
-  reverseSep: any
+  reverseSep: any,
 ): {};
 export function alignCoordinates(xss: any, alignTo: any): void;
 export function findSmallestWidthAlignment(g: any, xss: any): any;
 export function balance(
   xss: any,
-  align: any
+  align: any,
 ): {
   [x: string]: any;
 };