xstate 4.32.0 → 4.33.1

package/es/stateUtils.d.ts

@@ -3,6 +3,7 @@ import { StateNode } from './StateNode';
 declare type Configuration<TC, TE extends EventObject> = Iterable<StateNode<TC, any, TE>>;
 declare type AdjList<TC, TE extends EventObject> = Map<StateNode<TC, any, TE>, Array<StateNode<TC, any, TE>>>;
 export declare const isLeafNode: (stateNode: StateNode<any, any, any, any, any, any>) => boolean;
+export declare function getAllChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
 export declare function getChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
 export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any, any>): Array<StateNode<TC, any, TE, any, any, any>>;
 export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any, any>>): Set<StateNode<TC, any, TE, any, any, any>>;

package/es/stateUtils.js

@@ -4,10 +4,13 @@ import { flatten } from './utils.js';
 var isLeafNode = function (stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final';
 };
-function getChildren(stateNode) {
+function getAllChildren(stateNode) {
   return Object.keys(stateNode.states).map(function (key) {
     return stateNode.states[key];
-  }).filter(function (sn) {
+  });
+}
+function getChildren(stateNode) {
+  return getAllChildren(stateNode).filter(function (sn) {
     return sn.type !== 'history';
   });
 }
@@ -256,4 +259,4 @@ function getTagsFromConfiguration(configuration) {
   })));
 }
 
-export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getMeta, getTagsFromConfiguration, getValue, has, isInFinalState, isLeafNode, nextEvents };
+export { getAdjList, getAllChildren, getAllStateNodes, getChildren, getConfiguration, getMeta, getTagsFromConfiguration, getValue, has, isInFinalState, isLeafNode, nextEvents };

package/es/types.d.ts

@@ -422,6 +422,12 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      * @default false
      */
     preserveActionOrder?: boolean;
+    /**
+     * Whether XState calls actions with the event directly responsible for the related transition.
+     *
+     * @default false
+     */
+    predictableActionArguments?: boolean;
     /**
      * A text description of the state node
      */
@@ -856,6 +862,9 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
      */
     activities?: ActivityMap;
     meta?: any;
+    /**
+     * @deprecated
+     */
     events?: TEvent[];
     configuration: Array<StateNode<TContext, any, TEvent>>;
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
@@ -1018,7 +1027,7 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
     initialState: TEmitted;
     start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
 }
-export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
+export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends Interpreter<infer _, infer __, infer ___, infer ____, infer _____> ? R['initialState'] : R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
 declare type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ___, infer ____, infer _____, infer ______> ? TEvent : R extends Model<infer _, infer TEvent, infer __, infer ___> ? TEvent : R extends State<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ___, infer ____> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export declare type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
 export declare type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____, infer _____, infer ______> ? TContext : R extends Model<infer TContext, infer _, infer __, infer ___> ? TContext : R extends State<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends Interpreter<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : never : never;
@@ -1027,5 +1036,6 @@ declare type Matches<TypegenEnabledArg, TypegenDisabledArg> = {
     (stateValue: TypegenDisabledArg): any;
 };
 export declare type StateValueFrom<TMachine extends AnyStateMachine> = StateFrom<TMachine>['matches'] extends Matches<infer TypegenEnabledArg, infer TypegenDisabledArg> ? TMachine['__TResolvedTypesMeta'] extends TypegenEnabled ? TypegenEnabledArg : TypegenDisabledArg : never;
+export declare type PredictableActionArgumentsExec = (action: ActionObject<unknown, EventObject>, context: unknown, _event: SCXML.Event<EventObject>) => void;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/es/utils.d.ts

@@ -67,6 +67,6 @@ export declare function normalizeTarget<TContext, TEvent extends EventObject>(ta
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
 export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, any>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
 export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
-export declare function toObserver<T>(nextHandler: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
+export declare function toObserver<T>(nextHandler?: Partial<Observer<T>> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;
 //# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -605,18 +605,14 @@ function toInvokeSource(src) {
   return src;
 }
 function toObserver(nextHandler, errorHandler, completionHandler) {
-  if (typeof nextHandler === 'object') {
-    return nextHandler;
-  }
-
-  var noop = function () {
-    return void 0;
-  };
+  var noop = function () {};
 
+  var isObserver = typeof nextHandler === 'object';
+  var self = isObserver ? nextHandler : null;
   return {
-    next: nextHandler,
-    error: errorHandler || noop,
-    complete: completionHandler || noop
+    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
+    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
+    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
   };
 }
 function createInvokeId(stateNodeId, index) {

package/lib/Machine.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var StateNode = require('./StateNode.js');
+var environment = require('./environment.js');
 
+var warned = false;
 function Machine(config, options, initialContext) {
   if (initialContext === void 0) {
     initialContext = config.context;
@@ -12,6 +14,11 @@ function Machine(config, options, initialContext) {
   return new StateNode.StateNode(config, options, initialContext);
 }
 function createMachine(config, options) {
+  if (!environment.IS_PRODUCTION && !config.predictableActionArguments && !warned) {
+    warned = true;
+    console.warn('It is highly recommended to set `predictableActionArguments` to `true` when using `createMachine`. https://xstate.js.org/docs/guides/actions.html');
+  }
+
   return new StateNode.StateNode(config, options);
 }
 

package/lib/State.d.ts

@@ -1,4 +1,4 @@
-import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, EventType, StateConfig, SCXML, StateSchema, TransitionDefinition, Typestate, ActorRef, StateMachine, SimpleEventsOf } from './types';
+import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, StateConfig, SCXML, StateSchema, TransitionDefinition, Typestate, ActorRef, StateMachine, SimpleEventsOf } from './types';
 import { StateNode } from './StateNode';
 import { TypegenDisabled, TypegenEnabled } from './typegenTypes';
 import { BaseActionObject, Prop } from './types';
@@ -44,7 +44,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
     /**
      * The next events that will cause a transition from the current state.
      */
-    nextEvents: EventType[];
+    nextEvents: Array<TEvent['type']>;
     /**
      * The transition definitions that resulted in this state.
      */

package/lib/StateNode.d.ts

@@ -1,4 +1,4 @@
-import { Event, StateValue, StateTransition, MachineOptions, EventObject, HistoryValue, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, ActivityDefinition, StateNodeConfig, StateSchema, StateNodesConfig, InvokeDefinition, ActionObject, Mapper, PropertyMapper, SCXML, Typestate, TransitionDefinitionMap, MachineSchema, InternalMachineOptions, ServiceMap, StateConfig } from './types';
+import { Event, StateValue, StateTransition, MachineOptions, EventObject, HistoryValue, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, ActivityDefinition, StateNodeConfig, StateSchema, StateNodesConfig, InvokeDefinition, ActionObject, Mapper, PropertyMapper, SCXML, Typestate, TransitionDefinitionMap, MachineSchema, InternalMachineOptions, ServiceMap, StateConfig, PredictableActionArgumentsExec } from './types';
 import { State } from './State';
 import { TypegenDisabled } from './typegenTypes';
 declare class StateNode<TContext = any, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
@@ -189,12 +189,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     private _transition;
     getTransitionData(state: State<TContext, TEvent, any, any, any>, event: Event<TEvent> | SCXML.Event<TEvent>): StateTransition<TContext, TEvent> | undefined;
     private next;
-    private nodesFromChild;
-    /**
-     * Whether the given state node "escapes" this state node. If the `stateNode` is equal to or the parent of
-     * this state node, it does not escape.
-     */
-    private escapes;
+    private getExternalReentryNodes;
     private getActions;
     /**
      * Determines the next state given the current `state` and sent `event`.
@@ -203,7 +198,7 @@ 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: StateValue | State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>, context?: TContext): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    transition(state: StateValue | State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>, context?: TContext, exec?: PredictableActionArgumentsExec): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
     private resolveRaisedTransition;
     private resolveTransition;
     /**

package/lib/StateNode.js

@@ -120,7 +120,7 @@ function () {
       stateNode.order = order++;
 
       try {
-        for (var _b = _tslib.__values(stateUtils.getChildren(stateNode)), _c = _b.next(); !_c.done; _c = _b.next()) {
+        for (var _b = _tslib.__values(stateUtils.getAllChildren(stateNode)), _c = _b.next(); !_c.done; _c = _b.next()) {
           var child = _c.value;
           dfs(child);
         }
@@ -631,9 +631,14 @@ function () {
       return _this.getRelativeStateNodes(stateNode, state.historyValue);
     }));
     var isInternal = !!selectedTransition.internal;
-    var reentryNodes = isInternal ? [] : utils.flatten(allNextStateNodes.map(function (n) {
-      return _this.nodesFromChild(n);
-    }));
+    var reentryNodes = [];
+
+    if (!isInternal) {
+      nextStateNodes.forEach(function (targetNode) {
+        reentryNodes.push.apply(reentryNodes, _tslib.__spreadArray([], _tslib.__read(_this.getExternalReentryNodes(targetNode)), false));
+      });
+    }
+
     return {
       transitions: [selectedTransition],
       entrySet: reentryNodes,
@@ -644,58 +649,38 @@ function () {
     };
   };
 
-  StateNode.prototype.nodesFromChild = function (childStateNode) {
-    if (childStateNode.escapes(this)) {
-      return [];
-    }
-
+  StateNode.prototype.getExternalReentryNodes = function (targetNode) {
     var nodes = [];
-    var marker = childStateNode;
 
-    while (marker && marker !== this) {
+    var _a = _tslib.__read(targetNode.order > this.order ? [targetNode, this] : [this, targetNode], 2),
+        marker = _a[0],
+        possibleAncestor = _a[1];
+
+    while (marker && marker !== possibleAncestor) {
       nodes.push(marker);
       marker = marker.parent;
     }
 
-    nodes.push(this); // inclusive
-
-    return nodes;
-  };
-  /**
-   * Whether the given state node "escapes" this state node. If the `stateNode` is equal to or the parent of
-   * this state node, it does not escape.
-   */
-
-
-  StateNode.prototype.escapes = function (stateNode) {
-    if (this === stateNode) {
-      return false;
-    }
-
-    var parent = this.parent;
-
-    while (parent) {
-      if (parent === stateNode) {
-        return false;
-      }
-
-      parent = parent.parent;
+    if (marker !== possibleAncestor) {
+      // we never got to `possibleAncestor`, therefore the initial `marker` "escapes" it
+      // it's in a different part of the tree so no states will be reentered for such an external transition
+      return [];
     }
 
-    return true;
+    nodes.push(possibleAncestor);
+    return nodes;
   };
 
-  StateNode.prototype.getActions = function (transition, currentContext, _event, prevState) {
+  StateNode.prototype.getActions = function (resolvedConfig, isDone, transition, currentContext, _event, prevState) {
     var e_4, _a, e_5, _b;
 
     var prevConfig = stateUtils.getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);
-    var resolvedConfig = transition.configuration.length ? stateUtils.getConfiguration(prevConfig, transition.configuration) : prevConfig;
 
     try {
       for (var resolvedConfig_1 = _tslib.__values(resolvedConfig), resolvedConfig_1_1 = resolvedConfig_1.next(); !resolvedConfig_1_1.done; resolvedConfig_1_1 = resolvedConfig_1.next()) {
         var sn = resolvedConfig_1_1.value;
 
-        if (!stateUtils.has(prevConfig, sn)) {
+        if (!stateUtils.has(prevConfig, sn) || stateUtils.has(transition.entrySet, sn.parent)) {
           transition.entrySet.push(sn);
         }
       }
@@ -780,6 +765,18 @@ function () {
         exitActions = _c[1];
 
     var actions$1 = actions.toActionObjects(exitActions.concat(transition.actions).concat(entryActions), this.machine.options.actions);
+
+    if (isDone) {
+      var stopActions = actions.toActionObjects(utils.flatten(_tslib.__spreadArray([], _tslib.__read(resolvedConfig), false).sort(function (a, b) {
+        return b.order - a.order;
+      }).map(function (stateNode) {
+        return stateNode.onExit;
+      })), this.machine.options.actions).filter(function (action) {
+        return action.type !== actionTypes.raise && (action.type !== actionTypes.send || !!action.to && action.to !== types.SpecialTargets.Internal);
+      });
+      return actions$1.concat(stopActions);
+    }
+
     return actions$1;
   };
   /**
@@ -791,7 +788,7 @@ function () {
    */
 
 
-  StateNode.prototype.transition = function (state, event, context) {
+  StateNode.prototype.transition = function (state, event, context, exec) {
     if (state === void 0) {
       state = this.initialState;
     }
@@ -829,14 +826,14 @@ function () {
     var prevConfig = stateUtils.getConfiguration([], this.getStateNodes(currentState.value));
     var resolvedConfig = stateTransition.configuration.length ? stateUtils.getConfiguration(prevConfig, stateTransition.configuration) : prevConfig;
     stateTransition.configuration = _tslib.__spreadArray([], _tslib.__read(resolvedConfig), false);
-    return this.resolveTransition(stateTransition, currentState, currentState.context, _event);
+    return this.resolveTransition(stateTransition, currentState, currentState.context, exec, _event);
   };
 
-  StateNode.prototype.resolveRaisedTransition = function (state, _event, originalEvent) {
+  StateNode.prototype.resolveRaisedTransition = function (state, _event, originalEvent, predictableExec) {
     var _a;
 
     var currentActions = state.actions;
-    state = this.transition(state, _event); // Save original event to state
+    state = this.transition(state, _event, undefined, predictableExec); // Save original event to state
     // TODO: this should be the raised event! Delete in V5 (breaking)
 
     state._event = originalEvent;
@@ -847,7 +844,7 @@ function () {
     return state;
   };
 
-  StateNode.prototype.resolveTransition = function (stateTransition, currentState, context, _event) {
+  StateNode.prototype.resolveTransition = function (stateTransition, currentState, context, predictableExec, _event) {
     var e_6, _a;
 
     var _this = this;
@@ -861,9 +858,11 @@ function () {
     // - OR there are transitions
 
     var willTransition = !currentState || stateTransition.transitions.length > 0;
+    var resolvedConfiguration = willTransition ? stateTransition.configuration : currentState ? currentState.configuration : [];
+    var isDone = stateUtils.isInFinalState(resolvedConfiguration, this);
     var resolvedStateValue = willTransition ? stateUtils.getValue(this.machine, configuration) : undefined;
     var historyValue = currentState ? currentState.historyValue ? currentState.historyValue : stateTransition.source ? this.machine.historyValue(currentState.value) : undefined : undefined;
-    var actions$1 = this.getActions(stateTransition, context, _event, currentState);
+    var actions$1 = this.getActions(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState);
     var activities = currentState ? _tslib.__assign({}, currentState.activities) : {};
 
     try {
@@ -888,7 +887,7 @@ function () {
       }
     }
 
-    var _b = _tslib.__read(actions.resolveActions(this, currentState, context, _event, actions$1, this.machine.config.preserveActionOrder), 2),
+    var _b = _tslib.__read(actions.resolveActions(this, currentState, context, _event, actions$1, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
         resolvedActions = _b[0],
         updatedContext = _b[1];
 
@@ -907,8 +906,6 @@ function () {
       acc[action.activity.id] = Actor.createInvocableActor(action.activity, _this.machine, updatedContext, _event);
       return acc;
     }, currentState ? _tslib.__assign({}, currentState.children) : {});
-    var resolvedConfiguration = willTransition ? stateTransition.configuration : currentState ? currentState.configuration : [];
-    var isDone = stateUtils.isInFinalState(resolvedConfiguration, this);
     var nextState = new State.State({
       value: resolvedStateValue || currentState.value,
       context: updatedContext,
@@ -938,34 +935,33 @@ function () {
     // and if some of the state nodes have transient ("always") transitions.
 
 
-    var isTransient = !isDone && (this._transient || configuration.some(function (stateNode) {
+    var hasAlwaysTransitions = !isDone && (this._transient || configuration.some(function (stateNode) {
       return stateNode._transient;
     })); // If there are no enabled transitions, check if there are transient transitions.
     // If there are transient transitions, continue checking for more transitions
     // because an transient transition should be triggered even if there are no
     // enabled transitions.
     //
-    // If we're already working on an transient transition (by checking
-    // if the event is a NULL_EVENT), then stop to prevent an infinite loop.
+    // If we're already working on an transient transition then stop to prevent an infinite loop.
     //
     // Otherwise, if there are no enabled nor transient transitions, we are done.
 
-    if (!willTransition && (!isTransient || _event.name === NULL_EVENT)) {
+    if (!willTransition && (!hasAlwaysTransitions || _event.name === NULL_EVENT)) {
       return nextState;
     }
 
     var maybeNextState = nextState;
 
     if (!isDone) {
-      if (isTransient) {
+      if (hasAlwaysTransitions) {
         maybeNextState = this.resolveRaisedTransition(maybeNextState, {
           type: actionTypes.nullEvent
-        }, _event);
+        }, _event, predictableExec);
       }
 
       while (raisedEvents.length) {
         var raisedEvent = raisedEvents.shift();
-        maybeNextState = this.resolveRaisedTransition(maybeNextState, raisedEvent._event, _event);
+        maybeNextState = this.resolveRaisedTransition(maybeNextState, raisedEvent._event, _event, predictableExec);
       }
     } // Detect if state changed
 
@@ -1152,7 +1148,7 @@ function () {
     var configuration = this.getStateNodes(stateValue);
     return this.resolveTransition({
       configuration: configuration,
-      entrySet: configuration,
+      entrySet: _tslib.__spreadArray([], _tslib.__read(configuration), false),
       exitSet: [],
       transitions: [],
       source: undefined,

package/lib/actions.d.ts

@@ -1,4 +1,4 @@
-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, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject, Cast, EventFrom, AnyActorRef } 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, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject, Cast, EventFrom, AnyActorRef, PredictableActionArgumentsExec } from './types';
 import * as actionTypes from './actionTypes';
 import { State } from './State';
 import { StateNode } from './StateNode';
@@ -150,5 +150,5 @@ export declare function forwardTo<TContext, TEvent extends EventObject>(target:
  */
 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<ChooseCondition<TContext, TEvent>>): ChooseAction<TContext, TEvent>;
-export declare function resolveActions<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, any, any>, currentState: State<TContext, TEvent> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actions: Array<ActionObject<TContext, TEvent>>, preserveActionOrder?: boolean): [Array<ActionObject<TContext, TEvent>>, TContext];
+export declare function resolveActions<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, any, any>, currentState: State<TContext, TEvent, any, any, any> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actions: Array<ActionObject<TContext, TEvent>>, predictableExec?: PredictableActionArgumentsExec, preserveActionOrder?: boolean): [Array<ActionObject<TContext, TEvent>>, TContext];
 //# sourceMappingURL=actions.d.ts.map

package/lib/actions.js

@@ -378,6 +378,26 @@ function pure(getActions) {
  */
 
 function forwardTo(target, options) {
+  if (!environment.IS_PRODUCTION && (!target || typeof target === 'function')) {
+    var originalTarget_1 = target;
+
+    target = function () {
+      var args = [];
+
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+
+      var resolvedTarget = typeof originalTarget_1 === 'function' ? originalTarget_1.apply(void 0, _tslib.__spreadArray([], _tslib.__read(args), false)) : originalTarget_1;
+
+      if (!resolvedTarget) {
+        throw new Error("Attempted to forward event to undefined actor. This risks an infinite loop in the sender.");
+      }
+
+      return resolvedTarget;
+    };
+  }
+
   return send(function (_, event) {
     return event;
   }, _tslib.__assign(_tslib.__assign({}, options), {
@@ -408,7 +428,7 @@ function choose(conds) {
     conds: conds
   };
 }
-function resolveActions(machine, currentState, currentContext, _event, actions, preserveActionOrder) {
+function resolveActions(machine, currentState, currentContext, _event, actions, predictableExec, preserveActionOrder) {
   if (preserveActionOrder === void 0) {
     preserveActionOrder = false;
   }
@@ -426,7 +446,9 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
 
     switch (actionObject.type) {
       case actionTypes.raise:
-        return resolveRaise(actionObject);
+        {
+          return resolveRaise(actionObject);
+        }
 
       case actionTypes.send:
         var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
@@ -437,24 +459,32 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
           "No delay reference for delay expression '".concat(actionObject.delay, "' was found on machine '").concat(machine.id, "'"));
         }
 
+        if (sendAction.to !== types.SpecialTargets.Internal) {
+          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(sendAction, updatedContext, _event);
+        }
+
         return sendAction;
 
       case actionTypes.log:
-        return resolveLog(actionObject, updatedContext, _event);
+        {
+          var resolved = resolveLog(actionObject, updatedContext, _event);
+          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, updatedContext, _event);
+          return resolved;
+        }
 
       case actionTypes.choose:
         {
           var chooseAction = actionObject;
           var matchedActions = (_a = chooseAction.conds.find(function (condition) {
             var guard = utils.toGuard(condition.cond, machine.options.guards);
-            return !guard || utils.evaluateGuard(machine, guard, updatedContext, _event, currentState);
+            return !guard || utils.evaluateGuard(machine, guard, updatedContext, _event, !predictableExec ? currentState : undefined);
           })) === null || _a === void 0 ? void 0 : _a.actions;
 
           if (!matchedActions) {
             return [];
           }
 
-          var _b = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(utils.toArray(matchedActions), machine.options.actions), preserveActionOrder), 2),
+          var _b = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(utils.toArray(matchedActions), machine.options.actions), predictableExec, preserveActionOrder), 2),
               resolvedActionsFromChoose = _b[0],
               resolvedContextFromChoose = _b[1];
 
@@ -471,7 +501,7 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
             return [];
           }
 
-          var _c = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(utils.toArray(matchedActions), machine.options.actions), preserveActionOrder), 2),
+          var _c = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(utils.toArray(matchedActions), machine.options.actions), predictableExec, preserveActionOrder), 2),
               resolvedActionsFromPure = _c[0],
               resolvedContext = _c[1];
 
@@ -482,12 +512,14 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
 
       case actionTypes.stop:
         {
-          return resolveStop(actionObject, updatedContext, _event);
+          var resolved = resolveStop(actionObject, updatedContext, _event);
+          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, updatedContext, _event);
+          return resolved;
         }
 
       case actionTypes.assign:
         {
-          updatedContext = utils.updateContext(updatedContext, _event, [actionObject], currentState);
+          updatedContext = utils.updateContext(updatedContext, _event, [actionObject], !predictableExec ? currentState : undefined);
           preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
           break;
         }
@@ -496,7 +528,9 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
         var resolvedActionObject = toActionObject(actionObject, machine.options.actions);
         var exec_1 = resolvedActionObject.exec;
 
-        if (exec_1 && preservedContexts) {
+        if (predictableExec) {
+          predictableExec(resolvedActionObject, updatedContext, _event);
+        } else if (exec_1 && preservedContexts) {
           var contextIndex_1 = preservedContexts.length - 1;
           resolvedActionObject = _tslib.__assign(_tslib.__assign({}, resolvedActionObject), {
             exec: function (_ctx) {

package/lib/interpreter.d.ts

@@ -93,7 +93,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     execute(state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
     private update;
     onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>): this;
-    subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>): Subscription;
+    subscribe(observer: Partial<Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>>): Subscription;
     subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
      * Adds an event listener that is notified whenever an event is sent to the running interpreter.
@@ -134,6 +134,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param initialState The state to start the statechart from
      */
     start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | StateValue): this;
+    private _stop;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      *
@@ -158,6 +159,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      */
     sender(event: Event<TEvent>): () => State<TContext, TEvent, TStateSchema, TTypestate>;
     private sendTo;
+    private _nextState;
     /**
      * Returns the next state given the interpreter's current state and the event.
      *
@@ -169,6 +171,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     private forward;
     private defer;
     private cancel;
+    private _exec;
     private exec;
     private removeChild;
     private stopChild;