xstate 4.34.0 → 4.35.1

package/es/types.d.ts

@@ -610,7 +610,6 @@ export interface ActivityMap {
 export interface StateTransition<TContext, TEvent extends EventObject> {
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
     configuration: Array<StateNode<TContext, any, TEvent, any, any, any>>;
-    entrySet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
     exitSet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
     /**
      * The source state that preceded the transition.
@@ -754,7 +753,7 @@ export interface AssignAction<TContext, TEvent extends EventObject> extends Acti
 }
 export interface PureAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Pure;
-    get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent>> | undefined;
+    get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent> | ActionObject<TContext, TEvent>['type']> | undefined;
 }
 export interface ChooseAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Choose;

package/es/waitFor.d.ts

@@ -11,6 +11,8 @@ interface WaitForOptions {
 /**
  * Subscribes to an actor ref and waits for its emitted value to satisfy
  * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
  *
  * @example
  * ```js

package/es/waitFor.js

@@ -7,6 +7,8 @@ var defaultWaitForOptions = {
 /**
  * Subscribes to an actor ref and waits for its emitted value to satisfy
  * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
  *
  * @example
  * ```js

package/lib/Machine.js

@@ -14,7 +14,7 @@ function Machine(config, options, initialContext) {
   return new StateNode.StateNode(config, options, initialContext);
 }
 function createMachine(config, options) {
-  if (!environment.IS_PRODUCTION && !config.predictableActionArguments && !warned) {
+  if (!environment.IS_PRODUCTION && !('predictableActionArguments' in config) && !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');
   }

package/lib/StateNode.d.ts

@@ -189,7 +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 getExternalReentryNodes;
+    private getPotentiallyReenteringNodes;
     private getActions;
     /**
      * Determines the next state given the current `state` and sent `event`.

package/lib/StateNode.js

@@ -524,15 +524,11 @@ function () {
       return this.next(state, _event);
     }
 
-    var entryNodes = utils.flatten(stateTransitions.map(function (t) {
-      return t.entrySet;
-    }));
     var configuration = utils.flatten(Object.keys(transitionMap).map(function (key) {
       return transitionMap[key].configuration;
     }));
     return {
       transitions: enabledTransitions,
-      entrySet: entryNodes,
       exitSet: utils.flatten(stateTransitions.map(function (t) {
         return t.exitSet;
       })),
@@ -619,7 +615,6 @@ function () {
     if (!nextStateNodes.length) {
       return {
         transitions: [selectedTransition],
-        entrySet: [],
         exitSet: [],
         configuration: state.value ? [this] : [],
         source: state,
@@ -631,30 +626,28 @@ function () {
       return _this.getRelativeStateNodes(stateNode, state.historyValue);
     }));
     var isInternal = !!selectedTransition.internal;
-    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,
-      exitSet: isInternal ? [] : [this],
+      exitSet: isInternal ? [] : utils.flatten(nextStateNodes.map(function (targetNode) {
+        return _this.getPotentiallyReenteringNodes(targetNode);
+      })),
       configuration: allNextStateNodes,
       source: state,
       actions: actions
     };
-  };
+  }; // even though the name of this function mentions reentry nodes
+  // we are pushing its result into `exitSet`
+  // that's because what we exit might be reentered (it's an invariant of reentrancy)
 
-  StateNode.prototype.getExternalReentryNodes = function (targetNode) {
-    var nodes = [];
 
-    var _a = _tslib.__read(targetNode.order > this.order ? [targetNode, this] : [this, targetNode], 2),
-        marker = _a[0],
-        possibleAncestor = _a[1];
+  StateNode.prototype.getPotentiallyReenteringNodes = function (targetNode) {
+    if (this.order < targetNode.order) {
+      return [this];
+    }
+
+    var nodes = [];
+    var marker = this;
+    var possibleAncestor = targetNode;
 
     while (marker && marker !== possibleAncestor) {
       nodes.push(marker);
@@ -676,14 +669,17 @@ function () {
 
     var _this = this;
 
-    var prevConfig = stateUtils.getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);
+    var prevConfig = prevState ? stateUtils.getConfiguration([], this.getStateNodes(prevState.value)) : [];
+    var entrySet = new Set();
 
     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;
+      for (var _c = _tslib.__values(Array.from(resolvedConfig).sort(function (a, b) {
+        return a.order - b.order;
+      })), _d = _c.next(); !_d.done; _d = _c.next()) {
+        var sn = _d.value;
 
-        if (!stateUtils.has(prevConfig, sn) || stateUtils.has(transition.entrySet, sn.parent) && !stateUtils.has(transition.entrySet, sn)) {
-          transition.entrySet.push(sn);
+        if (!stateUtils.has(prevConfig, sn) || stateUtils.has(transition.exitSet, sn) || sn.parent && entrySet.has(sn.parent)) {
+          entrySet.add(sn);
         }
       }
     } catch (e_4_1) {
@@ -692,7 +688,7 @@ function () {
       };
     } finally {
       try {
-        if (resolvedConfig_1_1 && !resolvedConfig_1_1.done && (_a = resolvedConfig_1.return)) _a.call(resolvedConfig_1);
+        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
       } finally {
         if (e_4) throw e_4.error;
       }
@@ -718,7 +714,14 @@ function () {
       }
     }
 
-    var doneEvents = utils.flatten(transition.entrySet.map(function (sn) {
+    transition.exitSet.sort(function (a, b) {
+      return b.order - a.order;
+    });
+    var entryStates = Array.from(entrySet).sort(function (a, b) {
+      return a.order - b.order;
+    });
+    var exitStates = new Set(transition.exitSet);
+    var doneEvents = utils.flatten(entryStates.map(function (sn) {
       var events = [];
 
       if (sn.type !== 'final') {
@@ -745,27 +748,31 @@ function () {
 
       return events;
     }));
-    transition.exitSet.sort(function (a, b) {
-      return b.order - a.order;
-    });
-    transition.entrySet.sort(function (a, b) {
-      return a.order - b.order;
-    });
-    var entryStates = new Set(transition.entrySet);
-    var exitStates = new Set(transition.exitSet);
-    var entryActions = Array.from(entryStates).map(function (stateNode) {
+    var entryActions = entryStates.map(function (stateNode) {
       var entryActions = stateNode.onEntry;
       var invokeActions = stateNode.activities.map(function (activity) {
         return actions.start(activity);
       });
-      return actions.toActionObjects(predictableExec ? _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(entryActions), false), _tslib.__read(invokeActions), false) : _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(invokeActions), false), _tslib.__read(entryActions), false), _this.machine.options.actions);
-    }).concat([doneEvents.map(actions.raise)]);
+      return {
+        type: 'entry',
+        actions: actions.toActionObjects(predictableExec ? _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(entryActions), false), _tslib.__read(invokeActions), false) : _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(invokeActions), false), _tslib.__read(entryActions), false), _this.machine.options.actions)
+      };
+    }).concat({
+      type: 'state_done',
+      actions: doneEvents.map(actions.raise)
+    });
     var exitActions = Array.from(exitStates).map(function (stateNode) {
-      return actions.toActionObjects(_tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(stateNode.onExit), false), _tslib.__read(stateNode.activities.map(function (activity) {
-        return actions.stop(activity);
-      })), false), _this.machine.options.actions);
+      return {
+        type: 'exit',
+        actions: actions.toActionObjects(_tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(stateNode.onExit), false), _tslib.__read(stateNode.activities.map(function (activity) {
+          return actions.stop(activity);
+        })), false), _this.machine.options.actions)
+      };
     });
-    var actions$1 = exitActions.concat([actions.toActionObjects(transition.actions, this.machine.options.actions)]).concat(entryActions);
+    var actions$1 = exitActions.concat({
+      type: 'transition',
+      actions: actions.toActionObjects(transition.actions, this.machine.options.actions)
+    }).concat(entryActions);
 
     if (isDone) {
       var stopActions = actions.toActionObjects(utils.flatten(_tslib.__spreadArray([], _tslib.__read(resolvedConfig), false).sort(function (a, b) {
@@ -775,7 +782,10 @@ function () {
       })), 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.concat({
+        type: 'stop',
+        actions: stopActions
+      });
     }
 
     return actions$1;
@@ -819,7 +829,6 @@ function () {
     var stateTransition = this._transition(currentState.value, currentState, _event) || {
       transitions: [],
       configuration: [],
-      entrySet: [],
       exitSet: [],
       source: currentState,
       actions: []
@@ -871,8 +880,8 @@ function () {
         var block = actionBlocks_1_1.value;
 
         try {
-          for (var block_1 = (e_7 = void 0, _tslib.__values(block)), block_1_1 = block_1.next(); !block_1_1.done; block_1_1 = block_1.next()) {
-            var action = block_1_1.value;
+          for (var _c = (e_7 = void 0, _tslib.__values(block.actions)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var action = _d.value;
 
             if (action.type === actionTypes.start) {
               activities[action.activity.id || action.activity.type] = action;
@@ -886,7 +895,7 @@ function () {
           };
         } finally {
           try {
-            if (block_1_1 && !block_1_1.done && (_b = block_1.return)) _b.call(block_1);
+            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
           } finally {
             if (e_7) throw e_7.error;
           }
@@ -904,15 +913,15 @@ function () {
       }
     }
 
-    var _c = _tslib.__read(actions.resolveActions(this, currentState, context, _event, actionBlocks, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
-        resolvedActions = _c[0],
-        updatedContext = _c[1];
+    var _e = _tslib.__read(actions.resolveActions(this, currentState, context, _event, actionBlocks, predictableExec, this.machine.config.predictableActionArguments || this.machine.config.preserveActionOrder), 2),
+        resolvedActions = _e[0],
+        updatedContext = _e[1];
 
-    var _d = _tslib.__read(utils.partition(resolvedActions, function (action) {
+    var _f = _tslib.__read(utils.partition(resolvedActions, function (action) {
       return action.type === actionTypes.raise || action.type === actionTypes.send && action.to === types.SpecialTargets.Internal;
     }), 2),
-        raisedEvents = _d[0],
-        nonRaisedActions = _d[1];
+        raisedEvents = _f[0],
+        nonRaisedActions = _f[1];
 
     var invokeActions = resolvedActions.filter(function (action) {
       var _a;
@@ -1165,7 +1174,6 @@ function () {
     var configuration = this.getStateNodes(stateValue);
     return this.resolveTransition({
       configuration: configuration,
-      entrySet: configuration,
       exitSet: [],
       transitions: [],
       source: undefined,

package/lib/actions.d.ts

@@ -133,7 +133,7 @@ export declare function done(id: string, data?: any): DoneEventObject;
  */
 export declare function doneInvoke(id: string, data?: any): DoneEvent;
 export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
-export declare function pure<TContext, TEvent extends EventObject>(getActions: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent>> | undefined): PureAction<TContext, TEvent>;
+export declare function pure<TContext, TEvent extends EventObject>(getActions: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent> | ActionObject<TContext, TEvent>['type']> | undefined): PureAction<TContext, TEvent>;
 /**
  * Forwards (sends) an event to a specified service.
  *
@@ -150,5 +150,8 @@ 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, any, any, any> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actionBlocks: Array<Array<ActionObject<TContext, TEvent>>>, predictableExec?: PredictableActionArgumentsExec, 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>, actionBlocks: Array<{
+    type: string;
+    actions: Array<ActionObject<TContext, TEvent>>;
+}>, predictableExec?: PredictableActionArgumentsExec, preserveActionOrder?: boolean): [Array<ActionObject<TContext, TEvent>>, TContext];
 //# sourceMappingURL=actions.d.ts.map

package/lib/actions.js

@@ -439,10 +439,10 @@ var pluckAssigns = function (actionBlocks) {
       var block = actionBlocks_1_1.value;
       var i = 0;
 
-      while (i < block.length) {
-        if (block[i].type === actionTypes.assign) {
-          assignActions.push(block[i]);
-          block.splice(i, 1);
+      while (i < block.actions.length) {
+        if (block.actions[i].type === actionTypes.assign) {
+          assignActions.push(block.actions[i]);
+          block.actions.splice(i, 1);
           continue;
         }
 
@@ -474,7 +474,7 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
   var preservedContexts = preserveActionOrder ? [currentContext] : undefined;
   var deferredToBlockEnd = [];
 
-  function handleAction(actionObject) {
+  function handleAction(blockType, actionObject) {
     var _a;
 
     switch (actionObject.type) {
@@ -493,7 +493,11 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
         }
 
         if (predictableExec && sendAction.to !== types.SpecialTargets.Internal) {
-          deferredToBlockEnd.push(sendAction);
+          if (blockType === 'entry') {
+            deferredToBlockEnd.push(sendAction);
+          } else {
+            predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(sendAction, updatedContext, _event);
+          }
         }
 
         return sendAction;
@@ -517,7 +521,10 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
             return [];
           }
 
-          var _b = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, [toActionObjects(utils.toArray(matchedActions), machine.options.actions)], predictableExec, preserveActionOrder), 2),
+          var _b = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, [{
+            type: blockType,
+            actions: toActionObjects(utils.toArray(matchedActions), machine.options.actions)
+          }], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromChoose = _b[0],
               resolvedContextFromChoose = _b[1];
 
@@ -534,7 +541,10 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
             return [];
           }
 
-          var _c = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, [toActionObjects(utils.toArray(matchedActions), machine.options.actions)], predictableExec, preserveActionOrder), 2),
+          var _c = _tslib.__read(resolveActions(machine, currentState, updatedContext, _event, [{
+            type: blockType,
+            actions: toActionObjects(utils.toArray(matchedActions), machine.options.actions)
+          }], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromPure = _c[0],
               resolvedContext = _c[1];
 
@@ -588,9 +598,9 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
     var resolvedActions = [];
 
     try {
-      for (var block_1 = _tslib.__values(block), block_1_1 = block_1.next(); !block_1_1.done; block_1_1 = block_1.next()) {
-        var action = block_1_1.value;
-        var resolved = handleAction(action);
+      for (var _b = _tslib.__values(block.actions), _c = _b.next(); !_c.done; _c = _b.next()) {
+        var action = _c.value;
+        var resolved = handleAction(block.type, action);
 
         if (resolved) {
           resolvedActions = resolvedActions.concat(resolved);
@@ -602,7 +612,7 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
       };
     } finally {
       try {
-        if (block_1_1 && !block_1_1.done && (_a = block_1.return)) _a.call(block_1);
+        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
       } finally {
         if (e_2) throw e_2.error;
       }

package/lib/interpreter.js

@@ -805,7 +805,10 @@ function () {
           return actions.toActionObjects(stateNode.onExit, _this.machine.options.actions);
         }));
 
-        var _a = _tslib.__read(actions.resolveActions(_this.machine, _this.state, _this.state.context, _event, [exitActions], _this.machine.config.predictableActionArguments ? _this._exec : undefined, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2),
+        var _a = _tslib.__read(actions.resolveActions(_this.machine, _this.state, _this.state.context, _event, [{
+          type: 'exit',
+          actions: exitActions
+        }], _this.machine.config.predictableActionArguments ? _this._exec : undefined, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2),
             resolvedActions = _a[0],
             updatedContext = _a[1];
 

package/lib/model.d.ts

@@ -1,5 +1,8 @@
 import type { Cast, EventObject, BaseActionObject, Prop, IsNever } from './types';
 import { UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators } from './model.types';
+/**
+ * @deprecated Use [Typegen](https://stately.ai/blog/introducing-typescript-typegen-for-xstate) instead.
+ */
 export declare function createModel<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject>(initialContext: TContext): Model<TContext, TEvent, TAction, void>;
 export declare function createModel<TContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>, TComputedEvent = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'events'>>, TComputedAction = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'actions'>>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<TComputedEvent, EventObject>, IsNever<TComputedAction> extends true ? BaseActionObject : Cast<TComputedAction, BaseActionObject>, TFinalModelCreators>;
 //# sourceMappingURL=model.d.ts.map

package/lib/types.d.ts

@@ -610,7 +610,6 @@ export interface ActivityMap {
 export interface StateTransition<TContext, TEvent extends EventObject> {
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
     configuration: Array<StateNode<TContext, any, TEvent, any, any, any>>;
-    entrySet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
     exitSet: Array<StateNode<TContext, any, TEvent, any, any, any>>;
     /**
      * The source state that preceded the transition.
@@ -754,7 +753,7 @@ export interface AssignAction<TContext, TEvent extends EventObject> extends Acti
 }
 export interface PureAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Pure;
-    get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent>> | undefined;
+    get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent> | ActionObject<TContext, TEvent>['type']> | undefined;
 }
 export interface ChooseAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Choose;

package/lib/waitFor.d.ts

@@ -11,6 +11,8 @@ interface WaitForOptions {
 /**
  * Subscribes to an actor ref and waits for its emitted value to satisfy
  * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
  *
  * @example
  * ```js

package/lib/waitFor.js

@@ -11,6 +11,8 @@ var defaultWaitForOptions = {
 /**
  * Subscribes to an actor ref and waits for its emitted value to satisfy
  * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
  *
  * @example
  * ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.34.0",
+  "version": "4.35.1",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -63,7 +63,7 @@
     "rxjs": "^7.1.0",
     "ts-jest": "^26.5.6",
     "tslib": "^2.3.1",
-    "typescript": "^4.8.2",
+    "typescript": "^4.8.4",
     "xml-js": "^1.6.11"
   }
 }