xstate 4.35.2 → 5.0.0-alpha.1

package/lib/scxml.js

@@ -1,350 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toMachine = void 0;
-var xml_js_1 = require("xml-js");
-var index_1 = require("./index");
-var utils_1 = require("./utils");
-var actions = require("./actions");
-function getAttribute(element, attribute) {
-    return element.attributes ? element.attributes[attribute] : undefined;
-}
-function indexedRecord(items, identifier) {
-    var record = {};
-    var identifierFn = (0, utils_1.isString)(identifier)
-        ? function (item) { return item[identifier]; }
-        : identifier;
-    items.forEach(function (item) {
-        var key = identifierFn(item);
-        record[key] = item;
-    });
-    return record;
-}
-function executableContent(elements) {
-    var transition = {
-        actions: mapActions(elements)
-    };
-    return transition;
-}
-function getTargets(targetAttr) {
-    // return targetAttr ? [`#${targetAttr}`] : undefined;
-    return targetAttr
-        ? "".concat(targetAttr).split(/\s+/).map(function (target) { return "#".concat(target); })
-        : undefined;
-}
-function delayToMs(delay) {
-    if (!delay) {
-        return undefined;
-    }
-    if (typeof delay === 'number') {
-        return delay;
-    }
-    var millisecondsMatch = delay.match(/(\d+)ms/);
-    if (millisecondsMatch) {
-        return parseInt(millisecondsMatch[1], 10);
-    }
-    var secondsMatch = delay.match(/(\d*)(\.?)(\d+)s/);
-    if (secondsMatch) {
-        var hasDecimal = !!secondsMatch[2];
-        if (!hasDecimal) {
-            return parseInt(secondsMatch[3], 10) * 1000;
-        }
-        var secondsPart = !!secondsMatch[1]
-            ? parseInt(secondsMatch[1], 10) * 1000
-            : 0;
-        var millisecondsPart = parseInt(secondsMatch[3].padEnd(3, '0'), 10);
-        if (millisecondsPart >= 1000) {
-            throw new Error("Can't parse \"".concat(delay, " delay.\""));
-        }
-        return secondsPart + millisecondsPart;
-    }
-    throw new Error("Can't parse \"".concat(delay, " delay.\""));
-}
-var evaluateExecutableContent = function (context, _ev, meta, body) {
-    var datamodel = context
-        ? Object.keys(context)
-            .map(function (key) { return "const ".concat(key, " = context['").concat(key, "'];"); })
-            .join('\n')
-        : '';
-    var scope = ['const _sessionid = "NOT_IMPLEMENTED";', datamodel]
-        .filter(Boolean)
-        .join('\n');
-    var args = ['context', '_event'];
-    var fnBody = "\n    ".concat(scope, "\n    ").concat(body, "\n  ");
-    var fn = new (Function.bind.apply(Function, __spreadArray(__spreadArray([void 0], __read(args), false), [fnBody], false)))();
-    return fn(context, meta._event);
-};
-function createCond(cond) {
-    return function (context, _event, meta) {
-        return evaluateExecutableContent(context, _event, meta, "return ".concat(cond, ";"));
-    };
-}
-function mapAction(element) {
-    var e_1, _a;
-    switch (element.name) {
-        case 'raise': {
-            return actions.raise(element.attributes.event);
-        }
-        case 'assign': {
-            return actions.assign(function (context, e, meta) {
-                var fnBody = "\n            return {'".concat(element.attributes.location, "': ").concat(element.attributes.expr, "};\n          ");
-                return evaluateExecutableContent(context, e, meta, fnBody);
-            });
-        }
-        case 'send': {
-            var _b = element.attributes, event_1 = _b.event, eventexpr_1 = _b.eventexpr, target = _b.target;
-            var convertedEvent = void 0;
-            var convertedDelay = void 0;
-            var params_1 = element.elements &&
-                element.elements.reduce(function (acc, child) {
-                    if (child.name === 'content') {
-                        throw new Error('Conversion of <content/> inside <send/> not implemented.');
-                    }
-                    return "".concat(acc).concat(child.attributes.name, ":").concat(child.attributes.expr, ",\n");
-                }, '');
-            if (event_1 && !params_1) {
-                convertedEvent = event_1;
-            }
-            else {
-                convertedEvent = function (context, _ev, meta) {
-                    var fnBody = "\n              return { type: ".concat(event_1 ? "\"".concat(event_1, "\"") : eventexpr_1, ", ").concat(params_1 ? params_1 : '', " }\n            ");
-                    return evaluateExecutableContent(context, _ev, meta, fnBody);
-                };
-            }
-            if ('delay' in element.attributes) {
-                convertedDelay = delayToMs(element.attributes.delay);
-            }
-            else if (element.attributes.delayexpr) {
-                convertedDelay = function (context, _ev, meta) {
-                    var fnBody = "\n              return (".concat(delayToMs, ")(").concat(element.attributes.delayexpr, ");\n            ");
-                    return evaluateExecutableContent(context, _ev, meta, fnBody);
-                };
-            }
-            return actions.send(convertedEvent, {
-                delay: convertedDelay,
-                to: target
-            });
-        }
-        case 'log': {
-            var label = element.attributes.label;
-            return actions.log(function (context, e, meta) {
-                var fnBody = "\n              return ".concat(element.attributes.expr, ";\n            ");
-                return evaluateExecutableContent(context, e, meta, fnBody);
-            }, label !== undefined ? String(label) : undefined);
-        }
-        case 'if': {
-            var conds = [];
-            var current = {
-                cond: createCond(element.attributes.cond),
-                actions: []
-            };
-            try {
-                for (var _c = __values(element.elements), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var el = _d.value;
-                    if (el.type === 'comment') {
-                        continue;
-                    }
-                    switch (el.name) {
-                        case 'elseif':
-                            conds.push(current);
-                            current = {
-                                cond: createCond(el.attributes.cond),
-                                actions: []
-                            };
-                            break;
-                        case 'else':
-                            conds.push(current);
-                            current = { actions: [] };
-                            break;
-                        default:
-                            current.actions.push(mapAction(el));
-                            break;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            conds.push(current);
-            return actions.choose(conds);
-        }
-        default:
-            throw new Error("Conversion of \"".concat(element.name, "\" elements is not implemented yet."));
-    }
-}
-function mapActions(elements) {
-    var e_2, _a;
-    var mapped = [];
-    try {
-        for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
-            var element = elements_1_1.value;
-            if (element.type === 'comment') {
-                continue;
-            }
-            mapped.push(mapAction(element));
-        }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
-        }
-        finally { if (e_2) throw e_2.error; }
-    }
-    return mapped;
-}
-function toConfig(nodeJson, id, options) {
-    var parallel = nodeJson.name === 'parallel';
-    var initial = parallel ? undefined : nodeJson.attributes.initial;
-    var elements = nodeJson.elements;
-    switch (nodeJson.name) {
-        case 'history': {
-            if (!elements) {
-                return {
-                    id: id,
-                    history: nodeJson.attributes.type || 'shallow'
-                };
-            }
-            var _a = __read(elements.filter(function (element) { return element.name === 'transition'; }), 1), transitionElement = _a[0];
-            var target = getAttribute(transitionElement, 'target');
-            var history_1 = getAttribute(nodeJson, 'type') || 'shallow';
-            return {
-                id: id,
-                history: history_1,
-                target: target ? "#".concat(target) : undefined
-            };
-        }
-        case 'final': {
-            return __assign(__assign({}, nodeJson.attributes), { type: 'final' });
-        }
-        default:
-            break;
-    }
-    if (nodeJson.elements) {
-        var stateElements = nodeJson.elements.filter(function (element) {
-            return element.name === 'state' ||
-                element.name === 'parallel' ||
-                element.name === 'final' ||
-                element.name === 'history';
-        });
-        var transitionElements = nodeJson.elements.filter(function (element) { return element.name === 'transition'; });
-        var invokeElements = nodeJson.elements.filter(function (element) { return element.name === 'invoke'; });
-        var onEntryElement = nodeJson.elements.find(function (element) { return element.name === 'onentry'; });
-        var onExitElement = nodeJson.elements.find(function (element) { return element.name === 'onexit'; });
-        var states = indexedRecord(stateElements, function (item) { return "".concat(item.attributes.id); });
-        var initialElement = !initial
-            ? nodeJson.elements.find(function (element) { return element.name === 'initial'; })
-            : undefined;
-        if (initialElement && initialElement.elements.length) {
-            initial = initialElement.elements.find(function (element) { return element.name === 'transition'; }).attributes.target;
-        }
-        else if (!initialElement && stateElements.length) {
-            initial = stateElements[0].attributes.id;
-        }
-        var on = transitionElements.map(function (value) {
-            var event = getAttribute(value, 'event') || '';
-            var targets = getAttribute(value, 'target');
-            var internal = getAttribute(value, 'type') === 'internal';
-            return __assign(__assign(__assign({ event: event, target: getTargets(targets) }, (value.elements ? executableContent(value.elements) : undefined)), (value.attributes && value.attributes.cond
-                ? {
-                    cond: createCond(value.attributes.cond)
-                }
-                : undefined)), { internal: internal });
-        });
-        var onEntry = onEntryElement
-            ? mapActions(onEntryElement.elements)
-            : undefined;
-        var onExit = onExitElement
-            ? mapActions(onExitElement.elements)
-            : undefined;
-        var invoke = invokeElements.map(function (element) {
-            if (!['scxml', 'http://www.w3.org/TR/scxml/'].includes(element.attributes.type)) {
-                throw new Error('Currently only converting invoke elements of type SCXML is supported.');
-            }
-            var content = element.elements.find(function (el) { return el.name === 'content'; });
-            return scxmlToMachine(content, options);
-        });
-        return __assign(__assign(__assign(__assign(__assign(__assign(__assign({ id: id }, (initial ? { initial: initial } : undefined)), (parallel ? { type: 'parallel' } : undefined)), (stateElements.length
-            ? {
-                states: (0, utils_1.mapValues)(states, function (state, key) {
-                    return toConfig(state, key, options);
-                })
-            }
-            : undefined)), (transitionElements.length ? { on: on } : undefined)), (onEntry ? { onEntry: onEntry } : undefined)), (onExit ? { onExit: onExit } : undefined)), (invoke.length ? { invoke: invoke } : undefined));
-    }
-    return { id: id };
-}
-function scxmlToMachine(scxmlJson, options) {
-    var machineElement = scxmlJson.elements.find(function (element) { return element.name === 'scxml'; });
-    var dataModelEl = machineElement.elements.filter(function (element) { return element.name === 'datamodel'; })[0];
-    var extState = dataModelEl
-        ? dataModelEl
-            .elements.filter(function (element) { return element.name === 'data'; })
-            .reduce(function (acc, element) {
-            if (element.attributes.src) {
-                throw new Error("Conversion of `src` attribute on datamodel's <data> elements is not supported.");
-            }
-            acc[element.attributes.id] = element.attributes.expr
-                ? // tslint:disable-next-line:no-eval
-                    eval("(".concat(element.attributes.expr, ")"))
-                : undefined;
-            return acc;
-        }, {})
-        : undefined;
-    return (0, index_1.Machine)(__assign(__assign({}, toConfig(machineElement, '(machine)', options)), { context: extState, delimiter: options.delimiter }));
-}
-function toMachine(xml, options) {
-    var json = (0, xml_js_1.xml2js)(xml);
-    return scxmlToMachine(json, options);
-}
-exports.toMachine = toMachine;

package/lib/serviceScope.d.ts

@@ -1,4 +0,0 @@
-import { AnyInterpreter } from './types';
-export declare const provide: <T, TService extends AnyInterpreter>(service: TService | undefined, fn: (service: TService | undefined) => T) => T;
-export declare const consume: <T, TService extends AnyInterpreter>(fn: (service: TService) => T) => T;
-//# sourceMappingURL=serviceScope.d.ts.map

package/lib/serviceScope.js

@@ -1,21 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/**
- * Maintains a stack of the current service in scope.
- * This is used to provide the correct service to spawn().
- */
-var serviceStack = [];
-var provide = function (service, fn) {
-  serviceStack.push(service);
-  var result = fn(service);
-  serviceStack.pop();
-  return result;
-};
-var consume = function (fn) {
-  return fn(serviceStack[serviceStack.length - 1]);
-};
-
-exports.consume = consume;
-exports.provide = provide;

package/lib/stateUtils.d.ts

@@ -1,18 +0,0 @@
-import { EventObject, StateValue } from './types';
-import { StateNode } from './StateNode';
-declare type Configuration<TC, TE extends EventObject> = Iterable<StateNode<TC, any, TE>>;
-declare type AdjList<TC, TE extends EventObject> = Map<StateNode<TC, any, TE>, Array<StateNode<TC, any, TE>>>;
-export declare const isLeafNode: (stateNode: StateNode<any, any, any, any, any, any>) => boolean;
-export declare function getAllChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
-export declare function getChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
-export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any, any>): Array<StateNode<TC, any, TE, any, any, any>>;
-export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>): Set<StateNode<TC, any, TE, any, any, any>>;
-export declare function getAdjList<TC, TE extends EventObject>(configuration: Configuration<TC, TE>): AdjList<TC, TE>;
-export declare function getValue<TC, TE extends EventObject>(rootNode: StateNode<TC, any, TE, any>, configuration: Configuration<TC, TE>): StateValue;
-export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
-export declare function nextEvents<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE>>): Array<TE['type']>;
-export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any, any, any>>, stateNode: StateNode<TC, any, TE, any, any, any>): boolean;
-export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
-export declare function getTagsFromConfiguration(configuration: StateNode<any, any, any, any>[]): Set<string>;
-export {};
-//# sourceMappingURL=stateUtils.d.ts.map

package/lib/stateUtils.js

@@ -1,277 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _tslib = require('./_virtual/_tslib.js');
-var utils = require('./utils.js');
-
-var isLeafNode = function (stateNode) {
-  return stateNode.type === 'atomic' || stateNode.type === 'final';
-};
-function getAllChildren(stateNode) {
-  return Object.keys(stateNode.states).map(function (key) {
-    return stateNode.states[key];
-  });
-}
-function getChildren(stateNode) {
-  return getAllChildren(stateNode).filter(function (sn) {
-    return sn.type !== 'history';
-  });
-}
-function getAllStateNodes(stateNode) {
-  var stateNodes = [stateNode];
-
-  if (isLeafNode(stateNode)) {
-    return stateNodes;
-  }
-
-  return stateNodes.concat(utils.flatten(getChildren(stateNode).map(getAllStateNodes)));
-}
-function getConfiguration(prevStateNodes, stateNodes) {
-  var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
-
-  var prevConfiguration = new Set(prevStateNodes);
-  var prevAdjList = getAdjList(prevConfiguration);
-  var configuration = new Set(stateNodes);
-
-  try {
-    // add all ancestors
-    for (var configuration_1 = _tslib.__values(configuration), configuration_1_1 = configuration_1.next(); !configuration_1_1.done; configuration_1_1 = configuration_1.next()) {
-      var s = configuration_1_1.value;
-      var m = s.parent;
-
-      while (m && !configuration.has(m)) {
-        configuration.add(m);
-        m = m.parent;
-      }
-    }
-  } catch (e_1_1) {
-    e_1 = {
-      error: e_1_1
-    };
-  } finally {
-    try {
-      if (configuration_1_1 && !configuration_1_1.done && (_a = configuration_1.return)) _a.call(configuration_1);
-    } finally {
-      if (e_1) throw e_1.error;
-    }
-  }
-
-  var adjList = getAdjList(configuration);
-
-  try {
-    // add descendants
-    for (var configuration_2 = _tslib.__values(configuration), configuration_2_1 = configuration_2.next(); !configuration_2_1.done; configuration_2_1 = configuration_2.next()) {
-      var s = configuration_2_1.value; // if previously active, add existing child nodes
-
-      if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-        if (prevAdjList.get(s)) {
-          prevAdjList.get(s).forEach(function (sn) {
-            return configuration.add(sn);
-          });
-        } else {
-          s.initialStateNodes.forEach(function (sn) {
-            return configuration.add(sn);
-          });
-        }
-      } else {
-        if (s.type === 'parallel') {
-          try {
-            for (var _e = (e_3 = void 0, _tslib.__values(getChildren(s))), _f = _e.next(); !_f.done; _f = _e.next()) {
-              var child = _f.value;
-
-              if (!configuration.has(child)) {
-                configuration.add(child);
-
-                if (prevAdjList.get(child)) {
-                  prevAdjList.get(child).forEach(function (sn) {
-                    return configuration.add(sn);
-                  });
-                } else {
-                  child.initialStateNodes.forEach(function (sn) {
-                    return configuration.add(sn);
-                  });
-                }
-              }
-            }
-          } catch (e_3_1) {
-            e_3 = {
-              error: e_3_1
-            };
-          } finally {
-            try {
-              if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
-            } finally {
-              if (e_3) throw e_3.error;
-            }
-          }
-        }
-      }
-    }
-  } catch (e_2_1) {
-    e_2 = {
-      error: e_2_1
-    };
-  } finally {
-    try {
-      if (configuration_2_1 && !configuration_2_1.done && (_b = configuration_2.return)) _b.call(configuration_2);
-    } finally {
-      if (e_2) throw e_2.error;
-    }
-  }
-
-  try {
-    // add all ancestors
-    for (var configuration_3 = _tslib.__values(configuration), configuration_3_1 = configuration_3.next(); !configuration_3_1.done; configuration_3_1 = configuration_3.next()) {
-      var s = configuration_3_1.value;
-      var m = s.parent;
-
-      while (m && !configuration.has(m)) {
-        configuration.add(m);
-        m = m.parent;
-      }
-    }
-  } catch (e_4_1) {
-    e_4 = {
-      error: e_4_1
-    };
-  } finally {
-    try {
-      if (configuration_3_1 && !configuration_3_1.done && (_d = configuration_3.return)) _d.call(configuration_3);
-    } finally {
-      if (e_4) throw e_4.error;
-    }
-  }
-
-  return configuration;
-}
-
-function getValueFromAdj(baseNode, adjList) {
-  var childStateNodes = adjList.get(baseNode);
-
-  if (!childStateNodes) {
-    return {}; // todo: fix?
-  }
-
-  if (baseNode.type === 'compound') {
-    var childStateNode = childStateNodes[0];
-
-    if (childStateNode) {
-      if (isLeafNode(childStateNode)) {
-        return childStateNode.key;
-      }
-    } else {
-      return {};
-    }
-  }
-
-  var stateValue = {};
-  childStateNodes.forEach(function (csn) {
-    stateValue[csn.key] = getValueFromAdj(csn, adjList);
-  });
-  return stateValue;
-}
-
-function getAdjList(configuration) {
-  var e_5, _a;
-
-  var adjList = new Map();
-
-  try {
-    for (var configuration_4 = _tslib.__values(configuration), configuration_4_1 = configuration_4.next(); !configuration_4_1.done; configuration_4_1 = configuration_4.next()) {
-      var s = configuration_4_1.value;
-
-      if (!adjList.has(s)) {
-        adjList.set(s, []);
-      }
-
-      if (s.parent) {
-        if (!adjList.has(s.parent)) {
-          adjList.set(s.parent, []);
-        }
-
-        adjList.get(s.parent).push(s);
-      }
-    }
-  } catch (e_5_1) {
-    e_5 = {
-      error: e_5_1
-    };
-  } finally {
-    try {
-      if (configuration_4_1 && !configuration_4_1.done && (_a = configuration_4.return)) _a.call(configuration_4);
-    } finally {
-      if (e_5) throw e_5.error;
-    }
-  }
-
-  return adjList;
-}
-function getValue(rootNode, configuration) {
-  var config = getConfiguration([rootNode], configuration);
-  return getValueFromAdj(rootNode, getAdjList(config));
-}
-function has(iterable, item) {
-  if (Array.isArray(iterable)) {
-    return iterable.some(function (member) {
-      return member === item;
-    });
-  }
-
-  if (iterable instanceof Set) {
-    return iterable.has(item);
-  }
-
-  return false; // TODO: fix
-}
-function nextEvents(configuration) {
-  return _tslib.__spreadArray([], _tslib.__read(new Set(utils.flatten(_tslib.__spreadArray([], _tslib.__read(configuration.map(function (sn) {
-    return sn.ownEvents;
-  })), false)))), false);
-}
-function isInFinalState(configuration, stateNode) {
-  if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(function (s) {
-      return s.type === 'final' && has(configuration, s);
-    });
-  }
-
-  if (stateNode.type === 'parallel') {
-    return getChildren(stateNode).every(function (sn) {
-      return isInFinalState(configuration, sn);
-    });
-  }
-
-  return false;
-}
-function getMeta(configuration) {
-  if (configuration === void 0) {
-    configuration = [];
-  }
-
-  return configuration.reduce(function (acc, stateNode) {
-    if (stateNode.meta !== undefined) {
-      acc[stateNode.id] = stateNode.meta;
-    }
-
-    return acc;
-  }, {});
-}
-function getTagsFromConfiguration(configuration) {
-  return new Set(utils.flatten(configuration.map(function (sn) {
-    return sn.tags;
-  })));
-}
-
-exports.getAdjList = getAdjList;
-exports.getAllChildren = getAllChildren;
-exports.getAllStateNodes = getAllStateNodes;
-exports.getChildren = getChildren;
-exports.getConfiguration = getConfiguration;
-exports.getMeta = getMeta;
-exports.getTagsFromConfiguration = getTagsFromConfiguration;
-exports.getValue = getValue;
-exports.has = has;
-exports.isInFinalState = isInFinalState;
-exports.isLeafNode = isLeafNode;
-exports.nextEvents = nextEvents;

package/lib/typegenTypes.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });