xstate 5.32.2 → 6.0.0-alpha.10

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

@@ -1,9 +1,8 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { ActionArgs, AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, ExecutableActionObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, TransitionDefinition, TODO, UnknownAction, ParameterizedObject, AnyTransitionConfig, AnyActorScope } from "./types.js";
-type StateNodeIterable<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
-type AnyStateNodeIterable = StateNodeIterable<any, any>;
-export declare function isAtomicStateNode(stateNode: StateNode<any, any>): boolean;
+import { AnyEventObject, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, ExecutableActionObject, MachineContext, StateValue, TransitionDefinition, AnyAction, AnyTransitionConfig, AnyActor, AnyActorScope } from "./types.js";
+type AnyStateNodeIterable = Iterable<AnyStateNode>;
+export declare function isAtomicStateNode(stateNode: AnyStateNode): boolean;
 export declare function getProperAncestors(stateNode: AnyStateNode, toStateNode: AnyStateNode | undefined): Array<typeof stateNode>;
 export declare function getAllStateNodes(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
 export declare function getStateValue(rootNode: AnyStateNode, stateNodes: AnyStateNodeIterable): StateValue;
@@ -13,13 +12,11 @@ export declare function getCandidates<TEvent extends EventObject>(stateNode: Sta
 /** All delayed transitions from the config. */
 export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<MachineContext, EventObject>>;
 export declare function formatTransition(stateNode: AnyStateNode, descriptor: string, transitionConfig: AnyTransitionConfig): AnyTransitionDefinition;
-export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Map<string, TransitionDefinition<TContext, TEvent>[]>;
 /**
  * Collects route transitions from all descendants with explicit IDs. Called
  * once on the root node to avoid O(N²) repeated traversals.
  */
 export declare function formatRouteTransitions(rootStateNode: AnyStateNode): void;
-export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: string | undefined | InitialTransitionConfig<TContext, TEvent, TODO, TODO, TODO, TODO>): InitialTransitionDefinition<TContext, TEvent>;
 /**
  * Returns the relative state node from the given `statePath`, or throws.
  *
@@ -32,21 +29,25 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  * @param stateValue The state value or State instance
  */
 export declare function getStateNodes(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any, any>, event: TEvent, self: AnyActor): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 type Microstep = readonly [AnyMachineSnapshot, ExecutableActionObject[]];
 export declare function initialMicrostep(root: AnyStateNode, preInitialState: AnyMachineSnapshot, actorScope: AnyActorScope, initEvent: AnyEventObject, internalQueue: AnyEventObject[]): Microstep;
-export interface BuiltinAction {
-    (): void;
-    type: `xstate.${string}`;
-    resolve: (actorScope: AnyActorScope, snapshot: AnyMachineSnapshot, actionArgs: ActionArgs<any, any, any>, actionParams: ParameterizedObject['params'] | undefined, action: unknown, extra: unknown) => [
-        newState: AnyMachineSnapshot,
-        params: unknown,
-        actions?: UnknownAction[]
-    ];
-    retryResolve: (actorScope: AnyActorScope, snapshot: AnyMachineSnapshot, params: unknown) => void;
-    execute: (actorScope: AnyActorScope, params: unknown) => void;
-}
-export declare function resolveActionsAndContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds: string[] | undefined): AnyMachineSnapshot;
+/**
+ * Gets the transition result for a given transition without executing the
+ * transition.
+ */
+export declare function getTransitionResult(transition: Pick<AnyTransitionDefinition, 'target' | 'to' | 'source'> & {
+    reenter?: AnyTransitionDefinition['reenter'];
+    input?: AnyTransitionDefinition['input'];
+    context?: AnyTransitionDefinition['context'];
+}, snapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope): {
+    targets: Readonly<AnyStateNode[]> | undefined;
+    context: MachineContext | undefined;
+    actions: AnyAction[] | undefined;
+    reenter?: boolean;
+    internalEvents: EventObject[] | undefined;
+    input: Record<string, unknown> | undefined;
+};
 export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[]): {
     snapshot: typeof snapshot;
     microsteps: Microstep[];
@@ -58,4 +59,6 @@ export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObje
  * @param stateValue The partial state value to resolve.
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
+export declare function hasEffect(transition: AnyTransitionDefinition, context: MachineContext, event: EventObject, snapshot: AnyMachineSnapshot, self: AnyActor): boolean;
+export declare function evaluateCandidate(candidate: AnyTransitionDefinition, event: EventObject, snapshot: AnyMachineSnapshot, stateNode: AnyStateNode, self: AnyActor): boolean;
 export {};

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

@@ -1,21 +1,21 @@
 import { InspectionEvent } from "./inspection.js";
-import { ActorSystemInfo, AnyActorRef, Observer, EventObject, Subscription } from "./types.js";
+import { ActorSystemInfo, AnyActor, Observer, EventObject, Subscription, TimersRestoreStrategy } from "./types.js";
 interface ScheduledEvent {
     id: string;
     event: EventObject;
     startedAt: number;
     delay: number;
-    source: AnyActorRef;
-    target: AnyActorRef;
+    source: AnyActor;
+    target: AnyActor;
 }
 export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
 }
 interface Scheduler {
-    schedule(source: AnyActorRef, target: AnyActorRef, event: EventObject, delay: number, id: string | undefined): void;
-    cancel(source: AnyActorRef, id: string): void;
-    cancelAll(actorRef: AnyActorRef): void;
+    schedule(source: AnyActor, target: AnyActor, event: EventObject, delay: number, id: string | undefined): void;
+    cancel(source: AnyActor, id: string): void;
+    cancelAll(actor: AnyActor): void;
 }
 export interface ActorSystem<T extends ActorSystemInfo> {
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
@@ -30,9 +30,10 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     _logger: (...args: any[]) => void;
 }
 export type AnyActorSystem = ActorSystem<any>;
-export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyActorRef, options: {
+export declare function createRuntimeSystem<T extends ActorSystemInfo>(rootActor: AnyActor, options: {
     clock: Clock;
     logger: (...args: any[]) => void;
     snapshot?: unknown;
+    timers?: TimersRestoreStrategy;
 }): ActorSystem<T>;
 export {};

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

@@ -1,11 +1,14 @@
-import { AnyActorLogic, AnyStateMachine, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionsFrom, AnyTransitionDefinition, AnyMachineSnapshot } from "./types.js";
+import { AnyActorLogic, AnyStateMachine, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionObjectFromLogic, AnyTransitionDefinition, AnyMachineSnapshot } from "./types.js";
 /**
  * Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
  * `nextSnapshot` and `actions` to execute.
  *
  * This is a pure function that does not execute `actions`.
  */
-export declare function transition<T extends AnyActorLogic>(logic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): [nextSnapshot: SnapshotFrom<T>, actions: ExecutableActionsFrom<T>[]];
+export declare function transition<T extends AnyActorLogic>(logic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): [
+    nextSnapshot: SnapshotFrom<T>,
+    actions: ExecutableActionObjectFromLogic<T>[]
+];
 /**
  * Given actor `logic` and optional `input`, returns a tuple of the
  * `nextSnapshot` and `actions` to execute from the initial transition (no
@@ -13,14 +16,14 @@ export declare function transition<T extends AnyActorLogic>(logic: T, snapshot:
  *
  * This is a pure function that does not execute `actions`.
  */
-export declare function initialTransition<T extends AnyActorLogic>(logic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): [SnapshotFrom<T>, ExecutableActionsFrom<T>[]];
+export declare function initialTransition<T extends AnyActorLogic>(logic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): [SnapshotFrom<T>, ExecutableActionObjectFromLogic<T>[]];
 /**
  * Given a state `machine`, a `snapshot`, and an `event`, returns an array of
  * microsteps, where each microstep is a tuple of `[snapshot, actions]`.
  *
  * This is a pure function that does not execute `actions`.
  */
-export declare function getMicrosteps<T extends AnyStateMachine>(machine: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): Array<[SnapshotFrom<T>, ExecutableActionsFrom<T>[]]>;
+export declare function getMicrosteps<T extends AnyStateMachine>(machine: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): Array<[SnapshotFrom<T>, ExecutableActionObjectFromLogic<T>[]]>;
 /**
  * Given a state `machine` and optional `input`, returns an array of microsteps
  * from the initial transition, where each microstep is a tuple of `[snapshot,
@@ -28,7 +31,7 @@ export declare function getMicrosteps<T extends AnyStateMachine>(machine: T, sna
  *
  * This is a pure function that does not execute `actions`.
  */
-export declare function getInitialMicrosteps<T extends AnyStateMachine>(machine: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): Array<[SnapshotFrom<T>, ExecutableActionsFrom<T>[]]>;
+export declare function getInitialMicrosteps<T extends AnyStateMachine>(machine: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): Array<[SnapshotFrom<T>, ExecutableActionObjectFromLogic<T>[]]>;
 /**
  * Gets all potential next transitions from the current state.
  *

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

@@ -0,0 +1,4 @@
+import type { AnyAction, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, SpecialExecutableAction } from "./types.js";
+export declare function createTransitionEnqueue(actorScope: AnyActorScope, actions: any[], internalEvents: EventObject[], actorSubscriptions?: boolean): EnqueueObject<any, any>;
+export declare function isBuiltInExecutableAction(action: ExecutableActionObject): action is SpecialExecutableAction;
+export declare function resolveActionsWithContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: AnyAction[]): [AnyMachineSnapshot, ExecutableActionObject[]];