xstate 4.31.0 → 4.33.0

package/lib/interpreter.js

@@ -11,7 +11,6 @@ var environment = require('./environment.js');
 var utils = require('./utils.js');
 var scheduler = require('./scheduler.js');
 var Actor = require('./Actor.js');
-var stateUtils = require('./stateUtils.js');
 var registry = require('./registry.js');
 var devTools = require('./devTools.js');
 var serviceScope = require('./serviceScope.js');
@@ -132,17 +131,176 @@ function () {
       }
 
       if ('machine' in target) {
-        // Send SCXML events to machines
-        target.send(_tslib.__assign(_tslib.__assign({}, event), {
-          name: event.name === actionTypes.error ? "".concat(actions.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 !== 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), {
+            name: event.name === actionTypes.error ? "".concat(actions.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 || actions.getActionFunction(action.type, actionFunctionMap);
+      var exec = utils.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 actionTypes.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 actionTypes.cancel:
+          _this.cancel(action.sendId);
+
+          break;
+
+        case actionTypes.start:
+          {
+            if (_this.status !== exports.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 === types.ActionTypes.Invoke) {
+              var invokeSource = utils.toInvokeSource(activity.src);
+              var serviceCreator = _this.machine.options.services ? _this.machine.options.services[invokeSource.type] : undefined;
+              var id = activity.id,
+                  data = activity.data;
+
+              if (!environment.IS_PRODUCTION) {
+                utils.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 (!environment.IS_PRODUCTION) {
+                  utils.warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(_this.machine.id, "'."));
+                }
+
+                return;
+              }
+
+              var resolvedData = data ? utils.mapContext(data, context, _event) : undefined;
+
+              if (typeof serviceCreator === 'string') {
+                // TODO: warn
+                return;
+              }
+
+              var source = utils.isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
+                data: resolvedData,
+                src: invokeSource,
+                meta: activity.meta
+              }) : serviceCreator;
+
+              if (!source) {
+                // TODO: warn?
+                return;
+              }
+
+              var options = void 0;
+
+              if (utils.isMachine(source)) {
+                source = resolvedData ? source.withContext(resolvedData) : source;
+                options = {
+                  autoForward: autoForward
+                };
+              }
+
+              _this.spawn(source, id, options);
+            } else {
+              _this.spawnActivity(activity);
+            }
+
+            break;
+          }
+
+        case actionTypes.stop:
+          {
+            _this.stopChild(action.activity.id);
+
+            break;
+          }
+
+        case actionTypes.log:
+          var label = action.label,
+              value = action.value;
+
+          if (label) {
+            _this.logger(label, value);
+          } else {
+            _this.logger(value);
+          }
+
+          break;
+
+        default:
+          if (!environment.IS_PRODUCTION) {
+            utils.warn(false, "No implementation found for action type '".concat(action.type, "'"));
+          }
+
+          break;
+      }
+    };
+
     var resolvedOptions = _tslib.__assign(_tslib.__assign({}, Interpreter.defaultOptions), options);
 
     var clock = resolvedOptions.clock,
@@ -226,7 +384,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 === actions.initEvent) && this.options.execute) {
       this.execute(this.state);
     } // Update children
 
@@ -293,9 +453,7 @@ function () {
       }
     }
 
-    var isDone = stateUtils.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;
@@ -319,7 +477,7 @@ function () {
         }
       }
 
-      this.stop();
+      this._stop();
     }
   };
   /*
@@ -344,42 +502,35 @@ function () {
   completeListener) {
     var _this = this;
 
-    if (!nextListenerOrObserver) {
-      return {
-        unsubscribe: function () {
-          return void 0;
-        }
-      };
-    }
-
-    var listener;
-    var resolvedCompleteListener = completeListener;
+    var observer = utils.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 !== exports.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 !== exports.InterpreterStatus.NotStarted) {
-      listener(this.state);
-    }
+      _this.stopListeners.delete(completeOnce);
 
-    if (resolvedCompleteListener) {
-      if (this.status === exports.InterpreterStatus.Stopped) {
-        resolvedCompleteListener();
-      } else {
-        this.onDone(resolvedCompleteListener);
-      }
+      observer.complete();
+    };
+
+    if (this.status === exports.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);
       }
     };
   };
@@ -484,18 +635,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 = _tslib.__values(this.listeners), _g = _f.next(); !_g.done; _g = _f.next()) {
         var listener = _g.value;
@@ -571,40 +714,13 @@ function () {
       return this;
     }
 
-    _tslib.__spreadArray([], _tslib.__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 = _tslib.__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 (utils.isFunction(child.stop)) {
-        child.stop();
-      }
-    });
-    this.children.clear();
+    this.initialized = false;
+    this.status = exports.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 = _tslib.__values(Object.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
         var key = _q.value;
         this.clock.clearTimeout(this.delayedEventsMap[key]);
@@ -619,16 +735,85 @@ function () {
       } finally {
         if (e_10) throw e_10.error;
       }
-    }
+    } // clear everything that might be enqueued
+
 
     this.scheduler.clear();
     this.scheduler = new scheduler.Scheduler({
       deferEvents: this.options.deferEvents
     });
-    this.initialized = false;
-    this.status = exports.InterpreterStatus.Stopped;
-    this._initialState = undefined;
-    registry.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 = utils.toSCXMLEvent({
+        type: 'xstate.stop'
+      });
+
+      var nextState = serviceScope.provide(_this, function () {
+        var exitActions = utils.flatten(_tslib.__spreadArray([], _tslib.__read(_this.state.configuration), false).sort(function (a, b) {
+          return b.order - a.order;
+        }).map(function (stateNode) {
+          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),
+            resolvedActions = _a[0],
+            updatedContext = _a[1];
+
+        var newState = new State.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 !== actionTypes.raise && (action.type !== actionTypes.send || !!action.to && action.to !== types.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 (utils.isFunction(child.stop)) {
+          child.stop();
+        }
+      });
+
+      _this.children.clear();
+
+      registry.registry.free(_this.sessionId);
+    });
     return this;
   };
 
@@ -646,7 +831,7 @@ function () {
     }
 
     this.scheduler.schedule(function () {
-      var e_12, _a;
+      var e_11, _a;
 
       var nextState = _this.state;
       var batchChanged = false;
@@ -672,15 +857,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;
         }
       }
 
@@ -700,16 +885,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 = utils.toSCXMLEvent(event);
@@ -721,13 +898,25 @@ function () {
     }
 
     var nextState = serviceScope.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 = _tslib.__values(this.forwardTo), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -740,15 +929,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;
       }
     }
   };
@@ -775,150 +964,7 @@ function () {
       actionFunctionMap = this.machine.options.actions;
     }
 
-    var context = state.context,
-        _event = state._event;
-    var actionOrExec = action.exec || actions.getActionFunction(action.type, actionFunctionMap);
-    var exec = utils.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 actionTypes.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 actionTypes.cancel:
-        this.cancel(action.sendId);
-        break;
-
-      case actionTypes.start:
-        {
-          if (this.status !== exports.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 === types.ActionTypes.Invoke) {
-            var invokeSource = utils.toInvokeSource(activity.src);
-            var serviceCreator = this.machine.options.services ? this.machine.options.services[invokeSource.type] : undefined;
-            var id = activity.id,
-                data = activity.data;
-
-            if (!environment.IS_PRODUCTION) {
-              utils.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 (!environment.IS_PRODUCTION) {
-                utils.warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(this.machine.id, "'."));
-              }
-
-              return;
-            }
-
-            var resolvedData = data ? utils.mapContext(data, context, _event) : undefined;
-
-            if (typeof serviceCreator === 'string') {
-              // TODO: warn
-              return;
-            }
-
-            var source = utils.isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
-              data: resolvedData,
-              src: invokeSource,
-              meta: activity.meta
-            }) : serviceCreator;
-
-            if (!source) {
-              // TODO: warn?
-              return;
-            }
-
-            var options = void 0;
-
-            if (utils.isMachine(source)) {
-              source = resolvedData ? source.withContext(resolvedData) : source;
-              options = {
-                autoForward: autoForward
-              };
-            }
-
-            this.spawn(source, id, options);
-          } else {
-            this.spawnActivity(activity);
-          }
-
-          break;
-        }
-
-      case actionTypes.stop:
-        {
-          this.stopChild(action.activity.id);
-          break;
-        }
-
-      case actionTypes.log:
-        var label = action.label,
-            value = action.value;
-
-        if (label) {
-          this.logger(label, value);
-        } else {
-          this.logger(value);
-        }
-
-        break;
-
-      default:
-        if (!environment.IS_PRODUCTION) {
-          utils.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) {
@@ -946,6 +992,10 @@ function () {
   };
 
   Interpreter.prototype.spawn = function (entity, name, options) {
+    if (this.status !== exports.InterpreterStatus.Running) {
+      return Actor.createDeferredActor(entity, name);
+    }
+
     if (utils.isPromiseLike(entity)) {
       return this.spawnPromise(Promise.resolve(entity), name);
     } else if (utils.isFunction(entity)) {