xstate 4.7.8 → 4.10.0

package/lib/State.js

@@ -97,6 +97,7 @@ var State = /** @class */ (function () {
      * @param configuration
      */
     function State(config) {
+        var _this = this;
         this.actions = [];
         this.activities = constants_1.EMPTY_ACTIVITY_MAP;
         this.meta = {};
@@ -120,7 +121,7 @@ var State = /** @class */ (function () {
         this.done = !!config.done;
         Object.defineProperty(this, 'nextEvents', {
             get: function () {
-                return stateUtils_1.nextEvents(config.configuration);
+                return stateUtils_1.nextEvents(_this.configuration);
             }
         });
     }

package/lib/StateNode.d.ts

@@ -125,7 +125,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * @param options Options (actions, guards, activities, services) to recursively merge with the existing options.
      * @param context Custom context (will override predefined context)
      */
-    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext | undefined): StateNode<TContext, TStateSchema, TEvent>;
+    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext | undefined): StateNode<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Clones this state machine with custom context.
      *
@@ -182,7 +182,6 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * this state node, it does not escape.
      */
     private escapes;
-    private evaluateGuard;
     private getActions;
     /**
      * Determines the next state given the current `state` and sent `event`.
@@ -191,7 +190,10 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * @param event The event that was sent at the current state
      * @param context The current context (extended state) of the current state
      */
-    transition(state: string | StateValueMap | State<TContext, TEvent, any, any> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>, context?: TContext): State<TContext, TEvent, TStateSchema, TTypestate>;
+    transition(state: string | StateValueMap | State<TContext, TEvent, any, {
+        value: any;
+        context: TContext;
+    }> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>, context?: TContext): State<TContext, TEvent, TStateSchema, TTypestate>;
     private resolveRaisedTransition;
     private resolveTransition;
     /**

package/lib/StateNode.js

@@ -191,9 +191,7 @@ var StateNode = /** @class */ (function () {
         // TODO: deprecate (entry)
         this.onEntry = utils_1.toArray(this.config.entry || this.config.onEntry).map(function (action) { return actions_1.toActionObject(action); });
         // TODO: deprecate (exit)
-        this.onExit = utils_1.toArray(this.config.exit || this.config.onExit).map(function (action) {
-            return actions_1.toActionObject(action);
-        });
+        this.onExit = utils_1.toArray(this.config.exit || this.config.onExit).map(function (action) { return actions_1.toActionObject(action); });
         this.meta = this.config.meta;
         this.data =
             this.type === 'final'
@@ -263,14 +261,15 @@ var StateNode = /** @class */ (function () {
                 id: this.id,
                 key: this.key,
                 version: this.version,
+                context: this.context,
                 type: this.type,
                 initial: this.initial,
                 history: this.history,
                 states: utils_1.mapValues(this.states, function (state) { return state.definition; }),
                 on: this.on,
                 transitions: this.transitions,
-                onEntry: this.onEntry,
-                onExit: this.onExit,
+                entry: this.onEntry,
+                exit: this.onExit,
                 activities: this.activities || [],
                 meta: this.meta,
                 order: this.order || -1,
@@ -514,12 +513,11 @@ var StateNode = /** @class */ (function () {
                 var guardPassed = false;
                 try {
                     guardPassed =
-                        !cond || this.evaluateGuard(cond, resolvedContext, _event, state);
+                        !cond ||
+                            utils_1.evaluateGuard(this.machine, cond, resolvedContext, _event, state);
                 }
                 catch (err) {
-                    throw new Error("Unable to evaluate guard '" + (cond.name ||
-                        cond
-                            .type) + "' in transition for event '" + eventName + "' in state node '" + this.id + "':\n" + err.message);
+                    throw new Error("Unable to evaluate guard '" + (cond.name || cond.type) + "' in transition for event '" + eventName + "' in state node '" + this.id + "':\n" + err.message);
                 }
                 if (guardPassed && isInState) {
                     if (candidate.target !== undefined) {
@@ -597,23 +595,6 @@ var StateNode = /** @class */ (function () {
         }
         return true;
     };
-    StateNode.prototype.evaluateGuard = function (guard, context, _event, state) {
-        var guards = this.machine.options.guards;
-        var guardMeta = {
-            state: state,
-            cond: guard,
-            _event: _event
-        };
-        // TODO: do not hardcode!
-        if (guard.type === constants_1.DEFAULT_GUARD_TYPE) {
-            return guard.predicate(context, _event.data, guardMeta);
-        }
-        var condFn = guards[guard.type];
-        if (!condFn) {
-            throw new Error("Guard '" + guard.type + "' is not implemented on machine '" + this.machine.id + "'.");
-        }
-        return condFn(context, _event.data, guardMeta);
-    };
     StateNode.prototype.getActions = function (transition, currentContext, _event, prevState) {
         var e_4, _a, e_5, _b;
         var prevConfig = stateUtils_1.getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);
@@ -661,16 +642,17 @@ var StateNode = /** @class */ (function () {
                 return events;
             }
             var parent = sn.parent;
+            if (!parent.parent) {
+                return events;
+            }
             events.push(actions_1.done(sn.id, sn.data), // TODO: deprecate - final states should not emit done events for their own state.
             actions_1.done(parent.id, sn.data ? utils_1.mapContext(sn.data, currentContext, _event) : undefined));
-            if (parent.parent) {
-                var grandparent = parent.parent;
-                if (grandparent.type === 'parallel') {
-                    if (stateUtils_1.getChildren(grandparent).every(function (parentNode) {
-                        return stateUtils_1.isInFinalState(transition.configuration, parentNode);
-                    })) {
-                        events.push(actions_1.done(grandparent.id, grandparent.data));
-                    }
+            var grandparent = parent.parent;
+            if (grandparent.type === 'parallel') {
+                if (stateUtils_1.getChildren(grandparent).every(function (parentNode) {
+                    return stateUtils_1.isInFinalState(transition.configuration, parentNode);
+                })) {
+                    events.push(actions_1.done(grandparent.id, grandparent.data));
                 }
             }
             return events;
@@ -747,7 +729,6 @@ var StateNode = /** @class */ (function () {
     };
     StateNode.prototype.resolveTransition = function (stateTransition, currentState, _event, context) {
         var e_6, _a;
-        var _this = this;
         if (_event === void 0) { _event = actions_1.initEvent; }
         if (context === void 0) { context = this.machine.context; }
         var configuration = stateTransition.configuration;
@@ -772,10 +753,10 @@ var StateNode = /** @class */ (function () {
             for (var actions_2 = __values(actions), actions_2_1 = actions_2.next(); !actions_2_1.done; actions_2_1 = actions_2.next()) {
                 var action = actions_2_1.value;
                 if (action.type === actionTypes.start) {
-                    activities[action.activity.type] = action;
+                    activities[action.activity.id || action.activity.type] = action;
                 }
                 else if (action.type === actionTypes.stop) {
-                    activities[action.activity.type] = false;
+                    activities[action.activity.id || action.activity.type] = false;
                 }
             }
         }
@@ -786,34 +767,7 @@ var StateNode = /** @class */ (function () {
             }
             finally { if (e_6) throw e_6.error; }
         }
-        var _b = __read(utils_1.partition(actions, function (action) {
-            return action.type === actionTypes.assign;
-        }), 2), assignActions = _b[0], otherActions = _b[1];
-        var updatedContext = assignActions.length
-            ? utils_1.updateContext(currentContext, _event, assignActions, currentState)
-            : currentContext;
-        var resolvedActions = utils_1.flatten(otherActions.map(function (actionObject) {
-            switch (actionObject.type) {
-                case actionTypes.raise:
-                    return actions_1.resolveRaise(actionObject);
-                case actionTypes.send:
-                    var sendAction = actions_1.resolveSend(actionObject, updatedContext, _event, _this.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 '" + _this.machine.id + "'");
-                    }
-                    return sendAction;
-                case actionTypes.log:
-                    return actions_1.resolveLog(actionObject, updatedContext, _event);
-                case actionTypes.pure:
-                    return (actionObject.get(updatedContext, _event.data) || []);
-                default:
-                    return actions_1.toActionObject(actionObject, _this.options.actions);
-            }
-        }));
+        var _b = __read(actions_1.resolveActions(this, currentState, currentContext, _event, actions), 2), resolvedActions = _b[0], updatedContext = _b[1];
         var _c = __read(utils_1.partition(resolvedActions, function (action) {
             return action.type === actionTypes.raise ||
                 (action.type === actionTypes.send &&
@@ -875,8 +829,8 @@ var StateNode = /** @class */ (function () {
             children: children,
             done: isDone
         });
-        nextState.changed =
-            _event.name === actionTypes.update || !!assignActions.length;
+        var didUpdateContext = currentContext !== updatedContext;
+        nextState.changed = _event.name === actionTypes.update || didUpdateContext;
         // Dispose of penultimate histories to prevent memory leaks
         var history = nextState.history;
         if (history) {
@@ -903,7 +857,7 @@ var StateNode = /** @class */ (function () {
         var changed = maybeNextState.changed ||
             (history
                 ? !!maybeNextState.actions.length ||
-                    !!assignActions.length ||
+                    didUpdateContext ||
                     typeof history.value !== typeof maybeNextState.value ||
                     !State_1.stateValuesEqual(maybeNextState.value, history.value)
                 : undefined);
@@ -1326,7 +1280,10 @@ var StateNode = /** @class */ (function () {
                 : true;
         var guards = this.machine.options.guards;
         var target = this.resolveTarget(normalizedTarget);
-        return __assign(__assign({}, transitionConfig), { actions: actions_1.toActionObjects(utils_1.toArray(transitionConfig.actions)), cond: utils_1.toGuard(transitionConfig.cond, guards), target: target, source: this, internal: internal, eventType: transitionConfig.event });
+        var transition = __assign(__assign({}, transitionConfig), { actions: actions_1.toActionObjects(utils_1.toArray(transitionConfig.actions)), cond: utils_1.toGuard(transitionConfig.cond, guards), target: target, source: this, internal: internal, eventType: transitionConfig.event, toJSON: function () { return (__assign(__assign({}, transition), { target: transition.target
+                    ? transition.target.map(function (t) { return "#" + t.id; })
+                    : undefined, source: "#{this.id}" })); } });
+        return transition;
     };
     StateNode.prototype.formatTransitions = function () {
         var e_9, _a;
@@ -1353,6 +1310,9 @@ var StateNode = /** @class */ (function () {
         var doneConfig = this.config.onDone
             ? utils_1.toTransitionConfigArray(String(actions_1.done(this.id)), this.config.onDone)
             : [];
+        if (!environment_1.IS_PRODUCTION) {
+            utils_1.warn(!(this.config.onDone && !this.parent), "Root nodes cannot have an \".onDone\" transition. Please check the config of \"" + this.id + "\".");
+        }
         var invokeConfig = utils_1.flatten(this.invoke.map(function (invokeDef) {
             var settleTransitions = [];
             if (invokeDef.onDone) {

package/lib/actionTypes.d.ts

@@ -15,5 +15,6 @@ export declare const errorExecution = ActionTypes.ErrorExecution;
 export declare const errorPlatform = ActionTypes.ErrorPlatform;
 export declare const error = ActionTypes.ErrorCustom;
 export declare const update = ActionTypes.Update;
+export declare const choose = ActionTypes.Choose;
 export declare const pure = ActionTypes.Pure;
 //# sourceMappingURL=actionTypes.d.ts.map

package/lib/actionTypes.js

@@ -18,4 +18,5 @@ exports.errorExecution = types_1.ActionTypes.ErrorExecution;
 exports.errorPlatform = types_1.ActionTypes.ErrorPlatform;
 exports.error = types_1.ActionTypes.ErrorCustom;
 exports.update = types_1.ActionTypes.Update;
+exports.choose = types_1.ActionTypes.Choose;
 exports.pure = types_1.ActionTypes.Pure;

package/lib/actions.d.ts

@@ -1,12 +1,14 @@
-import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta } from './types';
+import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseConditon, ChooseAction, AnyEventObject } from './types';
 import * as actionTypes from './actionTypes';
+import { State } from './State';
+import { StateNode } from './StateNode';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
-    type: ActionTypes.Init;
+    type: ActionTypes;
 }>;
 export declare function getActionFunction<TContext, TEvent extends EventObject>(actionType: ActionType, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | undefined;
 export declare function toActionObject<TContext, TEvent extends EventObject>(action: Action<TContext, TEvent>, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): ActionObject<TContext, TEvent>;
-export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: string | RaiseAction<import("./types").AnyEventObject> | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent> | Action<TContext, TEvent>[] | undefined, actionFunctionMap?: Record<string, ActionFunction<TContext, TEvent> | ActionObject<TContext, TEvent>> | undefined) => ActionObject<TContext, TEvent>[];
+export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: string | RaiseAction<AnyEventObject> | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent, AnyEventObject> | ChooseAction<TContext, TEvent> | Action<TContext, TEvent>[] | undefined, actionFunctionMap?: Record<string, ActionFunction<TContext, TEvent> | ActionObject<TContext, TEvent>> | undefined) => ActionObject<TContext, TEvent>[];
 export declare function toActivityDefinition<TContext, TEvent extends EventObject>(action: string | ActivityDefinition<TContext, TEvent>): ActivityDefinition<TContext, TEvent>;
 /**
  * Raises an event. This places the event in the internal event queue, so that
@@ -14,7 +16,7 @@ export declare function toActivityDefinition<TContext, TEvent extends EventObjec
  *
  * @param eventType The event to raise.
  */
-export declare function raise<TContext, TEvent extends EventObject>(event: Event<TEvent>): RaiseAction<TEvent> | SendAction<TContext, TEvent>;
+export declare function raise<TContext, TEvent extends EventObject>(event: Event<TEvent>): RaiseAction<TEvent> | SendAction<TContext, TEvent, TEvent>;
 export declare function resolveRaise<TEvent extends EventObject>(action: RaiseAction<TEvent>): RaiseActionObject<TEvent>;
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
@@ -26,26 +28,28 @@ export declare function resolveRaise<TEvent extends EventObject>(action: RaiseAc
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-export declare function send<TContext, TEvent extends EventObject>(event: Event<TEvent> | SendExpr<TContext, TEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent>;
-export declare function resolveSend<TContext, TEvent extends EventObject>(action: SendAction<TContext, TEvent>, ctx: TContext, _event: SCXML.Event<TEvent>, delaysMap?: DelayFunctionMap<TContext, TEvent>): SendActionObject<TContext, TEvent>;
+export declare function send<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<TSentEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, TSentEvent>;
+export declare function resolveSend<TContext, TEvent extends EventObject, TSentEvent extends EventObject>(action: SendAction<TContext, TEvent, TSentEvent>, ctx: TContext, _event: SCXML.Event<TEvent>, delaysMap?: DelayFunctionMap<TContext, TEvent>): SendActionObject<TContext, TEvent, TSentEvent>;
 /**
  * Sends an event to this machine's parent.
  *
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext, TEvent extends EventObject>(event: Event<any> | SendExpr<TContext, TEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent>;
+export declare function sendParent<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<TSentEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, TSentEvent>;
 /**
  * Sends an update event to this machine's parent.
  */
-export declare function sendUpdate<TContext, TEvent extends EventObject>(): SendAction<TContext, TEvent>;
+export declare function sendUpdate<TContext, TEvent extends EventObject>(): SendAction<TContext, TEvent, {
+    type: ActionTypes.Update;
+}>;
 /**
  * Sends an event back to the sender of the original event.
  *
  * @param event The event to send back to the sender
  * @param options Options to pass into the send event
  */
-export declare function respond<TContext, TEvent extends EventObject>(event: Event<TEvent> | SendExpr<TContext, TEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent>;
+export declare function respond<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<TEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, AnyEventObject>;
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -117,7 +121,7 @@ export declare function pure<TContext, TEvent extends EventObject>(getActions: (
  * @param target The target service to forward the event to.
  * @param options Options to pass into the send action creator.
  */
-export declare function forwardTo<TContext, TEvent extends EventObject>(target: Required<SendActionOptions<TContext, TEvent>>['to'], options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent>;
+export declare function forwardTo<TContext, TEvent extends EventObject>(target: Required<SendActionOptions<TContext, TEvent>>['to'], options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, AnyEventObject>;
 /**
  * Escalates an error by sending it as an event to this machine's parent.
  *
@@ -125,5 +129,7 @@ export declare function forwardTo<TContext, TEvent extends EventObject>(target:
  * takes in the `context`, `event`, and `meta`, and returns the error data to send.
  * @param options Options to pass into the send action creator.
  */
-export declare function escalate<TContext, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent>;
+export declare function escalate<TContext, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, AnyEventObject>;
+export declare function choose<TContext, TEvent extends EventObject>(conds: Array<ChooseConditon<TContext, TEvent>>): ChooseAction<TContext, TEvent>;
+export declare function resolveActions<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent>, currentState: State<TContext, TEvent> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actions: Array<ActionObject<TContext, TEvent>>): [Array<ActionObject<TContext, TEvent>>, TContext];
 //# sourceMappingURL=actions.d.ts.map

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), machine.options.actions));
+                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), machine.options.actions));
+                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

@@ -1,7 +1,7 @@
 import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, DoneEvent, Unsubscribable, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate } from './types';
 import { State } from './State';
 import { Actor } from './Actor';
-export declare type StateListener<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext> = any> = (state: State<TContext, TEvent, any, TTypestate>, event: TEvent) => void;
+export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = any> = (state: State<TContext, TEvent, TStateSchema, TTypestate>, event: TEvent) => void;
 export declare type ContextListener<TContext = DefaultContext> = (context: TContext, prevContext: TContext | undefined) => void;
 export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export declare type Listener = () => void;
@@ -14,7 +14,7 @@ interface SpawnOptions {
     autoForward?: boolean;
     sync?: boolean;
 }
-export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = any> implements Actor<State<TContext, TEvent>, TEvent> {
+export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = any> implements Actor<State<TContext, TEvent, TStateSchema, TTypestate>, TEvent> {
     machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * The default interpreter options:
@@ -63,8 +63,8 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param options Interpreter options
      */
     constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>);
-    get initialState(): State<TContext, TEvent>;
-    get state(): State<TContext, TEvent>;
+    get initialState(): State<TContext, TEvent, TStateSchema, TTypestate>;
+    get state(): State<TContext, TEvent, TStateSchema, TTypestate>;
     static interpret: typeof interpret;
     /**
      * Executes the actions of the given state, with that state's `context` and `event`.
@@ -72,9 +72,9 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param state The state whose actions will be executed
      * @param actionsConfig The action implementations to use
      */
-    execute(state: State<TContext, TEvent>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
+    execute(state: State<TContext, TEvent, TStateSchema, TTypestate>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
     private update;
-    onTransition(listener: StateListener<TContext, TEvent, TTypestate>): this;
+    onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate>): this;
     subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate>>): Unsubscribable;
     subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Unsubscribable;
     /**
@@ -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, TStateSchema, TTypestate> | 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, TStateSchema, TTypestate> | StateValue): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      *
@@ -131,14 +131,14 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event(s) to send
      */
-    send: (event: TEvent | TEvent["type"] | Event<TEvent>[] | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, any, any>;
+    send: (event: TEvent | TEvent["type"] | Event<TEvent>[] | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate>;
     private batch;
     /**
      * Returns a send function bound to this interpreter instance.
      *
      * @param event The event to be sent by the sender.
      */
-    sender(event: Event<TEvent>): () => State<TContext, TEvent>;
+    sender(event: Event<TEvent>): () => State<TContext, TEvent, TStateSchema, TTypestate>;
     private sendTo;
     /**
      * Returns the next state given the interpreter's current state and the event.
@@ -147,11 +147,12 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event to determine the next state
      */
-    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent>;
+    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate>;
     private forward;
     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

@@ -636,8 +636,10 @@ var Interpreter = /** @class */ (function () {
         delete this.delayedEventsMap[sendId];
     };
     Interpreter.prototype.exec = function (action, state, actionFunctionMap) {
+        if (actionFunctionMap === void 0) { actionFunctionMap = this.machine
+            .options.actions; }
         var context = state.context, _event = state._event;
-        var actionOrExec = actions_1.getActionFunction(action.type, actionFunctionMap) || action.exec;
+        var actionOrExec = action.exec || actions_1.getActionFunction(action.type, actionFunctionMap);
         var exec = utils_1.isFunction(actionOrExec)
             ? actionOrExec
             : actionOrExec
@@ -686,7 +688,7 @@ var Interpreter = /** @class */ (function () {
                 // If the activity will be stopped right after it's started
                 // (such as in transient states)
                 // don't bother starting the activity.
-                if (!this.state.activities[activity.type]) {
+                if (!this.state.activities[activity.id || activity.type]) {
                     break;
                 }
                 // Invoked services
@@ -763,14 +765,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 +813,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 +831,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 +946,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 = {