xstate 4.30.4 → 4.31.0

package/es/waitFor.js

@@ -0,0 +1,66 @@
+import { __assign } from './_virtual/_tslib.js';
+
+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.
+ *
+ * @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 = __assign(__assign({}, defaultWaitForOptions), options);
+
+  return new Promise(function (res, rej) {
+    var done = false;
+    var handle = setTimeout(function () {
+      sub.unsubscribe();
+      rej(new Error("Timeout of ".concat(resolvedOptions.timeout, " ms exceeded")));
+    }, resolvedOptions.timeout);
+
+    var dispose = function () {
+      clearTimeout(handle);
+      done = true;
+      sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
+    };
+
+    var sub = actorRef.subscribe({
+      next: function (emitted) {
+        if (predicate(emitted)) {
+          dispose();
+          res(emitted);
+        }
+      },
+      error: function (err) {
+        dispose();
+        rej(err);
+      },
+      complete: function () {
+        dispose();
+        rej(new Error("Actor terminated without satisfying predicate"));
+      }
+    });
+
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
+}
+
+export { waitFor };

package/lib/SimulatedClock.js

@@ -1,83 +1,85 @@
-"use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+
+var SimulatedClock =
+/*#__PURE__*/
+
+/** @class */
+function () {
+  function SimulatedClock() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+  }
+
+  SimulatedClock.prototype.now = function () {
+    return this._now;
+  };
+
+  SimulatedClock.prototype.getId = function () {
+    return this._id++;
+  };
+
+  SimulatedClock.prototype.setTimeout = function (fn, timeout) {
+    var id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout: timeout,
+      fn: fn
+    });
+    return id;
+  };
+
+  SimulatedClock.prototype.clearTimeout = function (id) {
+    this.timeouts.delete(id);
+  };
+
+  SimulatedClock.prototype.set = function (time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
     }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimulatedClock = void 0;
-var SimulatedClock = /** @class */ (function () {
-    function SimulatedClock() {
-        this.timeouts = new Map();
-        this._now = 0;
-        this._id = 0;
-    }
-    SimulatedClock.prototype.now = function () {
-        return this._now;
-    };
-    SimulatedClock.prototype.getId = function () {
-        return this._id++;
-    };
-    SimulatedClock.prototype.setTimeout = function (fn, timeout) {
-        var id = this.getId();
-        this.timeouts.set(id, {
-            start: this.now(),
-            timeout: timeout,
-            fn: fn
-        });
-        return id;
-    };
-    SimulatedClock.prototype.clearTimeout = function (id) {
-        this.timeouts.delete(id);
-    };
-    SimulatedClock.prototype.set = function (time) {
-        if (this._now > time) {
-            throw new Error('Unable to travel back in time');
-        }
-        this._now = time;
-        this.flushTimeouts();
-    };
-    SimulatedClock.prototype.flushTimeouts = function () {
-        var _this = this;
-        __spreadArray([], __read(this.timeouts), false).sort(function (_a, _b) {
-            var _c = __read(_a, 2), _idA = _c[0], timeoutA = _c[1];
-            var _d = __read(_b, 2), _idB = _d[0], timeoutB = _d[1];
-            var endA = timeoutA.start + timeoutA.timeout;
-            var endB = timeoutB.start + timeoutB.timeout;
-            return endB > endA ? -1 : 1;
-        })
-            .forEach(function (_a) {
-            var _b = __read(_a, 2), id = _b[0], timeout = _b[1];
-            if (_this.now() - timeout.start >= timeout.timeout) {
-                _this.timeouts.delete(id);
-                timeout.fn.call(null);
-            }
-        });
-    };
-    SimulatedClock.prototype.increment = function (ms) {
-        this._now += ms;
-        this.flushTimeouts();
-    };
-    return SimulatedClock;
-}());
+
+    this._now = time;
+    this.flushTimeouts();
+  };
+
+  SimulatedClock.prototype.flushTimeouts = function () {
+    var _this = this;
+
+    _tslib.__spreadArray([], _tslib.__read(this.timeouts), false).sort(function (_a, _b) {
+      var _c = _tslib.__read(_a, 2);
+          _c[0];
+          var timeoutA = _c[1];
+
+      var _d = _tslib.__read(_b, 2);
+          _d[0];
+          var timeoutB = _d[1];
+
+      var endA = timeoutA.start + timeoutA.timeout;
+      var endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    }).forEach(function (_a) {
+      var _b = _tslib.__read(_a, 2),
+          id = _b[0],
+          timeout = _b[1];
+
+      if (_this.now() - timeout.start >= timeout.timeout) {
+        _this.timeouts.delete(id);
+
+        timeout.fn.call(null);
+      }
+    });
+  };
+
+  SimulatedClock.prototype.increment = function (ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  };
+
+  return SimulatedClock;
+}();
+
 exports.SimulatedClock = SimulatedClock;

package/lib/State.d.ts

@@ -98,7 +98,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * Whether the current state value is a subset of the given parent state value.
      * @param parentStateValue
      */
-    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'matchesStates'> : never>(parentStateValue: TSV): boolean;
+    matches<TSV extends TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'matchesStates'> : never>(parentStateValue: TSV): boolean;
     matches<TSV extends TResolvedTypesMeta extends TypegenDisabled ? TTypestate['value'] : never>(parentStateValue: TSV): this is State<(TTypestate extends any ? {
         value: TSV;
         context: any;
@@ -109,7 +109,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * Whether the current state configuration has a state node with the specified `tag`.
      * @param tag
      */
-    hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<TResolvedTypesMeta, 'tags'> : string): boolean;
+    hasTag(tag: TResolvedTypesMeta extends TypegenEnabled ? Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'tags'> : string): boolean;
     /**
      * Determines whether sending the `event` will cause a non-forbidden transition
      * to be selected, even if the transitions have no actions nor

package/lib/State.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
 var constants = require('./constants.js');
-var environment = require('./environment.js');
 var utils = require('./utils.js');
-var actions = require('./actions.js');
 var stateUtils = require('./stateUtils.js');
+var actions = require('./actions.js');
+var environment = require('./environment.js');
 
 function stateValuesEqual(a, b) {
   if (a === b) {
@@ -35,6 +35,11 @@ function isStateConfig(state) {
 
   return 'value' in state && '_event' in state;
 }
+/**
+ * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
+ */
+
+var isState = isStateConfig;
 function bindActionToState(action, state) {
   var exec = action.exec;
 
@@ -219,12 +224,12 @@ function () {
   };
 
   State.prototype.toJSON = function () {
-    var _a = this,
-        configuration = _a.configuration,
-        transitions = _a.transitions,
-        tags = _a.tags,
-        machine = _a.machine,
-        jsonValues = _tslib.__rest(_a, ["configuration", "transitions", "tags", "machine"]);
+    var _a = this;
+        _a.configuration;
+        _a.transitions;
+        var tags = _a.tags;
+        _a.machine;
+        var jsonValues = _tslib.__rest(_a, ["configuration", "transitions", "tags", "machine"]);
 
     return _tslib.__assign(_tslib.__assign({}, jsonValues), {
       tags: Array.from(tags)
@@ -272,5 +277,6 @@ function () {
 
 exports.State = State;
 exports.bindActionToState = bindActionToState;
+exports.isState = isState;
 exports.isStateConfig = isStateConfig;
 exports.stateValuesEqual = stateValuesEqual;

package/lib/StateNode.js

@@ -3,15 +3,15 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
+var utils = require('./utils.js');
 var types = require('./types.js');
+var State = require('./State.js');
 var actionTypes = require('./actionTypes.js');
-var constants = require('./constants.js');
-var environment = require('./environment.js');
-var utils = require('./utils.js');
 var actions = require('./actions.js');
-var Actor = require('./Actor.js');
+var environment = require('./environment.js');
+var constants = require('./constants.js');
 var stateUtils = require('./stateUtils.js');
-var State = require('./State.js');
+var Actor = require('./Actor.js');
 var invokeUtils = require('./invokeUtils.js');
 
 var NULL_EVENT = '';
@@ -447,7 +447,8 @@ function () {
       value: this.resolve(stateFromConfig.value),
       configuration: configuration,
       done: stateUtils.isInFinalState(configuration, this),
-      tags: stateUtils.getTagsFromConfiguration(configuration)
+      tags: stateUtils.getTagsFromConfiguration(configuration),
+      machine: this.machine
     }));
   };
 
@@ -923,7 +924,7 @@ function () {
       transitions: stateTransition.transitions,
       children: children,
       done: isDone,
-      tags: currentState === null || currentState === void 0 ? void 0 : currentState.tags,
+      tags: stateUtils.getTagsFromConfiguration(resolvedConfiguration),
       machine: this
     });
     var didUpdateContext = context !== updatedContext;
@@ -973,7 +974,6 @@ function () {
     maybeNextState.changed = changed; // Preserve original history after raised events
 
     maybeNextState.history = history;
-    maybeNextState.tags = stateUtils.getTagsFromConfiguration(maybeNextState.configuration);
     return maybeNextState;
   };
   /**

package/lib/actions.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _tslib = require('./_virtual/_tslib.js');
 var types = require('./types.js');
 var actionTypes = require('./actionTypes.js');
-var environment = require('./environment.js');
 var utils = require('./utils.js');
+var environment = require('./environment.js');
 
 var initEvent = /*#__PURE__*/utils.toSCXMLEvent({
   type: actionTypes.init

package/lib/behaviors.js

@@ -2,12 +2,78 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('./types.js');
-require('./actionTypes.js');
-require('./environment.js');
-var utils = require('./utils.js');
+var actions = require('./actions.js');
 var Actor = require('./Actor.js');
+var utils = require('./utils.js');
+
+/**
+ * Returns an actor behavior from a reducer and its initial state.
+ *
+ * @param transition The pure reducer that returns the next state given the current state and event.
+ * @param initialState The initial state of the reducer.
+ * @returns An actor behavior
+ */
+
+function fromReducer(transition, initialState) {
+  return {
+    transition: transition,
+    initialState: initialState
+  };
+}
+function fromPromise(promiseFn) {
+  var initialState = {
+    error: undefined,
+    data: undefined,
+    status: 'pending'
+  };
+  return {
+    transition: function (state, event, _a) {
+      var parent = _a.parent,
+          id = _a.id,
+          observers = _a.observers;
 
+      switch (event.type) {
+        case 'fulfill':
+          parent === null || parent === void 0 ? void 0 : parent.send(actions.doneInvoke(id, event.data));
+          return {
+            error: undefined,
+            data: event.data,
+            status: 'fulfilled'
+          };
+
+        case 'reject':
+          parent === null || parent === void 0 ? void 0 : parent.send(actions.error(id, event.error));
+          observers.forEach(function (observer) {
+            observer.error(event.error);
+          });
+          return {
+            error: event.error,
+            data: undefined,
+            status: 'rejected'
+          };
+
+        default:
+          return state;
+      }
+    },
+    initialState: initialState,
+    start: function (_a) {
+      var self = _a.self;
+      promiseFn().then(function (data) {
+        self.send({
+          type: 'fulfill',
+          data: data
+        });
+      }, function (reason) {
+        self.send({
+          type: 'reject',
+          error: reason
+        });
+      });
+      return initialState;
+    }
+  };
+}
 function spawnBehavior(behavior, options) {
   if (options === void 0) {
     options = {};
@@ -66,4 +132,6 @@ function spawnBehavior(behavior, options) {
   return actor;
 }
 
+exports.fromPromise = fromPromise;
+exports.fromReducer = fromReducer;
 exports.spawnBehavior = spawnBehavior;

package/lib/devTools.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+var environment = require('./environment.js');
+
 function getGlobal() {
   if (typeof globalThis !== 'undefined') {
     return globalThis;
@@ -20,7 +21,9 @@ function getGlobal() {
     return global;
   }
 
-  return undefined;
+  if (!environment.IS_PRODUCTION) {
+    console.warn('XState could not find a global object in this environment. Please let the maintainers know and raise an issue here: https://github.com/statelyai/xstate/issues');
+  }
 }
 
 function getDevTools() {

package/lib/each.js

@@ -1,15 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.each = void 0;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
 function each(collection, item, indexOrActions, maybeActions) {
-    var actions = maybeActions || indexOrActions;
-    var index = maybeActions ? indexOrActions : undefined;
-    return {
-        type: 'xstate.foreach',
-        collection: collection,
-        item: item,
-        index: index,
-        actions: actions
-    };
+  var actions = maybeActions || indexOrActions;
+  var index = maybeActions ? indexOrActions : undefined;
+  return {
+    type: 'xstate.foreach',
+    collection: collection,
+    item: item,
+    index: index,
+    actions: actions
+  };
 }
+
 exports.each = each;

package/lib/index.js

@@ -2,18 +2,18 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var types = require('./types.js');
-var utils = require('./utils.js');
 var actions = require('./actions.js');
 var Actor = require('./Actor.js');
-var State = require('./State.js');
-var behaviors = require('./behaviors.js');
 var interpreter = require('./interpreter.js');
-var StateNode = require('./StateNode.js');
 var Machine = require('./Machine.js');
 var mapState = require('./mapState.js');
 var match = require('./match.js');
 var schema = require('./schema.js');
+var State = require('./State.js');
+var StateNode = require('./StateNode.js');
+var behaviors = require('./behaviors.js');
+var types = require('./types.js');
+var utils = require('./utils.js');
 
 var assign = actions.assign,
     send = actions.send,
@@ -22,42 +22,36 @@ var assign = actions.assign,
     forwardTo = actions.forwardTo,
     doneInvoke = actions.doneInvoke;
 
-Object.defineProperty(exports, 'ActionTypes', {
-  enumerable: true,
-  get: function () {
-    return types.ActionTypes;
-  }
-});
-Object.defineProperty(exports, 'SpecialTargets', {
-  enumerable: true,
-  get: function () {
-    return types.SpecialTargets;
-  }
-});
-exports.matchesState = utils.matchesState;
-exports.toEventObject = utils.toEventObject;
-exports.toObserver = utils.toObserver;
-exports.toSCXMLEvent = utils.toSCXMLEvent;
 exports.actions = actions;
 exports.toActorRef = Actor.toActorRef;
-exports.State = State.State;
-exports.spawnBehavior = behaviors.spawnBehavior;
 exports.Interpreter = interpreter.Interpreter;
 Object.defineProperty(exports, 'InterpreterStatus', {
   enumerable: true,
-  get: function () {
-    return interpreter.InterpreterStatus;
-  }
+  get: function () { return interpreter.InterpreterStatus; }
 });
 exports.interpret = interpreter.interpret;
 exports.spawn = interpreter.spawn;
-exports.StateNode = StateNode.StateNode;
 exports.Machine = Machine.Machine;
 exports.createMachine = Machine.createMachine;
 exports.mapState = mapState.mapState;
 exports.matchState = match.matchState;
 exports.createSchema = schema.createSchema;
 exports.t = schema.t;
+exports.State = State.State;
+exports.StateNode = StateNode.StateNode;
+exports.spawnBehavior = behaviors.spawnBehavior;
+Object.defineProperty(exports, 'ActionTypes', {
+  enumerable: true,
+  get: function () { return types.ActionTypes; }
+});
+Object.defineProperty(exports, 'SpecialTargets', {
+  enumerable: true,
+  get: function () { return types.SpecialTargets; }
+});
+exports.matchesState = utils.matchesState;
+exports.toEventObject = utils.toEventObject;
+exports.toObserver = utils.toObserver;
+exports.toSCXMLEvent = utils.toSCXMLEvent;
 exports.assign = assign;
 exports.doneInvoke = doneInvoke;
 exports.forwardTo = forwardTo;

package/lib/interpreter.d.ts

@@ -23,7 +23,6 @@ export declare enum InterpreterStatus {
     Running = 1,
     Stopped = 2
 }
-/** @ts-ignore [symbolObservable] creates problems for people without `skipLibCheck` who are on older versions of TS, remove this comment when we drop support for TS@<4.3 */
 export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
@@ -190,8 +189,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     toJSON(): {
         id: string;
     };
-    /** @ts-ignore this creates problems for people without `skipLibCheck` who are on older versions of TS, remove this comment when we drop support for TS@<4.3 */
-    [symbolObservable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
+    [Symbol.observable](): InteropSubscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
     getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
 }
 export declare function spawn<T extends Behavior<any, any>>(entity: T, nameOrOptions?: string | SpawnOptions): ActorRefFrom<T>;