xstate 4.33.2 → 4.33.3

package/es/interpreter.d.ts

@@ -73,6 +73,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     sessionId: string;
     children: Map<string | number, ActorRef<any>>;
     private forwardTo;
+    private _outgoingQueue;
     private devTools?;
     /**
      * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.

package/es/interpreter.js

@@ -58,6 +58,7 @@ function () {
     this.status = InterpreterStatus.NotStarted;
     this.children = new Map();
     this.forwardTo = new Set();
+    this._outgoingQueue = [];
     /**
      * Alias for Interpreter.prototype.start
      */
@@ -132,14 +133,24 @@ function () {
         if (_this.status !== InterpreterStatus.Stopped || _this.parent !== target || // we need to send events to the parent from exit handlers of a machine that reached its final state
         _this.state.done) {
           // Send SCXML events to machines
-          target.send(__assign(__assign({}, event), {
+          var scxmlEvent = __assign(__assign({}, event), {
             name: event.name === error$1 ? "".concat(error(_this.id)) : event.name,
             origin: _this.sessionId
-          }));
+          });
+
+          if (_this.machine.config.predictableActionArguments) {
+            _this._outgoingQueue.push([target, scxmlEvent]);
+          } else {
+            target.send(scxmlEvent);
+          }
         }
       } else {
         // Send normal events to other targets
-        target.send(event.data);
+        if (_this.machine.config.predictableActionArguments) {
+          _this._outgoingQueue.push([target, event.data]);
+        } else {
+          target.send(event.data);
+        }
       }
     };
 
@@ -384,6 +395,12 @@ function () {
     // we can't just recompute it (and execute actions while doing so) because we try to preserve identity of actors created within initial assigns
     _event === initEvent) && this.options.execute) {
       this.execute(this.state);
+    } else {
+      var item = void 0;
+
+      while (item = this._outgoingQueue.shift()) {
+        item[0].send(item[1]);
+      }
     } // Update children
 
 
@@ -781,7 +798,7 @@ function () {
           return toActionObjects(stateNode.onExit, _this.machine.options.actions);
         }));
 
-        var _a = __read(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 = __read(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),
             resolvedActions = _a[0],
             updatedContext = _a[1];
 

package/lib/StateNode.js

@@ -671,9 +671,11 @@ function () {
     return nodes;
   };
 
-  StateNode.prototype.getActions = function (resolvedConfig, isDone, transition, currentContext, _event, prevState) {
+  StateNode.prototype.getActions = function (resolvedConfig, isDone, transition, currentContext, _event, prevState, predictableExec) {
     var e_4, _a, e_5, _b;
 
+    var _this = this;
+
     var prevConfig = stateUtils.getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);
 
     try {
@@ -751,20 +753,19 @@ function () {
     });
     var entryStates = new Set(transition.entrySet);
     var exitStates = new Set(transition.exitSet);
-
-    var _c = _tslib.__read([utils.flatten(Array.from(entryStates).map(function (stateNode) {
-      return _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(stateNode.activities.map(function (activity) {
+    var entryActions = Array.from(entryStates).map(function (stateNode) {
+      var entryActions = stateNode.onEntry;
+      var invokeActions = stateNode.activities.map(function (activity) {
         return actions.start(activity);
-      })), false), _tslib.__read(stateNode.onEntry), false);
-    })).concat(doneEvents.map(actions.raise)), utils.flatten(Array.from(exitStates).map(function (stateNode) {
-      return _tslib.__spreadArray(_tslib.__spreadArray([], _tslib.__read(stateNode.onExit), false), _tslib.__read(stateNode.activities.map(function (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)]);
+    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);
-    }))], 2),
-        entryActions = _c[0],
-        exitActions = _c[1];
-
-    var actions$1 = actions.toActionObjects(exitActions.concat(transition.actions).concat(entryActions), this.machine.options.actions);
+      })), false), _this.machine.options.actions);
+    });
+    var actions$1 = exitActions.concat([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) {
@@ -774,7 +775,7 @@ 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([stopActions]);
     }
 
     return actions$1;
@@ -845,7 +846,7 @@ function () {
   };
 
   StateNode.prototype.resolveTransition = function (stateTransition, currentState, context, predictableExec, _event) {
-    var e_6, _a;
+    var e_6, _a, e_7, _b;
 
     var _this = this;
 
@@ -862,17 +863,33 @@ function () {
     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(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState);
+    var actionBlocks = this.getActions(new Set(resolvedConfiguration), isDone, stateTransition, context, _event, currentState, predictableExec);
     var activities = currentState ? _tslib.__assign({}, currentState.activities) : {};
 
     try {
-      for (var actions_1 = _tslib.__values(actions$1), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
-        var action = actions_1_1.value;
+      for (var actionBlocks_1 = _tslib.__values(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()) {
+        var block = actionBlocks_1_1.value;
 
-        if (action.type === actionTypes.start) {
-          activities[action.activity.id || action.activity.type] = action;
-        } else if (action.type === actionTypes.stop) {
-          activities[action.activity.id || action.activity.type] = false;
+        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;
+
+            if (action.type === actionTypes.start) {
+              activities[action.activity.id || action.activity.type] = action;
+            } else if (action.type === actionTypes.stop) {
+              activities[action.activity.id || action.activity.type] = false;
+            }
+          }
+        } catch (e_7_1) {
+          e_7 = {
+            error: e_7_1
+          };
+        } finally {
+          try {
+            if (block_1_1 && !block_1_1.done && (_b = block_1.return)) _b.call(block_1);
+          } finally {
+            if (e_7) throw e_7.error;
+          }
         }
       }
     } catch (e_6_1) {
@@ -881,21 +898,21 @@ function () {
       };
     } finally {
       try {
-        if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
+        if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a = actionBlocks_1.return)) _a.call(actionBlocks_1);
       } finally {
         if (e_6) throw e_6.error;
       }
     }
 
-    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];
+    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 _c = _tslib.__read(utils.partition(resolvedActions, function (action) {
+    var _d = _tslib.__read(utils.partition(resolvedActions, function (action) {
       return action.type === actionTypes.raise || action.type === actionTypes.send && action.to === types.SpecialTargets.Internal;
     }), 2),
-        raisedEvents = _c[0],
-        nonRaisedActions = _c[1];
+        raisedEvents = _d[0],
+        nonRaisedActions = _d[1];
 
     var invokeActions = resolvedActions.filter(function (action) {
       var _a;
@@ -1344,7 +1361,7 @@ function () {
      * All the event types accepted by this state node and its descendants.
      */
     get: function () {
-      var e_7, _a, e_8, _b;
+      var e_8, _a, e_9, _b;
 
       if (this.__cache.events) {
         return this.__cache.events;
@@ -1361,32 +1378,32 @@ function () {
 
             if (state.states) {
               try {
-                for (var _e = (e_8 = void 0, _tslib.__values(state.events)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                for (var _e = (e_9 = void 0, _tslib.__values(state.events)), _f = _e.next(); !_f.done; _f = _e.next()) {
                   var event_1 = _f.value;
                   events.add("".concat(event_1));
                 }
-              } catch (e_8_1) {
-                e_8 = {
-                  error: e_8_1
+              } catch (e_9_1) {
+                e_9 = {
+                  error: e_9_1
                 };
               } finally {
                 try {
                   if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                 } finally {
-                  if (e_8) throw e_8.error;
+                  if (e_9) throw e_9.error;
                 }
               }
             }
           }
-        } catch (e_7_1) {
-          e_7 = {
-            error: e_7_1
+        } catch (e_8_1) {
+          e_8 = {
+            error: e_8_1
           };
         } finally {
           try {
             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
           } finally {
-            if (e_7) throw e_7.error;
+            if (e_8) throw e_8.error;
           }
         }
       }
@@ -1481,7 +1498,7 @@ function () {
   };
 
   StateNode.prototype.formatTransitions = function () {
-    var e_9, _a;
+    var e_10, _a;
 
     var _this = this;
 
@@ -1545,15 +1562,15 @@ function () {
         var delayedTransition = delayedTransitions_1_1.value;
         formattedTransitions.push(delayedTransition);
       }
-    } catch (e_9_1) {
-      e_9 = {
-        error: e_9_1
+    } catch (e_10_1) {
+      e_10 = {
+        error: e_10_1
       };
     } finally {
       try {
         if (delayedTransitions_1_1 && !delayedTransitions_1_1.done && (_a = delayedTransitions_1.return)) _a.call(delayedTransitions_1);
       } finally {
-        if (e_9) throw e_9.error;
+        if (e_10) throw e_10.error;
       }
     }
 

package/lib/actions.d.ts

@@ -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, any, any, any> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actions: 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<Array<ActionObject<TContext, TEvent>>>, predictableExec?: PredictableActionArgumentsExec, preserveActionOrder?: boolean): [Array<ActionObject<TContext, TEvent>>, TContext];
 //# sourceMappingURL=actions.d.ts.map

package/lib/actions.js

@@ -428,20 +428,53 @@ function choose(conds) {
     conds: conds
   };
 }
-function resolveActions(machine, currentState, currentContext, _event, actions, predictableExec, preserveActionOrder) {
+
+var pluckAssigns = function (actionBlocks) {
+  var e_1, _a;
+
+  var assignActions = [];
+
+  try {
+    for (var actionBlocks_1 = _tslib.__values(actionBlocks), actionBlocks_1_1 = actionBlocks_1.next(); !actionBlocks_1_1.done; actionBlocks_1_1 = actionBlocks_1.next()) {
+      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);
+          continue;
+        }
+
+        i++;
+      }
+    }
+  } catch (e_1_1) {
+    e_1 = {
+      error: e_1_1
+    };
+  } finally {
+    try {
+      if (actionBlocks_1_1 && !actionBlocks_1_1.done && (_a = actionBlocks_1.return)) _a.call(actionBlocks_1);
+    } finally {
+      if (e_1) throw e_1.error;
+    }
+  }
+
+  return assignActions;
+};
+
+function resolveActions(machine, currentState, currentContext, _event, actionBlocks, predictableExec, preserveActionOrder) {
   if (preserveActionOrder === void 0) {
     preserveActionOrder = false;
   }
 
-  var _a = _tslib.__read(preserveActionOrder ? [[], actions] : utils.partition(actions, function (action) {
-    return action.type === actionTypes.assign;
-  }), 2),
-      assignActions = _a[0],
-      otherActions = _a[1];
-
+  var assignActions = preserveActionOrder ? [] : pluckAssigns(actionBlocks);
   var updatedContext = assignActions.length ? utils.updateContext(currentContext, _event, assignActions, currentState) : currentContext;
   var preservedContexts = preserveActionOrder ? [currentContext] : undefined;
-  var resolvedActions = utils.flatten(otherActions.map(function (actionObject) {
+  var deferredToBlockEnd = [];
+
+  function handleAction(actionObject) {
     var _a;
 
     switch (actionObject.type) {
@@ -459,8 +492,8 @@ 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);
+        if (predictableExec && sendAction.to !== types.SpecialTargets.Internal) {
+          deferredToBlockEnd.push(sendAction);
         }
 
         return sendAction;
@@ -484,7 +517,7 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
             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, [toActionObjects(utils.toArray(matchedActions), machine.options.actions)], predictableExec, preserveActionOrder), 2),
               resolvedActionsFromChoose = _b[0],
               resolvedContextFromChoose = _b[1];
 
@@ -501,7 +534,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), predictableExec, 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];
 
@@ -513,7 +546,7 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
       case actionTypes.stop:
         {
           var resolved = resolveStop(actionObject, updatedContext, _event);
-          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, updatedContext, _event);
+          predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(resolved, currentContext, _event);
           return resolved;
         }
 
@@ -547,9 +580,42 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
 
         return resolvedActionObject;
     }
-  }).filter(function (a) {
-    return !!a;
-  }));
+  }
+
+  function processBlock(block) {
+    var e_2, _a;
+
+    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);
+
+        if (resolved) {
+          resolvedActions = resolvedActions.concat(resolved);
+        }
+      }
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
+      };
+    } finally {
+      try {
+        if (block_1_1 && !block_1_1.done && (_a = block_1.return)) _a.call(block_1);
+      } finally {
+        if (e_2) throw e_2.error;
+      }
+    }
+
+    deferredToBlockEnd.forEach(function (action) {
+      predictableExec(action, updatedContext, _event);
+    });
+    deferredToBlockEnd.length = 0;
+    return resolvedActions;
+  }
+
+  var resolvedActions = utils.flatten(actionBlocks.map(processBlock));
   return [resolvedActions, updatedContext];
 }
 

package/lib/interpreter.d.ts

@@ -73,6 +73,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     sessionId: string;
     children: Map<string | number, ActorRef<any>>;
     private forwardTo;
+    private _outgoingQueue;
     private devTools?;
     /**
      * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.

package/lib/interpreter.js

@@ -62,6 +62,7 @@ function () {
     this.status = exports.InterpreterStatus.NotStarted;
     this.children = new Map();
     this.forwardTo = new Set();
+    this._outgoingQueue = [];
     /**
      * Alias for Interpreter.prototype.start
      */
@@ -136,14 +137,24 @@ function () {
         if (_this.status !== exports.InterpreterStatus.Stopped || _this.parent !== target || // we need to send events to the parent from exit handlers of a machine that reached its final state
         _this.state.done) {
           // Send SCXML events to machines
-          target.send(_tslib.__assign(_tslib.__assign({}, event), {
+          var scxmlEvent = _tslib.__assign(_tslib.__assign({}, event), {
             name: event.name === actionTypes.error ? "".concat(actions.error(_this.id)) : event.name,
             origin: _this.sessionId
-          }));
+          });
+
+          if (_this.machine.config.predictableActionArguments) {
+            _this._outgoingQueue.push([target, scxmlEvent]);
+          } else {
+            target.send(scxmlEvent);
+          }
         }
       } else {
         // Send normal events to other targets
-        target.send(event.data);
+        if (_this.machine.config.predictableActionArguments) {
+          _this._outgoingQueue.push([target, event.data]);
+        } else {
+          target.send(event.data);
+        }
       }
     };
 
@@ -388,6 +399,12 @@ function () {
     // we can't just recompute it (and execute actions while doing so) because we try to preserve identity of actors created within initial assigns
     _event === actions.initEvent) && this.options.execute) {
       this.execute(this.state);
+    } else {
+      var item = void 0;
+
+      while (item = this._outgoingQueue.shift()) {
+        item[0].send(item[1]);
+      }
     } // Update children
 
 
@@ -785,7 +802,7 @@ 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, [exitActions], _this.machine.config.predictableActionArguments ? _this._exec : undefined, _this.machine.config.predictableActionArguments || _this.machine.config.preserveActionOrder), 2),
             resolvedActions = _a[0],
             updatedContext = _a[1];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.33.2",
+  "version": "4.33.3",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "lib/index.js",
   "module": "es/index.js",