xstate 5.14.0 → 5.16.0

package/dist/declarations/src/waitFor.d.ts

@@ -1,22 +1,22 @@
 import { AnyActorRef, SnapshotFrom } from "./types.js";
 interface WaitForOptions {
     /**
-     * How long to wait before rejecting, if no emitted
-     * state satisfies the predicate.
+     * How long to wait before rejecting, if no emitted state satisfies the
+     * predicate.
      *
      * @defaultValue Infinity
      */
     timeout: number;
 }
 /**
- * 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).
+ * 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
+ *
  * ```js
- * const state = await waitFor(someService, state => {
+ * const state = await waitFor(someService, (state) => {
  *   return state.hasTag('loaded');
  * });
  *
@@ -26,8 +26,8 @@ interface WaitForOptions {
  * @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
+ * @returns A promise that eventually resolves to the emitted value that matches
+ *   the condition
  */
 export declare function waitFor<TActorRef extends AnyActorRef>(actorRef: TActorRef, predicate: (emitted: SnapshotFrom<TActorRef>) => boolean, options?: Partial<WaitForOptions>): Promise<SnapshotFrom<TActorRef>>;
 export {};

package/dist/{log-c943e6aa.development.esm.js → log-17f4495d.development.esm.js}

@@ -1,8 +1,5 @@
-import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as executingCustomAction, W as XSTATE_ERROR, Y as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-0f400094.development.esm.js';
+import { T as ProcessingStatus, z as resolveReferencedActor, A as createActor, U as cloneMachineSnapshot, V as executingCustomAction, W as XSTATE_ERROR, Y as createErrorActorEvent, e as evaluateGuard, M as cancel, O as raise, P as spawnChild, R as stopChild } from './raise-7d030497.development.esm.js';
 
-// it's likely-ish that `(TActor & { src: TSrc })['logic']` would be faster
-// but it's only possible to do it since https://github.com/microsoft/TypeScript/pull/53098 (TS 5.1)
-// and we strive to support TS 5.0 whenever possible
 function createSpawner(actorScope, {
   machine,
   context
@@ -91,34 +88,36 @@ function resolveAssign(actorScope, snapshot, actionArgs, actionParams, {
 /**
  * Updates the current context of the machine.
  *
- * @param assignment An object that represents the partial context to update, or a
- * function that returns an object that represents the partial context to update.
- *
  * @example
-  ```ts
-  import { createMachine, assign } from 'xstate';
-
-  const countMachine = createMachine({
-    context: {
-      count: 0,
-      message: ''
-    },
-    on: {
-      inc: {
-        actions: assign({
-          count: ({ context }) => context.count + 1
-        })
-      },
-      updateMessage: {
-        actions: assign(({ context, event }) => {
-          return {
-            message: event.message.trim()
-          }
-        })
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { createMachine, assign } from 'xstate';
+ *
+ * const countMachine = createMachine({
+ *   context: {
+ *     count: 0,
+ *     message: ''
+ *   },
+ *   on: {
+ *     inc: {
+ *       actions: assign({
+ *         count: ({ context }) => context.count + 1
+ *       })
+ *     },
+ *     updateMessage: {
+ *       actions: assign(({ context, event }) => {
+ *         return {
+ *           message: event.message.trim()
+ *         };
+ *       })
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @param assignment An object that represents the partial context to update, or
+ *   a function that returns an object that represents the partial context to
+ *   update.
  */
 function assign(assignment) {
   if (executingCustomAction) {
@@ -152,43 +151,42 @@ function executeEmit(actorScope, {
   actorScope.defer(() => actorScope.emit(event));
 }
 /**
- * Emits an event to event handlers registered on the actor via `actor.on(event, handler)`.
+ * Emits an event to event handlers registered on the actor via `actor.on(event,
+ * handler)`.
  *
  * @example
-  ```ts
-  import { emit } from 'xstate';
-
-  const machine = createMachine({
-    // ...
-    on: {
-      something: {
-        actions: emit({
-          type: 'emitted',
-          some: 'data'
-        })
-      }
-    }
-    // ...
-  });
-
-  const actor = createActor(machine).start();
-
-  actor.on('emitted', (event) => {
-    console.log(event);
-  });
-
-  actor.send({ type: 'something' });
-  // logs:
-  // {
-  //   type: 'emitted',
-  //   some: 'data'
-  // }
-  ```
- */
-function emit(
-/**
- * The event to emit, or an expression that returns an event to emit.
+ *
+ * ```ts
+ * import { emit } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   // ...
+ *   on: {
+ *     something: {
+ *       actions: emit({
+ *         type: 'emitted',
+ *         some: 'data'
+ *       })
+ *     }
+ *   }
+ *   // ...
+ * });
+ *
+ * const actor = createActor(machine).start();
+ *
+ * actor.on('emitted', (event) => {
+ *   console.log(event);
+ * });
+ *
+ * actor.send({ type: 'something' });
+ * // logs:
+ * // {
+ * //   type: 'emitted',
+ * //   some: 'data'
+ * // }
+ * ```
  */
+function emit( /** The event to emit, or an expression that returns an event to emit. */
 eventOrExpr) {
   if (executingCustomAction) {
     console.warn('Custom actions should not call `emit()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
@@ -206,62 +204,52 @@ eventOrExpr) {
 }
 
 /**
- *
  * @remarks
- *
- * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
- * It especially is a problem when the union has a function member, like here:
+ * `T | unknown` reduces to `unknown` and that can be problematic when it comes
+ * to contextual typing. It especially is a problem when the union has a
+ * function member, like here:
  *
  * ```ts
- * declare function test(cbOrVal: ((arg: number) => unknown) | unknown): void;
- * test((arg) => {}) // oops, implicit any
+ * declare function test(
+ *   cbOrVal: ((arg: number) => unknown) | unknown
+ * ): void;
+ * test((arg) => {}); // oops, implicit any
  * ```
  *
- * This type can be used to avoid this problem. This union represents the same value space as `unknown`.
+ * This type can be used to avoid this problem. This union represents the same
+ * value space as `unknown`.
  */
 
 // https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
 
 // @TODO: Replace with native `NoInfer` when TS issue gets fixed:
 // https://github.com/microsoft/TypeScript/pull/57673
+/** @deprecated Use the built-in `NoInfer` type instead */
+/** The full definition of an event, with a string `type`. */
 /**
- * @deprecated Use the built-in `NoInfer` type instead
- */
-/**
- * The full definition of an event, with a string `type`.
- */
-/**
- * The string or object representing the state value relative to the parent state node.
+ * The string or object representing the state value relative to the parent
+ * state node.
  *
  * @remarks
- *
  * - For a child atomic state node, this is a string, e.g., `"pending"`.
- *
- * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
+ * - For complex state nodes, this is an object, e.g., `{ success:
+ *   "someChildState" }`.
  */
 // TODO: remove once TS fixes this type-widening issue
-/** @deprecated use `AnyMachineSnapshot` instead */
+/** @deprecated Use `AnyMachineSnapshot` instead */
 // TODO: possibly refactor this somehow, use even a simpler type, and maybe even make `machine.options` private or something
-/**
- * @hidden
- */
+/** @ignore */
 let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   SpecialTargets["Parent"] = "#_parent";
   SpecialTargets["Internal"] = "#_internal";
   return SpecialTargets;
 }({});
 
-/**
- * @deprecated Use `AnyActor` instead.
- */
+/** @deprecated Use `AnyActor` instead. */
 
 // Based on RxJS types
 
-/**
- * @deprecated Use `Actor<T>` instead.
- */
-
-// only meant to be used internally for debugging purposes
+/** @deprecated Use `Actor<T>` instead. */
 
 /**
  * Represents logic which can be used by an actor.
@@ -272,6 +260,8 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
  * @template TSystem - The type of the actor system.
  */
 
+/** @deprecated */
+
 function resolveSendTo(actorScope, snapshot, args, actionParams, {
   to,
   event: eventOrExpr,
@@ -346,10 +336,12 @@ function executeSendTo(actorScope, params) {
  * Sends an event to an actor.
  *
  * @param actor The `ActorRef` to send the event to.
- * @param event The event to send, or an expression that evaluates to the event to send
+ * @param event The event to send, or an expression that evaluates to the event
+ *   to send
  * @param options Send action options
- *  - `id` - The unique send event identifier (used with `cancel()`).
- *  - `delay` - The number of milliseconds to delay the sending of the event.
+ *
+ *   - `id` - The unique send event identifier (used with `cancel()`).
+ *   - `delay` - The number of milliseconds to delay the sending of the event.
  */
 function sendTo(to, eventOrExpr, options) {
   if (executingCustomAction) {
@@ -425,6 +417,9 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
     // then it fails to typecheck that because `...args` use `string` in place of `TDelay
     actions.push(sendTo(...args));
   };
+  enqueue.sendParent = (...args) => {
+    actions.push(sendParent(...args));
+  };
   enqueue.spawnChild = (...args) => {
     actions.push(spawnChild(...args));
   };
@@ -445,24 +440,26 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, {
   return [snapshot, undefined, actions];
 }
 /**
- * Creates an action object that will execute actions that are queued by the `enqueue(action)` function.
+ * Creates an action object that will execute actions that are queued by the
+ * `enqueue(action)` function.
  *
  * @example
-  ```ts
-  import { createMachine, enqueueActions } from 'xstate';
-
-  const machine = createMachine({
-    entry: enqueueActions(({ enqueue, check }) => {
-      enqueue.assign({ count: 0 });
-
-      if (check('someGuard')) {
-        enqueue.assign({ count: 1 });
-      }
-
-      enqueue('someAction');
-    })
-  })
-  ```
+ *
+ * ```ts
+ * import { createMachine, enqueueActions } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   entry: enqueueActions(({ enqueue, check }) => {
+ *     enqueue.assign({ count: 0 });
+ *
+ *     if (check('someGuard')) {
+ *       enqueue.assign({ count: 1 });
+ *     }
+ *
+ *     enqueue('someAction');
+ *   })
+ * });
+ * ```
  */
 function enqueueActions(collect) {
   function enqueueActions(args, params) {
@@ -498,11 +495,12 @@ function executeLog({
   }
 }
 /**
+ * @param expr The expression function to evaluate which will be logged. Takes
+ *   in 2 arguments:
+ *
+ *   - `ctx` - the current state context
+ *   - `event` - the event that caused this action to be executed.
  *
- * @param expr The expression function to evaluate which will be logged.
- *  Takes in 2 arguments:
- *  - `ctx` - the current state context
- *  - `event` - the event that caused this action to be executed.
  * @param label The label to give to the logged expression.
  */
 function log(value = ({