xstate 5.16.0 → 5.17.1

package/dist/xstate.development.cjs.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var guards_dist_xstateGuards = require('./State-a2464a1e.development.cjs.js');
+var log = require('./log-ec36113c.development.cjs.js');
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
-var guards_dist_xstateGuards = require('./raise-bad6a97b.development.cjs.js');
-var log = require('./log-31321d85.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
 class SimulatedClock {
@@ -601,78 +601,35 @@ class StateMachine {
   }
 }
 
-const defaultWaitForOptions = {
-  timeout: Infinity // much more than 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 an optional timeout. (defaults to Infinity).
+ * Asserts that the given event object is of the specified type or types. Throws
+ * an error if the event object is not of the specified types.
  *
  * @example
  *
- * ```js
- * const state = await waitFor(someService, (state) => {
- *   return state.hasTag('loaded');
- * });
+ * ```ts
+ * // ...
+ * entry: ({ event }) => {
+ *   assertEvent(event, 'doNothing');
+ *   // event is { type: 'doNothing' }
+ * },
+ * // ...
+ * exit: ({ event }) => {
+ *   assertEvent(event, 'greet');
+ *   // event is { type: 'greet'; message: string }
  *
- * state.hasTag('loaded'); // true
+ *   assertEvent(event, ['greet', 'notify']);
+ *   // event is { type: 'greet'; message: string }
+ *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+ * },
  * ```
- *
- * @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) {
-  const resolvedOptions = {
-    ...defaultWaitForOptions,
-    ...options
-  };
-  return new Promise((res, rej) => {
-    let done = false;
-    if (resolvedOptions.timeout < 0) {
-      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
-    }
-    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
-      sub.unsubscribe();
-      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
-    }, resolvedOptions.timeout);
-    const dispose = () => {
-      clearTimeout(handle);
-      done = true;
-      sub?.unsubscribe();
-    };
-    function checkEmitted(emitted) {
-      if (predicate(emitted)) {
-        dispose();
-        res(emitted);
-      }
-    }
-    let sub; // avoid TDZ when disposing synchronously
-
-    // See if the current snapshot already matches the predicate
-    checkEmitted(actorRef.getSnapshot());
-    if (done) {
-      return;
-    }
-    sub = actorRef.subscribe({
-      next: checkEmitted,
-      error: err => {
-        dispose();
-        rej(err);
-      },
-      complete: () => {
-        dispose();
-        rej(new Error(`Actor terminated without satisfying predicate`));
-      }
-    });
-    if (done) {
-      sub.unsubscribe();
-    }
-  });
+function assertEvent(event, type) {
+  const types = guards_dist_xstateGuards.toArray(type);
+  if (!types.includes(event.type)) {
+    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
+    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
+  }
 }
 
 // this is not 100% accurate since we can't make parallel regions required in the result
@@ -838,43 +795,80 @@ function toPromise(actor) {
   });
 }
 
+const defaultWaitForOptions = {
+  timeout: Infinity // much more than 10 seconds
+};
+
 /**
- * Asserts that the given event object is of the specified type or types. Throws
- * an error if the event object is not of the specified types.
+ * 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 an optional timeout. (defaults to Infinity).
  *
  * @example
  *
- * ```ts
- * // ...
- * entry: ({ event }) => {
- *   assertEvent(event, 'doNothing');
- *   // event is { type: 'doNothing' }
- * },
- * // ...
- * exit: ({ event }) => {
- *   assertEvent(event, 'greet');
- *   // event is { type: 'greet'; message: string }
+ * ```js
+ * const state = await waitFor(someService, (state) => {
+ *   return state.hasTag('loaded');
+ * });
  *
- *   assertEvent(event, ['greet', 'notify']);
- *   // event is { type: 'greet'; message: string }
- *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
- * },
+ * 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 assertEvent(event, type) {
-  const types = guards_dist_xstateGuards.toArray(type);
-  if (!types.includes(event.type)) {
-    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
-    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
-  }
+function waitFor(actorRef, predicate, options) {
+  const resolvedOptions = {
+    ...defaultWaitForOptions,
+    ...options
+  };
+  return new Promise((res, rej) => {
+    let done = false;
+    if (resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
+      sub.unsubscribe();
+      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+    }, resolvedOptions.timeout);
+    const dispose = () => {
+      clearTimeout(handle);
+      done = true;
+      sub?.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+    let sub; // avoid TDZ when disposing synchronously
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    if (done) {
+      return;
+    }
+    sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: err => {
+        dispose();
+        rej(err);
+      },
+      complete: () => {
+        dispose();
+        rej(new Error(`Actor terminated without satisfying predicate`));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
 }
 
-exports.createEmptyActor = actors_dist_xstateActors.createEmptyActor;
-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.Actor = guards_dist_xstateGuards.Actor;
 exports.__unsafe_getAllOwnEventDescriptors = guards_dist_xstateGuards.getAllOwnEventDescriptors;
 exports.and = guards_dist_xstateGuards.and;
@@ -901,6 +895,12 @@ exports.forwardTo = log.forwardTo;
 exports.log = log.log;
 exports.sendParent = log.sendParent;
 exports.sendTo = log.sendTo;
+exports.createEmptyActor = actors_dist_xstateActors.createEmptyActor;
+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.SimulatedClock = SimulatedClock;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;

package/dist/xstate.development.esm.js

@@ -1,8 +1,8 @@
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as toStatePath, w as isStateId, x as getStateNodeByPath, y as getPersistedSnapshot, z as resolveReferencedActor, A as createActor, $ as $$ACTOR_TYPE } from './State-34039d2a.development.esm.js';
+export { C as Actor, I as __unsafe_getAllOwnEventDescriptors, E as and, M as cancel, A as createActor, j as getStateNodes, D as interpret, B as isMachineSnapshot, J as matchesState, F as not, G as or, K as pathToStateValue, O as raise, P as spawnChild, H as stateIn, Q as stop, R as stopChild, L as toObserver } from './State-34039d2a.development.esm.js';
+import { a as assign } from './log-62f17756.development.esm.js';
+export { S as SpecialTargets, a as assign, e as emit, b as enqueueActions, f as forwardTo, l as log, s as sendParent, c as sendTo } from './log-62f17756.development.esm.js';
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as toStatePath, w as isStateId, x as getStateNodeByPath, y as getPersistedSnapshot, z as resolveReferencedActor, A as createActor, $ as $$ACTOR_TYPE } from './raise-7d030497.development.esm.js';
-export { B as Actor, I as __unsafe_getAllOwnEventDescriptors, E as and, M as cancel, A as createActor, j as getStateNodes, C as interpret, D as isMachineSnapshot, J as matchesState, F as not, G as or, K as pathToStateValue, O as raise, P as spawnChild, H as stateIn, Q as stop, R as stopChild, L as toObserver } from './raise-7d030497.development.esm.js';
-import { a as assign } from './log-17f4495d.development.esm.js';
-export { S as SpecialTargets, a as assign, e as emit, b as enqueueActions, f as forwardTo, l as log, s as sendParent, c as sendTo } from './log-17f4495d.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
 class SimulatedClock {
@@ -599,78 +599,35 @@ class StateMachine {
   }
 }
 
-const defaultWaitForOptions = {
-  timeout: Infinity // much more than 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 an optional timeout. (defaults to Infinity).
+ * Asserts that the given event object is of the specified type or types. Throws
+ * an error if the event object is not of the specified types.
  *
  * @example
  *
- * ```js
- * const state = await waitFor(someService, (state) => {
- *   return state.hasTag('loaded');
- * });
+ * ```ts
+ * // ...
+ * entry: ({ event }) => {
+ *   assertEvent(event, 'doNothing');
+ *   // event is { type: 'doNothing' }
+ * },
+ * // ...
+ * exit: ({ event }) => {
+ *   assertEvent(event, 'greet');
+ *   // event is { type: 'greet'; message: string }
  *
- * state.hasTag('loaded'); // true
+ *   assertEvent(event, ['greet', 'notify']);
+ *   // event is { type: 'greet'; message: string }
+ *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+ * },
  * ```
- *
- * @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) {
-  const resolvedOptions = {
-    ...defaultWaitForOptions,
-    ...options
-  };
-  return new Promise((res, rej) => {
-    let done = false;
-    if (resolvedOptions.timeout < 0) {
-      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
-    }
-    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
-      sub.unsubscribe();
-      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
-    }, resolvedOptions.timeout);
-    const dispose = () => {
-      clearTimeout(handle);
-      done = true;
-      sub?.unsubscribe();
-    };
-    function checkEmitted(emitted) {
-      if (predicate(emitted)) {
-        dispose();
-        res(emitted);
-      }
-    }
-    let sub; // avoid TDZ when disposing synchronously
-
-    // See if the current snapshot already matches the predicate
-    checkEmitted(actorRef.getSnapshot());
-    if (done) {
-      return;
-    }
-    sub = actorRef.subscribe({
-      next: checkEmitted,
-      error: err => {
-        dispose();
-        rej(err);
-      },
-      complete: () => {
-        dispose();
-        rej(new Error(`Actor terminated without satisfying predicate`));
-      }
-    });
-    if (done) {
-      sub.unsubscribe();
-    }
-  });
+function assertEvent(event, type) {
+  const types = toArray(type);
+  if (!types.includes(event.type)) {
+    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
+    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
+  }
 }
 
 // this is not 100% accurate since we can't make parallel regions required in the result
@@ -836,35 +793,78 @@ function toPromise(actor) {
   });
 }
 
+const defaultWaitForOptions = {
+  timeout: Infinity // much more than 10 seconds
+};
+
 /**
- * Asserts that the given event object is of the specified type or types. Throws
- * an error if the event object is not of the specified types.
+ * 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 an optional timeout. (defaults to Infinity).
  *
  * @example
  *
- * ```ts
- * // ...
- * entry: ({ event }) => {
- *   assertEvent(event, 'doNothing');
- *   // event is { type: 'doNothing' }
- * },
- * // ...
- * exit: ({ event }) => {
- *   assertEvent(event, 'greet');
- *   // event is { type: 'greet'; message: string }
+ * ```js
+ * const state = await waitFor(someService, (state) => {
+ *   return state.hasTag('loaded');
+ * });
  *
- *   assertEvent(event, ['greet', 'notify']);
- *   // event is { type: 'greet'; message: string }
- *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
- * },
+ * 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 assertEvent(event, type) {
-  const types = toArray(type);
-  if (!types.includes(event.type)) {
-    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
-    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
-  }
+function waitFor(actorRef, predicate, options) {
+  const resolvedOptions = {
+    ...defaultWaitForOptions,
+    ...options
+  };
+  return new Promise((res, rej) => {
+    let done = false;
+    if (resolvedOptions.timeout < 0) {
+      console.error('`timeout` passed to `waitFor` is negative and it will reject its internal promise immediately.');
+    }
+    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
+      sub.unsubscribe();
+      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+    }, resolvedOptions.timeout);
+    const dispose = () => {
+      clearTimeout(handle);
+      done = true;
+      sub?.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+    let sub; // avoid TDZ when disposing synchronously
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    if (done) {
+      return;
+    }
+    sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: err => {
+        dispose();
+        rej(err);
+      },
+      complete: () => {
+        dispose();
+        rej(new Error(`Actor terminated without satisfying predicate`));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
 }
 
 export { SimulatedClock, StateMachine, StateNode, assertEvent, createMachine, getInitialSnapshot, getNextSnapshot, setup, toPromise, waitFor };

package/dist/xstate.esm.js

@@ -1,8 +1,8 @@
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as toStatePath, w as isStateId, x as getStateNodeByPath, y as getPersistedSnapshot, z as resolveReferencedActor, A as createActor, $ as $$ACTOR_TYPE } from './State-cdbc7940.esm.js';
+export { C as Actor, I as __unsafe_getAllOwnEventDescriptors, E as and, M as cancel, A as createActor, j as getStateNodes, D as interpret, B as isMachineSnapshot, J as matchesState, F as not, G as or, K as pathToStateValue, O as raise, P as spawnChild, H as stateIn, Q as stop, R as stopChild, L as toObserver } from './State-cdbc7940.esm.js';
+import { a as assign } from './log-4a38a98a.esm.js';
+export { S as SpecialTargets, a as assign, e as emit, b as enqueueActions, f as forwardTo, l as log, s as sendParent, c as sendTo } from './log-4a38a98a.esm.js';
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as toStatePath, w as isStateId, x as getStateNodeByPath, y as getPersistedSnapshot, z as resolveReferencedActor, A as createActor, $ as $$ACTOR_TYPE } from './raise-2cfe6b8f.esm.js';
-export { B as Actor, I as __unsafe_getAllOwnEventDescriptors, E as and, M as cancel, A as createActor, j as getStateNodes, C as interpret, D as isMachineSnapshot, J as matchesState, F as not, G as or, K as pathToStateValue, O as raise, P as spawnChild, H as stateIn, Q as stop, R as stopChild, L as toObserver } from './raise-2cfe6b8f.esm.js';
-import { a as assign } from './log-8320f5e6.esm.js';
-export { S as SpecialTargets, a as assign, e as emit, b as enqueueActions, f as forwardTo, l as log, s as sendParent, c as sendTo } from './log-8320f5e6.esm.js';
 import '../dev/dist/xstate-dev.esm.js';
 
 class SimulatedClock {
@@ -596,75 +596,35 @@ class StateMachine {
   }
 }
 
-const defaultWaitForOptions = {
-  timeout: Infinity // much more than 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 an optional timeout. (defaults to Infinity).
+ * Asserts that the given event object is of the specified type or types. Throws
+ * an error if the event object is not of the specified types.
  *
  * @example
  *
- * ```js
- * const state = await waitFor(someService, (state) => {
- *   return state.hasTag('loaded');
- * });
+ * ```ts
+ * // ...
+ * entry: ({ event }) => {
+ *   assertEvent(event, 'doNothing');
+ *   // event is { type: 'doNothing' }
+ * },
+ * // ...
+ * exit: ({ event }) => {
+ *   assertEvent(event, 'greet');
+ *   // event is { type: 'greet'; message: string }
  *
- * state.hasTag('loaded'); // true
+ *   assertEvent(event, ['greet', 'notify']);
+ *   // event is { type: 'greet'; message: string }
+ *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+ * },
  * ```
- *
- * @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) {
-  const resolvedOptions = {
-    ...defaultWaitForOptions,
-    ...options
-  };
-  return new Promise((res, rej) => {
-    let done = false;
-    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
-      sub.unsubscribe();
-      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
-    }, resolvedOptions.timeout);
-    const dispose = () => {
-      clearTimeout(handle);
-      done = true;
-      sub?.unsubscribe();
-    };
-    function checkEmitted(emitted) {
-      if (predicate(emitted)) {
-        dispose();
-        res(emitted);
-      }
-    }
-    let sub; // avoid TDZ when disposing synchronously
-
-    // See if the current snapshot already matches the predicate
-    checkEmitted(actorRef.getSnapshot());
-    if (done) {
-      return;
-    }
-    sub = actorRef.subscribe({
-      next: checkEmitted,
-      error: err => {
-        dispose();
-        rej(err);
-      },
-      complete: () => {
-        dispose();
-        rej(new Error(`Actor terminated without satisfying predicate`));
-      }
-    });
-    if (done) {
-      sub.unsubscribe();
-    }
-  });
+function assertEvent(event, type) {
+  const types = toArray(type);
+  if (!types.includes(event.type)) {
+    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
+    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
+  }
 }
 
 // this is not 100% accurate since we can't make parallel regions required in the result
@@ -830,35 +790,75 @@ function toPromise(actor) {
   });
 }
 
+const defaultWaitForOptions = {
+  timeout: Infinity // much more than 10 seconds
+};
+
 /**
- * Asserts that the given event object is of the specified type or types. Throws
- * an error if the event object is not of the specified types.
+ * 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 an optional timeout. (defaults to Infinity).
  *
  * @example
  *
- * ```ts
- * // ...
- * entry: ({ event }) => {
- *   assertEvent(event, 'doNothing');
- *   // event is { type: 'doNothing' }
- * },
- * // ...
- * exit: ({ event }) => {
- *   assertEvent(event, 'greet');
- *   // event is { type: 'greet'; message: string }
+ * ```js
+ * const state = await waitFor(someService, (state) => {
+ *   return state.hasTag('loaded');
+ * });
  *
- *   assertEvent(event, ['greet', 'notify']);
- *   // event is { type: 'greet'; message: string }
- *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
- * },
+ * 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 assertEvent(event, type) {
-  const types = toArray(type);
-  if (!types.includes(event.type)) {
-    const typesText = types.length === 1 ? `type "${types[0]}"` : `one of types "${types.join('", "')}"`;
-    throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
-  }
+function waitFor(actorRef, predicate, options) {
+  const resolvedOptions = {
+    ...defaultWaitForOptions,
+    ...options
+  };
+  return new Promise((res, rej) => {
+    let done = false;
+    const handle = resolvedOptions.timeout === Infinity ? undefined : setTimeout(() => {
+      sub.unsubscribe();
+      rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+    }, resolvedOptions.timeout);
+    const dispose = () => {
+      clearTimeout(handle);
+      done = true;
+      sub?.unsubscribe();
+    };
+    function checkEmitted(emitted) {
+      if (predicate(emitted)) {
+        dispose();
+        res(emitted);
+      }
+    }
+    let sub; // avoid TDZ when disposing synchronously
+
+    // See if the current snapshot already matches the predicate
+    checkEmitted(actorRef.getSnapshot());
+    if (done) {
+      return;
+    }
+    sub = actorRef.subscribe({
+      next: checkEmitted,
+      error: err => {
+        dispose();
+        rej(err);
+      },
+      complete: () => {
+        dispose();
+        rej(new Error(`Actor terminated without satisfying predicate`));
+      }
+    });
+    if (done) {
+      sub.unsubscribe();
+    }
+  });
 }
 
 export { SimulatedClock, StateMachine, StateNode, assertEvent, createMachine, getInitialSnapshot, getNextSnapshot, setup, toPromise, waitFor };