xstate 4.32.1 → 4.33.0

package/es/interpreter.js

@@ -1,13 +1,12 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
-import { ActionTypes, SpecialTargets } from './types.js';
+import { SpecialTargets, ActionTypes } from './types.js';
 import { isStateConfig, State, bindActionToState } from './State.js';
-import { errorPlatform, log, stop, start, cancel, send, update, error as error$1 } from './actionTypes.js';
-import { doneInvoke, initEvent, getActionFunction, error } from './actions.js';
+import { raise, send, errorPlatform, update, error as error$1, log, stop, start, cancel } from './actionTypes.js';
+import { initEvent, doneInvoke, toActionObjects, resolveActions, error, getActionFunction } from './actions.js';
 import { IS_PRODUCTION } from './environment.js';
-import { warn, mapContext, isFunction, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
+import { warn, mapContext, toObserver, toSCXMLEvent, flatten, isFunction, isPromiseLike, isObservable, isMachine, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, toInvokeSource, uniqueId } from './utils.js';
 import { Scheduler } from './scheduler.js';
-import { isSpawnedActor, createDeferredActor } from './Actor.js';
-import { isInFinalState } from './stateUtils.js';
+import { createDeferredActor, isSpawnedActor } from './Actor.js';
 import { registry } from './registry.js';
 import { getGlobal, registerService } from './devTools.js';
 import { provide, consume } from './serviceScope.js';
@@ -128,17 +127,176 @@ function () {
       }
 
       if ('machine' in target) {
-        // Send SCXML events to machines
-        target.send(__assign(__assign({}, event), {
-          name: event.name === error$1 ? "".concat(error(_this.id)) : event.name,
-          origin: _this.sessionId
-        }));
+        // perhaps those events should be rejected in the parent
+        // but atm it doesn't have easy access to all of the information that is required to do it reliably
+        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), {
+            name: event.name === error$1 ? "".concat(error(_this.id)) : event.name,
+            origin: _this.sessionId
+          }));
+        }
       } else {
         // Send normal events to other targets
         target.send(event.data);
       }
     };
 
+    this._exec = function (action, context, _event, actionFunctionMap) {
+      if (actionFunctionMap === void 0) {
+        actionFunctionMap = _this.machine.options.actions;
+      }
+
+      var actionOrExec = action.exec || getActionFunction(action.type, actionFunctionMap);
+      var exec = isFunction(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;
+
+      if (exec) {
+        try {
+          return exec(context, _event.data, !_this.machine.config.predictableActionArguments ? {
+            action: action,
+            state: _this.state,
+            _event: _event
+          } : {
+            action: action,
+            _event: _event
+          });
+        } catch (err) {
+          if (_this.parent) {
+            _this.parent.send({
+              type: 'xstate.error',
+              data: err
+            });
+          }
+
+          throw err;
+        }
+      }
+
+      switch (action.type) {
+        case send:
+          var sendAction = action;
+
+          if (typeof sendAction.delay === 'number') {
+            _this.defer(sendAction);
+
+            return;
+          } else {
+            if (sendAction.to) {
+              _this.sendTo(sendAction._event, sendAction.to);
+            } else {
+              _this.send(sendAction._event);
+            }
+          }
+
+          break;
+
+        case cancel:
+          _this.cancel(action.sendId);
+
+          break;
+
+        case start:
+          {
+            if (_this.status !== InterpreterStatus.Running) {
+              return;
+            }
+
+            var activity = action.activity; // If the activity will be stopped right after it's started
+            // (such as in transient states)
+            // don't bother starting the activity.
+
+            if ( // in v4 with `predictableActionArguments` invokes are called eagerly when the `this.state` still points to the previous state
+            !_this.machine.config.predictableActionArguments && !_this.state.activities[activity.id || activity.type]) {
+              break;
+            } // Invoked services
+
+
+            if (activity.type === ActionTypes.Invoke) {
+              var invokeSource = toInvokeSource(activity.src);
+              var serviceCreator = _this.machine.options.services ? _this.machine.options.services[invokeSource.type] : undefined;
+              var id = activity.id,
+                  data = activity.data;
+
+              if (!IS_PRODUCTION) {
+                warn(!('forward' in activity), // tslint:disable-next-line:max-line-length
+                "`forward` property is deprecated (found in invocation of '".concat(activity.src, "' in in machine '").concat(_this.machine.id, "'). ") + "Please use `autoForward` instead.");
+              }
+
+              var autoForward = 'autoForward' in activity ? activity.autoForward : !!activity.forward;
+
+              if (!serviceCreator) {
+                // tslint:disable-next-line:no-console
+                if (!IS_PRODUCTION) {
+                  warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(_this.machine.id, "'."));
+                }
+
+                return;
+              }
+
+              var resolvedData = data ? mapContext(data, context, _event) : undefined;
+
+              if (typeof serviceCreator === 'string') {
+                // TODO: warn
+                return;
+              }
+
+              var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
+                data: resolvedData,
+                src: invokeSource,
+                meta: activity.meta
+              }) : serviceCreator;
+
+              if (!source) {
+                // TODO: warn?
+                return;
+              }
+
+              var options = void 0;
+
+              if (isMachine(source)) {
+                source = resolvedData ? source.withContext(resolvedData) : source;
+                options = {
+                  autoForward: autoForward
+                };
+              }
+
+              _this.spawn(source, id, options);
+            } else {
+              _this.spawnActivity(activity);
+            }
+
+            break;
+          }
+
+        case stop:
+          {
+            _this.stopChild(action.activity.id);
+
+            break;
+          }
+
+        case log:
+          var label = action.label,
+              value = action.value;
+
+          if (label) {
+            _this.logger(label, value);
+          } else {
+            _this.logger(value);
+          }
+
+          break;
+
+        default:
+          if (!IS_PRODUCTION) {
+            warn(false, "No implementation found for action type '".concat(action.type, "'"));
+          }
+
+          break;
+      }
+    };
+
     var resolvedOptions = __assign(__assign({}, Interpreter.defaultOptions), options);
 
     var clock = resolvedOptions.clock,
@@ -222,7 +380,9 @@ function () {
 
     this._state = state; // Execute actions
 
-    if (this.options.execute) {
+    if ((!this.machine.config.predictableActionArguments || // this is currently required to execute initial actions as the `initialState` gets cached
+    // 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);
     } // Update children
 
@@ -289,9 +449,7 @@ function () {
       }
     }
 
-    var isDone = isInFinalState(state.configuration || [], this.machine);
-
-    if (this.state.configuration && isDone) {
+    if (this.state.done) {
       // get final child state node
       var finalChildStateNode = state.configuration.find(function (sn) {
         return sn.type === 'final' && sn.parent === _this.machine;
@@ -315,7 +473,7 @@ function () {
         }
       }
 
-      this.stop();
+      this._stop();
     }
   };
   /*
@@ -340,42 +498,35 @@ function () {
   completeListener) {
     var _this = this;
 
-    if (!nextListenerOrObserver) {
-      return {
-        unsubscribe: function () {
-          return void 0;
-        }
-      };
-    }
-
-    var listener;
-    var resolvedCompleteListener = completeListener;
+    var observer = toObserver(nextListenerOrObserver, _, completeListener);
+    this.listeners.add(observer.next); // Send current state to listener
 
-    if (typeof nextListenerOrObserver === 'function') {
-      listener = nextListenerOrObserver;
-    } else {
-      listener = nextListenerOrObserver.next.bind(nextListenerOrObserver);
-      resolvedCompleteListener = nextListenerOrObserver.complete.bind(nextListenerOrObserver);
+    if (this.status !== InterpreterStatus.NotStarted) {
+      observer.next(this.state);
     }
 
-    this.listeners.add(listener); // Send current state to listener
+    var completeOnce = function () {
+      _this.doneListeners.delete(completeOnce);
 
-    if (this.status !== InterpreterStatus.NotStarted) {
-      listener(this.state);
-    }
+      _this.stopListeners.delete(completeOnce);
 
-    if (resolvedCompleteListener) {
-      if (this.status === InterpreterStatus.Stopped) {
-        resolvedCompleteListener();
-      } else {
-        this.onDone(resolvedCompleteListener);
-      }
+      observer.complete();
+    };
+
+    if (this.status === InterpreterStatus.Stopped) {
+      observer.complete();
+    } else {
+      this.onDone(completeOnce);
+      this.onStop(completeOnce);
     }
 
     return {
       unsubscribe: function () {
-        listener && _this.listeners.delete(listener);
-        resolvedCompleteListener && _this.doneListeners.delete(resolvedCompleteListener);
+        _this.listeners.delete(observer.next);
+
+        _this.doneListeners.delete(completeOnce);
+
+        _this.stopListeners.delete(completeOnce);
       }
     };
   };
@@ -480,18 +631,10 @@ function () {
     });
     return this;
   };
-  /**
-   * Stops the interpreter and unsubscribe all listeners.
-   *
-   * This will also notify the `onStop` listeners.
-   */
-
 
-  Interpreter.prototype.stop = function () {
+  Interpreter.prototype._stop = function () {
     var e_6, _a, e_7, _b, e_8, _c, e_9, _d, e_10, _e;
 
-    var _this = this;
-
     try {
       for (var _f = __values(this.listeners), _g = _f.next(); !_g.done; _g = _f.next()) {
         var listener = _g.value;
@@ -567,40 +710,13 @@ function () {
       return this;
     }
 
-    __spreadArray([], __read(this.state.configuration), false).sort(function (a, b) {
-      return b.order - a.order;
-    }).forEach(function (stateNode) {
-      var e_11, _a;
-
-      try {
-        for (var _b = __values(stateNode.definition.exit), _c = _b.next(); !_c.done; _c = _b.next()) {
-          var action = _c.value;
-
-          _this.exec(action, _this.state);
-        }
-      } catch (e_11_1) {
-        e_11 = {
-          error: e_11_1
-        };
-      } finally {
-        try {
-          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-        } finally {
-          if (e_11) throw e_11.error;
-        }
-      }
-    }); // Stop all children
-
-
-    this.children.forEach(function (child) {
-      if (isFunction(child.stop)) {
-        child.stop();
-      }
-    });
-    this.children.clear();
+    this.initialized = false;
+    this.status = InterpreterStatus.Stopped;
+    this._initialState = undefined;
 
     try {
-      // Cancel all delayed events
+      // we are going to stop within the current sync frame
+      // so we can safely just cancel this here as nothing async should be fired anyway
       for (var _p = __values(Object.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
         var key = _q.value;
         this.clock.clearTimeout(this.delayedEventsMap[key]);
@@ -615,16 +731,85 @@ function () {
       } finally {
         if (e_10) throw e_10.error;
       }
-    }
+    } // clear everything that might be enqueued
+
 
     this.scheduler.clear();
     this.scheduler = new Scheduler({
       deferEvents: this.options.deferEvents
     });
-    this.initialized = false;
-    this.status = InterpreterStatus.Stopped;
-    this._initialState = undefined;
-    registry.free(this.sessionId);
+  };
+  /**
+   * Stops the interpreter and unsubscribe all listeners.
+   *
+   * This will also notify the `onStop` listeners.
+   */
+
+
+  Interpreter.prototype.stop = function () {
+    // TODO: add warning for stopping non-root interpreters
+    var _this = this; // grab the current scheduler as it will be replaced in _stop
+
+
+    var scheduler = this.scheduler;
+
+    this._stop(); // let what is currently processed to be finished
+
+
+    scheduler.schedule(function () {
+      // it feels weird to handle this here but we need to handle this even slightly "out of band"
+      var _event = toSCXMLEvent({
+        type: 'xstate.stop'
+      });
+
+      var nextState = provide(_this, function () {
+        var exitActions = flatten(__spreadArray([], __read(_this.state.configuration), false).sort(function (a, b) {
+          return b.order - a.order;
+        }).map(function (stateNode) {
+          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),
+            resolvedActions = _a[0],
+            updatedContext = _a[1];
+
+        var newState = new State({
+          value: _this.state.value,
+          context: updatedContext,
+          _event: _event,
+          _sessionid: _this.sessionId,
+          historyValue: undefined,
+          history: _this.state,
+          actions: resolvedActions.filter(function (action) {
+            return action.type !== raise && (action.type !== send || !!action.to && action.to !== SpecialTargets.Internal);
+          }),
+          activities: {},
+          events: [],
+          configuration: [],
+          transitions: [],
+          children: {},
+          done: _this.state.done,
+          tags: _this.state.tags,
+          machine: _this.machine
+        });
+        newState.changed = true;
+        return newState;
+      });
+
+      _this.update(nextState, _event); // TODO: think about converting those to actions
+      // Stop all children
+
+
+      _this.children.forEach(function (child) {
+        if (isFunction(child.stop)) {
+          child.stop();
+        }
+      });
+
+      _this.children.clear();
+
+      registry.free(_this.sessionId);
+    });
     return this;
   };
 
@@ -642,7 +827,7 @@ function () {
     }
 
     this.scheduler.schedule(function () {
-      var e_12, _a;
+      var e_11, _a;
 
       var nextState = _this.state;
       var batchChanged = false;
@@ -668,15 +853,15 @@ function () {
 
           _loop_1(event_1);
         }
-      } catch (e_12_1) {
-        e_12 = {
-          error: e_12_1
+      } catch (e_11_1) {
+        e_11 = {
+          error: e_11_1
         };
       } finally {
         try {
           if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
         } finally {
-          if (e_12) throw e_12.error;
+          if (e_11) throw e_11.error;
         }
       }
 
@@ -696,16 +881,8 @@ function () {
   Interpreter.prototype.sender = function (event) {
     return this.send.bind(this, event);
   };
-  /**
-   * Returns the next state given the interpreter's current state and the event.
-   *
-   * This is a pure method that does _not_ update the interpreter's state.
-   *
-   * @param event The event to determine the next state
-   */
-
 
-  Interpreter.prototype.nextState = function (event) {
+  Interpreter.prototype._nextState = function (event) {
     var _this = this;
 
     var _event = toSCXMLEvent(event);
@@ -717,13 +894,25 @@ function () {
     }
 
     var nextState = provide(this, function () {
-      return _this.machine.transition(_this.state, _event);
+      return _this.machine.transition(_this.state, _event, undefined, _this.machine.config.predictableActionArguments ? _this._exec : undefined);
     });
     return nextState;
   };
+  /**
+   * Returns the next state given the interpreter's current state and the event.
+   *
+   * This is a pure method that does _not_ update the interpreter's state.
+   *
+   * @param event The event to determine the next state
+   */
+
+
+  Interpreter.prototype.nextState = function (event) {
+    return this._nextState(event);
+  };
 
   Interpreter.prototype.forward = function (event) {
-    var e_13, _a;
+    var e_12, _a;
 
     try {
       for (var _b = __values(this.forwardTo), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -736,15 +925,15 @@ function () {
 
         child.send(event);
       }
-    } catch (e_13_1) {
-      e_13 = {
-        error: e_13_1
+    } catch (e_12_1) {
+      e_12 = {
+        error: e_12_1
       };
     } finally {
       try {
         if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
       } finally {
-        if (e_13) throw e_13.error;
+        if (e_12) throw e_12.error;
       }
     }
   };
@@ -771,150 +960,7 @@ function () {
       actionFunctionMap = this.machine.options.actions;
     }
 
-    var context = state.context,
-        _event = state._event;
-    var actionOrExec = action.exec || getActionFunction(action.type, actionFunctionMap);
-    var exec = isFunction(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;
-
-    if (exec) {
-      try {
-        return exec(context, _event.data, {
-          action: action,
-          state: this.state,
-          _event: _event
-        });
-      } catch (err) {
-        if (this.parent) {
-          this.parent.send({
-            type: 'xstate.error',
-            data: err
-          });
-        }
-
-        throw err;
-      }
-    }
-
-    switch (action.type) {
-      case send:
-        var sendAction = action;
-
-        if (typeof sendAction.delay === 'number') {
-          this.defer(sendAction);
-          return;
-        } else {
-          if (sendAction.to) {
-            this.sendTo(sendAction._event, sendAction.to);
-          } else {
-            this.send(sendAction._event);
-          }
-        }
-
-        break;
-
-      case cancel:
-        this.cancel(action.sendId);
-        break;
-
-      case start:
-        {
-          if (this.status !== InterpreterStatus.Running) {
-            return;
-          }
-
-          var activity = action.activity; // If the activity will be stopped right after it's started
-          // (such as in transient states)
-          // don't bother starting the activity.
-
-          if (!this.state.activities[activity.id || activity.type]) {
-            break;
-          } // Invoked services
-
-
-          if (activity.type === ActionTypes.Invoke) {
-            var invokeSource = toInvokeSource(activity.src);
-            var serviceCreator = this.machine.options.services ? this.machine.options.services[invokeSource.type] : undefined;
-            var id = activity.id,
-                data = activity.data;
-
-            if (!IS_PRODUCTION) {
-              warn(!('forward' in activity), // tslint:disable-next-line:max-line-length
-              "`forward` property is deprecated (found in invocation of '".concat(activity.src, "' in in machine '").concat(this.machine.id, "'). ") + "Please use `autoForward` instead.");
-            }
-
-            var autoForward = 'autoForward' in activity ? activity.autoForward : !!activity.forward;
-
-            if (!serviceCreator) {
-              // tslint:disable-next-line:no-console
-              if (!IS_PRODUCTION) {
-                warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(this.machine.id, "'."));
-              }
-
-              return;
-            }
-
-            var resolvedData = data ? mapContext(data, context, _event) : undefined;
-
-            if (typeof serviceCreator === 'string') {
-              // TODO: warn
-              return;
-            }
-
-            var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
-              data: resolvedData,
-              src: invokeSource,
-              meta: activity.meta
-            }) : serviceCreator;
-
-            if (!source) {
-              // TODO: warn?
-              return;
-            }
-
-            var options = void 0;
-
-            if (isMachine(source)) {
-              source = resolvedData ? source.withContext(resolvedData) : source;
-              options = {
-                autoForward: autoForward
-              };
-            }
-
-            this.spawn(source, id, options);
-          } else {
-            this.spawnActivity(activity);
-          }
-
-          break;
-        }
-
-      case stop:
-        {
-          this.stopChild(action.activity.id);
-          break;
-        }
-
-      case log:
-        var label = action.label,
-            value = action.value;
-
-        if (label) {
-          this.logger(label, value);
-        } else {
-          this.logger(value);
-        }
-
-        break;
-
-      default:
-        if (!IS_PRODUCTION) {
-          warn(false, "No implementation found for action type '".concat(action.type, "'"));
-        }
-
-        break;
-    }
-
-    return undefined;
+    this._exec(action, state.context, state._event, actionFunctionMap);
   };
 
   Interpreter.prototype.removeChild = function (childId) {
@@ -942,6 +988,10 @@ function () {
   };
 
   Interpreter.prototype.spawn = function (entity, name, options) {
+    if (this.status !== InterpreterStatus.Running) {
+      return createDeferredActor(entity, name);
+    }
+
     if (isPromiseLike(entity)) {
       return this.spawnPromise(Promise.resolve(entity), name);
     } else if (isFunction(entity)) {