xstate 5.0.0-beta.43 → 5.0.0-beta.44

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

@@ -1,26 +1,21 @@
-import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg, Mapper } from "../types.js";
+import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg, Mapper, RequiredActorOptions, ConditionalRequired, IsNotNever } 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;
 }
-type DistributeActors<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = TActor extends any ? 'id' extends keyof TActor ? [
-    src: TActor['src'],
-    options: {
-        id: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
-        systemId?: string;
-        input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
-        syncSnapshot?: boolean;
-    }
-] : [
+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?: {
-        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
-        systemId?: string;
-        input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
-        syncSnapshot?: boolean;
+    options?: SpawnActionOptions<TContext, TExpressionEvent, TEvent, TActor> & {
+        [K in RequiredActorOptions<TActor>]: unknown;
     }
-] : never;
+], IsNotNever<RequiredActorOptions<TActor>>> : 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?: {

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

@@ -1,4 +1,4 @@
-import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyState, NoRequiredParams, NoInfer, WithDynamicParams } from "./types.js";
+import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyMachineSnapshot, NoRequiredParams, NoInfer, WithDynamicParams } from "./types.js";
 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;
@@ -15,5 +15,5 @@ export declare function stateIn<TContext extends MachineContext, TExpressionEven
 export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guard: Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
 export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
 export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
-export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, state: AnyState): boolean;
+export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, state: AnyMachineSnapshot): boolean;
 export {};

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

@@ -9,7 +9,7 @@ export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
 import { createMachine } from "./Machine.js";
-export { type MachineSnapshot } from "./State.js";
+export { type MachineSnapshot, isMachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 export { matchesState, pathToStateValue, toObserver } from "./utils.js";
 export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };

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

@@ -1,21 +1,16 @@
-import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyState, InputFrom, IsLiteralString, ProvidedActor } from "./types.js";
-export type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
+import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, InputFrom, IsLiteralString, ProvidedActor, RequiredActorOptions, IsNotNever, ConditionalRequired } from "./types.js";
+type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
-} ? 'id' extends keyof TActor ? [
-    options: {
-        id: TActor['id'];
-        systemId?: string;
-        input?: InputFrom<TActor['logic']>;
-        syncSnapshot?: boolean;
-    }
-] : [
+} ? ConditionalRequired<[
     options?: {
-        id?: string;
+        id?: TActor['id'];
         systemId?: string;
         input?: InputFrom<TActor['logic']>;
         syncSnapshot?: boolean;
+    } & {
+        [K in RequiredActorOptions<TActor>]: unknown;
     }
-] : never;
+], IsNotNever<RequiredActorOptions<TActor>>> : never;
 export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<(TActor & {
     src: TSrc;
 })['logic']> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
@@ -24,4 +19,5 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src'
     input?: unknown;
     syncSnapshot?: boolean;
 }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
-export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyState, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
+export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
+export {};

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

@@ -1,6 +1,6 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyEventObject, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig, AnyActorScope } from "./types.js";
+import { AnyEventObject, AnyHistoryValue, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig, AnyActorScope } from "./types.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
@@ -45,9 +45,9 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyState, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyState;
-export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyState;
-export declare function macrostep(state: AnyState, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
+export declare function resolveActionsAndContext(currentState: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyMachineSnapshot;
+export declare function macrostep(state: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

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

@@ -33,6 +33,7 @@ export type NonReducibleUnknown = {} | null | undefined;
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
+export type IsNotNever<T> = [T] extends [never] ? false : true;
 export type Compute<A extends any> = {
     [K in keyof A]: A[K];
 } & unknown;
@@ -97,7 +98,7 @@ export interface ChooseBranch<TContext extends MachineContext, TExpressionEvent
 export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? {
     type: T['type'];
 } extends T ? T['type'] : never : never;
-type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
+export type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
 export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent extends EventObject, T extends ParameterizedObject> = T extends any ? ConditionalRequired<{
     type: T['type'];
     params?: T['params'] | (({ context, event }: {
@@ -108,7 +109,7 @@ export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent
 export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>;
 export type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject['params'] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string>;
 export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>>;
-export type StateKey = string | AnyState;
+export type StateKey = string | AnyMachineSnapshot;
 export interface StateValueMap {
     [key: string]: StateValue;
 }
@@ -186,6 +187,11 @@ type DistributeActors<TContext extends MachineContext, TEvent extends EventObjec
      * The source of the machine to be invoked, or the machine itself.
      */
     src: TSrc;
+    /**
+     * The unique identifier for the invoked machine. If not specified, this
+     * will be the machine's own `id`, or the URL (from `src`).
+     */
+    id?: TSpecificActor['id'];
     input?: Mapper<TContext, TEvent, InputFrom<TSpecificActor['logic']>, TEvent> | InputFrom<TSpecificActor['logic']>;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
@@ -196,19 +202,9 @@ type DistributeActors<TContext extends MachineContext, TEvent extends EventObjec
      */
     onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
     onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay>>;
-} & (TSpecificActor['id'] extends string ? {
-    /**
-     * The unique identifier for the invoked machine. If not specified, this
-     * will be the machine's own `id`, or the URL (from `src`).
-     */
-    id: TSpecificActor['id'];
-} : {
-    /**
-     * The unique identifier for the invoked machine. If not specified, this
-     * will be the machine's own `id`, or the URL (from `src`).
-     */
-    id?: string;
-})> : never;
+} & {
+    [K in RequiredActorOptions<TSpecificActor>]: unknown;
+}> : never;
 export type InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TActor> : {
     /**
      * The unique identifier for the invoked machine. If not specified, this
@@ -347,7 +343,9 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyState = MachineSnapshot<any, any, any, any, any, any>;
+export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any>;
+/** @deprecated use `AnyMachineSnapshot` instead */
+export type AnyState = AnyMachineSnapshot;
 export type AnyStateMachine = StateMachine<any, any, any, any, any, any, any, any, any, // delays
 any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
@@ -850,4 +848,5 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     inspect: (observer: Observer<InspectionEvent>) => void;
 }
 export type AnyActorSystem = ActorSystem<any>;
+export type RequiredActorOptions<TActor extends ProvidedActor> = ('id' extends keyof TActor ? 'id' : never) | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
 export {};

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

@@ -1,11 +1,9 @@
-import { AnyState } from "./index.js";
 import type { StateNode } from "./StateNode.js";
 import type { ActorLogic, AnyEventObject, EventObject, MachineContext, Mapper, Observer, ErrorActorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfigTarget, AnyActorRef, AnyTransitionConfig, NonReducibleUnknown, AnyStateMachine } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
 export declare function toStatePath(stateId: string | string[]): string[];
-export declare function isStateLike(state: any): state is AnyState;
-export declare function toStateValue(stateValue: StateLike<any> | StateValue | string[]): StateValue;
+export declare function toStateValue(stateValue: StateLike<any> | StateValue): StateValue;
 export declare function pathToStateValue(statePath: string[]): StateValue;
 export declare function mapValues<P, O extends Record<string, unknown>>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
     [key in keyof O]: P;