xstate 4.35.2 → 5.0.0-alpha.1

package/lib/interpreter.js

@@ -1,1494 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _tslib = require('./_virtual/_tslib.js');
-var types = require('./types.js');
-var State = require('./State.js');
-var actionTypes = require('./actionTypes.js');
-var actions = require('./actions.js');
-var environment = require('./environment.js');
-var utils = require('./utils.js');
-var scheduler = require('./scheduler.js');
-var Actor = require('./Actor.js');
-var registry = require('./registry.js');
-var devTools = require('./devTools.js');
-var serviceScope = require('./serviceScope.js');
-var behaviors = require('./behaviors.js');
-
-var DEFAULT_SPAWN_OPTIONS = {
-  sync: false,
-  autoForward: false
-};
-exports.InterpreterStatus = void 0;
-
-(function (InterpreterStatus) {
-  InterpreterStatus[InterpreterStatus["NotStarted"] = 0] = "NotStarted";
-  InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
-  InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
-})(exports.InterpreterStatus || (exports.InterpreterStatus = {}));
-
-var Interpreter =
-/*#__PURE__*/
-
-/** @class */
-function () {
-  /**
-   * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
-   *
-   * @param machine The machine to be interpreted
-   * @param options Interpreter options
-   */
-  function Interpreter(machine, options) {
-    if (options === void 0) {
-      options = Interpreter.defaultOptions;
-    }
-
-    var _this = this;
-
-    this.machine = machine;
-    this.delayedEventsMap = {};
-    this.listeners = new Set();
-    this.contextListeners = new Set();
-    this.stopListeners = new Set();
-    this.doneListeners = new Set();
-    this.eventListeners = new Set();
-    this.sendListeners = new Set();
-    /**
-     * Whether the service is started.
-     */
-
-    this.initialized = false;
-    this.status = exports.InterpreterStatus.NotStarted;
-    this.children = new Map();
-    this.forwardTo = new Set();
-    this._outgoingQueue = [];
-    /**
-     * Alias for Interpreter.prototype.start
-     */
-
-    this.init = this.start;
-    /**
-     * Sends an event to the running interpreter to trigger a transition.
-     *
-     * An array of events (batched) can be sent as well, which will send all
-     * batched events to the running interpreter. The listeners will be
-     * notified only **once** when all events are processed.
-     *
-     * @param event The event(s) to send
-     */
-
-    this.send = function (event, payload) {
-      if (utils.isArray(event)) {
-        _this.batch(event);
-
-        return _this.state;
-      }
-
-      var _event = utils.toSCXMLEvent(utils.toEventObject(event, payload));
-
-      if (_this.status === exports.InterpreterStatus.Stopped) {
-        // do nothing
-        if (!environment.IS_PRODUCTION) {
-          utils.warn(false, "Event \"".concat(_event.name, "\" was sent to stopped service \"").concat(_this.machine.id, "\". This service has already reached its final state, and will not transition.\nEvent: ").concat(JSON.stringify(_event.data)));
-        }
-
-        return _this.state;
-      }
-
-      if (_this.status !== exports.InterpreterStatus.Running && !_this.options.deferEvents) {
-        throw new Error("Event \"".concat(_event.name, "\" was sent to uninitialized service \"").concat(_this.machine.id // tslint:disable-next-line:max-line-length
-        , "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.\nEvent: ").concat(JSON.stringify(_event.data)));
-      }
-
-      _this.scheduler.schedule(function () {
-        // Forward copy of event to child actors
-        _this.forward(_event);
-
-        var nextState = _this._nextState(_event);
-
-        _this.update(nextState, _event);
-      });
-
-      return _this._state; // TODO: deprecate (should return void)
-      // tslint:disable-next-line:semicolon
-    };
-
-    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;
-
-      if (!target) {
-        if (!isParent) {
-          throw new Error("Unable to send event to child '".concat(to, "' from service '").concat(_this.id, "'."));
-        } // tslint:disable-next-line:no-console
-
-
-        if (!environment.IS_PRODUCTION) {
-          utils.warn(false, "Service '".concat(_this.id, "' has no parent: unable to send event ").concat(event.type));
-        }
-
-        return;
-      }
-
-      if ('machine' in target) {
-        // 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
-          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
-        if (!immediate && _this.machine.config.predictableActionArguments) {
-          _this._outgoingQueue.push([target, event.data]);
-        } else {
-          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, _event === actions.initEvent);
-            } 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,
-        logger = resolvedOptions.logger,
-        parent = resolvedOptions.parent,
-        id = resolvedOptions.id;
-    var resolvedId = id !== undefined ? id : machine.id;
-    this.id = resolvedId;
-    this.logger = logger;
-    this.clock = clock;
-    this.parent = parent;
-    this.options = resolvedOptions;
-    this.scheduler = new scheduler.Scheduler({
-      deferEvents: this.options.deferEvents
-    });
-    this.sessionId = registry.registry.bookId();
-  }
-
-  Object.defineProperty(Interpreter.prototype, "initialState", {
-    get: function () {
-      var _this = this;
-
-      if (this._initialState) {
-        return this._initialState;
-      }
-
-      return serviceScope.provide(this, function () {
-        _this._initialState = _this.machine.initialState;
-        return _this._initialState;
-      });
-    },
-    enumerable: false,
-    configurable: true
-  });
-  Object.defineProperty(Interpreter.prototype, "state", {
-    /**
-     * @deprecated Use `.getSnapshot()` instead.
-     */
-    get: function () {
-      if (!environment.IS_PRODUCTION) {
-        utils.warn(this.status !== exports.InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '".concat(this.id, "'. Make sure the service is started first."));
-      }
-
-      return this._state;
-    },
-    enumerable: false,
-    configurable: true
-  });
-  /**
-   * Executes the actions of the given state, with that state's `context` and `event`.
-   *
-   * @param state The state whose actions will be executed
-   * @param actionsConfig The action implementations to use
-   */
-
-  Interpreter.prototype.execute = function (state, actionsConfig) {
-    var e_1, _a;
-
-    try {
-      for (var _b = _tslib.__values(state.actions), _c = _b.next(); !_c.done; _c = _b.next()) {
-        var action = _c.value;
-        this.exec(action, state, actionsConfig);
-      }
-    } catch (e_1_1) {
-      e_1 = {
-        error: e_1_1
-      };
-    } finally {
-      try {
-        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-      } finally {
-        if (e_1) throw e_1.error;
-      }
-    }
-  };
-
-  Interpreter.prototype.update = function (state, _event) {
-    var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
-
-    var _this = this; // Attach session ID to state
-
-
-    state._sessionid = this.sessionId; // Update state
-
-    this._state = state; // Execute actions
-
-    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);
-    } else {
-      var item = void 0;
-
-      while (item = this._outgoingQueue.shift()) {
-        item[0].send(item[1]);
-      }
-    } // Update children
-
-
-    this.children.forEach(function (child) {
-      _this.state.children[child.id] = child;
-    }); // Dev tools
-
-    if (this.devTools) {
-      this.devTools.send(_event.data, state);
-    } // Execute listeners
-
-
-    if (state.event) {
-      try {
-        for (var _e = _tslib.__values(this.eventListeners), _f = _e.next(); !_f.done; _f = _e.next()) {
-          var listener = _f.value;
-          listener(state.event);
-        }
-      } catch (e_2_1) {
-        e_2 = {
-          error: e_2_1
-        };
-      } finally {
-        try {
-          if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
-        } finally {
-          if (e_2) throw e_2.error;
-        }
-      }
-    }
-
-    try {
-      for (var _g = _tslib.__values(this.listeners), _h = _g.next(); !_h.done; _h = _g.next()) {
-        var listener = _h.value;
-        listener(state, state.event);
-      }
-    } catch (e_3_1) {
-      e_3 = {
-        error: e_3_1
-      };
-    } finally {
-      try {
-        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-      } finally {
-        if (e_3) throw e_3.error;
-      }
-    }
-
-    try {
-      for (var _j = _tslib.__values(this.contextListeners), _k = _j.next(); !_k.done; _k = _j.next()) {
-        var contextListener = _k.value;
-        contextListener(this.state.context, this.state.history ? this.state.history.context : undefined);
-      }
-    } catch (e_4_1) {
-      e_4 = {
-        error: e_4_1
-      };
-    } finally {
-      try {
-        if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
-      } finally {
-        if (e_4) throw e_4.error;
-      }
-    }
-
-    if (this.state.done) {
-      // get final child state node
-      var finalChildStateNode = state.configuration.find(function (sn) {
-        return sn.type === 'final' && sn.parent === _this.machine;
-      });
-      var doneData = finalChildStateNode && finalChildStateNode.doneData ? utils.mapContext(finalChildStateNode.doneData, state.context, _event) : undefined;
-
-      try {
-        for (var _l = _tslib.__values(this.doneListeners), _m = _l.next(); !_m.done; _m = _l.next()) {
-          var listener = _m.value;
-          listener(actions.doneInvoke(this.id, doneData));
-        }
-      } catch (e_5_1) {
-        e_5 = {
-          error: e_5_1
-        };
-      } finally {
-        try {
-          if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
-        } finally {
-          if (e_5) throw e_5.error;
-        }
-      }
-
-      this._stop();
-
-      this._stopChildren();
-    }
-  };
-  /*
-   * Adds a listener that is notified whenever a state transition happens. The listener is called with
-   * the next state and the event object that caused the state transition.
-   *
-   * @param listener The state listener
-   */
-
-
-  Interpreter.prototype.onTransition = function (listener) {
-    this.listeners.add(listener); // Send current state to listener
-
-    if (this.status === exports.InterpreterStatus.Running) {
-      listener(this.state, this.state.event);
-    }
-
-    return this;
-  };
-
-  Interpreter.prototype.subscribe = function (nextListenerOrObserver, _, // TODO: error listener
-  completeListener) {
-    var _this = this;
-
-    var observer = utils.toObserver(nextListenerOrObserver, _, completeListener);
-    this.listeners.add(observer.next); // Send current state to listener
-
-    if (this.status !== exports.InterpreterStatus.NotStarted) {
-      observer.next(this.state);
-    }
-
-    var completeOnce = function () {
-      _this.doneListeners.delete(completeOnce);
-
-      _this.stopListeners.delete(completeOnce);
-
-      observer.complete();
-    };
-
-    if (this.status === exports.InterpreterStatus.Stopped) {
-      observer.complete();
-    } else {
-      this.onDone(completeOnce);
-      this.onStop(completeOnce);
-    }
-
-    return {
-      unsubscribe: function () {
-        _this.listeners.delete(observer.next);
-
-        _this.doneListeners.delete(completeOnce);
-
-        _this.stopListeners.delete(completeOnce);
-      }
-    };
-  };
-  /**
-   * Adds an event listener that is notified whenever an event is sent to the running interpreter.
-   * @param listener The event listener
-   */
-
-
-  Interpreter.prototype.onEvent = function (listener) {
-    this.eventListeners.add(listener);
-    return this;
-  };
-  /**
-   * Adds an event listener that is notified whenever a `send` event occurs.
-   * @param listener The event listener
-   */
-
-
-  Interpreter.prototype.onSend = function (listener) {
-    this.sendListeners.add(listener);
-    return this;
-  };
-  /**
-   * Adds a context listener that is notified whenever the state context changes.
-   * @param listener The context listener
-   */
-
-
-  Interpreter.prototype.onChange = function (listener) {
-    this.contextListeners.add(listener);
-    return this;
-  };
-  /**
-   * Adds a listener that is notified when the machine is stopped.
-   * @param listener The listener
-   */
-
-
-  Interpreter.prototype.onStop = function (listener) {
-    this.stopListeners.add(listener);
-    return this;
-  };
-  /**
-   * Adds a state listener that is notified when the statechart has reached its final state.
-   * @param listener The state listener
-   */
-
-
-  Interpreter.prototype.onDone = function (listener) {
-    this.doneListeners.add(listener);
-    return this;
-  };
-  /**
-   * Removes a listener.
-   * @param listener The listener to remove
-   */
-
-
-  Interpreter.prototype.off = function (listener) {
-    this.listeners.delete(listener);
-    this.eventListeners.delete(listener);
-    this.sendListeners.delete(listener);
-    this.stopListeners.delete(listener);
-    this.doneListeners.delete(listener);
-    this.contextListeners.delete(listener);
-    return this;
-  };
-  /**
-   * Starts the interpreter from the given state, or the initial state.
-   * @param initialState The state to start the statechart from
-   */
-
-
-  Interpreter.prototype.start = function (initialState) {
-    var _this = this;
-
-    if (this.status === exports.InterpreterStatus.Running) {
-      // Do not restart the service if it is already started
-      return this;
-    } // yes, it's a hack but we need the related cache to be populated for some things to work (like delayed transitions)
-    // this is usually called by `machine.getInitialState` but if we rehydrate from a state we might bypass this call
-    // we also don't want to call this method here as it resolves the full initial state which might involve calling assign actions
-    // and that could potentially lead to some unwanted side-effects (even such as creating some rogue actors)
-
-
-    this.machine._init();
-
-    registry.registry.register(this.sessionId, this);
-    this.initialized = true;
-    this.status = exports.InterpreterStatus.Running;
-    var resolvedState = initialState === undefined ? this.initialState : serviceScope.provide(this, function () {
-      return State.isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.State.from(initialState, _this.machine.context));
-    });
-
-    if (this.options.devTools) {
-      this.attachDev();
-    }
-
-    this.scheduler.initialize(function () {
-      _this.update(resolvedState, actions.initEvent);
-    });
-    return this;
-  };
-
-  Interpreter.prototype._stopChildren = function () {
-    // TODO: think about converting those to actions
-    this.children.forEach(function (child) {
-      if (utils.isFunction(child.stop)) {
-        child.stop();
-      }
-    });
-    this.children.clear();
-  };
-
-  Interpreter.prototype._stop = function () {
-    var e_6, _a, e_7, _b, e_8, _c, e_9, _d, e_10, _e;
-
-    try {
-      for (var _f = _tslib.__values(this.listeners), _g = _f.next(); !_g.done; _g = _f.next()) {
-        var listener = _g.value;
-        this.listeners.delete(listener);
-      }
-    } catch (e_6_1) {
-      e_6 = {
-        error: e_6_1
-      };
-    } finally {
-      try {
-        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
-      } finally {
-        if (e_6) throw e_6.error;
-      }
-    }
-
-    try {
-      for (var _h = _tslib.__values(this.stopListeners), _j = _h.next(); !_j.done; _j = _h.next()) {
-        var listener = _j.value; // call listener, then remove
-
-        listener();
-        this.stopListeners.delete(listener);
-      }
-    } catch (e_7_1) {
-      e_7 = {
-        error: e_7_1
-      };
-    } finally {
-      try {
-        if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
-      } finally {
-        if (e_7) throw e_7.error;
-      }
-    }
-
-    try {
-      for (var _k = _tslib.__values(this.contextListeners), _l = _k.next(); !_l.done; _l = _k.next()) {
-        var listener = _l.value;
-        this.contextListeners.delete(listener);
-      }
-    } catch (e_8_1) {
-      e_8 = {
-        error: e_8_1
-      };
-    } finally {
-      try {
-        if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
-      } finally {
-        if (e_8) throw e_8.error;
-      }
-    }
-
-    try {
-      for (var _m = _tslib.__values(this.doneListeners), _o = _m.next(); !_o.done; _o = _m.next()) {
-        var listener = _o.value;
-        this.doneListeners.delete(listener);
-      }
-    } catch (e_9_1) {
-      e_9 = {
-        error: e_9_1
-      };
-    } finally {
-      try {
-        if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
-      } finally {
-        if (e_9) throw e_9.error;
-      }
-    }
-
-    if (!this.initialized) {
-      // Interpreter already stopped; do nothing
-      return this;
-    }
-
-    this.initialized = false;
-    this.status = exports.InterpreterStatus.Stopped;
-    this._initialState = undefined;
-
-    try {
-      // 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]);
-      }
-    } catch (e_10_1) {
-      e_10 = {
-        error: e_10_1
-      };
-    } finally {
-      try {
-        if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
-      } 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
-    });
-  };
-  /**
-   * 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, [{
-          type: 'exit',
-          actions: 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);
-
-      _this._stopChildren();
-
-      registry.registry.free(_this.sessionId);
-    });
-    return this;
-  };
-
-  Interpreter.prototype.batch = function (events) {
-    var _this = this;
-
-    if (this.status === exports.InterpreterStatus.NotStarted && this.options.deferEvents) {
-      // tslint:disable-next-line:no-console
-      if (!environment.IS_PRODUCTION) {
-        utils.warn(false, "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\" and are deferred. Make sure .start() is called for this service.\nEvent: ").concat(JSON.stringify(event)));
-      }
-    } else if (this.status !== exports.InterpreterStatus.Running) {
-      throw new Error( // tslint:disable-next-line:max-line-length
-      "".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;
-
-      var nextState = _this.state;
-      var batchChanged = false;
-      var batchedActions = [];
-
-      var _loop_1 = function (event_1) {
-        var _event = utils.toSCXMLEvent(event_1);
-
-        _this.forward(_event);
-
-        nextState = serviceScope.provide(_this, function () {
-          return _this.machine.transition(nextState, _event, undefined, exec || undefined);
-        });
-        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;
-      };
-
-      try {
-        for (var events_1 = _tslib.__values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
-          var event_1 = events_1_1.value;
-
-          _loop_1(event_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_11) throw e_11.error;
-        }
-      }
-
-      nextState.changed = batchChanged;
-      nextState.actions = batchedActions;
-
-      _this.update(nextState, utils.toSCXMLEvent(events[events.length - 1]));
-    });
-  };
-  /**
-   * Returns a send function bound to this interpreter instance.
-   *
-   * @param event The event to be sent by the sender.
-   */
-
-
-  Interpreter.prototype.sender = function (event) {
-    return this.send.bind(this, event);
-  };
-
-  Interpreter.prototype._nextState = function (event, exec) {
-    var _this = this;
-
-    if (exec === void 0) {
-      exec = !!this.machine.config.predictableActionArguments && this._exec;
-    }
-
-    var _event = utils.toSCXMLEvent(event);
-
-    if (_event.name.indexOf(actionTypes.errorPlatform) === 0 && !this.state.nextEvents.some(function (nextEvent) {
-      return nextEvent.indexOf(actionTypes.errorPlatform) === 0;
-    })) {
-      throw _event.data.data;
-    }
-
-    var nextState = serviceScope.provide(this, function () {
-      return _this.machine.transition(_this.state, _event, undefined, 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, false);
-  };
-
-  Interpreter.prototype.forward = function (event) {
-    var e_12, _a;
-
-    try {
-      for (var _b = _tslib.__values(this.forwardTo), _c = _b.next(); !_c.done; _c = _b.next()) {
-        var id = _c.value;
-        var child = this.children.get(id);
-
-        if (!child) {
-          throw new Error("Unable to forward event '".concat(event, "' from interpreter '").concat(this.id, "' to nonexistant child '").concat(id, "'."));
-        }
-
-        child.send(event);
-      }
-    } 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_12) throw e_12.error;
-      }
-    }
-  };
-
-  Interpreter.prototype.defer = function (sendAction) {
-    var _this = this;
-
-    this.delayedEventsMap[sendAction.id] = this.clock.setTimeout(function () {
-      if (sendAction.to) {
-        _this.sendTo(sendAction._event, sendAction.to, true);
-      } else {
-        _this.send(sendAction._event);
-      }
-    }, sendAction.delay);
-  };
-
-  Interpreter.prototype.cancel = function (sendId) {
-    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
-    delete this.delayedEventsMap[sendId];
-  };
-
-  Interpreter.prototype.exec = function (action, state, actionFunctionMap) {
-    if (actionFunctionMap === void 0) {
-      actionFunctionMap = this.machine.options.actions;
-    }
-
-    this._exec(action, state.context, state._event, actionFunctionMap);
-  };
-
-  Interpreter.prototype.removeChild = function (childId) {
-    var _a;
-
-    this.children.delete(childId);
-    this.forwardTo.delete(childId); // this.state might not exist at the time this is called,
-    // such as when a child is added then removed while initializing the state
-
-    (_a = this.state) === null || _a === void 0 ? true : delete _a.children[childId];
-  };
-
-  Interpreter.prototype.stopChild = function (childId) {
-    var child = this.children.get(childId);
-
-    if (!child) {
-      return;
-    }
-
-    this.removeChild(childId);
-
-    if (utils.isFunction(child.stop)) {
-      child.stop();
-    }
-  };
-
-  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)) {
-      return this.spawnCallback(entity, name);
-    } else if (Actor.isSpawnedActor(entity)) {
-      return this.spawnActor(entity, name);
-    } else if (utils.isObservable(entity)) {
-      return this.spawnObservable(entity, name);
-    } else if (utils.isMachine(entity)) {
-      return this.spawnMachine(entity, _tslib.__assign(_tslib.__assign({}, options), {
-        id: name
-      }));
-    } else if (utils.isBehavior(entity)) {
-      return this.spawnBehavior(entity, name);
-    } else {
-      throw new Error("Unable to spawn entity \"".concat(name, "\" of type \"").concat(typeof entity, "\"."));
-    }
-  };
-
-  Interpreter.prototype.spawnMachine = function (machine, options) {
-    var _this = this;
-
-    if (options === void 0) {
-      options = {};
-    }
-
-    var childService = new Interpreter(machine, _tslib.__assign(_tslib.__assign({}, this.options), {
-      parent: this,
-      id: options.id || machine.id
-    }));
-
-    var resolvedOptions = _tslib.__assign(_tslib.__assign({}, DEFAULT_SPAWN_OPTIONS), options);
-
-    if (resolvedOptions.sync) {
-      childService.onTransition(function (state) {
-        _this.send(actionTypes.update, {
-          state: state,
-          id: childService.id
-        });
-      });
-    }
-
-    var actor = childService;
-    this.children.set(childService.id, actor);
-
-    if (resolvedOptions.autoForward) {
-      this.forwardTo.add(childService.id);
-    }
-
-    childService.onDone(function (doneEvent) {
-      _this.removeChild(childService.id);
-
-      _this.send(utils.toSCXMLEvent(doneEvent, {
-        origin: childService.id
-      }));
-    }).start();
-    return actor;
-  };
-
-  Interpreter.prototype.spawnBehavior = function (behavior, id) {
-    var actorRef = behaviors.spawnBehavior(behavior, {
-      id: id,
-      parent: this
-    });
-    this.children.set(id, actorRef);
-    return actorRef;
-  };
-
-  Interpreter.prototype.spawnPromise = function (promise, id) {
-    var _a;
-
-    var _this = this;
-
-    var canceled = false;
-    var resolvedData;
-    promise.then(function (response) {
-      if (!canceled) {
-        resolvedData = response;
-
-        _this.removeChild(id);
-
-        _this.send(utils.toSCXMLEvent(actions.doneInvoke(id, response), {
-          origin: id
-        }));
-      }
-    }, function (errorData) {
-      if (!canceled) {
-        _this.removeChild(id);
-
-        var errorEvent = actions.error(id, errorData);
-
-        try {
-          // Send "error.platform.id" to this (parent).
-          _this.send(utils.toSCXMLEvent(errorEvent, {
-            origin: id
-          }));
-        } catch (error) {
-          utils.reportUnhandledExceptionOnInvocation(errorData, error, id);
-
-          if (_this.devTools) {
-            _this.devTools.send(errorEvent, _this.state);
-          }
-
-          if (_this.machine.strict) {
-            // it would be better to always stop the state machine if unhandled
-            // exception/promise rejection happens but because we don't want to
-            // break existing code so enforce it on strict mode only especially so
-            // because documentation says that onError is optional
-            _this.stop();
-          }
-        }
-      }
-    });
-    var actor = (_a = {
-      id: id,
-      send: function () {
-        return void 0;
-      },
-      subscribe: function (next, handleError, complete) {
-        var observer = utils.toObserver(next, handleError, complete);
-        var unsubscribed = false;
-        promise.then(function (response) {
-          if (unsubscribed) {
-            return;
-          }
-
-          observer.next(response);
-
-          if (unsubscribed) {
-            return;
-          }
-
-          observer.complete();
-        }, function (err) {
-          if (unsubscribed) {
-            return;
-          }
-
-          observer.error(err);
-        });
-        return {
-          unsubscribe: function () {
-            return unsubscribed = true;
-          }
-        };
-      },
-      stop: function () {
-        canceled = true;
-      },
-      toJSON: function () {
-        return {
-          id: id
-        };
-      },
-      getSnapshot: function () {
-        return resolvedData;
-      }
-    }, _a[utils.symbolObservable] = function () {
-      return this;
-    }, _a);
-    this.children.set(id, actor);
-    return actor;
-  };
-
-  Interpreter.prototype.spawnCallback = function (callback, id) {
-    var _a;
-
-    var _this = this;
-
-    var canceled = false;
-    var receivers = new Set();
-    var listeners = new Set();
-    var emitted;
-
-    var receive = function (e) {
-      emitted = e;
-      listeners.forEach(function (listener) {
-        return listener(e);
-      });
-
-      if (canceled) {
-        return;
-      }
-
-      _this.send(utils.toSCXMLEvent(e, {
-        origin: id
-      }));
-    };
-
-    var callbackStop;
-
-    try {
-      callbackStop = callback(receive, function (newListener) {
-        receivers.add(newListener);
-      });
-    } catch (err) {
-      this.send(actions.error(id, err));
-    }
-
-    if (utils.isPromiseLike(callbackStop)) {
-      // it turned out to be an async function, can't reliably check this before calling `callback`
-      // because transpiled async functions are not recognizable
-      return this.spawnPromise(callbackStop, id);
-    }
-
-    var actor = (_a = {
-      id: id,
-      send: function (event) {
-        return receivers.forEach(function (receiver) {
-          return receiver(event);
-        });
-      },
-      subscribe: function (next) {
-        var observer = utils.toObserver(next);
-        listeners.add(observer.next);
-        return {
-          unsubscribe: function () {
-            listeners.delete(observer.next);
-          }
-        };
-      },
-      stop: function () {
-        canceled = true;
-
-        if (utils.isFunction(callbackStop)) {
-          callbackStop();
-        }
-      },
-      toJSON: function () {
-        return {
-          id: id
-        };
-      },
-      getSnapshot: function () {
-        return emitted;
-      }
-    }, _a[utils.symbolObservable] = function () {
-      return this;
-    }, _a);
-    this.children.set(id, actor);
-    return actor;
-  };
-
-  Interpreter.prototype.spawnObservable = function (source, id) {
-    var _a;
-
-    var _this = this;
-
-    var emitted;
-    var subscription = source.subscribe(function (value) {
-      emitted = value;
-
-      _this.send(utils.toSCXMLEvent(value, {
-        origin: id
-      }));
-    }, function (err) {
-      _this.removeChild(id);
-
-      _this.send(utils.toSCXMLEvent(actions.error(id, err), {
-        origin: id
-      }));
-    }, function () {
-      _this.removeChild(id);
-
-      _this.send(utils.toSCXMLEvent(actions.doneInvoke(id), {
-        origin: id
-      }));
-    });
-    var actor = (_a = {
-      id: id,
-      send: function () {
-        return void 0;
-      },
-      subscribe: function (next, handleError, complete) {
-        return source.subscribe(next, handleError, complete);
-      },
-      stop: function () {
-        return subscription.unsubscribe();
-      },
-      getSnapshot: function () {
-        return emitted;
-      },
-      toJSON: function () {
-        return {
-          id: id
-        };
-      }
-    }, _a[utils.symbolObservable] = function () {
-      return this;
-    }, _a);
-    this.children.set(id, actor);
-    return actor;
-  };
-
-  Interpreter.prototype.spawnActor = function (actor, name) {
-    this.children.set(name, actor);
-    return actor;
-  };
-
-  Interpreter.prototype.spawnActivity = function (activity) {
-    var implementation = this.machine.options && this.machine.options.activities ? this.machine.options.activities[activity.type] : undefined;
-
-    if (!implementation) {
-      if (!environment.IS_PRODUCTION) {
-        utils.warn(false, "No implementation found for activity '".concat(activity.type, "'"));
-      } // tslint:disable-next-line:no-console
-
-
-      return;
-    } // Start implementation
-
-
-    var dispose = implementation(this.state.context, activity);
-    this.spawnEffect(activity.id, dispose);
-  };
-
-  Interpreter.prototype.spawnEffect = function (id, dispose) {
-    var _a;
-
-    this.children.set(id, (_a = {
-      id: id,
-      send: function () {
-        return void 0;
-      },
-      subscribe: function () {
-        return {
-          unsubscribe: function () {
-            return void 0;
-          }
-        };
-      },
-      stop: dispose || undefined,
-      getSnapshot: function () {
-        return undefined;
-      },
-      toJSON: function () {
-        return {
-          id: id
-        };
-      }
-    }, _a[utils.symbolObservable] = function () {
-      return this;
-    }, _a));
-  };
-
-  Interpreter.prototype.attachDev = function () {
-    var global = devTools.getGlobal();
-
-    if (this.options.devTools && global) {
-      if (global.__REDUX_DEVTOOLS_EXTENSION__) {
-        var devToolsOptions = typeof this.options.devTools === 'object' ? this.options.devTools : undefined;
-        this.devTools = global.__REDUX_DEVTOOLS_EXTENSION__.connect(_tslib.__assign(_tslib.__assign({
-          name: this.id,
-          autoPause: true,
-          stateSanitizer: function (state) {
-            return {
-              value: state.value,
-              context: state.context,
-              actions: state.actions
-            };
-          }
-        }, devToolsOptions), {
-          features: _tslib.__assign({
-            jump: false,
-            skip: false
-          }, devToolsOptions ? devToolsOptions.features : undefined)
-        }), this.machine);
-        this.devTools.init(this.state);
-      } // add XState-specific dev tooling hook
-
-
-      devTools.registerService(this);
-    }
-  };
-
-  Interpreter.prototype.toJSON = function () {
-    return {
-      id: this.id
-    };
-  };
-
-  Interpreter.prototype[utils.symbolObservable] = function () {
-    return this;
-  };
-
-  Interpreter.prototype.getSnapshot = function () {
-    if (this.status === exports.InterpreterStatus.NotStarted) {
-      return this.initialState;
-    }
-
-    return this._state;
-  };
-  /**
-   * The default interpreter options:
-   *
-   * - `clock` uses the global `setTimeout` and `clearTimeout` functions
-   * - `logger` uses the global `console.log()` method
-   */
-
-
-  Interpreter.defaultOptions = {
-    execute: true,
-    deferEvents: true,
-    clock: {
-      setTimeout: function (fn, ms) {
-        return setTimeout(fn, ms);
-      },
-      clearTimeout: function (id) {
-        return clearTimeout(id);
-      }
-    },
-    logger: /*#__PURE__*/console.log.bind(console),
-    devTools: false
-  };
-  Interpreter.interpret = interpret;
-  return Interpreter;
-}();
-
-var resolveSpawnOptions = function (nameOrOptions) {
-  if (utils.isString(nameOrOptions)) {
-    return _tslib.__assign(_tslib.__assign({}, DEFAULT_SPAWN_OPTIONS), {
-      name: nameOrOptions
-    });
-  }
-
-  return _tslib.__assign(_tslib.__assign(_tslib.__assign({}, DEFAULT_SPAWN_OPTIONS), {
-    name: utils.uniqueId()
-  }), nameOrOptions);
-};
-
-function spawn(entity, nameOrOptions) {
-  var resolvedOptions = resolveSpawnOptions(nameOrOptions);
-  return serviceScope.consume(function (service) {
-    if (!environment.IS_PRODUCTION) {
-      var isLazyEntity = utils.isMachine(entity) || utils.isFunction(entity);
-      utils.warn(!!service || isLazyEntity, "Attempted to spawn an Actor (ID: \"".concat(utils.isMachine(entity) ? entity.id : 'undefined', "\") outside of a service. This will have no effect."));
-    }
-
-    if (service) {
-      return service.spawn(entity, resolvedOptions.name, resolvedOptions);
-    } else {
-      return Actor.createDeferredActor(entity, resolvedOptions.name);
-    }
-  });
-}
-/**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
- *
- * @param machine The machine to interpret
- * @param options Interpreter options
- */
-
-function interpret(machine, options) {
-  var interpreter = new Interpreter(machine, options);
-  return interpreter;
-}
-
-exports.Interpreter = Interpreter;
-exports.interpret = interpret;
-exports.spawn = spawn;