xstate 4.7.8 → 4.10.0

package/es/actions.js

@@ -1,10 +1,9 @@
-import { __assign, __rest } from './_virtual/_tslib.js';
-import { toSCXMLEvent, isFunction, toEventObject, getEventType, isString, isArray } from './utils.js';
+import { __assign, __read, __rest } from './_virtual/_tslib.js';
+import { IS_PRODUCTION } from './environment.js';
+import { toSCXMLEvent, isFunction, toEventObject, getEventType, isString, partition, updateContext, flatten, toArray, toGuard, evaluateGuard, warn, isArray } from './utils.js';
 import { SpecialTargets, ActionTypes } from './types.js';
-import { send as send$1, update, assign as assign$1, raise as raise$1, init, log as log$1, cancel as cancel$1, error as error$1 } from './actionTypes.js';
-var initEvent =
-/*#__PURE__*/
-toSCXMLEvent({
+import { send as send$1, update, assign as assign$1, init, raise as raise$1, log as log$1, cancel as cancel$1, error as error$1, pure as pure$1, choose as choose$1 } from './actionTypes.js';
+var initEvent = /*#__PURE__*/toSCXMLEvent({
   type: init
 });
 
@@ -361,6 +360,13 @@ function error(id, data) {
 
   return eventObject;
 }
+
+function pure(getActions) {
+  return {
+    type: ActionTypes.Pure,
+    get: getActions
+  };
+}
 /**
  * Forwards (sends) an event to a specified service.
  *
@@ -396,4 +402,77 @@ function escalate(errorData, options) {
   }));
 }
 
-export { after, assign, cancel, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, log, raise, resolveLog, resolveRaise, resolveSend, respond, send, sendParent, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };
+function choose(conds) {
+  return {
+    type: ActionTypes.Choose,
+    conds: conds
+  };
+}
+
+function resolveActions(machine, currentState, currentContext, _event, actions) {
+  var _a = __read(partition(actions, function (action) {
+    return action.type === assign$1;
+  }), 2),
+      assignActions = _a[0],
+      otherActions = _a[1];
+
+  var updatedContext = assignActions.length ? updateContext(currentContext, _event, assignActions, currentState) : currentContext;
+  var resolvedActions = flatten(otherActions.map(function (actionObject) {
+    var _a;
+
+    switch (actionObject.type) {
+      case raise$1:
+        return resolveRaise(actionObject);
+
+      case send$1:
+        var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
+
+        if (!IS_PRODUCTION) {
+          // warn after resolving as we can create better contextual message here
+          warn(!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 log$1:
+        return resolveLog(actionObject, updatedContext, _event);
+
+      case choose$1:
+        {
+          var chooseAction = actionObject;
+          var matchedActions = (_a = chooseAction.conds.find(function (condition) {
+            var guard = toGuard(condition.cond, machine.options.guards);
+            return !guard || evaluateGuard(machine, guard, updatedContext, _event, currentState);
+          })) === null || _a === void 0 ? void 0 : _a.actions;
+
+          if (!matchedActions) {
+            return [];
+          }
+
+          var resolved = resolveActions(machine, currentState, updatedContext, _event, toActionObjects(toArray(matchedActions), machine.options.actions));
+          updatedContext = resolved[1];
+          return resolved[0];
+        }
+
+      case pure$1:
+        {
+          var matchedActions = actionObject.get(updatedContext, _event.data);
+
+          if (!matchedActions) {
+            return [];
+          }
+
+          var resolved = resolveActions(machine, currentState, updatedContext, _event, toActionObjects(toArray(matchedActions), machine.options.actions));
+          updatedContext = resolved[1];
+          return resolved[0];
+        }
+
+      default:
+        return toActionObject(actionObject, machine.options.actions);
+    }
+  }));
+  return [resolvedActions, updatedContext];
+}
+
+export { after, assign, cancel, choose, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, log, pure, raise, resolveActions, resolveLog, resolveRaise, resolveSend, respond, send, sendParent, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };

package/es/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/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

@@ -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 | State<TContext, TEvent, any, any> | import("./types").StateValueMap | undefined) => Interpreter<TContext, TStateSchema, TEvent, any>;
+    init: (initialState?: string | State<TContext, TEvent, TStateSchema, TTypestate> | 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, 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/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);
@@ -738,9 +736,13 @@ function () {
   };
 
   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 = getActionFunction(action.type, actionFunctionMap) || action.exec;
+    var actionOrExec = action.exec || getActionFunction(action.type, actionFunctionMap);
     var exec = isFunction(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;
 
     if (exec) {
@@ -789,7 +791,7 @@ function () {
           // (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
 
@@ -866,6 +868,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 +881,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 +929,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 +936,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 +952,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 +1106,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 +1228,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, TEvent, 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 {
@@ -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> = {
     /**
@@ -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;
@@ -528,22 +541,22 @@ export interface LogAction<TContext, TEvent extends EventObject> extends ActionO
 export interface LogActionObject<TContext, TEvent extends EventObject> extends LogAction<TContext, TEvent> {
     value: any;
 }
-export interface SendAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface SendAction<TContext, TEvent extends EventObject, TSentEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     to: string | number | Actor | ExprWithMeta<TContext, TEvent, string | number | Actor> | undefined;
-    event: TEvent | SendExpr<TContext, TEvent>;
+    event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>;
     delay?: number | string | DelayExpr<TContext, TEvent>;
     id: string | number;
 }
-export interface SendActionObject<TContext, TEvent extends EventObject> extends SendAction<TContext, TEvent> {
+export interface SendActionObject<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> extends SendAction<TContext, TEvent, TSentEvent> {
     to: string | number | Actor | undefined;
-    _event: SCXML.Event<TEvent>;
-    event: TEvent;
+    _event: SCXML.Event<TSentEvent>;
+    event: TSentEvent;
     delay?: number;
     id: string | number;
 }
 export declare type Expr<TContext, TEvent extends EventObject, T> = (context: TContext, event: TEvent) => T;
 export declare type ExprWithMeta<TContext, TEvent extends EventObject, T> = (context: TContext, event: TEvent, meta: SCXMLEventMeta<TEvent>) => T;
-export declare type SendExpr<TContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, TEvent>;
+export declare type SendExpr<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> = ExprWithMeta<TContext, TEvent, TSentEvent>;
 export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
@@ -576,12 +589,23 @@ 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>;
     actions: Array<ActionObject<TContext, TEvent>>;
     cond?: Guard<TContext, TEvent>;
     eventType: TEvent['type'] | NullEvent['type'] | '*';
+    toJSON: () => {
+        target: string[] | undefined;
+        source: string;
+        actions: Array<ActionObject<TContext, TEvent>>;
+        cond?: Guard<TContext, TEvent>;
+        eventType: TEvent['type'] | NullEvent['type'] | '*';
+    };
 }
 export declare type TransitionDefinitionMap<TContext, TEvent extends EventObject> = {
     [K in TEvent['type'] | NullEvent['type'] | '*']: Array<TransitionDefinition<TContext, K extends TEvent['type'] ? Extract<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/Machine.d.ts

@@ -1,5 +1,8 @@
 import { StateMachine, MachineOptions, DefaultContext, MachineConfig, StateSchema, EventObject, AnyEventObject, Typestate } from './types';
 export declare function Machine<TContext = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>, initialContext?: TContext): StateMachine<TContext, any, TEvent>;
 export declare function Machine<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TStateSchema, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>, initialContext?: TContext): StateMachine<TContext, TStateSchema, TEvent>;
-export declare function createMachine<TContext, TEvent extends EventObject = AnyEventObject, TTypestate extends Typestate<TContext> = any>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
+export declare function createMachine<TContext, TEvent extends EventObject = AnyEventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
 //# sourceMappingURL=Machine.d.ts.map

package/lib/State.d.ts

@@ -2,9 +2,12 @@ import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, Event
 import { StateNode } from './StateNode';
 import { Actor } from './Actor';
 export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
-export declare function isState<TContext, TEvent extends EventObject>(state: object | string): state is State<TContext, TEvent>;
+export declare function isState<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = any>(state: object | string): state is State<TContext, TEvent, TStateSchema, TTypestate>;
 export declare function bindActionToState<TC, TE extends EventObject>(action: ActionObject<TC, TE>, state: State<TC, TE>): ActionObject<TC, TE>;
-export declare class State<TContext, TEvent extends EventObject = EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = any> {
+export declare class State<TContext, TEvent extends EventObject = EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}> {
     value: StateValue;
     context: TContext;
     historyValue?: HistoryValue | undefined;
@@ -86,8 +89,10 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * Whether the current state value is a subset of the given parent state value.
      * @param parentStateValue
      */
-    matches<TSV extends TTypestate['value']>(parentStateValue: TSV): this is TTypestate extends {
+    matches<TSV extends TTypestate['value']>(parentStateValue: TSV): this is State<(TTypestate extends {
+        value: TSV;
+    } ? TTypestate : never)['context'], TEvent, TStateSchema, TTypestate> & {
         value: TSV;
-    } ? State<TTypestate['context'], TEvent, TStateSchema, TTypestate> : never;
+    };
 }
 //# sourceMappingURL=State.d.ts.map