xstate 5.0.0-alpha.0 → 5.0.0-alpha.1

package/dist/xstate.cjs.dev.js

@@ -2,63 +2,844 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var guards_dist_xstateGuards = require('./actions-6b86876d.cjs.dev.js');
+var actors_dist_xstateActors = require('./actions-b08d0da8.cjs.dev.js');
 require('./index-2a564d03.cjs.dev.js');
-var Machine = require('./Machine-9ce74c11.cjs.dev.js');
 
 function pure(getActions) {
-  return guards_dist_xstateGuards.createDynamicAction(guards_dist_xstateGuards.pure, {
-    get: getActions
-  }, function (_ref, ctx, _event) {
+  return actors_dist_xstateActors.createDynamicAction({
+    type: actors_dist_xstateActors.pure,
+    params: {
+      get: getActions
+    }
+  }, function (_event, _ref) {
     var _toArray;
 
-    var params = _ref.params;
-    return {
-      type: guards_dist_xstateGuards.pure,
+    var state = _ref.state;
+    return [state, {
+      type: actors_dist_xstateActors.pure,
       params: {
-        actions: (_toArray = guards_dist_xstateGuards.toArray(params.get(ctx, _event.data))) !== null && _toArray !== void 0 ? _toArray : []
+        actions: (_toArray = actors_dist_xstateActors.toArray(getActions(state.context, _event.data))) !== null && _toArray !== void 0 ? _toArray : []
       }
-    };
+    }];
   });
 }
 
-function mapState(stateMap, stateId) {
-  var foundStateId;
+var _excluded = ["onDone", "onError"];
+var EMPTY_OBJECT = {};
+var StateNode = /*#__PURE__*/function () {
+  /**
+   * The relative key of the state node, which represents its location in the overall state value.
+   */
 
-  for (var _i = 0, _Object$keys = Object.keys(stateMap); _i < _Object$keys.length; _i++) {
-    var mappedStateId = _Object$keys[_i];
+  /**
+   * The unique ID of the state node.
+   */
 
-    if (guards_dist_xstateGuards.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
-      foundStateId = mappedStateId;
+  /**
+   * The type of this state node:
+   *
+   *  - `'atomic'` - no child state nodes
+   *  - `'compound'` - nested child state nodes (XOR)
+   *  - `'parallel'` - orthogonal nested child state nodes (AND)
+   *  - `'history'` - history state node
+   *  - `'final'` - final state node
+   */
+
+  /**
+   * The string path from the root machine node to this node.
+   */
+
+  /**
+   * The child state nodes.
+   */
+
+  /**
+   * The type of history on this state node. Can be:
+   *
+   *  - `'shallow'` - recalls only top-level historical state value
+   *  - `'deep'` - recalls historical state value at all levels
+   */
+
+  /**
+   * The action(s) to be executed upon entering the state node.
+   */
+
+  /**
+   * The action(s) to be executed upon exiting the state node.
+   */
+
+  /**
+   * The parent state node.
+   */
+
+  /**
+   * The root machine node.
+   */
+
+  /**
+   * The meta data associated with this state node, which will be returned in State instances.
+   */
+
+  /**
+   * The data sent with the "done.state._id_" event if this is a final state node.
+   */
+
+  /**
+   * The order this state node appears. Corresponds to the implicit SCXML document order.
+   */
+  function StateNode(
+  /**
+   * The raw config used to create the machine.
+   */
+  config, options) {
+    var _this = this;
+
+    actors_dist_xstateActors._classCallCheck(this, StateNode);
+
+    this.config = config;
+
+    actors_dist_xstateActors._defineProperty(this, "key", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "id", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "type", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "path", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "states", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "history", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "entry", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "exit", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "parent", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "machine", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "meta", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "doneData", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "order", -1);
+
+    actors_dist_xstateActors._defineProperty(this, "description", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "tags", []);
+
+    actors_dist_xstateActors._defineProperty(this, "transitions", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "always", void 0);
+
+    this.parent = options._parent;
+    this.key = options._key;
+    this.machine = options._machine;
+    this.path = this.parent ? this.parent.path.concat(this.key) : [];
+    this.id = this.config.id || [this.machine.id].concat(actors_dist_xstateActors._toConsumableArray(this.path)).join(this.machine.delimiter);
+    this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
+    this.description = this.config.description;
+    this.order = this.machine.idMap.size;
+    this.machine.idMap.set(this.id, this);
+    this.states = this.config.states ? actors_dist_xstateActors.mapValues(this.config.states, function (stateConfig, key) {
+      var stateNode = new StateNode(stateConfig, {
+        _parent: _this,
+        _key: key,
+        _machine: _this.machine
+      });
+      return stateNode;
+    }) : EMPTY_OBJECT;
+
+    if (this.type === 'compound' && !this.config.initial) {
+      throw new Error("No initial state specified for compound state node \"#".concat(this.id, "\". Try adding { initial: \"").concat(Object.keys(this.states)[0], "\" } to the state config."));
+    } // History config
+
+
+    this.history = this.config.history === true ? 'shallow' : this.config.history || false;
+    this.entry = actors_dist_xstateActors.toActionObjects(this.config.entry);
+    this.exit = actors_dist_xstateActors.toActionObjects(this.config.exit);
+    this.meta = this.config.meta;
+    this.doneData = this.type === 'final' ? this.config.data : undefined;
+    this.tags = actors_dist_xstateActors.toArray(config.tags);
+  }
+
+  actors_dist_xstateActors._createClass(StateNode, [{
+    key: "_initialize",
+    value: function _initialize() {
+      var _this2 = this;
+
+      this.transitions = actors_dist_xstateActors.formatTransitions(this);
+
+      if (this.config.always) {
+        this.always = actors_dist_xstateActors.toTransitionConfigArray(actors_dist_xstateActors.NULL_EVENT, this.config.always).map(function (t) {
+          return actors_dist_xstateActors.formatTransition(_this2, t);
+        });
+      }
+
+      Object.keys(this.states).forEach(function (key) {
+        _this2.states[key]._initialize();
+      });
+    }
+    /**
+     * The well-structured state node definition.
+     */
+
+  }, {
+    key: "definition",
+    get: function get() {
+      var _this3 = this;
+
+      return {
+        id: this.id,
+        key: this.key,
+        version: this.machine.version,
+        type: this.type,
+        initial: this.initial ? {
+          target: this.initial.target,
+          source: this,
+          actions: this.initial.actions,
+          eventType: null,
+          toJSON: function toJSON() {
+            return {
+              target: _this3.initial.target.map(function (t) {
+                return "#".concat(t.id);
+              }),
+              source: "#".concat(_this3.id),
+              actions: _this3.initial.actions,
+              eventType: null
+            };
+          }
+        } : undefined,
+        history: this.history,
+        states: actors_dist_xstateActors.mapValues(this.states, function (state) {
+          return state.definition;
+        }),
+        on: this.on,
+        transitions: this.transitions,
+        entry: this.entry,
+        exit: this.exit,
+        meta: this.meta,
+        order: this.order || -1,
+        data: this.doneData,
+        invoke: this.invoke,
+        description: this.description,
+        tags: this.tags
+      };
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return this.definition;
+    }
+    /**
+     * The behaviors invoked as actors by this state node.
+     */
+
+  }, {
+    key: "invoke",
+    get: function get() {
+      var _this4 = this;
+
+      return actors_dist_xstateActors.memo(this, 'invoke', function () {
+        return actors_dist_xstateActors.toArray(_this4.config.invoke).map(function (invocable, i) {
+          var generatedId = actors_dist_xstateActors.createInvokeId(_this4.id, i);
+          var invokeConfig = actors_dist_xstateActors.toInvokeConfig(invocable, generatedId);
+          var resolvedId = invokeConfig.id || generatedId;
+          var src = invokeConfig.src;
+          var resolvedSrc = actors_dist_xstateActors.toInvokeSource(actors_dist_xstateActors.isString(src) ? src : !('type' in src) ? resolvedId : src);
+
+          if (!_this4.machine.options.actors[resolvedId] && typeof src !== 'string' && !('type' in src)) {
+            _this4.machine.options.actors = actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, _this4.machine.options.actors), {}, actors_dist_xstateActors._defineProperty({}, resolvedId, typeof src === 'function' ? src : function () {
+              return src;
+            }));
+          }
+
+          return actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({
+            type: actors_dist_xstateActors.invoke
+          }, invokeConfig), {}, {
+            src: resolvedSrc,
+            id: resolvedId,
+            toJSON: function toJSON() {
+              var onDone = invokeConfig.onDone,
+                  onError = invokeConfig.onError,
+                  invokeDefValues = actors_dist_xstateActors._objectWithoutProperties(invokeConfig, _excluded);
+
+              return actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, invokeDefValues), {}, {
+                type: actors_dist_xstateActors.invoke,
+                src: resolvedSrc,
+                id: resolvedId
+              });
+            }
+          });
+        });
+      });
+    }
+    /**
+     * The mapping of events to transitions.
+     */
+
+  }, {
+    key: "on",
+    get: function get() {
+      var _this5 = this;
+
+      return actors_dist_xstateActors.memo(this, 'on', function () {
+        var transitions = _this5.transitions;
+        return transitions.reduce(function (map, transition) {
+          map[transition.eventType] = map[transition.eventType] || [];
+          map[transition.eventType].push(transition);
+          return map;
+        }, {});
+      });
+    }
+  }, {
+    key: "after",
+    get: function get() {
+      var _this6 = this;
+
+      return actors_dist_xstateActors.memo(this, 'delayedTransitions', function () {
+        return actors_dist_xstateActors.getDelayedTransitions(_this6);
+      });
+    }
+  }, {
+    key: "initial",
+    get: function get() {
+      var _this7 = this;
+
+      return actors_dist_xstateActors.memo(this, 'initial', function () {
+        return actors_dist_xstateActors.formatInitialTransition(_this7, _this7.config.initial || []);
+      });
+    }
+    /**
+     * Returns `true` if this state node explicitly handles the given event.
+     *
+     * @param event The event in question
+     */
+
+  }, {
+    key: "handles",
+    value: function handles(event) {
+      return this.events.includes(event.type);
+    }
+  }, {
+    key: "next",
+    value: function next(state, _event) {
+      var _this8 = this;
+
+      var eventName = _event.name;
+      var actions = [];
+      var selectedTransition;
+      var candidates = actors_dist_xstateActors.memo(this, "candidates-".concat(eventName.toString()), function () {
+        return actors_dist_xstateActors.getCandidates(_this8, eventName, _this8.machine.config.scxml // Whether token matching should be used
+        );
+      });
+
+      var _iterator = actors_dist_xstateActors._createForOfIteratorHelper(candidates),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var candidate = _step.value;
+          var guard = candidate.guard;
+          var resolvedContext = state.context;
+          var guardPassed = false;
+
+          try {
+            guardPassed = !guard || actors_dist_xstateActors.evaluateGuard(guard, resolvedContext, _event, state);
+          } catch (err) {
+            throw new Error("Unable to evaluate guard '".concat(guard.type, "' in transition for event '").concat(eventName, "' in state node '").concat(this.id, "':\n").concat(err.message));
+          }
+
+          if (guardPassed) {
+            actions.push.apply(actions, actors_dist_xstateActors._toConsumableArray(candidate.actions));
+            selectedTransition = candidate;
+            break;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      return selectedTransition ? [selectedTransition] : undefined;
+    }
+    /**
+     * The target state value of the history state node, if it exists. This represents the
+     * default state value to transition to if no history value exists yet.
+     */
+
+  }, {
+    key: "target",
+    get: function get() {
+      if (this.type === 'history') {
+        var historyConfig = this.config;
+        return historyConfig.target;
+      }
+
+      return undefined;
     }
+    /**
+     * All the state node IDs of this state node and its descendant state nodes.
+     */
+
+  }, {
+    key: "stateIds",
+    get: function get() {
+      var _this9 = this;
+
+      var childStateIds = actors_dist_xstateActors.flatten(Object.keys(this.states).map(function (stateKey) {
+        return _this9.states[stateKey].stateIds;
+      }));
+      return [this.id].concat(childStateIds);
+    }
+    /**
+     * All the event types accepted by this state node and its descendants.
+     */
+
+  }, {
+    key: "events",
+    get: function get() {
+      var _this10 = this;
+
+      return actors_dist_xstateActors.memo(this, 'events', function () {
+        var states = _this10.states;
+        var events = new Set(_this10.ownEvents);
+
+        if (states) {
+          for (var _i = 0, _Object$keys = Object.keys(states); _i < _Object$keys.length; _i++) {
+            var stateId = _Object$keys[_i];
+            var state = states[stateId];
+
+            if (state.states) {
+              var _iterator2 = actors_dist_xstateActors._createForOfIteratorHelper(state.events),
+                  _step2;
+
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var event = _step2.value;
+                  events.add("".concat(event));
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+            }
+          }
+        }
+
+        return Array.from(events);
+      });
+    }
+    /**
+     * All the events that have transitions directly from this state node.
+     *
+     * Excludes any inert events.
+     */
+
+  }, {
+    key: "ownEvents",
+    get: function get() {
+      var events = new Set(this.transitions.filter(function (transition) {
+        return !(!transition.target && !transition.actions.length && transition.internal);
+      }).map(function (transition) {
+        return transition.eventType;
+      }));
+      return Array.from(events);
+    }
+  }]);
+
+  return StateNode;
+}();
+
+var STATE_IDENTIFIER = '#';
+
+function createDefaultOptions() {
+  return {
+    actions: {},
+    actors: {},
+    delays: {},
+    guards: {},
+    context: {}
+  };
+}
+
+function resolveContext(context, partialContext) {
+  if (actors_dist_xstateActors.isFunction(partialContext)) {
+    return actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, context), partialContext);
   }
 
-  return stateMap[foundStateId];
+  return actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, context), partialContext);
 }
 
-function matchState(state, patterns, defaultValue) {
-  var resolvedState = guards_dist_xstateGuards.State.from(state, state instanceof guards_dist_xstateGuards.State ? state.context : undefined);
+var StateMachine = /*#__PURE__*/function () {
+  function StateMachine(
+  /**
+   * The raw config used to create the machine.
+   */
+  config, options) {
+    var _this$config$schema;
+
+    actors_dist_xstateActors._classCallCheck(this, StateMachine);
+
+    this.config = config;
+
+    actors_dist_xstateActors._defineProperty(this, "_contextFactory", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "version", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "delimiter", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "options", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "schema", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "__xstatenode", true);
+
+    actors_dist_xstateActors._defineProperty(this, "idMap", new Map());
+
+    actors_dist_xstateActors._defineProperty(this, "root", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "id", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "states", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "events", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "__TContext", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "__TEvent", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "__TAction", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "__TActorMap", void 0);
+
+    actors_dist_xstateActors._defineProperty(this, "__TResolvedTypesMeta", void 0);
+
+    this.id = config.id || '(machine)';
+    this.options = Object.assign(createDefaultOptions(), options);
+    this._contextFactory = actors_dist_xstateActors.isFunction(config.context) ? config.context : function (stuff) {
+      var partialContext = typeof (options === null || options === void 0 ? void 0 : options.context) === 'function' ? options.context(stuff) : options === null || options === void 0 ? void 0 : options.context;
+      return resolveContext(config.context, partialContext);
+    }; // TODO: fix types
+    // this.context = resolveContext(config.context, options?.context);
+
+    this.delimiter = this.config.delimiter || actors_dist_xstateActors.STATE_DELIMITER;
+    this.version = this.config.version;
+    this.schema = (_this$config$schema = this.config.schema) !== null && _this$config$schema !== void 0 ? _this$config$schema : {};
+    this.transition = this.transition.bind(this);
+    this.root = new StateNode(config, {
+      _key: this.id,
+      _machine: this
+    });
+
+    this.root._initialize();
+
+    this.states = this.root.states; // TODO: remove!
+
+    this.events = this.root.events;
+  }
+  /**
+   * Clones this state machine with the provided implementations
+   * and merges the `context` (if provided).
+   *
+   * @param implementations Options (`actions`, `guards`, `actors`, `delays`, `context`)
+   *  to recursively merge with the existing options.
+   *
+   * @returns A new `StateMachine` instance with the provided implementations.
+   */
+
+
+  actors_dist_xstateActors._createClass(StateMachine, [{
+    key: "context",
+    get: function get() {
+      return this.getContextAndActions()[0];
+    }
+  }, {
+    key: "getContextAndActions",
+    value: function getContextAndActions() {
+      var actions = []; // TODO: merge with this.options.context
+
+      var context = this._contextFactory({
+        spawn: actors_dist_xstateActors.createSpawner(this, null, null, actions) // TODO: fix types
+
+      });
+
+      return [context, actions];
+    }
+    /**
+     * The machine's own version.
+     */
+
+  }, {
+    key: "provide",
+    value: function provide(implementations) {
+      var _this$options = this.options,
+          actions = _this$options.actions,
+          guards = _this$options.guards,
+          actors = _this$options.actors,
+          delays = _this$options.delays;
+      return new StateMachine(this.config, {
+        actions: actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, actions), implementations.actions),
+        guards: actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, guards), implementations.guards),
+        actors: actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, actors), implementations.actors),
+        delays: actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, delays), implementations.delays),
+        context: implementations.context
+      });
+    }
+    /**
+     * Clones this state machine with custom `context`.
+     *
+     * The `context` provided can be partial `context`, which will be combined with the original `context`.
+     *
+     * @param context Custom context (will override predefined context, not recursive)
+     */
+
+  }, {
+    key: "withContext",
+    value: function withContext(context) {
+      return this.provide({
+        context: context
+      });
+    }
+    /**
+     * Resolves the given `state` to a new `State` instance relative to this machine.
+     *
+     * This ensures that `.nextEvents` represent the correct values.
+     *
+     * @param state The state to resolve
+     */
+
+  }, {
+    key: "resolveState",
+    value: function resolveState(state) {
+      var configurationSet = actors_dist_xstateActors.getConfiguration(actors_dist_xstateActors.getStateNodes(this.root, state.value));
+      var configuration = Array.from(configurationSet);
+      return this.createState(actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, state), {}, {
+        value: actors_dist_xstateActors.resolveStateValue(this.root, state.value),
+        configuration: configuration,
+        done: actors_dist_xstateActors.isInFinalState(configuration)
+      }));
+    }
+  }, {
+    key: "resolveStateValue",
+    value: function resolveStateValue(stateValue) {
+      var resolvedStateValue = actors_dist_xstateActors.resolveStateValue(this.root, stateValue);
+
+      var resolvedContext = this.context;
+      return this.resolveState(actors_dist_xstateActors.State.from(resolvedStateValue, resolvedContext, this));
+    }
+    /**
+     * Determines the next state given the current `state` and received `event`.
+     * Calculates a full macrostep from all microsteps.
+     *
+     * @param state The current State instance or state value
+     * @param event The received event
+     */
+
+  }, {
+    key: "transition",
+    value: function transition() {
+      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.initialState;
+      var event = arguments.length > 1 ? arguments[1] : undefined;
+      var actorCtx = arguments.length > 2 ? arguments[2] : undefined;
+      var currentState = state instanceof actors_dist_xstateActors.State ? state : this.resolveStateValue(state); // TODO: handle error events in a better way
+
+      var scxmlEvent = actors_dist_xstateActors.toSCXMLEvent(event);
+
+      if (actors_dist_xstateActors.isSCXMLErrorEvent(scxmlEvent) && !currentState.nextEvents.some(function (nextEvent) {
+        return nextEvent === scxmlEvent.name;
+      })) {
+        throw scxmlEvent.data.data;
+      }
+
+      var _macrostep = actors_dist_xstateActors.macrostep(currentState, scxmlEvent, actorCtx),
+          nextState = _macrostep.state;
+
+      return nextState;
+    }
+    /**
+     * Determines the next state given the current `state` and `event`.
+     * Calculates a microstep.
+     *
+     * @param state The current state
+     * @param event The received event
+     */
+
+  }, {
+    key: "microstep",
+    value: function microstep() {
+      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.initialState;
+      var event = arguments.length > 1 ? arguments[1] : undefined;
+      var actorCtx = arguments.length > 2 ? arguments[2] : undefined;
+      var scxmlEvent = actors_dist_xstateActors.toSCXMLEvent(event);
+
+      var _macrostep2 = actors_dist_xstateActors.macrostep(state, scxmlEvent, actorCtx),
+          microstates = _macrostep2.microstates;
+
+      return microstates;
+    }
+  }, {
+    key: "getTransitionData",
+    value: function getTransitionData(state, _event) {
+      return actors_dist_xstateActors.transitionNode(this.root, state.value, state, _event) || [];
+    }
+    /**
+     * The initial state _before_ evaluating any microsteps.
+     * This "pre-initial" state is provided to initial actions executed in the initial state.
+     */
+
+  }, {
+    key: "getPreInitialState",
+    value: function getPreInitialState(actorCtx) {
+      var _actorCtx$sessionId, _preInitial$actions;
 
-  var _iterator = guards_dist_xstateGuards._createForOfIteratorHelper(patterns),
-      _step;
+      var _this$getContextAndAc = this.getContextAndActions(),
+          _this$getContextAndAc2 = actors_dist_xstateActors._slicedToArray(_this$getContextAndAc, 2),
+          context = _this$getContextAndAc2[0],
+          actions = _this$getContextAndAc2[1];
+
+      var config = actors_dist_xstateActors.getInitialConfiguration(this.root);
+      var preInitial = this.resolveState(this.createState({
+        value: {},
+        // TODO: this is computed in state constructor
+        context: context,
+        _event: actors_dist_xstateActors.initEvent,
+        _sessionid: (_actorCtx$sessionId = actorCtx === null || actorCtx === void 0 ? void 0 : actorCtx.sessionId) !== null && _actorCtx$sessionId !== void 0 ? _actorCtx$sessionId : undefined,
+        actions: [],
+        meta: undefined,
+        configuration: config,
+        transitions: [],
+        children: {}
+      }));
+      preInitial._initial = true;
+
+      (_preInitial$actions = preInitial.actions).unshift.apply(_preInitial$actions, actors_dist_xstateActors._toConsumableArray(actions));
+
+      if (actorCtx) {
+        var _resolveActionsAndCon = actors_dist_xstateActors.resolveActionsAndContext(actions, actors_dist_xstateActors.initEvent, preInitial, actorCtx),
+            nextState = _resolveActionsAndCon.nextState;
+
+        preInitial.children = nextState.children;
+        preInitial.actions = nextState.actions;
+      }
+
+      return preInitial;
+    }
+    /**
+     * The initial State instance, which includes all actions to be executed from
+     * entering the initial state.
+     */
 
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = guards_dist_xstateGuards._slicedToArray(_step.value, 2),
-          stateValue = _step$value[0],
-          getValue = _step$value[1];
+  }, {
+    key: "initialState",
+    get: function get() {
+      return this.getInitialState();
+    }
+    /**
+     * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
+     */
+
+  }, {
+    key: "getInitialState",
+    value: function getInitialState(actorCtx) {
+      var _nextState$actions;
+
+      var preInitialState = this.getPreInitialState(actorCtx);
+      var nextState = actors_dist_xstateActors.microstep([], preInitialState, actorCtx, actors_dist_xstateActors.initEvent);
+
+      (_nextState$actions = nextState.actions).unshift.apply(_nextState$actions, actors_dist_xstateActors._toConsumableArray(preInitialState.actions));
+
+      var _macrostep3 = actors_dist_xstateActors.macrostep(nextState, actors_dist_xstateActors.initEvent, actorCtx),
+          macroState = _macrostep3.state;
+
+      return macroState;
+    }
+  }, {
+    key: "start",
+    value: function start(state, actorCtx) {
+      // When starting from a restored state, execute the actions
+      state.actions.forEach(function (action) {
+        var _action$execute;
+
+        (_action$execute = action.execute) === null || _action$execute === void 0 ? void 0 : _action$execute.call(action, actorCtx);
+      });
+      return state;
+    }
+  }, {
+    key: "getStateNodeById",
+    value: function getStateNodeById(stateId) {
+      var resolvedStateId = actors_dist_xstateActors.isStateId(stateId) ? stateId.slice(STATE_IDENTIFIER.length) : stateId;
+      var stateNode = this.idMap.get(resolvedStateId);
 
-      if (resolvedState.matches(stateValue)) {
-        return getValue(resolvedState);
+      if (!stateNode) {
+        throw new Error("Child state node '#".concat(resolvedStateId, "' does not exist on machine '").concat(this.id, "'"));
       }
+
+      return stateNode;
+    }
+  }, {
+    key: "definition",
+    get: function get() {
+      return actors_dist_xstateActors._objectSpread2({
+        context: this.context
+      }, this.root.definition);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return this.definition;
+    }
+  }, {
+    key: "createState",
+    value: function createState(stateConfig) {
+      var state = stateConfig instanceof actors_dist_xstateActors.State ? stateConfig : new actors_dist_xstateActors.State(stateConfig, this);
+
+      var _resolveActionsAndCon2 = actors_dist_xstateActors.resolveActionsAndContext(state.actions, state._event, state, undefined),
+          resolvedState = _resolveActionsAndCon2.nextState;
+
+      return resolvedState;
+    }
+  }, {
+    key: "getStatus",
+    value: function getStatus(state) {
+      return state.done ? {
+        status: 'done',
+        data: state.output
+      } : {
+        status: 'active'
+      };
+    }
+  }, {
+    key: "restoreState",
+    value: function restoreState(state, _actorCtx) {
+      var restoredState = actors_dist_xstateActors.isStateConfig(state) ? this.resolveState(state) : this.resolveState(actors_dist_xstateActors.State.from(state, this.context, this));
+      return restoredState;
+    }
+    /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
+
+  }]);
+
+  return StateMachine;
+}();
+
+function createMachine(config, implementations) {
+  return new StateMachine(config, implementations);
+}
+
+function mapState(stateMap, stateId) {
+  var foundStateId;
+
+  for (var _i = 0, _Object$keys = Object.keys(stateMap); _i < _Object$keys.length; _i++) {
+    var mappedStateId = _Object$keys[_i];
+
+    if (actors_dist_xstateActors.matchesState(mappedStateId, stateId) && (!foundStateId || stateId.length > foundStateId.length)) {
+      foundStateId = mappedStateId;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
 
-  return defaultValue(resolvedState);
+  return stateMap[foundStateId];
 }
 
 function createSchema(schema) {
@@ -68,16 +849,16 @@ var t = createSchema;
 
 var SimulatedClock = /*#__PURE__*/function () {
   function SimulatedClock() {
-    guards_dist_xstateGuards._classCallCheck(this, SimulatedClock);
+    actors_dist_xstateActors._classCallCheck(this, SimulatedClock);
 
-    guards_dist_xstateGuards._defineProperty(this, "timeouts", new Map());
+    actors_dist_xstateActors._defineProperty(this, "timeouts", new Map());
 
-    guards_dist_xstateGuards._defineProperty(this, "_now", 0);
+    actors_dist_xstateActors._defineProperty(this, "_now", 0);
 
-    guards_dist_xstateGuards._defineProperty(this, "_id", 0);
+    actors_dist_xstateActors._defineProperty(this, "_id", 0);
   }
 
-  guards_dist_xstateGuards._createClass(SimulatedClock, [{
+  actors_dist_xstateActors._createClass(SimulatedClock, [{
     key: "now",
     value: function now() {
       return this._now;
@@ -118,12 +899,12 @@ var SimulatedClock = /*#__PURE__*/function () {
     value: function flushTimeouts() {
       var _this = this;
 
-      guards_dist_xstateGuards._toConsumableArray(this.timeouts).sort(function (_ref, _ref2) {
-        var _ref3 = guards_dist_xstateGuards._slicedToArray(_ref, 2),
+      actors_dist_xstateActors._toConsumableArray(this.timeouts).sort(function (_ref, _ref2) {
+        var _ref3 = actors_dist_xstateActors._slicedToArray(_ref, 2),
             _idA = _ref3[0],
             timeoutA = _ref3[1];
 
-        var _ref4 = guards_dist_xstateGuards._slicedToArray(_ref2, 2),
+        var _ref4 = actors_dist_xstateActors._slicedToArray(_ref2, 2),
             _idB = _ref4[0],
             timeoutB = _ref4[1];
 
@@ -131,7 +912,7 @@ var SimulatedClock = /*#__PURE__*/function () {
         var endB = timeoutB.start + timeoutB.timeout;
         return endB > endA ? -1 : 1;
       }).forEach(function (_ref5) {
-        var _ref6 = guards_dist_xstateGuards._slicedToArray(_ref5, 2),
+        var _ref6 = actors_dist_xstateActors._slicedToArray(_ref5, 2),
             id = _ref6[0],
             timeout = _ref6[1];
 
@@ -154,64 +935,59 @@ var SimulatedClock = /*#__PURE__*/function () {
 }();
 
 var actions = {
-  raise: guards_dist_xstateGuards.raise,
-  send: guards_dist_xstateGuards.send,
-  sendParent: guards_dist_xstateGuards.sendParent,
-  sendTo: guards_dist_xstateGuards.sendTo,
-  sendUpdate: guards_dist_xstateGuards.sendUpdate,
-  log: guards_dist_xstateGuards.log,
-  cancel: guards_dist_xstateGuards.cancel,
-  stop: guards_dist_xstateGuards.stop,
-  assign: guards_dist_xstateGuards.assign,
-  after: guards_dist_xstateGuards.after,
-  done: guards_dist_xstateGuards.done,
-  respond: guards_dist_xstateGuards.respond,
-  forwardTo: guards_dist_xstateGuards.forwardTo,
-  escalate: guards_dist_xstateGuards.escalate,
-  choose: guards_dist_xstateGuards.choose,
+  raise: actors_dist_xstateActors.raise,
+  send: actors_dist_xstateActors.send,
+  sendParent: actors_dist_xstateActors.sendParent,
+  sendTo: actors_dist_xstateActors.sendTo,
+  log: actors_dist_xstateActors.log,
+  cancel: actors_dist_xstateActors.cancel,
+  stop: actors_dist_xstateActors.stop,
+  assign: actors_dist_xstateActors.assign,
+  after: actors_dist_xstateActors.after,
+  done: actors_dist_xstateActors.done,
+  respond: actors_dist_xstateActors.respond,
+  forwardTo: actors_dist_xstateActors.forwardTo,
+  escalate: actors_dist_xstateActors.escalate,
+  choose: actors_dist_xstateActors.choose,
   pure: pure
 };
 
 Object.defineProperty(exports, 'ActionTypes', {
   enumerable: true,
   get: function () {
-    return guards_dist_xstateGuards.ActionTypes;
+    return actors_dist_xstateActors.ActionTypes;
   }
 });
-exports.Interpreter = guards_dist_xstateGuards.Interpreter;
+exports.Interpreter = actors_dist_xstateActors.Interpreter;
 Object.defineProperty(exports, 'InterpreterStatus', {
   enumerable: true,
   get: function () {
-    return guards_dist_xstateGuards.InterpreterStatus;
+    return actors_dist_xstateActors.ActorStatus;
   }
 });
-exports.ObservableActorRef = guards_dist_xstateGuards.ObservableActorRef;
 Object.defineProperty(exports, 'SpecialTargets', {
   enumerable: true,
   get: function () {
-    return guards_dist_xstateGuards.SpecialTargets;
+    return actors_dist_xstateActors.SpecialTargets;
   }
 });
-exports.State = guards_dist_xstateGuards.State;
-exports.assign = guards_dist_xstateGuards.assign;
-exports.doneInvoke = guards_dist_xstateGuards.doneInvoke;
-exports.forwardTo = guards_dist_xstateGuards.forwardTo;
-exports.getStateNodes = guards_dist_xstateGuards.getStateNodes;
-exports.interpret = guards_dist_xstateGuards.interpret;
-exports.matchesState = guards_dist_xstateGuards.matchesState;
-exports.pathToStateValue = guards_dist_xstateGuards.pathToStateValue;
-exports.send = guards_dist_xstateGuards.send;
-exports.sendParent = guards_dist_xstateGuards.sendParent;
-exports.sendUpdate = guards_dist_xstateGuards.sendUpdate;
-exports.toEventObject = guards_dist_xstateGuards.toEventObject;
-exports.toObserver = guards_dist_xstateGuards.toObserver;
-exports.toSCXMLEvent = guards_dist_xstateGuards.toSCXMLEvent;
-exports.StateMachine = Machine.StateMachine;
-exports.StateNode = Machine.StateNode;
-exports.createMachine = Machine.createMachine;
+exports.State = actors_dist_xstateActors.State;
+exports.assign = actors_dist_xstateActors.assign;
+exports.doneInvoke = actors_dist_xstateActors.doneInvoke;
+exports.forwardTo = actors_dist_xstateActors.forwardTo;
+exports.getStateNodes = actors_dist_xstateActors.getStateNodes;
+exports.interpret = actors_dist_xstateActors.interpret;
+exports.matchesState = actors_dist_xstateActors.matchesState;
+exports.pathToStateValue = actors_dist_xstateActors.pathToStateValue;
+exports.send = actors_dist_xstateActors.send;
+exports.sendParent = actors_dist_xstateActors.sendParent;
+exports.toObserver = actors_dist_xstateActors.toObserver;
+exports.toSCXMLEvent = actors_dist_xstateActors.toSCXMLEvent;
 exports.SimulatedClock = SimulatedClock;
+exports.StateMachine = StateMachine;
+exports.StateNode = StateNode;
 exports.actions = actions;
+exports.createMachine = createMachine;
 exports.createSchema = createSchema;
 exports.mapState = mapState;
-exports.matchState = matchState;
 exports.t = t;