xstate 5.0.0-beta.44 → 5.0.0-beta.45

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

@@ -1,4 +1,18 @@
-import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyMachineSnapshot, NoRequiredParams, NoInfer, WithDynamicParams } from "./types.js";
+import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyMachineSnapshot, NoRequiredParams, NoInfer, WithDynamicParams, Identity, Elements } 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;
@@ -12,8 +26,16 @@ 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>;
-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 not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<NoInfer<TArg>>>;
+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<NoInfer<TArg>>>;
+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<NoInfer<TArg>>>;
 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

@@ -8,13 +8,14 @@ export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
-import { createMachine } from "./Machine.js";
+import { createMachine } from "./createMachine.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 };
 export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./system.js";
 export { and, not, or, stateIn } from "./guards.js";
+export { setup } from "./setup.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -39,6 +39,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
     private observers;
     private logger;
     _parent?: ActorRef<any, any>;
+    _syncSnapshot?: boolean;
     ref: ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>>;
     private _actorScope;
     private _systemId;

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

@@ -0,0 +1,32 @@
+import { ResolveTypegenMeta, StateMachine, TypegenDisabled } from "./index.js";
+import { GuardPredicate } from "./guards.js";
+import { AnyActorLogic, MachineContext, AnyEventObject, NonReducibleUnknown, MachineConfig, Values, ParameterizedObject, ActionFunction, SetupTypes, DelayConfig } from "./types.js";
+type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
+    [K in keyof TParameterizedMap & string]: {
+        type: K;
+        params: TParameterizedMap[K];
+    };
+}>;
+type ToProvidedActor<TActors extends Record<string, AnyActorLogic>> = Values<{
+    [K in keyof TActors & string]: {
+        src: K;
+        logic: TActors[K];
+    };
+}>;
+export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
+TActors extends Record<string, AnyActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown>({ actors, actions, guards, delays }: {
+    types?: SetupTypes<TContext, TEvent, TTag, TInput, TOutput>;
+    actors?: TActors;
+    actions?: {
+        [K in keyof TActions]: ActionFunction<TContext, TEvent, TEvent, TActions[K], ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay>;
+    };
+    guards?: {
+        [K in keyof TGuards]: GuardPredicate<TContext, TEvent, TGuards[K], ToParameterizedObject<TGuards>>;
+    };
+    delays?: {
+        [K in TDelay]: DelayConfig<TContext, TEvent, ToParameterizedObject<TActions>['params'], TEvent>;
+    };
+}): {
+    createMachine: (config: MachineConfig<TContext, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>) => StateMachine<TContext, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>;
+};
+export {};

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

@@ -1,14 +1,14 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.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 StateNodeIterable<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+type AnyStateNodeIterable = StateNodeIterable<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
 export declare const isAtomicStateNode: (stateNode: StateNode<any, any>) => boolean;
-export declare function getConfiguration(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
-export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(configuration: Configuration<TContext, TE>): AdjList;
-export declare function getStateValue(rootNode: AnyStateNode, configuration: AnyConfiguration): StateValue;
-export declare function isInFinalState(configuration: Set<AnyStateNode>, stateNode: AnyStateNode): boolean;
+export declare function getAllStateNodes(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
+export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(stateNodes: StateNodeIterable<TContext, TE>): AdjList;
+export declare function getStateValue(rootNode: AnyStateNode, stateNodes: AnyStateNodeIterable): StateValue;
+export declare function isInFinalState(stateNodeSet: Set<AnyStateNode>, stateNode: AnyStateNode): boolean;
 export declare const isStateId: (str: string) => boolean;
 export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type']): Array<TransitionDefinition<any, TEvent>>;
 /**
@@ -41,7 +41,7 @@ export declare function transitionAtomicNode<TContext extends MachineContext, TE
 export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, 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, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
+export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, stateNodeSet: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
  */

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

@@ -8,6 +8,9 @@ import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
 import { Spawner } from "./spawn.js";
 import { AssignArgs } from "./actions/assign.js";
 import { InspectionEvent } from './system.js';
+export type Identity<T> = {
+    [K in keyof T]: T[K];
+};
 export type HomomorphicPick<T, K extends keyof any> = {
     [P in keyof T as P & K]: T[P];
 };
@@ -39,6 +42,7 @@ export type Compute<A extends any> = {
 } & unknown;
 export type Prop<T, K> = K extends keyof T ? T[K] : never;
 export type Values<T> = T[keyof T];
+export type Elements<T> = T[keyof T & `${number}`];
 export type Merge<M, N> = Omit<M, keyof N> & N;
 export type IndexByProp<T extends Record<P, string>, P extends keyof T> = {
     [E in T as E[P]]: E;
@@ -68,7 +72,7 @@ export interface AnyEventObject extends EventObject {
 }
 export interface ParameterizedObject {
     type: string;
-    params?: Record<string, unknown>;
+    params?: NonReducibleUnknown;
 }
 export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
     context: TContext;
@@ -95,9 +99,7 @@ export interface ChooseBranch<TContext extends MachineContext, TExpressionEvent
     guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
     actions: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>;
 }
-export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? {
-    type: T['type'];
-} extends T ? T['type'] : never : never;
+export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? undefined extends T['params'] ? T['type'] : never : never;
 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'];
@@ -412,8 +414,8 @@ type GenerateDelaysImplementationsPart<TContext extends MachineContext, TResolve
 type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
     guards?: MachineImplementationsGuards<TContext, TResolvedTypesMeta>;
 }>;
-export type InternalMachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TDelay extends string, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>;
-export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+export type InternalMachineImplementations<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>;
+export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
 type InitialContext<TContext extends MachineContext, TActor extends ProvidedActor, TInput> = TContext | ContextFactory<TContext, TActor, TInput>;
 export type ContextFactory<TContext extends MachineContext, TActor extends ProvidedActor, TInput> = ({ spawn, input }: {
     spawn: Spawner<TActor>;
@@ -439,16 +441,18 @@ export interface ProvidedActor {
     logic: AnyActorLogic;
     id?: string;
 }
-export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TTypesMeta = TypegenDisabled> {
+export interface SetupTypes<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TInput, TOutput> {
     context?: TContext;
     events?: TEvent;
+    tags?: TTag;
+    input?: TInput;
+    output?: TOutput;
+}
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TTypesMeta = TypegenDisabled> extends SetupTypes<TContext, TEvent, TTag, TInput, TOutput> {
     actors?: TActor;
     actions?: TAction;
     guards?: TGuard;
     delays?: TDelay;
-    tags?: TTag;
-    input?: TInput;
-    output?: TOutput;
     typegen?: TTypesMeta;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
@@ -539,7 +543,6 @@ export interface StateLike<TContext extends MachineContext> {
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
     context: TContext;
     historyValue?: HistoryValue<TContext, TEvent>;
-    configuration: Array<StateNode<TContext, TEvent>>;
     children: Record<string, ActorRef<any, any>>;
     status: 'active' | 'done' | 'error' | 'stopped';
     output?: any;
@@ -599,7 +602,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      *
      * @see https://stately.ai/docs/persistence
      */
-    state?: any;
+    state?: Snapshot<unknown>;
     /**
      * The source definition.
      */
@@ -734,7 +737,7 @@ export type DevToolsAdapter = (service: AnyActor) => void;
  * @deprecated Use `Actor<T>` instead.
  */
 export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, ActorSystem<any>>> : never;
-export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer TAction, infer _TGuard, infer TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
 any, // event
 any, // actor