xstate 4.31.0 → 4.33.0

package/es/model.types.d.ts

@@ -1,8 +1,11 @@
-import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, ExtractEvent, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions, ServiceMap } from './types';
+import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions, ServiceMap } from './types';
 import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
+declare type SimplisticExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
+    type: TEventType;
+} ? TEvent : never;
 export interface Model<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
     initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
+    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, SimplisticExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, SimplisticExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, SimplisticExtractEvent<TEvent, TEventType>>;
     events: Prop<TModelCreators, 'events'>;
     actions: Prop<TModelCreators, 'actions'>;
     reset: () => AssignAction<TContext, any>;
@@ -49,4 +52,5 @@ export interface FinalModelCreators<Self> {
 export declare type UnionFromCreatorsReturnTypes<TCreators> = {
     [K in keyof TCreators]: TCreators[K] extends AnyFunction ? ReturnType<TCreators[K]> : never;
 }[keyof TCreators];
+export {};
 //# sourceMappingURL=model.types.d.ts.map

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/typegenTypes.d.ts

@@ -113,18 +113,21 @@ declare type AllowAllEvents = {
 };
 export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TServiceMap extends ServiceMap> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
-    resolved: TTypesMeta extends TypegenEnabled ? TTypesMeta & {
-        indexedActions: IndexByType<TAction>;
-        indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
-    } : TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
-        indexedActions: IndexByType<TAction>;
-        indexedEvents: Record<string, TEvent> & {
-            __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
-                data: any;
+    resolved: {
+        enabled: TTypesMeta & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+        };
+        disabled: TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: Record<string, TEvent> & {
+                __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
+                    data: any;
+                };
             };
+            invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
         };
-        invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
-    };
+    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
 }
 export {};
 //# sourceMappingURL=typegenTypes.d.ts.map

package/es/types.d.ts

@@ -2,7 +2,7 @@ import { Clock, Interpreter } from './interpreter';
 import { Model } from './model.types';
 import { State } from './State';
 import { StateNode } from './StateNode';
-import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+import { MarkAllImplementationsAsProvided, TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, AreAllImplementationsAssumedToBeProvided, TypegenEnabled } from './typegenTypes';
 export declare type AnyFunction = (...args: any[]) => any;
 declare type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export declare type IsNever<T> = [T] extends [never] ? true : false;
@@ -15,9 +15,7 @@ export declare type Merge<M, N> = Omit<M, keyof N> & N;
 export declare type IndexByType<T extends {
     type: string;
 }> = {
-    [K in T['type']]: Extract<T, {
-        type: K;
-    }>;
+    [K in T['type']]: T extends any ? (K extends T['type'] ? T : never) : never;
 };
 export declare type Equals<A1 extends any, A2 extends any> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
 export declare type IsAny<T> = Equals<T, any>;
@@ -241,13 +239,7 @@ export declare type StatesDefinition<TContext, TStateSchema extends StateSchema,
 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>>;
 export declare type TransitionsConfigMap<TContext, TEvent extends EventObject> = {
-    [K in TEvent['type']]?: TransitionConfigOrTarget<TContext, TEvent extends {
-        type: K;
-    } ? TEvent : never>;
-} & {
-    ''?: TransitionConfigOrTarget<TContext, TEvent>;
-} & {
-    '*'?: TransitionConfigOrTarget<TContext, TEvent>;
+    [K in TEvent['type'] | '' | '*']?: K extends '' | '*' ? TransitionConfigOrTarget<TContext, TEvent> : TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>>;
 };
 declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<(TEvent extends EventObject ? TransitionConfig<TContext, TEvent> & {
     event: TEvent['type'];
@@ -430,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
      */
@@ -864,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>>;
@@ -988,9 +989,7 @@ export interface Subscribable<T> extends InteropSubscribable<T> {
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
 export declare type Spawnable = AnyStateMachine | PromiseLike<any> | InvokeCallback | InteropObservable<any> | Subscribable<any> | Behavior<any>;
-export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
-    type: TEventType;
-} ? TEvent : never;
+export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends any ? TEventType extends TEvent['type'] ? TEvent : never : never;
 export interface BaseActorRef<TEvent extends EventObject> {
     send: (event: TEvent) => void;
 }
@@ -1001,6 +1000,7 @@ export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Su
     stop?: () => void;
     toJSON?: () => any;
 }
+export declare type AnyActorRef = ActorRef<any, any>;
 /**
  * @deprecated Use `ActorRef` instead.
  */
@@ -1027,11 +1027,15 @@ 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 = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : Extract<TEvent, {
-    type: K;
-}>;
+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;
+declare type Matches<TypegenEnabledArg, TypegenDisabledArg> = {
+    (stateValue: TypegenEnabledArg): any;
+    (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/es/waitFor.js

@@ -29,7 +29,12 @@ function waitFor(actorRef, predicate, options) {
 
   return new Promise(function (res, rej) {
     var done = false;
-    var handle = setTimeout(function () {
+
+    if (process.env.NODE_ENV !== 'production' && resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+
+    var handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(function () {
       sub.unsubscribe();
       rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
     }, resolvedOptions.timeout);

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.
      */
@@ -91,7 +91,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * @param delimiter The character(s) that separate each subpath in the string state node path.
      */
     toStrings(stateValue?: StateValue, delimiter?: string): string[];
-    toJSON(): Omit<this, "machine" | "tags" | "transitions" | "configuration"> & {
+    toJSON(): Omit<this, "machine" | "configuration" | "transitions" | "tags"> & {
         tags: string[];
     };
     /**

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, ActorRef, EventFrom } 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';
@@ -52,7 +52,7 @@ declare type InferEvent<E extends EventObject> = {
  * @param options Send action options
  * @returns An XState send action object
  */
-export declare function sendTo<TContext, TEvent extends EventObject, TActor extends ActorRef<EventObject>>(actor: (ctx: TContext) => TActor, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, any>;
+export declare function sendTo<TContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: (ctx: TContext) => TActor, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, any>;
 /**
  * Sends an update event to this machine's parent.
  */
@@ -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