xstate 4.31.0 → 4.33.0

package/lib/actions.js

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

package/lib/interpreter.d.ts

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