xstate 5.0.0-beta.7 → 5.0.0-beta.8

package/dist/xstate.cjs.prod.js

@@ -2,30 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var actors_dist_xstateActors = require('./actions-a1a641d3.cjs.prod.js');
+var actors_dist_xstateActors = require('./actions-900f9761.cjs.prod.js');
 require('../dev/dist/xstate-dev.cjs.prod.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 () {
@@ -426,13 +405,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 +427,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,
@@ -780,11 +759,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);
@@ -861,24 +835,70 @@ 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;
+    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 () {
@@ -899,23 +919,35 @@ Object.defineProperty(exports, '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.esm.js

@@ -1,28 +1,7 @@
-import { c as createDynamicAction, p as pure$1, t as toArray, a as toActionObjects, _ as _createClass, f as formatTransitions, b as toTransitionConfigArray, N as NULL_EVENT, d as formatTransition, m as mapValues, e as memo, g as _createForOfIteratorHelper, h as evaluateGuard, i as _toConsumableArray, j as flatten, k as _classCallCheck, l as _defineProperty, n as createInvokeId, o as toInvokeConfig, q as _objectSpread2, r as invoke, s as _objectWithoutProperties, u as getDelayedTransitions, v as formatInitialTransition, w as getCandidates, x as isString, y as createSpawner, z as createInitEvent, A as getConfiguration, B as getStateNodes, C as resolveStateValue, D as isInFinalState, S as State, E as toSCXMLEvent, F as isSCXMLErrorEvent, G as macrostep, H as transitionNode, I as _slicedToArray, J as getInitialConfiguration, K as resolveActionsAndContext, L as microstep, M as error, O as isStateId, P as getStateNodeByPath, Q as getPersistedState, R as resolveReferencedActor, T as interpret, U as STATE_DELIMITER, V as initEvent, W as matchesState, X as raise, Y as send, Z as sendParent, $ as sendTo, a0 as log, a1 as cancel, a2 as stop, a3 as assign, a4 as after, a5 as done, a6 as respond, a7 as forwardTo, a8 as escalate, a9 as choose } from './actions-b334e916.esm.js';
-export { af as ActionTypes, aa as Interpreter, ab as InterpreterStatus, ag as SpecialTargets, S as State, a3 as assign, ac as doneInvoke, a7 as forwardTo, B as getStateNodes, T as interpret, W as matchesState, ad as pathToStateValue, Y as send, Z as sendParent, $ as sendTo, ae as toObserver, E as toSCXMLEvent } from './actions-b334e916.esm.js';
+import { _ as _createClass, f as formatTransitions, t as toTransitionConfigArray, N as NULL_EVENT, a as formatTransition, m as mapValues, b as memo, c as _createForOfIteratorHelper, e as evaluateGuard, d as _toConsumableArray, g as flatten, h as _classCallCheck, i as _defineProperty, j as toActionObjects, k as toArray, l as createInvokeId, n as toInvokeConfig, o as _objectSpread2, p as invoke, q as _objectWithoutProperties, r as getDelayedTransitions, s as formatInitialTransition, u as getCandidates, v as isString, w as createSpawner, x as createInitEvent, y as getConfiguration, z as getStateNodes, A as resolveStateValue, B as isInFinalState, S as State, C as toSCXMLEvent, D as isSCXMLErrorEvent, E as macrostep, F as transitionNode, G as _slicedToArray, H as getInitialConfiguration, I as resolveActionsAndContext, J as microstep, K as error, L as isStateId, M as getStateNodeByPath, O as getPersistedState, P as resolveReferencedActor, Q as interpret, R as STATE_DELIMITER, T as initEvent, U as matchesState } from './actions-c8d7df32.esm.js';
+export { ai as ActionTypes, Y as Interpreter, Z as InterpreterStatus, aj as SpecialTargets, S as State, ag as and, a0 as assign, a1 as cancel, a2 as choose, $ as doneInvoke, X as forwardTo, ab as fromCallback, ac as fromEventObservable, aa as fromObservable, a9 as fromPromise, ad as fromTransition, z as getStateNodes, Q as interpret, a3 as log, U as matchesState, af as not, ah as or, a7 as pathToStateValue, a4 as pure, a5 as raise, W as sendParent, V as sendTo, ae as stateIn, a6 as stop, a8 as toObserver, C as toSCXMLEvent } from './actions-c8d7df32.esm.js';
 import './index-50bd0aff.esm.js';
 
-function pure(getActions) {
-  return createDynamicAction({
-    type: pure$1,
-    params: {
-      get: getActions
-    }
-  }, function (_event, _ref) {
-    var _toArray;
-    var state = _ref.state;
-    return [state, {
-      type: pure$1,
-      params: {
-        actions: (_toArray = toArray(toActionObjects(getActions({
-          context: state.context,
-          event: _event.data
-        })))) !== null && _toArray !== void 0 ? _toArray : []
-      }
-    }];
-  });
-}
-
 var _excluded = ["onDone", "onError"];
 var EMPTY_OBJECT = {};
 var StateNode = /*#__PURE__*/function () {
@@ -423,13 +402,13 @@ var StateMachine = /*#__PURE__*/function () {
    * The raw config used to create the machine.
    */
   config, options) {
-    var _this$config$schema;
+    var _this$config$types;
     _classCallCheck(this, StateMachine);
     this.config = config;
     _defineProperty(this, "version", void 0);
     _defineProperty(this, "delimiter", void 0);
     _defineProperty(this, "options", void 0);
-    _defineProperty(this, "schema", void 0);
+    _defineProperty(this, "types", void 0);
     _defineProperty(this, "__xstatenode", true);
     _defineProperty(this, "idMap", new Map());
     _defineProperty(this, "root", void 0);
@@ -445,7 +424,7 @@ var StateMachine = /*#__PURE__*/function () {
     this.options = Object.assign(createDefaultOptions(), options);
     this.delimiter = this.config.delimiter || 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,
@@ -777,11 +756,6 @@ function mapState(stateMap, stateId) {
   return stateMap[foundStateId];
 }
 
-function createSchema(schema) {
-  return schema;
-}
-var t = createSchema;
-
 var SimulatedClock = /*#__PURE__*/function () {
   function SimulatedClock() {
     _classCallCheck(this, SimulatedClock);
@@ -858,22 +832,71 @@ var SimulatedClock = /*#__PURE__*/function () {
   return SimulatedClock;
 }();
 
-var actions = {
-  raise: raise,
-  send: send,
-  sendParent: sendParent,
-  sendTo: sendTo,
-  log: log,
-  cancel: cancel,
-  stop: stop,
-  assign: assign,
-  after: after,
-  done: done,
-  respond: respond,
-  forwardTo: forwardTo,
-  escalate: escalate,
-  choose: choose,
-  pure: pure
+var defaultWaitForOptions = {
+  timeout: 10000 // 10 seconds
 };
 
-export { SimulatedClock, StateMachine, StateNode, actions, createMachine, createSchema, mapState, t };
+/**
+ * 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 = _objectSpread2(_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();
+    }
+  });
+}
+
+export { SimulatedClock, StateMachine, StateNode, createMachine, mapState, waitFor };