xstate 5.17.4 → 5.18.1

package/dist/xstate.development.cjs.js

@@ -2,74 +2,39 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var guards_dist_xstateGuards = require('./State-a2464a1e.development.cjs.js');
-var log = require('./log-40d606d3.development.cjs.js');
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-830a98f7.development.cjs.js');
+var log = require('./log-d26be77d.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
-class SimulatedClock {
-  constructor() {
-    this.timeouts = new Map();
-    this._now = 0;
-    this._id = 0;
-    this._flushing = false;
-    this._flushingInvalidated = false;
-  }
-  now() {
-    return this._now;
-  }
-  getId() {
-    return this._id++;
-  }
-  setTimeout(fn, timeout) {
-    this._flushingInvalidated = this._flushing;
-    const id = this.getId();
-    this.timeouts.set(id, {
-      start: this.now(),
-      timeout,
-      fn
-    });
-    return id;
-  }
-  clearTimeout(id) {
-    this._flushingInvalidated = this._flushing;
-    this.timeouts.delete(id);
-  }
-  set(time) {
-    if (this._now > time) {
-      throw new Error('Unable to travel back in time');
-    }
-    this._now = time;
-    this.flushTimeouts();
-  }
-  flushTimeouts() {
-    if (this._flushing) {
-      this._flushingInvalidated = true;
-      return;
-    }
-    this._flushing = true;
-    const sorted = [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
-      const endA = timeoutA.start + timeoutA.timeout;
-      const endB = timeoutB.start + timeoutB.timeout;
-      return endB > endA ? -1 : 1;
-    });
-    for (const [id, timeout] of sorted) {
-      if (this._flushingInvalidated) {
-        this._flushingInvalidated = false;
-        this._flushing = false;
-        this.flushTimeouts();
-        return;
-      }
-      if (this.now() - timeout.start >= timeout.timeout) {
-        this.timeouts.delete(id);
-        timeout.fn.call(null);
-      }
-    }
-    this._flushing = false;
-  }
-  increment(ms) {
-    this._now += ms;
-    this.flushTimeouts();
+/**
+ * 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
+ *
+ * ```ts
+ * // ...
+ * entry: ({ event }) => {
+ *   assertEvent(event, 'doNothing');
+ *   // event is { type: 'doNothing' }
+ * },
+ * // ...
+ * exit: ({ event }) => {
+ *   assertEvent(event, 'greet');
+ *   // event is { type: 'greet'; message: string }
+ *
+ *   assertEvent(event, ['greet', 'notify']);
+ *   // event is { type: 'greet'; message: string }
+ *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+ * },
+ * ```
+ */
+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}`);
   }
 }
 
@@ -601,37 +566,6 @@ class StateMachine {
   }
 }
 
-/**
- * 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
- *
- * ```ts
- * // ...
- * entry: ({ event }) => {
- *   assertEvent(event, 'doNothing');
- *   // event is { type: 'doNothing' }
- * },
- * // ...
- * exit: ({ event }) => {
- *   assertEvent(event, 'greet');
- *   // event is { type: 'greet'; message: string }
- *
- *   assertEvent(event, ['greet', 'notify']);
- *   // event is { type: 'greet'; message: string }
- *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
- * },
- * ```
- */
-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
 // `TTestValue` doesn't encode this information anyhow for us to be able to do that
 // this is fine for most practical use cases anyway though
@@ -761,6 +695,72 @@ function setup({
   };
 }
 
+class SimulatedClock {
+  constructor() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+    this._flushing = false;
+    this._flushingInvalidated = false;
+  }
+  now() {
+    return this._now;
+  }
+  getId() {
+    return this._id++;
+  }
+  setTimeout(fn, timeout) {
+    this._flushingInvalidated = this._flushing;
+    const id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout,
+      fn
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this._flushingInvalidated = this._flushing;
+    this.timeouts.delete(id);
+  }
+  set(time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
+    }
+    this._now = time;
+    this.flushTimeouts();
+  }
+  flushTimeouts() {
+    if (this._flushing) {
+      this._flushingInvalidated = true;
+      return;
+    }
+    this._flushing = true;
+    const sorted = [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
+      const endA = timeoutA.start + timeoutA.timeout;
+      const endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    });
+    for (const [id, timeout] of sorted) {
+      if (this._flushingInvalidated) {
+        this._flushingInvalidated = false;
+        this._flushing = false;
+        this.flushTimeouts();
+        return;
+      }
+      if (this.now() - timeout.start >= timeout.timeout) {
+        this.timeouts.delete(id);
+        timeout.fn.call(null);
+      }
+    }
+    this._flushing = false;
+  }
+  increment(ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  }
+}
+
 /**
  * Returns a promise that resolves to the `output` of the actor when it is done.
  *
@@ -826,18 +826,28 @@ function waitFor(actorRef, predicate, options) {
     ...options
   };
   return new Promise((res, rej) => {
+    const {
+      signal
+    } = resolvedOptions;
+    if (signal?.aborted) {
+      rej(signal.reason);
+      return;
+    }
     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();
+      dispose();
       rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
     }, resolvedOptions.timeout);
     const dispose = () => {
       clearTimeout(handle);
       done = true;
       sub?.unsubscribe();
+      if (abortListener) {
+        signal.removeEventListener('abort', abortListener);
+      }
     };
     function checkEmitted(emitted) {
       if (predicate(emitted)) {
@@ -845,6 +855,12 @@ function waitFor(actorRef, predicate, options) {
         res(emitted);
       }
     }
+
+    /**
+     * If the `signal` option is provided, this will be the listener for its
+     * `abort` event
+     */
+    let abortListener;
     let sub; // avoid TDZ when disposing synchronously
 
     // See if the current snapshot already matches the predicate
@@ -852,6 +868,16 @@ function waitFor(actorRef, predicate, options) {
     if (done) {
       return;
     }
+
+    // only define the `abortListener` if the `signal` option is provided
+    if (signal) {
+      abortListener = () => {
+        dispose();
+        // XState does not "own" the signal, so we should reject with its reason (if any)
+        rej(signal.reason);
+      };
+      signal.addEventListener('abort', abortListener);
+    }
     sub = actorRef.subscribe({
       next: checkEmitted,
       error: err => {
@@ -869,6 +895,12 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+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;
@@ -895,12 +927,6 @@ 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,73 +1,38 @@
-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-4f8360d3.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-4f8360d3.development.esm.js';
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
+import { t as toArray, S as STATE_DELIMITER, m as mapValues, 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-206d3d29.development.esm.js';
+export { B as Actor, I as __unsafe_getAllOwnEventDescriptors, D as and, M as cancel, A as createActor, j as getStateNodes, C as interpret, H as isMachineSnapshot, J as matchesState, E as not, F as or, K as pathToStateValue, O as raise, P as spawnChild, G as stateIn, Q as stop, R as stopChild, L as toObserver } from './raise-206d3d29.development.esm.js';
+import { a as assign } from './log-c92a07bc.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-c92a07bc.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
-class SimulatedClock {
-  constructor() {
-    this.timeouts = new Map();
-    this._now = 0;
-    this._id = 0;
-    this._flushing = false;
-    this._flushingInvalidated = false;
-  }
-  now() {
-    return this._now;
-  }
-  getId() {
-    return this._id++;
-  }
-  setTimeout(fn, timeout) {
-    this._flushingInvalidated = this._flushing;
-    const id = this.getId();
-    this.timeouts.set(id, {
-      start: this.now(),
-      timeout,
-      fn
-    });
-    return id;
-  }
-  clearTimeout(id) {
-    this._flushingInvalidated = this._flushing;
-    this.timeouts.delete(id);
-  }
-  set(time) {
-    if (this._now > time) {
-      throw new Error('Unable to travel back in time');
-    }
-    this._now = time;
-    this.flushTimeouts();
-  }
-  flushTimeouts() {
-    if (this._flushing) {
-      this._flushingInvalidated = true;
-      return;
-    }
-    this._flushing = true;
-    const sorted = [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
-      const endA = timeoutA.start + timeoutA.timeout;
-      const endB = timeoutB.start + timeoutB.timeout;
-      return endB > endA ? -1 : 1;
-    });
-    for (const [id, timeout] of sorted) {
-      if (this._flushingInvalidated) {
-        this._flushingInvalidated = false;
-        this._flushing = false;
-        this.flushTimeouts();
-        return;
-      }
-      if (this.now() - timeout.start >= timeout.timeout) {
-        this.timeouts.delete(id);
-        timeout.fn.call(null);
-      }
-    }
-    this._flushing = false;
-  }
-  increment(ms) {
-    this._now += ms;
-    this.flushTimeouts();
+/**
+ * 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
+ *
+ * ```ts
+ * // ...
+ * entry: ({ event }) => {
+ *   assertEvent(event, 'doNothing');
+ *   // event is { type: 'doNothing' }
+ * },
+ * // ...
+ * exit: ({ event }) => {
+ *   assertEvent(event, 'greet');
+ *   // event is { type: 'greet'; message: string }
+ *
+ *   assertEvent(event, ['greet', 'notify']);
+ *   // event is { type: 'greet'; message: string }
+ *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+ * },
+ * ```
+ */
+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}`);
   }
 }
 
@@ -599,37 +564,6 @@ class StateMachine {
   }
 }
 
-/**
- * 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
- *
- * ```ts
- * // ...
- * entry: ({ event }) => {
- *   assertEvent(event, 'doNothing');
- *   // event is { type: 'doNothing' }
- * },
- * // ...
- * exit: ({ event }) => {
- *   assertEvent(event, 'greet');
- *   // event is { type: 'greet'; message: string }
- *
- *   assertEvent(event, ['greet', 'notify']);
- *   // event is { type: 'greet'; message: string }
- *   // or { type: 'notify'; message: string; level: 'info' | 'error' }
- * },
- * ```
- */
-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
 // `TTestValue` doesn't encode this information anyhow for us to be able to do that
 // this is fine for most practical use cases anyway though
@@ -759,6 +693,72 @@ function setup({
   };
 }
 
+class SimulatedClock {
+  constructor() {
+    this.timeouts = new Map();
+    this._now = 0;
+    this._id = 0;
+    this._flushing = false;
+    this._flushingInvalidated = false;
+  }
+  now() {
+    return this._now;
+  }
+  getId() {
+    return this._id++;
+  }
+  setTimeout(fn, timeout) {
+    this._flushingInvalidated = this._flushing;
+    const id = this.getId();
+    this.timeouts.set(id, {
+      start: this.now(),
+      timeout,
+      fn
+    });
+    return id;
+  }
+  clearTimeout(id) {
+    this._flushingInvalidated = this._flushing;
+    this.timeouts.delete(id);
+  }
+  set(time) {
+    if (this._now > time) {
+      throw new Error('Unable to travel back in time');
+    }
+    this._now = time;
+    this.flushTimeouts();
+  }
+  flushTimeouts() {
+    if (this._flushing) {
+      this._flushingInvalidated = true;
+      return;
+    }
+    this._flushing = true;
+    const sorted = [...this.timeouts].sort(([_idA, timeoutA], [_idB, timeoutB]) => {
+      const endA = timeoutA.start + timeoutA.timeout;
+      const endB = timeoutB.start + timeoutB.timeout;
+      return endB > endA ? -1 : 1;
+    });
+    for (const [id, timeout] of sorted) {
+      if (this._flushingInvalidated) {
+        this._flushingInvalidated = false;
+        this._flushing = false;
+        this.flushTimeouts();
+        return;
+      }
+      if (this.now() - timeout.start >= timeout.timeout) {
+        this.timeouts.delete(id);
+        timeout.fn.call(null);
+      }
+    }
+    this._flushing = false;
+  }
+  increment(ms) {
+    this._now += ms;
+    this.flushTimeouts();
+  }
+}
+
 /**
  * Returns a promise that resolves to the `output` of the actor when it is done.
  *
@@ -824,18 +824,28 @@ function waitFor(actorRef, predicate, options) {
     ...options
   };
   return new Promise((res, rej) => {
+    const {
+      signal
+    } = resolvedOptions;
+    if (signal?.aborted) {
+      rej(signal.reason);
+      return;
+    }
     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();
+      dispose();
       rej(new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
     }, resolvedOptions.timeout);
     const dispose = () => {
       clearTimeout(handle);
       done = true;
       sub?.unsubscribe();
+      if (abortListener) {
+        signal.removeEventListener('abort', abortListener);
+      }
     };
     function checkEmitted(emitted) {
       if (predicate(emitted)) {
@@ -843,6 +853,12 @@ function waitFor(actorRef, predicate, options) {
         res(emitted);
       }
     }
+
+    /**
+     * If the `signal` option is provided, this will be the listener for its
+     * `abort` event
+     */
+    let abortListener;
     let sub; // avoid TDZ when disposing synchronously
 
     // See if the current snapshot already matches the predicate
@@ -850,6 +866,16 @@ function waitFor(actorRef, predicate, options) {
     if (done) {
       return;
     }
+
+    // only define the `abortListener` if the `signal` option is provided
+    if (signal) {
+      abortListener = () => {
+        dispose();
+        // XState does not "own" the signal, so we should reject with its reason (if any)
+        rej(signal.reason);
+      };
+      signal.addEventListener('abort', abortListener);
+    }
     sub = actorRef.subscribe({
       next: checkEmitted,
       error: err => {