xstate 5.0.0-alpha.1 → 5.0.0-alpha.3

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

@@ -1,11 +1,11 @@
-import type { AnyActorRef, AnyStateMachine, Behavior, EventFromBehavior, InterpreterFrom, SnapshotFrom } from './types';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
-import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, StateValue, Subscription } from './types';
-import { symbolObservable } from './symbolObservable';
-export declare type SnapshotListener<TBehavior extends Behavior<any, any>> = (state: SnapshotFrom<TBehavior>) => void;
-export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
-export declare type Listener = () => void;
-export declare type ErrorListener = (error: any) => void;
+import type { AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, SnapshotFrom, ActorSystem, AnyActorBehavior, RaiseActionObject } from './types.js';
+import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.js';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.js';
+import { symbolObservable } from './symbolObservable.js';
+export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
+export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
+export type Listener = () => void;
+export type ErrorListener = (error: any) => void;
 export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
@@ -15,18 +15,17 @@ export declare enum ActorStatus {
     Running = 1,
     Stopped = 2
 }
-declare type InternalStateFrom<TBehavior extends Behavior<any, any, any>> = TBehavior extends Behavior<infer _, infer __, infer TInternalState> ? TInternalState : never;
-export declare class Interpreter<TBehavior extends Behavior<any, any>, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
+export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
     behavior: TBehavior;
     /**
      * The current state of the interpreted behavior.
      */
-    private _state?;
+    private _state;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
     clock: Clock;
-    options: Readonly<InterpreterOptions>;
+    options: Readonly<InterpreterOptions<TBehavior>>;
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -42,22 +41,24 @@ export declare class Interpreter<TBehavior extends Behavior<any, any>, TEvent ex
     _parent?: ActorRef<any>;
     ref: ActorRef<TEvent>;
     private _actorContext;
+    private _systemId;
     /**
      * The globally unique process ID for this invocation.
      */
     sessionId: string;
-    _forwardTo: Set<AnyActorRef>;
+    system: ActorSystem<any>;
+    private _doneEvent?;
+    src?: string;
     /**
      * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
      *
      * @param behavior The behavior to be interpreted
      * @param options Interpreter options
      */
-    constructor(behavior: TBehavior, options?: InterpreterOptions);
+    constructor(behavior: TBehavior, options?: InterpreterOptions<TBehavior>);
+    private _initState;
     private _deferred;
-    private _getInitialState;
     private update;
-    onTransition(listener: SnapshotListener<TBehavior>): this;
     subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
     subscribe(nextListener?: (state: SnapshotFrom<TBehavior>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
@@ -66,34 +67,30 @@ export declare class Interpreter<TBehavior extends Behavior<any, any>, TEvent ex
      */
     onDone(listener: EventListener<DoneEvent>): this;
     /**
-     * Starts the interpreter from the given state, or the initial state.
-     * @param initialState The state to start the statechart from
+     * Starts the interpreter from the initial state
      */
-    start(initialState?: InternalStateFrom<TBehavior> | StateValue): this;
+    start(): this;
     private _process;
+    private _stop;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      */
     stop(): this;
     private _complete;
-    private _stop;
+    private _stopProcedure;
     /**
      * Sends an event to the running interpreter to trigger a transition.
      *
-     * An array of events (batched) can be sent as well, which will send all
-     * batched events to the running interpreter. The listeners will be
-     * notified only **once** when all events are processed.
-     *
-     * @param event The event(s) to send
+     * @param event The event to send
      */
     send(event: TEvent | SCXML.Event<TEvent>): void;
-    private forward;
-    delaySend(sendAction: SendActionObject): void;
+    delaySend(sendAction: SendActionObject | RaiseActionObject<any, any, any>): void;
     cancel(sendId: string | number): void;
     private attachDevTools;
     toJSON(): {
         id: string;
     };
+    getPersistedState(): PersistedStateFrom<TBehavior> | undefined;
     [Symbol.observable](): InteropSubscribable<SnapshotFrom<TBehavior>>;
     getSnapshot(): SnapshotFrom<TBehavior>;
 }
@@ -103,6 +100,5 @@ export declare class Interpreter<TBehavior extends Behavior<any, any>, TEvent ex
  * @param machine The machine to interpret
  * @param options Interpreter options
  */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions): InterpreterFrom<TMachine>;
-export declare function interpret<TBehavior extends Behavior<any, any>>(behavior: TBehavior, options?: InterpreterOptions): Interpreter<TBehavior>;
-export {};
+export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
+export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;

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

@@ -1,2 +1,2 @@
-import { MachineContext, EventObject, SCXML, InvokeActionObject, AnyStateMachine, Spawner } from '.';
-export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(machine: AnyStateMachine, context: TContext, _event: SCXML.Event<TEvent>, mutCapturedActions: InvokeActionObject[]): Spawner;
+import { InvokeActionObject, AnyStateMachine, Spawner, ActorRef, MachineContext, EventObject, SCXML } from '.';
+export declare function createSpawner<TContext extends MachineContext, TEvent extends EventObject>(self: ActorRef<any, any> | undefined, machine: AnyStateMachine, context: TContext, _event: SCXML.Event<TEvent>, mutCapturedActions: InvokeActionObject[]): Spawner;

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

@@ -1,11 +1,11 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types';
-import { State } from './State';
-import { NULL_EVENT } from './constants';
-import type { StateNode } from './StateNode';
-import { ActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from '.';
-declare type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
-declare type AnyConfiguration = Configuration<any, any>;
-declare type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.js';
+import { State } from './State.js';
+import { NULL_EVENT } from './constants.js';
+import type { StateNode } from './StateNode.js';
+import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from '.';
+type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+type AnyConfiguration = Configuration<any, any>;
+type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
 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;
@@ -51,11 +51,11 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param currentState
  * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: ActorContext<any, any> | undefined, scxmlEvent: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], scxmlEvent: SCXML.Event<TEvent>, currentState: State<TContext, TEvent, any>, actorCtx: ActorContext<any, any> | undefined): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined, scxmlEvent: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], scxmlEvent: SCXML.Event<TEvent>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
     nextState: AnyState;
 };
-export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, scxmlEvent: SCXML.Event<TMachine['__TEvent']>, actorCtx: ActorContext<any, any> | undefined): {
+export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, scxmlEvent: SCXML.Event<TMachine['__TEvent']>, actorCtx: AnyActorContext | undefined): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

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

@@ -0,0 +1,2 @@
+import { ActorSystem, ActorSystemInfo } from './types.js';
+export declare function createSystem<T extends ActorSystemInfo>(): ActorSystem<T>;

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

@@ -1,4 +1,4 @@
-import { BaseActionObject, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast } from './types';
+import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.js';
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -78,12 +78,12 @@ export interface TypegenMeta extends TypegenEnabled {
 }
 export interface ResolvedTypegenMeta extends TypegenMeta {
     resolved: TypegenMeta & {
-        indexedActions: Record<string, BaseActionObject>;
+        indexedActions: Record<string, ParameterizedObject>;
         indexedEvents: Record<string, EventObject>;
     };
 }
-export declare type TypegenConstraint = TypegenEnabled | TypegenDisabled;
-export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
+export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
+export type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
     [K in keyof TMissingImplementations]: TMissingImplementations[K];
 }>> extends true ? true : false : true;
 interface AllImplementationsProvided {
@@ -98,20 +98,20 @@ export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
     '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
     resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
 }
-declare type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
+type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
     type: TEventType;
 } & Prop<TActorMap, TActorName> : never;
-declare type GenerateActorEvents<TActorMap extends ActorMap, TInvokeSrcNameMap> = string extends keyof TActorMap ? never : Cast<{
+type GenerateActorEvents<TActorMap extends ActorMap, TInvokeSrcNameMap> = string extends keyof TActorMap ? never : Cast<{
     [K in keyof TInvokeSrcNameMap]: GenerateActorEvent<K, TInvokeSrcNameMap[K], TActorMap>;
 }[keyof TInvokeSrcNameMap], EventObject>;
-declare type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
-declare type AllowAllEvents = {
+type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
+type AllowAllEvents = {
     eventsCausingActions: Record<string, string>;
     eventsCausingActors: Record<string, string>;
     eventsCausingDelays: Record<string, string>;
     eventsCausingGuards: Record<string, string>;
 };
-export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TActorMap extends ActorMap> {
+export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends ParameterizedObject, TActorMap extends ActorMap> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
     resolved: {
         enabled: TTypesMeta & {