xstate 5.14.0 → 5.15.0

package/dist/{raise-f79d2832.cjs.js → raise-a6298350.cjs.js}

@@ -59,8 +59,8 @@ const XSTATE_ERROR = 'xstate.error';
 const XSTATE_STOP = 'xstate.stop';
 
 /**
- * Returns an event that represents an implicit event that
- * is sent after the specified `delay`.
+ * Returns an event that represents an implicit event that is sent after the
+ * specified `delay`.
  *
  * @param delayRef The delay in milliseconds
  * @param id The state node ID where this event is handled
@@ -72,8 +72,8 @@ function createAfterEvent(delayRef, id) {
 }
 
 /**
- * Returns an event that represents that a final state node
- * has been reached in the parent state node.
+ * Returns an event that represents that a final state node has been reached in
+ * the parent state node.
  *
  * @param id The final state node's parent state node `id`
  * @param output The data to pass into the event
@@ -88,8 +88,8 @@ function createDoneStateEvent(id, output) {
 /**
  * Returns an event that represents that an invoked service has terminated.
  *
- * An invoked service is terminated when it has reached a top-level final state node,
- * but not when it is canceled.
+ * An invoked service is terminated when it has reached a top-level final state
+ * node, but not when it is canceled.
  *
  * @param invokeId The invoked service ID
  * @param output The data to pass into the event
@@ -116,11 +116,12 @@ function createInitEvent(input) {
 }
 
 /**
- * This function makes sure that unhandled errors are thrown in a separate macrotask.
- * It allows those errors to be detected by global error handlers and reported to bug tracking services
- * without interrupting our own stack of execution.
+ * This function makes sure that unhandled errors are thrown in a separate
+ * macrotask. It allows those errors to be detected by global error handlers and
+ * reported to bug tracking services without interrupting our own stack of
+ * execution.
  *
- * @param err error to be thrown
+ * @param err Error to be thrown
  */
 function reportUnhandledError(err) {
   setTimeout(() => {
@@ -440,29 +441,29 @@ const defaultOptions = {
 };
 
 /**
- * An Actor is a running process that can receive events, send events and change its behavior based on the events it receives, which can cause effects outside of the actor. When you run a state machine, it becomes an actor.
+ * An Actor is a running process that can receive events, send events and change
+ * its behavior based on the events it receives, which can cause effects outside
+ * of the actor. When you run a state machine, it becomes an actor.
  */
 class Actor {
   /**
-   * Creates a new actor instance for the given logic with the provided options, if any.
+   * Creates a new actor instance for the given logic with the provided options,
+   * if any.
    *
    * @param logic The logic to create an actor from
    * @param options Actor options
    */
   constructor(logic, options) {
     this.logic = logic;
-    /**
-     * The current internal state of the actor.
-     */
+    /** The current internal state of the actor. */
     this._snapshot = void 0;
     /**
-     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     * The clock that is responsible for setting and clearing timeouts, such as
+     * delayed events and transitions.
      */
     this.clock = void 0;
     this.options = void 0;
-    /**
-     * The unique identifier for this actor relative to its parent.
-     */
+    /** The unique identifier for this actor relative to its parent. */
     this.id = void 0;
     this.mailbox = new Mailbox(this._process.bind(this));
     this.observers = new Set();
@@ -478,13 +479,9 @@ class Actor {
     // TODO: add typings for system
     this._actorScope = void 0;
     this._systemId = void 0;
-    /**
-     * The globally unique process ID for this invocation.
-     */
+    /** The globally unique process ID for this invocation. */
     this.sessionId = void 0;
-    /**
-     * The system to which this actor belongs.
-     */
+    /** The system to which this actor belongs. */
     this.system = void 0;
     this._doneEvent = void 0;
     this.src = void 0;
@@ -648,11 +645,15 @@ class Actor {
    * Subscribe an observer to an actor’s snapshot values.
    *
    * @remarks
-   * The observer will receive the actor’s snapshot value when it is emitted. The observer can be:
+   * The observer will receive the actor’s snapshot value when it is emitted.
+   * The observer can be:
+   *
    * - A plain function that receives the latest snapshot, or
-   * - An observer object whose `.next(snapshot)` method receives the latest snapshot
+   * - An observer object whose `.next(snapshot)` method receives the latest
+   *   snapshot
    *
    * @example
+   *
    * ```ts
    * // Observer as a plain function
    * const subscription = actor.subscribe((snapshot) => {
@@ -661,6 +662,7 @@ class Actor {
    * ```
    *
    * @example
+   *
    * ```ts
    * // Observer as an object
    * const subscription = actor.subscribe({
@@ -672,13 +674,16 @@ class Actor {
    *   },
    *   complete() {
    *     // ...
-   *   },
+   *   }
    * });
    * ```
    *
-   * The return value of `actor.subscribe(observer)` is a subscription object that has an `.unsubscribe()` method. You can call `subscription.unsubscribe()` to unsubscribe the observer:
+   * The return value of `actor.subscribe(observer)` is a subscription object
+   * that has an `.unsubscribe()` method. You can call
+   * `subscription.unsubscribe()` to unsubscribe the observer:
    *
    * @example
+   *
    * ```ts
    * const subscription = actor.subscribe((snapshot) => {
    *   // ...
@@ -688,9 +693,12 @@ class Actor {
    * subscription.unsubscribe();
    * ```
    *
-   * When the actor is stopped, all of its observers will automatically be unsubscribed.
+   * When the actor is stopped, all of its observers will automatically be
+   * unsubscribed.
    *
-   * @param observer - Either a plain function that receives the latest snapshot, or an observer object whose `.next(snapshot)` method receives the latest snapshot
+   * @param observer - Either a plain function that receives the latest
+   *   snapshot, or an observer object whose `.next(snapshot)` method receives
+   *   the latest snapshot
    */
 
   subscribe(nextListenerOrObserver, errorListener, completeListener) {
@@ -743,9 +751,7 @@ class Actor {
     };
   }
 
-  /**
-   * Starts the Actor from the initial state
-   */
+  /** Starts the Actor from the initial state */
   start() {
     if (this._processingStatus === ProcessingStatus.Running) {
       // Do not restart the service if it is already started
@@ -861,9 +867,7 @@ class Actor {
     return this;
   }
 
-  /**
-   * Stops the Actor and unsubscribe all listeners.
-   */
+  /** Stops the Actor and unsubscribe all listeners. */
   stop() {
     if (this._parent) {
       throw new Error('A non-root actor cannot be stopped directly.');
@@ -935,9 +939,7 @@ class Actor {
     return this;
   }
 
-  /**
-   * @internal
-   */
+  /** @internal */
   _send(event) {
     if (this._processingStatus === ProcessingStatus.Stopped) {
       return;
@@ -975,10 +977,11 @@ class Actor {
    * @remarks
    * The internal state can be persisted from any actor, not only machines.
    *
-   * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+   * Note that the persisted state is not the same as the snapshot from
+   * {@link Actor.getSnapshot}. Persisted state represents the internal state of
+   * the actor, while snapshots represent the actor's last emitted value.
    *
    * Can be restored with {@link ActorOptions.state}
-   *
    * @see https://stately.ai/docs/persistence
    */
 
@@ -995,11 +998,11 @@ class Actor {
    * @remarks
    * The snapshot represent an actor's last emitted value.
    *
-   * When an actor receives an event, its internal state may change.
-   * An actor may emit a snapshot when a state transition occurs.
-   *
-   * Note that some actors, such as callback actors generated with `fromCallback`, will not emit snapshots.
+   * When an actor receives an event, its internal state may change. An actor
+   * may emit a snapshot when a state transition occurs.
    *
+   * Note that some actors, such as callback actors generated with
+   * `fromCallback`, will not emit snapshots.
    * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
    * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
    */
@@ -1008,13 +1011,16 @@ class Actor {
   }
 }
 /**
- * Creates a new actor instance for the given actor logic with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided
+ * options, if any.
  *
  * @remarks
- * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
- * Any actors spawned from this root actor and its descendants are part of that actor system.
- *
+ * When you create an actor from actor logic via `createActor(logic)`, you
+ * implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that
+ * actor system.
  * @example
+ *
  * ```ts
  * import { createActor } from 'xstate';
  * import { someActorLogic } from './someActorLogic.ts';
@@ -1036,7 +1042,10 @@ class Actor {
  * actor.stop();
  * ```
  *
- * @param logic - The actor logic to create an actor from. For a state machine actor logic creator, see {@link createMachine}. Other actor logic creators include {@link fromCallback}, {@link fromEventObservable}, {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
+ * @param logic - The actor logic to create an actor from. For a state machine
+ *   actor logic creator, see {@link createMachine}. Other actor logic creators
+ *   include {@link fromCallback}, {@link fromEventObservable},
+ *   {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
  * @param options - Actor options
  */
 function createActor(logic, ...[options]) {
@@ -1044,15 +1053,14 @@ function createActor(logic, ...[options]) {
 }
 
 /**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ * Creates a new Interpreter instance for the given machine with the provided
+ * options, if any.
  *
  * @deprecated Use `createActor` instead
  */
 const interpret = createActor;
 
-/**
- * @deprecated Use `Actor` instead.
- */
+/** @deprecated Use `Actor` instead. */
 
 function resolveCancel(_, snapshot, actionArgs, actionParams, {
   sendId
@@ -1066,30 +1074,36 @@ function executeCancel(actorScope, resolvedSendId) {
   });
 }
 /**
- * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The canceled `sendTo(...)` action
- * will not send its event or execute, unless the `delay` has already elapsed before `cancel(...)` is called.
+ * Cancels a delayed `sendTo(...)` action that is waiting to be executed. The
+ * canceled `sendTo(...)` action will not send its event or execute, unless the
+ * `delay` has already elapsed before `cancel(...)` is called.
  *
- * @param sendId The `id` of the `sendTo(...)` action to cancel.
- * 
  * @example
-  ```ts
-  import { createMachine, sendTo, cancel } from 'xstate';
-
-  const machine = createMachine({
-    // ...
-    on: {
-      sendEvent: {
-        actions: sendTo('some-actor', { type: 'someEvent' }, {
-          id: 'some-id',
-          delay: 1000
-        })
-      },
-      cancelEvent: {
-        actions: cancel('some-id')
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { createMachine, sendTo, cancel } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   // ...
+ *   on: {
+ *     sendEvent: {
+ *       actions: sendTo(
+ *         'some-actor',
+ *         { type: 'someEvent' },
+ *         {
+ *           id: 'some-id',
+ *           delay: 1000
+ *         }
+ *       )
+ *     },
+ *     cancelEvent: {
+ *       actions: cancel('some-id')
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @param sendId The `id` of the `sendTo(...)` action to cancel.
  */
 function cancel(sendId) {
   function cancel(args, params) {
@@ -1257,30 +1271,33 @@ function checkNot(snapshot, {
 }
 
 /**
- * Higher-order guard that evaluates to `true` if the `guard` passed to it evaluates to `false`.
+ * Higher-order guard that evaluates to `true` if the `guard` passed to it
+ * evaluates to `false`.
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, not } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => false
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: not('someNamedGuard'),
-        actions: () => {
-          // will be executed if guard in `not(...)`
-          // evaluates to `false`
-        }
-      }
-    }
-  });
-  ```
- * @returns A guard 
+ *
+ * ```ts
+ * import { setup, not } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => false
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: not('someNamedGuard'),
+ *       actions: () => {
+ *         // will be executed if guard in `not(...)`
+ *         // evaluates to `false`
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @returns A guard
  */
 function not(guard) {
   function not(args, params) {
@@ -1305,28 +1322,27 @@ function checkAnd(snapshot, {
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, and } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => true
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: and([
-          ({ context }) => context.value > 0,
-          'someNamedGuard'
-        ]),
-        actions: () => {
-          // will be executed if all guards in `and(...)`
-          // evaluate to true
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, and } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => true
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: and([({ context }) => context.value > 0, 'someNamedGuard']),
+ *       actions: () => {
+ *         // will be executed if all guards in `and(...)`
+ *         // evaluate to true
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard action object
  */
 function and(guards) {
@@ -1347,33 +1363,32 @@ function checkOr(snapshot, {
 }
 
 /**
- * Higher-order guard that evaluates to `true` if any of the `guards` passed to it
- * evaluate to `true`.
+ * Higher-order guard that evaluates to `true` if any of the `guards` passed to
+ * it evaluate to `true`.
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, or } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => true
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: or([
-          ({ context }) => context.value > 0,
-          'someNamedGuard'
-        ]),
-        actions: () => {
-          // will be executed if any of the guards in `or(...)`
-          // evaluate to true
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, or } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => true
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: or([({ context }) => context.value > 0, 'someNamedGuard']),
+ *       actions: () => {
+ *         // will be executed if any of the guards in `or(...)`
+ *         // evaluate to true
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard action object
  */
 function or(guards) {
@@ -1550,9 +1565,7 @@ function getCandidates(stateNode, receivedEventType) {
   return candidates;
 }
 
-/**
- * All delayed transitions from the config.
- */
+/** All delayed transitions from the config. */
 function getDelayedTransitions(stateNode) {
   const afterConfig = stateNode.config.after;
   if (!afterConfig) {
@@ -1739,9 +1752,7 @@ function getInitialStateNodes(stateNode) {
   iter(stateNode);
   return set;
 }
-/**
- * Returns the child state node from its relative `stateKey`, or throws.
- */
+/** Returns the child state node from its relative `stateKey`, or throws. */
 function getStateNode(stateNode, stateKey) {
   if (isStateId(stateKey)) {
     return stateNode.machine.getStateNodeById(stateKey);
@@ -1982,9 +1993,7 @@ function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
   return true;
 }
 
-/**
- * https://www.w3.org/TR/scxml/#microstepProcedure
- */
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentSnapshot;
@@ -2394,7 +2403,8 @@ function selectEventlessTransitions(nextState, event) {
 }
 
 /**
- * Resolves a partial state value with its full representation in the state node's machine.
+ * Resolves a partial state value with its full representation in the state
+ * node's machine.
  *
  * @param stateValue The partial state value to resolve.
  */