xstate 4.33.2 → 4.33.5

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.
@@ -128,7 +129,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     /**
      * Alias for Interpreter.prototype.start
      */
-    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | undefined) => this;
+    init: (initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateConfig<TContext, TEvent> | StateValue) => this;
     /**
      * Starts the interpreter from the given state, or the initial state.
      * @param initialState The state to start the statechart from
@@ -151,7 +152,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event(s) to send
      */
-    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData) => State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
     private batch;
     /**
      * Returns a send function bound to this interpreter instance.
@@ -177,7 +178,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     private removeChild;
     private stopChild;
     spawn(entity: Spawnable, name: string, options?: SpawnOptions): ActorRef<any>;
-    spawnMachine<TChildContext, TChildStateSchema, TChildEvent extends EventObject>(machine: StateMachine<TChildContext, TChildStateSchema, TChildEvent>, options?: {
+    spawnMachine<TChildContext, TChildStateSchema extends StateSchema, TChildEvent extends EventObject>(machine: StateMachine<TChildContext, TChildStateSchema, TChildEvent>, options?: {
         id?: string;
         autoForward?: boolean;
         sync?: boolean;

package/lib/interpreter.js

@@ -40,12 +40,12 @@ function () {
    * @param options Interpreter options
    */
   function Interpreter(machine, options) {
-    var _this = this;
-
     if (options === void 0) {
       options = Interpreter.defaultOptions;
     }
 
+    var _this = this;
+
     this.machine = machine;
     this.delayedEventsMap = {};
     this.listeners = new Set();
@@ -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
      */
@@ -113,7 +114,7 @@ function () {
       // tslint:disable-next-line:semicolon
     };
 
-    this.sendTo = function (event, to) {
+    this.sendTo = function (event, to, immediate) {
       var isParent = _this.parent && (to === types.SpecialTargets.Parent || _this.parent.id === to);
       var target = isParent ? _this.parent : utils.isString(to) ? _this.children.get(to) || registry.registry.get(to) : utils.isActor(to) ? to : undefined;
 
@@ -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 (!immediate && _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 (!immediate && _this.machine.config.predictableActionArguments) {
+          _this._outgoingQueue.push([target, event.data]);
+        } else {
+          target.send(event.data);
+        }
       }
     };
 
@@ -187,7 +198,7 @@ function () {
             return;
           } else {
             if (sendAction.to) {
-              _this.sendTo(sendAction._event, sendAction.to);
+              _this.sendTo(sendAction._event, sendAction.to, _event === actions.initEvent);
             } else {
               _this.send(sendAction._event);
             }
@@ -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];
 
@@ -834,6 +851,11 @@ function () {
       "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options."));
     }
 
+    if (!events.length) {
+      return;
+    }
+
+    var exec = !!this.machine.config.predictableActionArguments && this._exec;
     this.scheduler.schedule(function () {
       var e_11, _a;
 
@@ -847,9 +869,9 @@ function () {
         _this.forward(_event);
 
         nextState = serviceScope.provide(_this, function () {
-          return _this.machine.transition(nextState, _event);
+          return _this.machine.transition(nextState, _event, undefined, exec || undefined);
         });
-        batchedActions.push.apply(batchedActions, _tslib.__spreadArray([], _tslib.__read(nextState.actions.map(function (a) {
+        batchedActions.push.apply(batchedActions, _tslib.__spreadArray([], _tslib.__read(_this.machine.config.predictableActionArguments ? nextState.actions : nextState.actions.map(function (a) {
           return State.bindActionToState(a, nextState);
         })), false));
         batchChanged = batchChanged || !!nextState.changed;
@@ -955,7 +977,7 @@ function () {
 
     this.delayedEventsMap[sendAction.id] = this.clock.setTimeout(function () {
       if (sendAction.to) {
-        _this.sendTo(sendAction._event, sendAction.to);
+        _this.sendTo(sendAction._event, sendAction.to, true);
       } else {
         _this.send(sendAction._event);
       }

package/lib/types.d.ts

@@ -228,13 +228,13 @@ export declare type DelayedTransitions<TContext, TEvent extends EventObject> = R
 export declare type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | string;
 export declare type SingleOrArray<T> = T[] | T;
 export declare type StateNodesConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
-    [K in keyof TStateSchema['states']]: StateNode<TContext, TStateSchema['states'][K], TEvent>;
+    [K in keyof TStateSchema['states']]: StateNode<TContext, TStateSchema['states'][K] & {}, TEvent>;
 };
 export declare type StatesConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = {
-    [K in keyof TStateSchema['states']]: StateNodeConfig<TContext, TStateSchema['states'][K], TEvent, TAction>;
+    [K in keyof TStateSchema['states']]: StateNodeConfig<TContext, TStateSchema['states'][K] & {}, TEvent, TAction>;
 };
 export declare type StatesDefinition<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
-    [K in keyof TStateSchema['states']]: StateNodeDefinition<TContext, TStateSchema['states'][K], TEvent>;
+    [K in keyof TStateSchema['states']]: StateNodeDefinition<TContext, TStateSchema['states'][K] & {}, TEvent>;
 };
 export declare type TransitionConfigTarget<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
 export declare type TransitionConfigOrTarget<TContext, TEvent extends EventObject> = SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TEvent>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.33.2",
+  "version": "4.33.5",
   "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.5.2",
+    "typescript": "^4.8.2",
     "xml-js": "^1.6.11"
   }
 }