xstate 4.7.7 → 4.9.1

package/lib/actions.js

@@ -21,12 +21,29 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var types_1 = require("./types");
 var actionTypes = require("./actionTypes");
 exports.actionTypes = actionTypes;
 var utils_1 = require("./utils");
 var utils_2 = require("./utils");
+var environment_1 = require("./environment");
 exports.initEvent = utils_1.toSCXMLEvent({ type: actionTypes.init });
 function getActionFunction(actionType, actionFunctionMap) {
     return actionFunctionMap
@@ -84,7 +101,9 @@ exports.toActionObjects = function (action, actionFunctionMap) {
         return [];
     }
     var actions = utils_2.isArray(action) ? action : [action];
-    return actions.map(function (subAction) { return toActionObject(subAction, actionFunctionMap); });
+    return actions.map(function (subAction) {
+        return toActionObject(subAction, actionFunctionMap);
+    });
 };
 function toActivityDefinition(action) {
     var actionObject = toActionObject(action);
@@ -366,3 +385,64 @@ function escalate(errorData, options) {
     }, __assign(__assign({}, options), { to: types_1.SpecialTargets.Parent }));
 }
 exports.escalate = escalate;
+function choose(conds) {
+    return {
+        type: types_1.ActionTypes.Choose,
+        conds: conds
+    };
+}
+exports.choose = choose;
+function resolveActions(machine, currentState, currentContext, _event, actions) {
+    var _a = __read(utils_1.partition(actions, function (action) {
+        return action.type === actionTypes.assign;
+    }), 2), assignActions = _a[0], otherActions = _a[1];
+    var updatedContext = assignActions.length
+        ? utils_1.updateContext(currentContext, _event, assignActions, currentState)
+        : currentContext;
+    var resolvedActions = utils_1.flatten(otherActions.map(function (actionObject) {
+        var _a;
+        switch (actionObject.type) {
+            case actionTypes.raise:
+                return resolveRaise(actionObject);
+            case actionTypes.send:
+                var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
+                if (!environment_1.IS_PRODUCTION) {
+                    // warn after resolving as we can create better contextual message here
+                    utils_1.warn(!utils_1.isString(actionObject.delay) ||
+                        typeof sendAction.delay === 'number', 
+                    // tslint:disable-next-line:max-line-length
+                    "No delay reference for delay expression '" + actionObject.delay + "' was found on machine '" + machine.id + "'");
+                }
+                return sendAction;
+            case actionTypes.log:
+                return exports.resolveLog(actionObject, updatedContext, _event);
+            case actionTypes.choose: {
+                var chooseAction = actionObject;
+                var matchedActions = (_a = chooseAction.conds.find(function (condition) {
+                    var guard = utils_1.toGuard(condition.cond, machine.options.guards);
+                    return (!guard ||
+                        utils_1.evaluateGuard(machine, guard, updatedContext, _event, currentState));
+                })) === null || _a === void 0 ? void 0 : _a.actions;
+                if (!matchedActions) {
+                    return [];
+                }
+                var resolved = resolveActions(machine, currentState, updatedContext, _event, exports.toActionObjects(utils_1.toArray(matchedActions)));
+                updatedContext = resolved[1];
+                return resolved[0];
+            }
+            case actionTypes.pure: {
+                var matchedActions = actionObject.get(updatedContext, _event.data);
+                if (!matchedActions) {
+                    return [];
+                }
+                var resolved = resolveActions(machine, currentState, updatedContext, _event, exports.toActionObjects(utils_1.toArray(matchedActions)));
+                updatedContext = resolved[1];
+                return resolved[0];
+            }
+            default:
+                return toActionObject(actionObject, machine.options.actions);
+        }
+    }));
+    return [resolvedActions, updatedContext];
+}
+exports.resolveActions = resolveActions;

package/lib/index.d.ts

@@ -4,7 +4,7 @@ import { StateNode } from './StateNode';
 import { State } from './State';
 import { Machine, createMachine } from './Machine';
 import { Actor } from './Actor';
-import { raise, send, sendParent, sendUpdate, log, start, stop, assign, after, done, respond, doneInvoke, forwardTo, escalate } from './actions';
+import { raise, send, sendParent, sendUpdate, log, start, stop, assign, after, done, respond, doneInvoke, forwardTo, escalate, choose, pure } from './actions';
 import { interpret, Interpreter, spawn } from './interpreter';
 import { matchState } from './match';
 declare const actions: {
@@ -22,6 +22,8 @@ declare const actions: {
     respond: typeof respond;
     forwardTo: typeof forwardTo;
     escalate: typeof escalate;
+    choose: typeof choose;
+    pure: typeof pure;
 };
 export { Actor, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, matchState, spawn, doneInvoke, createMachine };
 export * from './types';

package/lib/index.js

@@ -41,7 +41,9 @@ var actions = {
     done: actions_1.done,
     respond: actions_1.respond,
     forwardTo: actions_1.forwardTo,
-    escalate: actions_1.escalate
+    escalate: actions_1.escalate,
+    choose: actions_1.choose,
+    pure: actions_1.pure
 };
 exports.actions = actions;
 __export(require("./types"));

package/lib/interpreter.d.ts

@@ -64,7 +64,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      */
     constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>);
     get initialState(): State<TContext, TEvent>;
-    get state(): State<TContext, TEvent>;
+    get state(): State<TContext, TEvent, any, TTypestate>;
     static interpret: typeof interpret;
     /**
      * Executes the actions of the given state, with that state's `context` and `event`.
@@ -110,12 +110,12 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     /**
      * Alias for Interpreter.prototype.start
      */
-    init: (initialState?: string | import("./types").StateValueMap | State<TContext, TEvent, any, any> | undefined) => Interpreter<TContext, TStateSchema, TEvent, any>;
+    init: (initialState?: string | import("./types").StateValueMap | State<TContext, TEvent, any, any> | undefined) => Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Starts the interpreter from the given state, or the initial state.
      * @param initialState The state to start the statechart from
      */
-    start(initialState?: State<TContext, TEvent> | StateValue): Interpreter<TContext, TStateSchema, TEvent>;
+    start(initialState?: State<TContext, TEvent> | StateValue): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      *
@@ -152,6 +152,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     private defer;
     private cancel;
     private exec;
+    private removeChild;
     private stopChild;
     spawn(entity: Spawnable, name: string, options?: SpawnOptions): Actor;
     spawnMachine<TChildContext, TChildStateSchema, TChildEvent extends EventObject>(machine: StateMachine<TChildContext, TChildStateSchema, TChildEvent>, options?: {

package/lib/interpreter.js

@@ -763,14 +763,17 @@ var Interpreter = /** @class */ (function () {
         }
         return undefined;
     };
+    Interpreter.prototype.removeChild = function (childId) {
+        this.children.delete(childId);
+        this.forwardTo.delete(childId);
+        delete this.state.children[childId];
+    };
     Interpreter.prototype.stopChild = function (childId) {
         var child = this.children.get(childId);
         if (!child) {
             return;
         }
-        this.children.delete(childId);
-        this.forwardTo.delete(childId);
-        delete this.state.children[childId];
+        this.removeChild(childId);
         if (utils_1.isFunction(child.stop)) {
             child.stop();
         }
@@ -808,16 +811,17 @@ var Interpreter = /** @class */ (function () {
                 });
             });
         }
-        childService
-            .onDone(function (doneEvent) {
-            _this.send(utils_1.toSCXMLEvent(doneEvent, { origin: childService.id }));
-        })
-            .start();
         var actor = childService;
         this.children.set(childService.id, actor);
         if (resolvedOptions.autoForward) {
             this.forwardTo.add(childService.id);
         }
+        childService
+            .onDone(function (doneEvent) {
+            _this.removeChild(childService.id);
+            _this.send(utils_1.toSCXMLEvent(doneEvent, { origin: childService.id }));
+        })
+            .start();
         return actor;
     };
     Interpreter.prototype.spawnPromise = function (promise, id) {
@@ -825,10 +829,12 @@ var Interpreter = /** @class */ (function () {
         var canceled = false;
         promise.then(function (response) {
             if (!canceled) {
+                _this.removeChild(id);
                 _this.send(utils_1.toSCXMLEvent(actions_1.doneInvoke(id, response), { origin: id }));
             }
         }, function (errorData) {
             if (!canceled) {
+                _this.removeChild(id);
                 var errorEvent = actions_1.error(id, errorData);
                 try {
                     // Send "error.platform.id" to this (parent).
@@ -938,8 +944,10 @@ var Interpreter = /** @class */ (function () {
         var subscription = source.subscribe(function (value) {
             _this.send(utils_1.toSCXMLEvent(value, { origin: id }));
         }, function (err) {
+            _this.removeChild(id);
             _this.send(utils_1.toSCXMLEvent(actions_1.error(id, err), { origin: id }));
         }, function () {
+            _this.removeChild(id);
             _this.send(utils_1.toSCXMLEvent(actions_1.doneInvoke(id), { origin: id }));
         });
         var actor = {

package/lib/json.d.ts

@@ -0,0 +1,31 @@
+import { StateNode, ActionObject, Guard, InvokeDefinition } from './';
+interface JSONFunction {
+    $function: string;
+}
+export declare function stringifyFunction(fn: Function): JSONFunction;
+interface TransitionConfig {
+    target: string[];
+    source: string;
+    actions: Array<ActionObject<any, any>>;
+    cond: Guard<any, any> | undefined;
+    eventType: string;
+}
+interface StateNodeConfig {
+    type: StateNode['type'];
+    id: string;
+    key: string;
+    initial?: string;
+    entry: Array<ActionObject<any, any>>;
+    exit: Array<ActionObject<any, any>>;
+    on: {
+        [key: string]: TransitionConfig[];
+    };
+    invoke: Array<InvokeDefinition<any, any>>;
+    states: Record<string, StateNodeConfig>;
+}
+export declare function machineToJSON(stateNode: StateNode): StateNodeConfig;
+export declare function stringify(machine: StateNode): string;
+export declare function parse(machineString: string): StateNodeConfig;
+export declare function jsonify<T extends Record<string, any>>(value: T): T;
+export {};
+//# sourceMappingURL=json.d.ts.map

package/lib/json.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("./utils");
+// tslint:disable-next-line:ban-types
+function stringifyFunction(fn) {
+    return {
+        $function: fn.toString()
+    };
+}
+exports.stringifyFunction = stringifyFunction;
+function getStateNodeId(stateNode) {
+    return "#" + stateNode.id;
+}
+// derive config from machine
+function machineToJSON(stateNode) {
+    var config = {
+        type: stateNode.type,
+        initial: stateNode.initial === undefined ? undefined : String(stateNode.initial),
+        id: stateNode.id,
+        key: stateNode.key,
+        entry: stateNode.onEntry,
+        exit: stateNode.onExit,
+        on: utils_1.mapValues(stateNode.on, function (transition) {
+            return transition.map(function (t) {
+                return {
+                    target: t.target ? t.target.map(getStateNodeId) : [],
+                    source: getStateNodeId(t.source),
+                    actions: t.actions,
+                    cond: t.cond,
+                    eventType: t.eventType
+                };
+            });
+        }),
+        invoke: stateNode.invoke,
+        states: {}
+    };
+    Object.values(stateNode.states).forEach(function (sn) {
+        config.states[sn.key] = machineToJSON(sn);
+    });
+    return config;
+}
+exports.machineToJSON = machineToJSON;
+function stringify(machine) {
+    return JSON.stringify(machineToJSON(machine), function (_, value) {
+        if (utils_1.isFunction(value)) {
+            return { $function: value.toString() };
+        }
+        return value;
+    });
+}
+exports.stringify = stringify;
+function parse(machineString) {
+    var config = JSON.parse(machineString, function (_, value) {
+        if (typeof value === 'object' && '$function' in value) {
+            return new Function(value.value);
+        }
+        return value;
+    });
+    return config;
+}
+exports.parse = parse;
+function jsonify(value) {
+    Object.defineProperty(value, 'toJSON', {
+        value: function () {
+            return utils_1.mapValues(value, function (subValue) {
+                if (utils_1.isFunction(subValue)) {
+                    return stringifyFunction(subValue);
+                }
+                else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
+                    // mostly for assignments
+                    return utils_1.mapValues(subValue, function (subSubValue) {
+                        if (utils_1.isFunction(subSubValue)) {
+                            return stringifyFunction(subSubValue);
+                        }
+                        return subSubValue;
+                    });
+                }
+                return subValue;
+            });
+        }
+    });
+    return value;
+}
+exports.jsonify = jsonify;

package/lib/scxml.js

@@ -30,6 +30,17 @@ var __spread = (this && this.__spread) || function () {
     for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
     return ar;
 };
+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 });
 var xml_js_1 = require("xml-js");
 var index_1 = require("./index");
@@ -103,60 +114,128 @@ var evaluateExecutableContent = function (context, _ev, meta, body) {
     var fn = new (Function.bind.apply(Function, __spread([void 0], args, [fnBody])))();
     return fn(context, meta._event);
 };
-function mapActions(elements) {
-    return elements.map(function (element) {
-        switch (element.name) {
-            case 'raise':
-                return actions.raise(element.attributes
-                    .event);
-            case 'assign':
-                return actions.assign(function (context, e, meta) {
-                    var fnBody = "\n            return {'" + element.attributes.location + "': " + element.attributes.expr + "};\n          ";
-                    return evaluateExecutableContent(context, e, meta, fnBody);
-                });
-            case 'send':
-                var _a = element.attributes, event_1 = _a.event, eventexpr_1 = _a.eventexpr, target = _a.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 "" + acc + child.attributes.name + ":" + child.attributes.expr + ",\n";
-                    }, '');
-                if (event_1 && !params_1) {
-                    convertedEvent = event_1;
-                }
-                else {
-                    convertedEvent = function (context, _ev, meta) {
-                        var fnBody = "\n              return { type: " + (event_1 ? "\"" + event_1 + "\"" : eventexpr_1) + ", " + (params_1 ? params_1 : '') + " }\n            ";
-                        return evaluateExecutableContent(context, _ev, meta, fnBody);
-                    };
-                }
-                if ('delay' in element.attributes) {
-                    convertedDelay = delayToMs(element.attributes.delay);
+function createCond(cond) {
+    return function (context, _event, meta) {
+        return evaluateExecutableContent(context, _event, meta, "return " + 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 {'" + element.attributes.location + "': " + 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 "" + acc + child.attributes.name + ":" + child.attributes.expr + ",\n";
+                }, '');
+            if (event_1 && !params_1) {
+                convertedEvent = event_1;
+            }
+            else {
+                convertedEvent = function (context, _ev, meta) {
+                    var fnBody = "\n              return { type: " + (event_1 ? "\"" + event_1 + "\"" : eventexpr_1) + ", " + (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 (" + delayToMs + ")(" + 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 " + 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;
+                    }
                 }
-                else if (element.attributes.delayexpr) {
-                    convertedDelay = function (context, _ev, meta) {
-                        var fnBody = "\n              return (" + delayToMs + ")(" + element.attributes.delayexpr + ");\n            ";
-                        return evaluateExecutableContent(context, _ev, meta, fnBody);
-                    };
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                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 " + element.attributes.expr + ";\n            ";
-                    return evaluateExecutableContent(context, e, meta, fnBody);
-                }, label !== undefined ? String(label) : undefined);
-            default:
-                return { type: 'not-implemented' };
+                finally { if (e_1) throw e_1.error; }
+            }
+            conds.push(current);
+            return actions.choose(conds);
         }
-    });
+        default:
+            throw new Error("Conversion of \"" + 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';
@@ -212,10 +291,7 @@ function toConfig(nodeJson, id, options) {
             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: function (context, _event, meta) {
-                        var fnBody = "\n                      return " + value.attributes.cond + ";\n                    ";
-                        return evaluateExecutableContent(context, _event, meta, fnBody);
-                    }
+                    cond: createCond(value.attributes.cond)
                 }
                 : undefined)), { internal: internal });
         });
@@ -226,8 +302,7 @@ function toConfig(nodeJson, id, options) {
             ? mapActions(onExitElement.elements)
             : undefined;
         var invoke = invokeElements.map(function (element) {
-            if (!['scxml', 'http://www.w3.org/TR/scxml/'].includes(element.attributes
-                .type)) {
+            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'; });