xstate 5.32.1 → 6.0.0-alpha.1

package/dist/declarations/src/actions/spawnChild.d.ts

@@ -1,34 +0,0 @@
-import { ActionArgs, ActionFunction, AnyActorLogic, ConditionalRequired, EventObject, InputFrom, IsLiteralString, IsNotNever, MachineContext, Mapper, ParameterizedObject, ProvidedActor, RequiredActorOptions, UnifiedArg } from "../types.js";
-type ResolvableActorId<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TId extends string | undefined> = TId | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TId);
-export interface SpawnAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TActor?: TActor;
-}
-export interface SpawnActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> {
-    id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
-    systemId?: string;
-    input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
-    syncSnapshot?: boolean;
-}
-type DistributeActors<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = (TActor extends any ? ConditionalRequired<[
-    src: TActor['src'],
-    options?: SpawnActionOptions<TContext, TExpressionEvent, TEvent, TActor> & {
-        [K in RequiredActorOptions<TActor>]: unknown;
-    }
-], IsNotNever<RequiredActorOptions<TActor>>> : never) | [
-    src: AnyActorLogic,
-    options?: SpawnActionOptions<TContext, TExpressionEvent, TEvent, ProvidedActor> & {
-        id?: never;
-    }
-];
-type SpawnArguments<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TExpressionEvent, TEvent, TActor> : [
-    src: string | AnyActorLogic,
-    options?: {
-        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
-        systemId?: string;
-        input?: unknown;
-        syncSnapshot?: boolean;
-    }
-];
-export declare function spawnChild<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor>(...[src, { id, systemId, input, syncSnapshot }]: SpawnArguments<TContext, TExpressionEvent, TEvent, TActor>): ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, never, never, never, never>;
-export {};

package/dist/declarations/src/actions/stopChild.d.ts

@@ -1,19 +0,0 @@
-import { ActionArgs, AnyActorRef, EventObject, MachineContext, ParameterizedObject } from "../types.js";
-type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | AnyActorRef | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => AnyActorRef | string);
-export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-}
-/**
- * Stops a child actor.
- *
- * @param actorRef The actor to stop.
- */
-export declare function stopChild<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TParams, TEvent>): StopAction<TContext, TExpressionEvent, TParams, TEvent>;
-/**
- * Stops a child actor.
- *
- * @deprecated Use `stopChild(...)` instead
- * @alias
- */
-export declare const stop: typeof stopChild;
-export {};

package/dist/declarations/src/actors/transition.d.ts

@@ -1,143 +0,0 @@
-import { AnyActorSystem } from "../system.js";
-import { ActorLogic, ActorRefFromLogic, ActorScope, EventObject, NonReducibleUnknown, Snapshot } from "../types.js";
-export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
-    context: TContext;
-};
-export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem, TEmitted>;
-/**
- * Represents an actor created by `fromTransition`.
- *
- * The type of `self` within the actor's logic.
- *
- * @example
- *
- * ```ts
- * import {
- *   fromTransition,
- *   createActor,
- *   type AnyActorSystem
- * } from 'xstate';
- *
- * //* The actor's stored context.
- * type Context = {
- *   // The current count.
- *   count: number;
- *   // The amount to increase `count` by.
- *   step: number;
- * };
- * // The events the actor receives.
- * type Event = { type: 'increment' };
- * // The actor's input.
- * type Input = { step?: number };
- *
- * // Actor logic that increments `count` by `step` when it receives an event of
- * // type `increment`.
- * const logic = fromTransition<Context, Event, AnyActorSystem, Input>(
- *   (state, event, actorScope) => {
- *     actorScope.self;
- *     //         ^? TransitionActorRef<Context, Event>
- *
- *     if (event.type === 'increment') {
- *       return {
- *         ...state,
- *         count: state.count + state.step
- *       };
- *     }
- *     return state;
- *   },
- *   ({ input, self }) => {
- *     self;
- *     // ^? TransitionActorRef<Context, Event>
- *
- *     return {
- *       count: 0,
- *       step: input.step ?? 1
- *     };
- *   }
- * );
- *
- * const actor = createActor(logic, { input: { step: 10 } });
- * //    ^? TransitionActorRef<Context, Event>
- * ```
- *
- * @see {@link fromTransition}
- */
-export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFromLogic<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
-/**
- * Returns actor logic given a transition function and its initial state.
- *
- * A “transition function” is a function that takes the current `state` and
- * received `event` object as arguments, and returns the next state, similar to
- * a reducer.
- *
- * Actors created from transition logic (“transition actors”) can:
- *
- * - Receive events
- * - Emit snapshots of its state
- *
- * The transition function’s `state` is used as its transition actor’s
- * `context`.
- *
- * Note that the "state" for a transition function is provided by the initial
- * state argument, and is not the same as the State object of an actor or a
- * state within a machine configuration.
- *
- * @example
- *
- * ```ts
- * const transitionLogic = fromTransition(
- *   (state, event) => {
- *     if (event.type === 'increment') {
- *       return {
- *         ...state,
- *         count: state.count + 1
- *       };
- *     }
- *     return state;
- *   },
- *   { count: 0 }
- * );
- *
- * const transitionActor = createActor(transitionLogic);
- * transitionActor.subscribe((snapshot) => {
- *   console.log(snapshot);
- * });
- * transitionActor.start();
- * // => {
- * //   status: 'active',
- * //   context: { count: 0 },
- * //   ...
- * // }
- *
- * transitionActor.send({ type: 'increment' });
- * // => {
- * //   status: 'active',
- * //   context: { count: 1 },
- * //   ...
- * // }
- * ```
- *
- * @param transition The transition function used to describe the transition
- *   logic. It should return the next state given the current state and event.
- *   It receives the following arguments:
- *
- *   - `state` - the current state.
- *   - `event` - the received event.
- *   - `actorScope` - the actor scope object, with properties like `self` and
- *       `system`.
- *
- * @param initialContext The initial state of the transition function, either an
- *   object representing the state, or a function which returns a state object.
- *   If a function, it will receive as its only argument an object with the
- *   following properties:
- *
- *   - `input` - the `input` provided to its parent transition actor.
- *   - `self` - a reference to its parent transition actor.
- *
- * @returns Actor logic
- * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
- */
-export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends AnyActorSystem, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(transition: (snapshot: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem, TEmitted>) => TContext, initialContext: TContext | (({ input, self }: {
-    input: TInput;
-    self: TransitionActorRef<TContext, TEvent>;
-}) => TContext)): TransitionActorLogic<TContext, TEvent, TInput, TEmitted>;

package/dist/declarations/src/dev/index.d.ts

@@ -1,14 +0,0 @@
-import { AnyActor, DevToolsAdapter } from "../types.js";
-type ServiceListener = (service: AnyActor) => void;
-export interface XStateDevInterface {
-    register: (service: AnyActor) => void;
-    unregister: (service: AnyActor) => void;
-    onRegister: (listener: ServiceListener) => {
-        unsubscribe: () => void;
-    };
-    services: Set<AnyActor>;
-}
-export declare function getGlobal(): typeof globalThis | undefined;
-export declare function registerService(service: AnyActor): void;
-export declare const devToolsAdapter: DevToolsAdapter;
-export {};

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

@@ -1,128 +0,0 @@
-import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyMachineSnapshot, NoRequiredParams, WithDynamicParams, Identity, Elements, DoNotInfer } from "./types.js";
-type SingleGuardArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuardArg> = [TGuardArg] extends [{
-    type: string;
-}] ? Identity<TGuardArg> : [TGuardArg] extends [string] ? TGuardArg : GuardPredicate<TContext, TExpressionEvent, TParams, ParameterizedObject>;
-type NormalizeGuardArg<TGuardArg> = TGuardArg extends {
-    type: string;
-} ? Identity<TGuardArg> & {
-    params: unknown;
-} : TGuardArg extends string ? {
-    type: TGuardArg;
-    params: undefined;
-} : '_out_TGuard' extends keyof TGuardArg ? TGuardArg['_out_TGuard'] & ParameterizedObject : never;
-type NormalizeGuardArgArray<TArg extends unknown[]> = Elements<{
-    [K in keyof TArg]: NormalizeGuardArg<TArg[K]>;
-}>;
-export type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = {
-    (args: GuardArgs<TContext, TExpressionEvent>, params: TParams): boolean;
-    _out_TGuard?: TGuard;
-};
-export interface GuardArgs<TContext extends MachineContext, TExpressionEvent extends EventObject> {
-    context: TContext;
-    event: TExpressionEvent;
-}
-export type Guard<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = NoRequiredParams<TGuard> | WithDynamicParams<TContext, TExpressionEvent, TGuard> | GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
-export type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;
-type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject['params'], ParameterizedObject>;
-type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;
-export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
-/**
- * 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
- */
-export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<DoNotInfer<TArg>>>;
-/**
- * Higher-order guard that evaluates to `true` if all `guards` passed to it
- * evaluate to `true`.
- *
- * @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
- *       }
- *     }
- *   }
- * });
- * ```
- *
- * @returns A guard action object
- */
-export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
-    ...{
-        [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
-    }
-]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<DoNotInfer<TArg>>>;
-/**
- * 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
- *       }
- *     }
- *   }
- * });
- * ```
- *
- * @returns A guard action object
- */
-export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
-    ...{
-        [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
-    }
-]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<DoNotInfer<TArg>>>;
-export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, snapshot: AnyMachineSnapshot): boolean;
-export {};