xstate 6.0.0-alpha.47 → 6.0.0-alpha.49

package/dist/types-3c3455f7.esm.js

@@ -0,0 +1,185 @@
+import { S as StateMachine } from './StateMachine-2af31c11.esm.js';
+
+/**
+ * Creates a state machine (statechart) with the given configuration.
+ *
+ * The state machine represents the pure logic of a state machine actor.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine } from 'xstate';
+ *
+ * const lightMachine = createMachine({
+ *   id: 'light',
+ *   initial: 'green',
+ *   states: {
+ *     green: {
+ *       on: {
+ *         TIMER: { target: 'yellow' }
+ *       }
+ *     },
+ *     yellow: {
+ *       on: {
+ *         TIMER: { target: 'red' }
+ *       }
+ *     },
+ *     red: {
+ *       on: {
+ *         TIMER: { target: 'green' }
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const lightActor = createActor(lightMachine);
+ * lightActor.start();
+ *
+ * lightActor.send({ type: 'TIMER' });
+ * ```
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+ *   to provide machine sources instead.
+ */
+// Overload 1: With schemas.context — context type inferred from schema
+
+// Overload 2: Without schemas.context — context type inferred from config.context
+
+// Implementation
+function createMachine(config) {
+  return new StateMachine(config);
+}
+function createStateConfig(config) {
+  return config;
+}
+
+// this is needed to make JSDoc `@link` work properly
+// oxlint-disable-next-line no-unused-vars
+
+/**
+ * @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:
+ *
+ * ```ts
+ * 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`.
+ */
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+
+// @TODO: we can't use native `NoInfer` as we need those:
+// https://github.com/microsoft/TypeScript/pull/61092
+// https://github.com/microsoft/TypeScript/pull/61077
+// but even with those fixes native NoInfer still doesn't work - further issues have to be reproduced and fixed
+
+/** @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.
+ *
+ * @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" }`.
+ */
+
+// Accept any StateNode instance regardless of generic parameters
+// Using a union type to handle variance issues with machine.resolveState
+
+let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
+  SpecialTargets["Internal"] = "#_internal";
+  return SpecialTargets;
+}({});
+
+/** A deterministic delayed-delivery declaration owned by a logic snapshot. */
+
+/** The logical input delivered to a timer's source when its runtime delay ends. */
+
+/** A persisted snapshot tied to a versioned actor logic identity. */
+
+/**
+ * A persisted snapshot restorable into the given actor logic: any snapshot
+ * created by logic with the same machine `id` is accepted, regardless of
+ * version (version mismatches are handled at runtime, e.g. by `migrate`).
+ */
+
+/** @deprecated Use `AnyActor` instead. */
+
+// Based on RxJS types
+
+/**
+ * A consumer-facing actor handle.
+ *
+ * `ActorRef` describes the contract a consumer needs: which events can be sent
+ * to the actor, which snapshot it publishes for observation, and which emitted
+ * events can be listened to. It intentionally does not expose lifecycle control
+ * or runtime internals. A concrete `Actor` satisfies this interface, so APIs
+ * should accept `ActorRef` whenever they only need to send events, read
+ * snapshots, or listen to emitted events.
+ */
+
+/**
+ * Runtime-only actor capabilities.
+ *
+ * These members are needed by the interpreter, scheduler, inspection, and child
+ * management code. Public consumer APIs should prefer `ActorRef` unless they
+ * genuinely need lifecycle control such as starting, stopping, or accessing
+ * system-owned runtime state.
+ */
+
+/**
+ * A concrete actor instance type.
+ *
+ * `ActorInstance` combines the consumer `ActorRef` contract with runtime
+ * lifecycle capabilities. Values returned by `createActor(...)` and
+ * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
+ */
+
+/**
+ * The actor's own full self handle.
+ *
+ * Internals and action/guard sources receive this shape because `self` can
+ * participate in runtime-owned behavior while still being usable wherever an
+ * `ActorRef` is expected.
+ */
+
+// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
+
+/** The concrete actor instance type produced from actor logic. */
+
+/**
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
+ */
+
+// Actors that don't have literal string IDs — these are the only ones
+// that should appear in the index signature fallback, since actors with
+// literal IDs are already covered by ToConcreteChildren.
+
+/** Maps state IDs to their input types based on the StateSchema. */
+
+/** @deprecated */
+
+/** The terminal result published when an actor completes or errors. */
+
+/** An executable effect that publishes an actor's terminal result. */
+
+/** Mappers for subscribeTo - maps lifecycle events to machine events */
+
+export { SpecialTargets as S, createStateConfig as a, createMachine as c };

package/dist/types-adda3842.development.esm.js

@@ -0,0 +1,185 @@
+import { S as StateMachine } from './StateMachine-faf50c5c.development.esm.js';
+
+/**
+ * Creates a state machine (statechart) with the given configuration.
+ *
+ * The state machine represents the pure logic of a state machine actor.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine } from 'xstate';
+ *
+ * const lightMachine = createMachine({
+ *   id: 'light',
+ *   initial: 'green',
+ *   states: {
+ *     green: {
+ *       on: {
+ *         TIMER: { target: 'yellow' }
+ *       }
+ *     },
+ *     yellow: {
+ *       on: {
+ *         TIMER: { target: 'red' }
+ *       }
+ *     },
+ *     red: {
+ *       on: {
+ *         TIMER: { target: 'green' }
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const lightActor = createActor(lightMachine);
+ * lightActor.start();
+ *
+ * lightActor.send({ type: 'TIMER' });
+ * ```
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+ *   to provide machine sources instead.
+ */
+// Overload 1: With schemas.context — context type inferred from schema
+
+// Overload 2: Without schemas.context — context type inferred from config.context
+
+// Implementation
+function createMachine(config) {
+  return new StateMachine(config);
+}
+function createStateConfig(config) {
+  return config;
+}
+
+// this is needed to make JSDoc `@link` work properly
+// oxlint-disable-next-line no-unused-vars
+
+/**
+ * @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:
+ *
+ * ```ts
+ * 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`.
+ */
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+
+// @TODO: we can't use native `NoInfer` as we need those:
+// https://github.com/microsoft/TypeScript/pull/61092
+// https://github.com/microsoft/TypeScript/pull/61077
+// but even with those fixes native NoInfer still doesn't work - further issues have to be reproduced and fixed
+
+/** @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.
+ *
+ * @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" }`.
+ */
+
+// Accept any StateNode instance regardless of generic parameters
+// Using a union type to handle variance issues with machine.resolveState
+
+let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
+  SpecialTargets["Internal"] = "#_internal";
+  return SpecialTargets;
+}({});
+
+/** A deterministic delayed-delivery declaration owned by a logic snapshot. */
+
+/** The logical input delivered to a timer's source when its runtime delay ends. */
+
+/** A persisted snapshot tied to a versioned actor logic identity. */
+
+/**
+ * A persisted snapshot restorable into the given actor logic: any snapshot
+ * created by logic with the same machine `id` is accepted, regardless of
+ * version (version mismatches are handled at runtime, e.g. by `migrate`).
+ */
+
+/** @deprecated Use `AnyActor` instead. */
+
+// Based on RxJS types
+
+/**
+ * A consumer-facing actor handle.
+ *
+ * `ActorRef` describes the contract a consumer needs: which events can be sent
+ * to the actor, which snapshot it publishes for observation, and which emitted
+ * events can be listened to. It intentionally does not expose lifecycle control
+ * or runtime internals. A concrete `Actor` satisfies this interface, so APIs
+ * should accept `ActorRef` whenever they only need to send events, read
+ * snapshots, or listen to emitted events.
+ */
+
+/**
+ * Runtime-only actor capabilities.
+ *
+ * These members are needed by the interpreter, scheduler, inspection, and child
+ * management code. Public consumer APIs should prefer `ActorRef` unless they
+ * genuinely need lifecycle control such as starting, stopping, or accessing
+ * system-owned runtime state.
+ */
+
+/**
+ * A concrete actor instance type.
+ *
+ * `ActorInstance` combines the consumer `ActorRef` contract with runtime
+ * lifecycle capabilities. Values returned by `createActor(...)` and
+ * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
+ */
+
+/**
+ * The actor's own full self handle.
+ *
+ * Internals and action/guard sources receive this shape because `self` can
+ * participate in runtime-owned behavior while still being usable wherever an
+ * `ActorRef` is expected.
+ */
+
+// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
+
+/** The concrete actor instance type produced from actor logic. */
+
+/**
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
+ */
+
+// Actors that don't have literal string IDs — these are the only ones
+// that should appear in the index signature fallback, since actors with
+// literal IDs are already covered by ToConcreteChildren.
+
+/** Maps state IDs to their input types based on the StateSchema. */
+
+/** @deprecated */
+
+/** The terminal result published when an actor completes or errors. */
+
+/** An executable effect that publishes an actor's terminal result. */
+
+/** Mappers for subscribeTo - maps lifecycle events to machine events */
+
+export { SpecialTargets as S, createStateConfig as a, createMachine as c };

package/dist/types-b3fea5bd.development.cjs.js

@@ -0,0 +1,189 @@
+'use strict';
+
+var StateMachine = require('./StateMachine-29450e6d.development.cjs.js');
+
+/**
+ * Creates a state machine (statechart) with the given configuration.
+ *
+ * The state machine represents the pure logic of a state machine actor.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine } from 'xstate';
+ *
+ * const lightMachine = createMachine({
+ *   id: 'light',
+ *   initial: 'green',
+ *   states: {
+ *     green: {
+ *       on: {
+ *         TIMER: { target: 'yellow' }
+ *       }
+ *     },
+ *     yellow: {
+ *       on: {
+ *         TIMER: { target: 'red' }
+ *       }
+ *     },
+ *     red: {
+ *       on: {
+ *         TIMER: { target: 'green' }
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const lightActor = createActor(lightMachine);
+ * lightActor.start();
+ *
+ * lightActor.send({ type: 'TIMER' });
+ * ```
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+ *   to provide machine sources instead.
+ */
+// Overload 1: With schemas.context — context type inferred from schema
+
+// Overload 2: Without schemas.context — context type inferred from config.context
+
+// Implementation
+function createMachine(config) {
+  return new StateMachine.StateMachine(config);
+}
+function createStateConfig(config) {
+  return config;
+}
+
+// this is needed to make JSDoc `@link` work properly
+// oxlint-disable-next-line no-unused-vars
+
+/**
+ * @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:
+ *
+ * ```ts
+ * 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`.
+ */
+
+// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
+
+// @TODO: we can't use native `NoInfer` as we need those:
+// https://github.com/microsoft/TypeScript/pull/61092
+// https://github.com/microsoft/TypeScript/pull/61077
+// but even with those fixes native NoInfer still doesn't work - further issues have to be reproduced and fixed
+
+/** @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.
+ *
+ * @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" }`.
+ */
+
+// Accept any StateNode instance regardless of generic parameters
+// Using a union type to handle variance issues with machine.resolveState
+
+let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
+  SpecialTargets["Internal"] = "#_internal";
+  return SpecialTargets;
+}({});
+
+/** A deterministic delayed-delivery declaration owned by a logic snapshot. */
+
+/** The logical input delivered to a timer's source when its runtime delay ends. */
+
+/** A persisted snapshot tied to a versioned actor logic identity. */
+
+/**
+ * A persisted snapshot restorable into the given actor logic: any snapshot
+ * created by logic with the same machine `id` is accepted, regardless of
+ * version (version mismatches are handled at runtime, e.g. by `migrate`).
+ */
+
+/** @deprecated Use `AnyActor` instead. */
+
+// Based on RxJS types
+
+/**
+ * A consumer-facing actor handle.
+ *
+ * `ActorRef` describes the contract a consumer needs: which events can be sent
+ * to the actor, which snapshot it publishes for observation, and which emitted
+ * events can be listened to. It intentionally does not expose lifecycle control
+ * or runtime internals. A concrete `Actor` satisfies this interface, so APIs
+ * should accept `ActorRef` whenever they only need to send events, read
+ * snapshots, or listen to emitted events.
+ */
+
+/**
+ * Runtime-only actor capabilities.
+ *
+ * These members are needed by the interpreter, scheduler, inspection, and child
+ * management code. Public consumer APIs should prefer `ActorRef` unless they
+ * genuinely need lifecycle control such as starting, stopping, or accessing
+ * system-owned runtime state.
+ */
+
+/**
+ * A concrete actor instance type.
+ *
+ * `ActorInstance` combines the consumer `ActorRef` contract with runtime
+ * lifecycle capabilities. Values returned by `createActor(...)` and
+ * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
+ */
+
+/**
+ * The actor's own full self handle.
+ *
+ * Internals and action/guard sources receive this shape because `self` can
+ * participate in runtime-owned behavior while still being usable wherever an
+ * `ActorRef` is expected.
+ */
+
+// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
+
+/** The concrete actor instance type produced from actor logic. */
+
+/**
+ * Represents logic which can be used by an actor.
+ *
+ * @template TSnapshot - The type of the snapshot.
+ * @template TEvent - The type of the event object.
+ * @template TInput - The type of the input.
+ * @template TSystem - The type of the actor system.
+ */
+
+// Actors that don't have literal string IDs — these are the only ones
+// that should appear in the index signature fallback, since actors with
+// literal IDs are already covered by ToConcreteChildren.
+
+/** Maps state IDs to their input types based on the StateSchema. */
+
+/** @deprecated */
+
+/** The terminal result published when an actor completes or errors. */
+
+/** An executable effect that publishes an actor's terminal result. */
+
+/** Mappers for subscribeTo - maps lifecycle events to machine events */
+
+exports.SpecialTargets = SpecialTargets;
+exports.createMachine = createMachine;
+exports.createStateConfig = createStateConfig;