xstate 5.0.0-alpha.6 → 5.0.0-beta.10

package/dist/xstate.cjs.dev.js

@@ -2,30 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-bf7bb1c5.cjs.dev.js');
+var actors_dist_xstateActors = require('./actions-109712d3.cjs.dev.js');
 require('./index-ebaab3c9.cjs.dev.js');
 
-function pure(getActions) {
-  return actors_dist_xstateActors.createDynamicAction({
-    type: actors_dist_xstateActors.pure,
-    params: {
-      get: getActions
-    }
-  }, function (_event, _ref) {
-    var _toArray;
-    var state = _ref.state;
-    return [state, {
-      type: actors_dist_xstateActors.pure,
-      params: {
-        actions: (_toArray = actors_dist_xstateActors.toArray(actors_dist_xstateActors.toActionObjects(getActions({
-          context: state.context,
-          event: _event.data
-        })))) !== null && _toArray !== void 0 ? _toArray : []
-      }
-    }];
-  });
-}
-
 var _excluded = ["onDone", "onError"];
 var EMPTY_OBJECT = {};
 var StateNode = /*#__PURE__*/function () {
@@ -87,7 +66,7 @@ var StateNode = /*#__PURE__*/function () {
    */
 
   /**
-   * The order this state node appears. Corresponds to the implicit SCXML document order.
+   * The order this state node appears. Corresponds to the implicit document order.
    */
 
   function StateNode(
@@ -176,7 +155,7 @@ var StateNode = /*#__PURE__*/function () {
           source: this,
           actions: this.initial.actions,
           eventType: null,
-          external: false,
+          reenter: false,
           toJSON: function toJSON() {
             return {
               target: _this3.initial.target.map(function (t) {
@@ -235,9 +214,9 @@ var StateNode = /*#__PURE__*/function () {
             id: resolvedId,
             systemId: systemId,
             toJSON: function toJSON() {
-              var onDone = invokeConfig.onDone,
-                onError = invokeConfig.onError,
-                invokeDefValues = actors_dist_xstateActors._objectWithoutProperties(invokeConfig, _excluded);
+              invokeConfig.onDone;
+                invokeConfig.onError;
+                var invokeDefValues = actors_dist_xstateActors._objectWithoutProperties(invokeConfig, _excluded);
               return actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, invokeDefValues), {}, {
                 type: actors_dist_xstateActors.invoke,
                 src: resolvedSrc,
@@ -281,27 +260,15 @@ var StateNode = /*#__PURE__*/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) {
+    value: function next(state, event) {
       var _this8 = this;
-      var eventName = _event.name;
+      var eventType = event.type;
       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 candidates = actors_dist_xstateActors.memo(this, "candidates-".concat(eventType), function () {
+        return actors_dist_xstateActors.getCandidates(_this8, eventType);
       });
       var _iterator = actors_dist_xstateActors._createForOfIteratorHelper(candidates),
         _step;
@@ -312,9 +279,9 @@ var StateNode = /*#__PURE__*/function () {
           var resolvedContext = state.context;
           var guardPassed = false;
           try {
-            guardPassed = !guard || actors_dist_xstateActors.evaluateGuard(guard, resolvedContext, _event, state);
+            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));
+            throw new Error("Unable to evaluate guard '".concat(guard.type, "' in transition for event '").concat(eventType, "' in state node '").concat(this.id, "':\n").concat(err.message));
           }
           if (guardPassed) {
             actions.push.apply(actions, actors_dist_xstateActors._toConsumableArray(candidate.actions));
@@ -400,7 +367,7 @@ var StateNode = /*#__PURE__*/function () {
     key: "ownEvents",
     get: function get() {
       var events = new Set(this.transitions.filter(function (transition) {
-        return !(!transition.target && !transition.actions.length && !transition.external);
+        return !(!transition.target && !transition.actions.length && !transition.reenter);
       }).map(function (transition) {
         return transition.eventType;
       }));
@@ -426,13 +393,13 @@ var StateMachine = /*#__PURE__*/function () {
    * The raw config used to create the machine.
    */
   config, options) {
-    var _this$config$schema;
+    var _this$config$types;
     actors_dist_xstateActors._classCallCheck(this, StateMachine);
     this.config = config;
     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, "types", 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);
@@ -448,7 +415,7 @@ var StateMachine = /*#__PURE__*/function () {
     this.options = Object.assign(createDefaultOptions(), options);
     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.types = (_this$config$types = this.config.types) !== null && _this$config$types !== void 0 ? _this$config$types : {};
     this.transition = this.transition.bind(this);
     this.root = new StateNode(config, {
       _key: this.id,
@@ -548,13 +515,12 @@ var StateMachine = /*#__PURE__*/function () {
       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;
+      if (actors_dist_xstateActors.isErrorEvent(event) && !currentState.nextEvents.some(function (nextEvent) {
+        return nextEvent === event.type;
       })) {
-        throw scxmlEvent.data.data;
+        throw event.data;
       }
-      var _macrostep = actors_dist_xstateActors.macrostep(currentState, scxmlEvent, actorCtx),
+      var _macrostep = actors_dist_xstateActors.macrostep(currentState, event, actorCtx),
         nextState = _macrostep.state;
       return nextState;
     }
@@ -572,15 +538,12 @@ var StateMachine = /*#__PURE__*/function () {
       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;
+      return actors_dist_xstateActors.macrostep(state, event, actorCtx).microstates;
     }
   }, {
     key: "getTransitionData",
-    value: function getTransitionData(state, _event) {
-      return actors_dist_xstateActors.transitionNode(this.root, state.value, state, _event) || [];
+    value: function getTransitionData(state, event) {
+      return actors_dist_xstateActors.transitionNode(this.root, state.value, state, event) || [];
     }
 
     /**
@@ -600,7 +563,7 @@ var StateMachine = /*#__PURE__*/function () {
         value: {},
         // TODO: this is computed in state constructor
         context: context,
-        _event: actors_dist_xstateActors.createInitEvent({}),
+        event: actors_dist_xstateActors.createInitEvent({}),
         actions: [],
         meta: undefined,
         configuration: config,
@@ -640,8 +603,8 @@ var StateMachine = /*#__PURE__*/function () {
       var preInitialState = this.getPreInitialState(actorCtx, input);
       var nextState = actors_dist_xstateActors.microstep([], preInitialState, actorCtx, initEvent);
       (_nextState$actions = nextState.actions).unshift.apply(_nextState$actions, actors_dist_xstateActors._toConsumableArray(preInitialState.actions));
-      var _macrostep3 = actors_dist_xstateActors.macrostep(nextState, initEvent, actorCtx),
-        macroState = _macrostep3.state;
+      var _macrostep2 = actors_dist_xstateActors.macrostep(nextState, initEvent, actorCtx),
+        macroState = _macrostep2.state;
       return macroState;
     }
   }, {
@@ -696,7 +659,7 @@ var StateMachine = /*#__PURE__*/function () {
     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),
+      var _resolveActionsAndCon2 = actors_dist_xstateActors.resolveActionsAndContext(state.actions, state.event, state, undefined),
         resolvedState = _resolveActionsAndCon2.nextState;
       return resolvedState;
     }
@@ -780,11 +743,6 @@ function mapState(stateMap, stateId) {
   return stateMap[foundStateId];
 }
 
-function createSchema(schema) {
-  return schema;
-}
-var t = createSchema;
-
 var SimulatedClock = /*#__PURE__*/function () {
   function SimulatedClock() {
     actors_dist_xstateActors._classCallCheck(this, SimulatedClock);
@@ -832,12 +790,12 @@ var SimulatedClock = /*#__PURE__*/function () {
     value: function flushTimeouts() {
       var _this = this;
       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 = actors_dist_xstateActors._slicedToArray(_ref2, 2),
-          _idB = _ref4[0],
-          timeoutB = _ref4[1];
+        var _ref3 = actors_dist_xstateActors._slicedToArray(_ref, 2);
+          _ref3[0];
+          var timeoutA = _ref3[1];
+        var _ref4 = actors_dist_xstateActors._slicedToArray(_ref2, 2);
+          _ref4[0];
+          var timeoutB = _ref4[1];
         var endA = timeoutA.start + timeoutA.timeout;
         var endB = timeoutB.start + timeoutB.timeout;
         return endB > endA ? -1 : 1;
@@ -861,61 +819,115 @@ var SimulatedClock = /*#__PURE__*/function () {
   return SimulatedClock;
 }();
 
-var actions = {
-  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
+var defaultWaitForOptions = {
+  timeout: 10000 // 10 seconds
 };
 
+/**
+ * Subscribes to an actor ref and waits for its emitted value to satisfy
+ * a predicate, and then resolves with that value.
+ * Will throw if the desired state is not reached after a timeout
+ * (defaults to 10 seconds).
+ *
+ * @example
+ * ```js
+ * const state = await waitFor(someService, state => {
+ *   return state.hasTag('loaded');
+ * });
+ *
+ * state.hasTag('loaded'); // true
+ * ```
+ *
+ * @param actorRef The actor ref to subscribe to
+ * @param predicate Determines if a value matches the condition to wait for
+ * @param options
+ * @returns A promise that eventually resolves to the emitted value
+ * that matches the condition
+ */
+function waitFor(actorRef, predicate, options) {
+  var resolvedOptions = actors_dist_xstateActors._objectSpread2(actors_dist_xstateActors._objectSpread2({}, defaultWaitForOptions), options);
+  return new Promise(function (res, rej) {
+    var done = false;
+    if (process.env.NODE_ENV !== 'production' && resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+    var handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(function () {
+      sub.unsubscribe();
+      rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
+    }, resolvedOptions.timeout);
+    var dispose = function dispose() {
+      clearTimeout(handle);
+      done = true;
+      sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    var sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: function error(err) {
+        dispose();
+        rej(err);
+      },
+      complete: function complete() {
+        dispose();
+        rej(new Error("Actor terminated without satisfying predicate"));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
+}
+
 Object.defineProperty(exports, 'ActionTypes', {
   enumerable: true,
-  get: function () {
-    return actors_dist_xstateActors.ActionTypes;
-  }
+  get: function () { return actors_dist_xstateActors.ActionTypes; }
 });
 exports.Interpreter = actors_dist_xstateActors.Interpreter;
 Object.defineProperty(exports, 'InterpreterStatus', {
   enumerable: true,
-  get: function () {
-    return actors_dist_xstateActors.ActorStatus;
-  }
+  get: function () { return actors_dist_xstateActors.ActorStatus; }
 });
 Object.defineProperty(exports, 'SpecialTargets', {
   enumerable: true,
-  get: function () {
-    return actors_dist_xstateActors.SpecialTargets;
-  }
+  get: function () { return actors_dist_xstateActors.SpecialTargets; }
 });
 exports.State = actors_dist_xstateActors.State;
+exports.and = actors_dist_xstateActors.and;
 exports.assign = actors_dist_xstateActors.assign;
+exports.cancel = actors_dist_xstateActors.cancel;
+exports.choose = actors_dist_xstateActors.choose;
 exports.doneInvoke = actors_dist_xstateActors.doneInvoke;
 exports.forwardTo = actors_dist_xstateActors.forwardTo;
+exports.fromCallback = actors_dist_xstateActors.fromCallback;
+exports.fromEventObservable = actors_dist_xstateActors.fromEventObservable;
+exports.fromObservable = actors_dist_xstateActors.fromObservable;
+exports.fromPromise = actors_dist_xstateActors.fromPromise;
+exports.fromTransition = actors_dist_xstateActors.fromTransition;
 exports.getStateNodes = actors_dist_xstateActors.getStateNodes;
 exports.interpret = actors_dist_xstateActors.interpret;
+exports.log = actors_dist_xstateActors.log;
 exports.matchesState = actors_dist_xstateActors.matchesState;
+exports.not = actors_dist_xstateActors.not;
+exports.or = actors_dist_xstateActors.or;
 exports.pathToStateValue = actors_dist_xstateActors.pathToStateValue;
-exports.send = actors_dist_xstateActors.send;
+exports.pure = actors_dist_xstateActors.pure;
+exports.raise = actors_dist_xstateActors.raise;
 exports.sendParent = actors_dist_xstateActors.sendParent;
 exports.sendTo = actors_dist_xstateActors.sendTo;
+exports.stateIn = actors_dist_xstateActors.stateIn;
+exports.stop = actors_dist_xstateActors.stop;
 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.t = t;
+exports.waitFor = waitFor;

package/dist/xstate.cjs.mjs

@@ -0,0 +1,38 @@
+export {
+  ActionTypes,
+  Interpreter,
+  InterpreterStatus,
+  SimulatedClock,
+  SpecialTargets,
+  State,
+  StateMachine,
+  StateNode,
+  and,
+  assign,
+  cancel,
+  choose,
+  createMachine,
+  doneInvoke,
+  forwardTo,
+  fromCallback,
+  fromEventObservable,
+  fromObservable,
+  fromPromise,
+  fromTransition,
+  getStateNodes,
+  interpret,
+  log,
+  mapState,
+  matchesState,
+  not,
+  or,
+  pathToStateValue,
+  pure,
+  raise,
+  sendParent,
+  sendTo,
+  stateIn,
+  stop,
+  toObserver,
+  waitFor
+} from "./xstate.cjs.js";