xstate 4.7.7 → 4.9.1

package/es/index.js

@@ -1,7 +1,7 @@
 export { matchesState } from './utils.js';
 export { mapState } from './mapState.js';
 export { ActionTypes, SpecialTargets } from './types.js';
-import { raise, send, sendParent, sendUpdate, log, cancel, start, stop, assign, after, done, respond, forwardTo, escalate } from './actions.js';
+import { raise, send, sendParent, sendUpdate, log, cancel, start, stop, assign, after, done, respond, forwardTo, escalate, choose, pure } from './actions.js';
 export { assign, doneInvoke, forwardTo, send, sendParent, sendUpdate } from './actions.js';
 export { State } from './State.js';
 export { StateNode } from './StateNode.js';
@@ -22,6 +22,8 @@ var actions = {
   done: done,
   respond: respond,
   forwardTo: forwardTo,
-  escalate: escalate
+  escalate: escalate,
+  choose: choose,
+  pure: pure
 };
 export { actions };

package/es/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 | State<TContext, TEvent, any, any> | import("./types").StateValueMap | undefined) => Interpreter<TContext, TStateSchema, TEvent, any>;
+    init: (initialState?: string | State<TContext, TEvent, any, any> | import("./types").StateValueMap | 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/es/interpreter.js

@@ -21,9 +21,7 @@ var DEFAULT_SPAWN_OPTIONS = {
  * @private
  */
 
-var withServiceScope =
-/*#__PURE__*/
-function () {
+var withServiceScope = /*#__PURE__*/function () {
   var serviceStack = [];
   return function (service, fn) {
     service && serviceStack.push(service);
@@ -866,6 +864,12 @@ 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);
 
@@ -873,9 +877,7 @@ function () {
       return;
     }
 
-    this.children.delete(childId);
-    this.forwardTo.delete(childId);
-    delete this.state.children[childId];
+    this.removeChild(childId);
 
     if (isFunction(child.stop)) {
       child.stop();
@@ -923,11 +925,6 @@ function () {
       });
     }
 
-    childService.onDone(function (doneEvent) {
-      _this.send(toSCXMLEvent(doneEvent, {
-        origin: childService.id
-      }));
-    }).start();
     var actor = childService;
     this.children.set(childService.id, actor);
 
@@ -935,6 +932,13 @@ function () {
       this.forwardTo.add(childService.id);
     }
 
+    childService.onDone(function (doneEvent) {
+      _this.removeChild(childService.id);
+
+      _this.send(toSCXMLEvent(doneEvent, {
+        origin: childService.id
+      }));
+    }).start();
     return actor;
   };
 
@@ -944,12 +948,16 @@ function () {
     var canceled = false;
     promise.then(function (response) {
       if (!canceled) {
+        _this.removeChild(id);
+
         _this.send(toSCXMLEvent(doneInvoke(id, response), {
           origin: id
         }));
       }
     }, function (errorData) {
       if (!canceled) {
+        _this.removeChild(id);
+
         var errorEvent = error(id, errorData);
 
         try {
@@ -1094,10 +1102,14 @@ function () {
         origin: id
       }));
     }, function (err) {
+      _this.removeChild(id);
+
       _this.send(toSCXMLEvent(error(id, err), {
         origin: id
       }));
     }, function () {
+      _this.removeChild(id);
+
       _this.send(toSCXMLEvent(doneInvoke(id), {
         origin: id
       }));
@@ -1212,9 +1224,7 @@ function () {
    */
 
 
-  Interpreter.defaultOptions =
-  /*#__PURE__*/
-  function (global) {
+  Interpreter.defaultOptions = /*#__PURE__*/function (global) {
     return {
       execute: true,
       deferEvents: true,

package/es/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/es/registry.js

@@ -1,6 +1,4 @@
-var children =
-/*#__PURE__*/
-new Map();
+var children = /*#__PURE__*/new Map();
 var sessionIdIndex = 0;
 var registry = {
   bookId: function () {

package/es/types.d.ts

@@ -50,7 +50,11 @@ export interface AssignMeta<TContext, TEvent extends EventObject> {
     _event: SCXML.Event<TEvent>;
 }
 export declare type ActionFunction<TContext, TEvent extends EventObject> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>) => any | void;
-export declare type Action<TContext, TEvent extends EventObject> = ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent> | RaiseAction<AnyEventObject>;
+export interface ChooseConditon<TContext, TEvent extends EventObject> {
+    cond?: Condition<TContext, TEvent>;
+    actions: Actions<TContext, TEvent>;
+}
+export declare type Action<TContext, TEvent extends EventObject> = ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, AnyEventObject> | RaiseAction<AnyEventObject> | ChooseAction<TContext, TEvent>;
 export declare type Actions<TContext, TEvent extends EventObject> = SingleOrArray<Action<TContext, TEvent>>;
 export declare type StateKey = string | State<any>;
 export interface StateValueMap {
@@ -124,7 +128,7 @@ export declare type InvokeCallback = (callback: Sender<any>, onReceive: Receiver
  * @param context The current machine `context`
  * @param event The event that invoked the service
  */
-export declare type InvokeCreator<TContext, TFinalContext = any> = (context: TContext, event: AnyEventObject) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<any> | InvokeCallback;
+export declare type InvokeCreator<TContext, TEvent = AnyEventObject, TFinalContext = any> = (context: TContext, event: TEvent) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<any> | InvokeCallback;
 export interface InvokeDefinition<TContext, TEvent extends EventObject> extends ActivityDefinition<TContext, TEvent> {
     /**
      * The source of the machine to be invoked, or the machine itself.
@@ -171,21 +175,28 @@ export declare type StatesConfig<TContext, TStateSchema extends StateSchema, TEv
 export declare type StatesDefinition<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
     [K in keyof TStateSchema['states']]: StateNodeDefinition<TContext, TStateSchema['states'][K], TEvent>;
 };
-export declare type TransitionConfigTargetShortcut<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
+export declare type TransitionConfigTarget<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
+export declare type TransitionConfigOrTarget<TContext, TEvent extends EventObject> = SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TEvent>>;
 declare type TransitionsConfigMap<TContext, TEvent extends EventObject> = {
-    [K in TEvent['type'] | NullEvent['type'] | '*']?: SingleOrArray<TransitionConfigTargetShortcut<TContext, TEvent> | (TransitionConfig<TContext, K extends TEvent['type'] ? Extract<TEvent, {
+    [K in TEvent['type']]?: TransitionConfigOrTarget<TContext, TEvent extends {
         type: K;
-    }> : EventObject> & {
-        event?: undefined;
-    })>;
+    } ? TEvent : never>;
+} & {
+    ''?: TransitionConfigOrTarget<TContext, TEvent>;
+} & {
+    '*'?: TransitionConfigOrTarget<TContext, TEvent>;
 };
 declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<{
-    [K in TEvent['type'] | NullEvent['type'] | '*']: TransitionConfig<TContext, K extends TEvent['type'] ? Extract<TEvent, {
+    [K in TEvent['type']]: TransitionConfig<TContext, TEvent extends {
         type: K;
-    }> : EventObject> & {
+    } ? TEvent : never> & {
         event: K;
     };
-}[TEvent['type'] | NullEvent['type'] | '*']>;
+}[TEvent['type']] | (TransitionConfig<TContext, TEvent> & {
+    event: '';
+}) | (TransitionConfig<TContext, TEvent> & {
+    event: '*';
+})>;
 export declare type TransitionsConfig<TContext, TEvent extends EventObject> = TransitionsConfigMap<TContext, TEvent> | TransitionsConfigArray<TContext, TEvent>;
 export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
     /**
@@ -196,7 +207,7 @@ export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
     /**
      * The source of the machine to be invoked, or the machine itself.
      */
-    src: string | StateMachine<any, any, any> | InvokeCreator<any, any>;
+    src: string | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent, any>;
     /**
      * If `true`, events sent to the parent service will be forwarded to the invoked service.
      *
@@ -345,14 +356,15 @@ export interface StateNodeDefinition<TContext, TStateSchema extends StateSchema,
     id: string;
     version: string | undefined;
     key: string;
+    context: TContext;
     type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
     initial: StateNodeConfig<TContext, TStateSchema, TEvent>['initial'];
     history: boolean | 'shallow' | 'deep' | undefined;
     states: StatesDefinition<TContext, TStateSchema, TEvent>;
     on: TransitionDefinitionMap<TContext, TEvent>;
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    onEntry: Array<ActionObject<TContext, TEvent>>;
-    onExit: Array<ActionObject<TContext, TEvent>>;
+    entry: Array<ActionObject<TContext, TEvent>>;
+    exit: Array<ActionObject<TContext, TEvent>>;
     activities: Array<ActivityDefinition<TContext, TEvent>>;
     meta: any;
     order: number;
@@ -478,7 +490,8 @@ export declare enum ActionTypes {
     ErrorPlatform = "error.platform",
     ErrorCustom = "xstate.error",
     Update = "xstate.update",
-    Pure = "xstate.pure"
+    Pure = "xstate.pure",
+    Choose = "xstate.choose"
 }
 export interface RaiseAction<TEvent extends EventObject> {
     type: ActionTypes.Raise;
@@ -576,6 +589,10 @@ export interface PureAction<TContext, TEvent extends EventObject> extends Action
     type: ActionTypes.Pure;
     get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent>> | undefined;
 }
+export interface ChooseAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+    type: ActionTypes.Choose;
+    conds: Array<ChooseConditon<TContext, TEvent>>;
+}
 export interface TransitionDefinition<TContext, TEvent extends EventObject> extends TransitionConfig<TContext, TEvent> {
     target: Array<StateNode<TContext, any, TEvent>> | undefined;
     source: StateNode<TContext, any, TEvent>;

package/es/types.js

@@ -20,6 +20,7 @@ var ActionTypes;
   ActionTypes["ErrorCustom"] = "xstate.error";
   ActionTypes["Update"] = "xstate.update";
   ActionTypes["Pure"] = "xstate.pure";
+  ActionTypes["Choose"] = "xstate.choose";
 })(ActionTypes || (ActionTypes = {}));
 
 var SpecialTargets;

package/es/utils.d.ts

@@ -1,4 +1,4 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Guard, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTargetShortcut, NullEvent, SingleOrArray } from './types';
+import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard } from './types';
 import { StateNode } from './StateNode';
 import { State } from '.';
 import { Actor } from './Actor';
@@ -59,9 +59,10 @@ export declare function isActor(value: any): value is Actor;
 export declare const uniqueId: () => string;
 export declare function toEventObject<TEvent extends EventObject>(event: Event<TEvent>, payload?: EventData): TEvent;
 export declare function toSCXMLEvent<TEvent extends EventObject>(event: Event<TEvent> | SCXML.Event<TEvent>, scxmlEvent?: Partial<SCXML.Event<TEvent>>): SCXML.Event<TEvent>;
-export declare function toTransitionConfigArray<TContext, TEvent extends EventObject>(event: TEvent['type'] | NullEvent['type'] | '*', configLike: SingleOrArray<TransitionConfig<TContext, TEvent> | TransitionConfigTargetShortcut<TContext, TEvent>>): Array<TransitionConfig<TContext, TEvent> & {
+export declare function toTransitionConfigArray<TContext, TEvent extends EventObject>(event: TEvent['type'] | NullEvent['type'] | '*', configLike: SingleOrArray<TransitionConfig<TContext, TEvent> | TransitionConfigTarget<TContext, TEvent>>): Array<TransitionConfig<TContext, TEvent> & {
     event: TEvent['type'] | NullEvent['type'] | '*';
 }>;
 export declare function normalizeTarget<TContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, any, TEvent>> | undefined): Array<string | StateNode<TContext, any, TEvent>> | undefined;
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
+export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -482,9 +482,7 @@ function isObservable(value) {
   }
 }
 
-var symbolObservable =
-/*#__PURE__*/
-function () {
+var symbolObservable = /*#__PURE__*/function () {
   return typeof Symbol === 'function' && Symbol.observable || '@@observable';
 }();
 
@@ -496,9 +494,7 @@ function isMachine(value) {
   }
 }
 
-var uniqueId =
-/*#__PURE__*/
-function () {
+var uniqueId = /*#__PURE__*/function () {
   var currentId = 0;
   return function () {
     currentId++;
@@ -571,4 +567,25 @@ function reportUnhandledExceptionOnInvocation(originalError, currentError, id) {
   }
 }
 
-export { flatten, getEventType, isArray, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };
+function evaluateGuard(machine, guard, context, _event, state) {
+  var guards = machine.options.guards;
+  var guardMeta = {
+    state: state,
+    cond: guard,
+    _event: _event
+  }; // TODO: do not hardcode!
+
+  if (guard.type === 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 '" + machine.id + "'.");
+  }
+
+  return condFn(context, _event.data, guardMeta);
+}
+
+export { evaluateGuard, flatten, getEventType, isArray, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };

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`.

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;
@@ -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,13 @@ 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 });
+        Object.defineProperty(transition, 'toJSON', {
+            value: 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;

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 } 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<import("./types").AnyEventObject> | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, import("./types").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
@@ -126,4 +128,6 @@ export declare function forwardTo<TContext, TEvent extends EventObject>(target:
  * @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 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