xstate 4.31.0 → 5.0.0-alpha.0

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

@@ -0,0 +1,38 @@
+import type { InvokeCallback, Subscribable, InterpreterOptions, Lazy, Behavior, ActorContext, EventObject, ActorRef, AnyStateMachine, BaseActorRef, EventFrom, StateFrom } from './types';
+import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+/**
+ * Returns an actor behavior from a reducer and its initial state.
+ *
+ * @param transition The pure reducer that returns the next state given the current state and event.
+ * @param initialState The initial state of the reducer.
+ * @returns An actor behavior
+ */
+export declare function fromReducer<TState, TEvent extends EventObject>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState>) => TState, initialState: TState): Behavior<TEvent, TState>;
+export declare const startSignalType: unique symbol;
+export declare const stopSignalType: unique symbol;
+export declare const startSignal: StartSignal;
+export declare const stopSignal: StopSignal;
+export interface StartSignal {
+    type: typeof startSignalType;
+}
+export interface StopSignal {
+    type: typeof stopSignalType;
+}
+export declare type LifecycleSignal = StartSignal | StopSignal;
+export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): Behavior<TEvent, undefined>;
+export declare function fromPromise<T>(lazyPromise: Lazy<PromiseLike<T>>): Behavior<{
+    type: string;
+}, T | undefined>;
+export declare function fromObservable<T, TEvent extends EventObject>(lazyObservable: Lazy<Subscribable<T>>): Behavior<TEvent, T | undefined>;
+/**
+ * Creates an event observable behavior that listens to an observable
+ * that delivers event objects.
+ *
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns An event observable behavior
+ */
+export declare function fromEventObservable<T extends EventObject>(lazyObservable: Lazy<Subscribable<T>>): Behavior<EventObject, T | undefined>;
+export declare function fromMachine<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: Partial<InterpreterOptions>): Behavior<EventFrom<TMachine>, StateFrom<TMachine>>;
+export declare function isActorRef(item: any): item is ActorRef<any>;
+export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;

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

@@ -0,0 +1,5 @@
+export declare const STATE_DELIMITER = ".";
+export declare const TARGETLESS_KEY = "";
+export declare const NULL_EVENT = "";
+export declare const STATE_IDENTIFIER = "#";
+export declare const WILDCARD = "*";

package/{lib/devTools.d.ts → dist/declarations/src/dev/index.d.ts}

@@ -1,4 +1,4 @@
-import { AnyInterpreter } from './types';
+import { AnyInterpreter, DevToolsAdapter } from '../types';
 declare type ServiceListener = (service: AnyInterpreter) => void;
 export interface XStateDevInterface {
     register: (service: AnyInterpreter) => void;
@@ -10,5 +10,5 @@ export interface XStateDevInterface {
 }
 export declare function getGlobal(): typeof globalThis | undefined;
 export declare function registerService(service: AnyInterpreter): void;
+export declare const devToolsAdapter: DevToolsAdapter;
 export {};
-//# sourceMappingURL=devTools.d.ts.map

package/{es → dist/declarations/src}/environment.d.ts

@@ -1,2 +1 @@
 export declare const IS_PRODUCTION: boolean;
-//# sourceMappingURL=environment.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types';
+import type { State } from './State';
+import type { StateMachine } from './StateMachine';
+export declare function stateIn<TContext extends MachineContext, TEvent extends EventObject>(stateValue: StateValue): GuardDefinition<TContext, TEvent>;
+export declare function not<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardConfig<TContext, TEvent>): BooleanGuardDefinition<TContext, TEvent>;
+export declare function and<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
+export declare function or<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
+export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardDefinition<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>, machine: StateMachine<TContext, TEvent>): boolean;
+export declare function toGuardDefinition<TContext extends MachineContext, TEvent extends EventObject>(guardConfig: GuardConfig<TContext, TEvent>, getPredicate?: (guardType: string) => GuardPredicate<TContext, TEvent>): GuardDefinition<TContext, TEvent>;

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

@@ -0,0 +1,47 @@
+import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo, sendUpdate } from './actions';
+import { assign } from './actions/assign';
+import { cancel } from './actions/cancel';
+import { choose } from './actions/choose';
+import { log } from './actions/log';
+import { pure } from './actions/pure';
+import { raise } from './actions/raise';
+import { send } from './actions/send';
+import { stop } from './actions/stop';
+import { interpret, Interpreter, InterpreterStatus } from './interpreter';
+import { createMachine } from './Machine';
+import { mapState } from './mapState';
+import { matchState } from './match';
+import { State } from './State';
+import { StateNode } from './StateNode';
+export { createSchema, t } from './schema';
+export { SimulatedClock } from './SimulatedClock';
+export { StateMachine } from './StateMachine';
+export { getStateNodes } from './stateUtils';
+export { ObservableActorRef } from './ObservableActorRef';
+export * from './typegenTypes';
+export * from './types';
+export { matchesState, pathToStateValue, toEventObject, toObserver, toSCXMLEvent } from './utils';
+export { StateNode, State, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, doneInvoke, createMachine };
+declare const actions: {
+    raise: typeof raise;
+    send: typeof send;
+    sendParent: typeof sendParent;
+    sendTo: typeof sendTo;
+    sendUpdate: typeof sendUpdate;
+    log: typeof log;
+    cancel: typeof cancel;
+    stop: typeof stop;
+    assign: typeof assign;
+    after: typeof after;
+    done: typeof done;
+    respond: typeof respond;
+    forwardTo: typeof forwardTo;
+    escalate: typeof escalate;
+    choose: typeof choose;
+    pure: typeof pure;
+};
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}

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

@@ -0,0 +1,147 @@
+import { AnyStateMachine, InterpreterFrom } from '.';
+import { State } from './State';
+import type { StateMachine } from './StateMachine';
+import { TypegenDisabled, AreAllImplementationsAssumedToBeProvided } from './typegenTypes';
+import type { MachineContext, PayloadSender } from './types';
+import { ActorRef, DoneEvent, Event, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, StateValue, Subscription } from './types';
+import { symbolObservable } from './utils';
+export declare type StateListener<TContext extends MachineContext, TEvent extends EventObject, TResolvedTypesMeta = TypegenDisabled> = (state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent) => void;
+export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
+export declare type Listener = () => void;
+export declare type ErrorListener = (error: any) => void;
+export interface Clock {
+    setTimeout(fn: (...args: any[]) => void, timeout: number): any;
+    clearTimeout(id: any): void;
+}
+export declare enum InterpreterStatus {
+    NotStarted = 0,
+    Running = 1,
+    Stopped = 2
+}
+export declare class Interpreter<TContext extends MachineContext, TEvent extends EventObject = EventObject, TResolvedTypesMeta = TypegenDisabled> implements ActorRef<TEvent, State<TContext, TEvent, TResolvedTypesMeta>> {
+    machine: StateMachine<TContext, TEvent, any, any, TResolvedTypesMeta>;
+    /**
+     * The current state of the interpreted machine.
+     */
+    private _state?;
+    private _initialState?;
+    /**
+     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     */
+    clock: Clock;
+    options: Readonly<InterpreterOptions>;
+    id: string;
+    private mailbox;
+    private delayedEventsMap;
+    private listeners;
+    private stopListeners;
+    private errorListeners;
+    private doneListeners;
+    private logger;
+    /**
+     * Whether the service is started.
+     */
+    status: InterpreterStatus;
+    _parent?: ActorRef<any>;
+    name: string;
+    ref: ActorRef<TEvent>;
+    /**
+     * The globally unique process ID for this invocation.
+     */
+    sessionId: string;
+    private forwardTo;
+    /**
+     * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
+     *
+     * @param machine The machine to be interpreted
+     * @param options Interpreter options
+     */
+    constructor(machine: StateMachine<TContext, TEvent, any, any, TResolvedTypesMeta>, options?: InterpreterOptions);
+    get initialized(): boolean;
+    get initialState(): State<TContext, TEvent, TResolvedTypesMeta>;
+    get state(): State<TContext, TEvent, TResolvedTypesMeta>;
+    /**
+     * Executes the actions of the given state, with that state's `context` and `event`.
+     *
+     * @param state The state whose actions will be executed
+     */
+    execute(state: State<TContext, TEvent, TResolvedTypesMeta>): void;
+    private update;
+    onTransition(listener: StateListener<TContext, TEvent, TResolvedTypesMeta>): this;
+    subscribe(observer: Observer<State<TContext, TEvent, TResolvedTypesMeta>>): Subscription;
+    subscribe(nextListener?: (state: State<TContext, TEvent, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    /**
+  
+     * Adds a listener that is notified when the machine is stopped.
+     *
+     * @param listener The listener
+     */
+    onStop(listener: Listener): this;
+    /**
+     * Adds an error listener that is notified with an `Error` whenever an
+     * error occurs during execution.
+     *
+     * @param listener The error listener
+     */
+    onError(listener: ErrorListener): this;
+    /**
+     * Adds a state listener that is notified when the statechart has reached its final state.
+     * @param listener The state listener
+     */
+    onDone(listener: EventListener<DoneEvent>): this;
+    /**
+     * Removes a listener.
+     * @param listener The listener to remove
+     */
+    off(listener: (...args: any[]) => void): this;
+    /**
+     * Starts the interpreter from the given state, or the initial state.
+     * @param initialState The state to start the statechart from
+     */
+    start(initialState?: State<TContext, TEvent, TResolvedTypesMeta> | StateValue): this;
+    private _process;
+    /**
+     * Stops the interpreter and unsubscribe all listeners.
+     *
+     * This will also notify the `onStop` listeners.
+     */
+    stop(): this;
+    /**
+     * 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
+     */
+    send: PayloadSender<TEvent>;
+    private sendTo;
+    /**
+     * Returns the next state given the interpreter's current state and the event.
+     *
+     * This is a pure method that does _not_ update the interpreter's state.
+     *
+     * @param event The event to determine the next state
+     */
+    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
+    private forward;
+    private defer;
+    private cancel;
+    private getActionFunction;
+    private exec;
+    private stopChild;
+    private attachDevTools;
+    toJSON(): {
+        id: string;
+    };
+    [Symbol.observable](): InteropSubscribable<State<TContext, TEvent, TResolvedTypesMeta>>;
+    getSnapshot(): State<TContext, TEvent, TResolvedTypesMeta>;
+}
+/**
+ * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ *
+ * @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>;

package/{es → dist/declarations/src}/mapState.d.ts

@@ -1,4 +1,3 @@
 export declare function mapState(stateMap: {
     [stateId: string]: any;
 }, stateId: string): any;
-//# sourceMappingURL=mapState.d.ts.map

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

@@ -0,0 +1,5 @@
+import { State } from './State';
+import { StateValue, EventObject, MachineContext } from './types';
+export declare type ValueFromStateGetter<T, TContext extends MachineContext, TEvent extends EventObject> = (state: State<TContext, TEvent>) => T;
+export declare type StatePatternTuple<T, TContext extends MachineContext, TEvent extends EventObject> = [StateValue, ValueFromStateGetter<T, TContext, TEvent>];
+export declare function matchState<T, TContext extends MachineContext, TEvent extends EventObject>(state: State<TContext, TEvent> | StateValue, patterns: Array<StatePatternTuple<T, TContext, TEvent>>, defaultValue: ValueFromStateGetter<T, TContext, TEvent>): T;

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

@@ -0,0 +1 @@
+export declare function memo<T>(object: any, key: string, fn: () => T): T;

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

@@ -0,0 +1,5 @@
+import type { MachineContext, Cast, EventObject, BaseActionObject, Prop, IsNever } from './types';
+import { UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators } from './model.types';
+export declare function createModel<TContext extends MachineContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject>(initialContext: TContext): Model<TContext, TEvent, TAction, void>;
+export declare function createModel<TContext extends MachineContext, TEvent extends EventObject>(initialContext: TContext): Model<TContext, TEvent, never>;
+export declare function createModel<TContext extends MachineContext, TModelCreators extends ModelCreators<TModelCreators>, TFinalModelCreators = FinalModelCreators<TModelCreators>, TComputedEvent = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'events'>>, TComputedAction = UnionFromCreatorsReturnTypes<Prop<TFinalModelCreators, 'actions'>>>(initialContext: TContext, creators: TModelCreators): Model<TContext, Cast<TComputedEvent, EventObject>, IsNever<TComputedAction> extends true ? BaseActionObject : Cast<TComputedAction, BaseActionObject>, TFinalModelCreators>;

package/{lib → dist/declarations/src}/model.types.d.ts

@@ -1,16 +1,17 @@
-import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, ExtractEvent, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions, ServiceMap } from './types';
+import type { StateMachine } from './StateMachine';
 import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
-export interface Model<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
+import { ActorMap, AnyFunction, Assigner, BaseActionObject, Compute, DynamicAssignAction, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, Prop, PropertyAssigner } from './types';
+declare type SimplisticExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
+    type: TEventType;
+} ? TEvent : never;
+export interface Model<TContext extends MachineContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
     initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, ExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, ExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, ExtractEvent<TEvent, TEventType>>;
+    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, SimplisticExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, SimplisticExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => DynamicAssignAction<TContext, SimplisticExtractEvent<TEvent, TEventType>>;
     events: Prop<TModelCreators, 'events'>;
     actions: Prop<TModelCreators, 'actions'>;
-    reset: () => AssignAction<TContext, any>;
+    reset: () => DynamicAssignAction<TContext, any>;
     createMachine: {
-        <TServiceMap extends ServiceMap = ServiceMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, any, TEvent, TAction, TServiceMap, TTypesMeta>, implementations?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>): StateMachine<TContext, any, TEvent, {
-            value: any;
-            context: TContext;
-        }, TAction, TServiceMap, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TServiceMap>>;
+        <TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TAction, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActorMap>>): StateMachine<TContext, TEvent, TAction, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, TAction, TActorMap>>;
     };
 }
 export declare type ModelContextFrom<TModel extends Model<any, any, any, any>> = TModel extends Model<infer TContext, any, any, any> ? TContext : never;
@@ -49,4 +50,4 @@ export interface FinalModelCreators<Self> {
 export declare type UnionFromCreatorsReturnTypes<TCreators> = {
     [K in keyof TCreators]: TCreators[K] extends AnyFunction ? ReturnType<TCreators[K]> : never;
 }[keyof TCreators];
-//# sourceMappingURL=model.types.d.ts.map
+export {};

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

@@ -0,0 +1,8 @@
+import { ActorRef } from './types';
+export interface Registry {
+    bookId(): string;
+    register(id: string, actor: ActorRef<any>): string;
+    get(id: string): ActorRef<any> | undefined;
+    free(id: string): void;
+}
+export declare const registry: Registry;

package/{es → dist/declarations/src}/schema.d.ts

@@ -1,3 +1,2 @@
 export declare function createSchema<T>(schema?: any): T;
 export declare const t: typeof createSchema;
-//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +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;

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

@@ -0,0 +1,85 @@
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, DelayedTransitionDefinition, SingleOrArray, SCXML, Transitions, StateValueMap, HistoryValue, InitialTransitionConfig, InitialTransitionDefinition, Event, MachineContext } from './types';
+import { State } from './State';
+import { NULL_EVENT } from './constants';
+import type { StateMachine } from './StateMachine';
+import type { StateNode } from './StateNode';
+import { AnyStateMachine } from '.';
+declare type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+declare type AdjList<TContext extends MachineContext, TE extends EventObject> = Map<StateNode<TContext, TE>, Array<StateNode<TContext, TE>>>;
+export declare const isAtomicStateNode: (stateNode: StateNode<any, any>) => boolean;
+export declare function getChildren<TContext extends MachineContext, TE extends EventObject>(stateNode: StateNode<TContext, TE>): Array<StateNode<TContext, TE>>;
+export declare function getProperAncestors<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, toStateNode: StateNode<TContext, TEvent> | null): Array<typeof stateNode>;
+export declare function getAllStateNodes<TContext extends MachineContext, TE extends EventObject>(stateNode: StateNode<TContext, TE>): Array<StateNode<TContext, TE>>;
+export declare function getConfiguration<TC extends MachineContext, TE extends EventObject>(stateNodes: Iterable<StateNode<TC, TE>>): Set<StateNode<TC, TE>>;
+export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(configuration: Configuration<TContext, TE>): AdjList<TContext, TE>;
+export declare function getStateValue<TContext extends MachineContext, TE extends EventObject>(rootNode: StateNode<TContext, TE>, configuration: Configuration<TContext, TE>): StateValue;
+export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
+export declare function nextEvents<TContext extends MachineContext, TE extends EventObject>(configuration: Array<StateNode<TContext, TE>>): Array<TE['type']>;
+export declare function isInFinalState<TContext extends MachineContext, TE extends EventObject>(configuration: Array<StateNode<TContext, TE>>, stateNode?: StateNode<TContext, TE>): boolean;
+export declare const isStateId: (str: string) => boolean;
+export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type'], 
+/**
+ * If `true`, will use SCXML event partial token matching semantics
+ * without the need for the ".*" suffix
+ */
+partialMatch?: boolean): Array<TransitionDefinition<any, TEvent>>;
+/**
+ * All delayed transitions from the config.
+ */
+export declare function getDelayedTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>): Array<DelayedTransitionDefinition<TContext, TEvent>>;
+export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, transitionConfig: TransitionConfig<TContext, TEvent> & {
+    event: TEvent['type'] | typeof NULL_EVENT | '*';
+}): TransitionDefinition<TContext, TEvent>;
+export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>): Array<TransitionDefinition<TContext, TEvent>>;
+export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, _target: SingleOrArray<string> | InitialTransitionConfig<TContext, TEvent>): InitialTransitionDefinition<TContext, TEvent>;
+export declare function resolveTarget<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, _target: Array<string | StateNode<TContext, TEvent>> | undefined): Array<StateNode<TContext, TEvent>> | undefined;
+export declare function getInitialStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>): Array<StateNode<TContext, TEvent>>;
+/**
+ * Returns the child state node from its relative `stateKey`, or throws.
+ */
+export declare function getStateNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateKey: string): StateNode<TContext, TEvent>;
+/**
+ * Returns the state nodes represented by the current state value.
+ *
+ * @param state The state value or State instance
+ */
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, state: StateValue | State<TContext, TEvent>): Array<StateNode<TContext, TEvent>>;
+export declare function transitionLeafNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: string, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
+export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: StateNode<TContext, TEvent>, stateValue: StateValue, state: State<TContext, TEvent, any>, _event: SCXML.Event<TEvent>): Transitions<TContext, TEvent> | undefined;
+export declare function removeConflictingTransitions<TContext extends MachineContext, TEvent extends EventObject>(enabledTransitions: Array<TransitionDefinition<TContext, TEvent>>, configuration: Set<StateNode<TContext, TEvent>>, state: State<TContext, TEvent>): Array<TransitionDefinition<TContext, TEvent>>;
+export declare function enterStates<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, mutConfiguration: Set<StateNode<TContext, TEvent>>, state: State<TContext, TEvent>): {
+    statesToInvoke: Set<StateNode<TContext, TEvent>>;
+    internalQueue: SCXML.Event<TEvent>[];
+    actions: BaseActionObject[];
+};
+/**
+ * https://www.w3.org/TR/scxml/#microstepProcedure
+ *
+ * @private
+ * @param transitions
+ * @param currentState
+ * @param mutConfiguration
+ */
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent>, context: TContext, mutConfiguration: Set<StateNode<TContext, TEvent>>, machine: StateMachine<TContext, TEvent>, _event: SCXML.Event<TEvent>): {
+    actions: BaseActionObject[];
+    configuration: typeof mutConfiguration;
+    historyValue: HistoryValue<TContext, TEvent>;
+    internalQueue: Array<SCXML.Event<TEvent>>;
+    context: TContext;
+};
+export declare function resolveMicroTransition<TContext extends MachineContext, TEvent extends EventObject>(machine: StateMachine<TContext, TEvent, any, any, any>, transitions: Transitions<TContext, TEvent>, currentState: State<TContext, TEvent, any>, _event?: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
+declare type StateFromMachine<TMachine extends AnyStateMachine> = TMachine['initialState'];
+export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, event: Event<TMachine['__TEvent']> | SCXML.Event<TMachine['__TEvent']> | null, machine: TMachine): typeof state;
+/**
+ * Resolves a partial state value with its full representation in the state node's machine.
+ *
+ * @param stateValue The partial state value to resolve.
+ */
+export declare function resolveStateValue<TContext extends MachineContext, TEvent extends EventObject>(rootNode: StateNode<TContext, TEvent>, stateValue: StateValue): StateValue;
+export declare function toState<TMachine extends AnyStateMachine>(state: StateValue | TMachine['initialState'], machine: TMachine): StateFromMachine<TMachine>;
+export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
+export declare function getMeta(configuration?: Array<StateNode<any, any>>): Record<string, any>;
+export declare function getTagsFromConfiguration(configuration: Array<StateNode<any, any>>): Set<string>;
+export {};

package/{lib → dist/declarations/src}/typegenTypes.d.ts

@@ -1,4 +1,4 @@
-import { BaseActionObject, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ServiceMap, Cast } from './types';
+import { BaseActionObject, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast } from './types';
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -20,23 +20,23 @@ export interface TypegenMeta extends TypegenEnabled {
      */
     missingImplementations: {
         actions: string;
+        actors: string;
         delays: string;
         guards: string;
-        services: string;
     };
     /**
      * A map for the internal events of the machine.
      *
-     * key: 'done.invoke.myService'
+     * key: 'done.invoke.myActor'
      * value: {
-     *   type: 'done.invoke.myService';
+     *   type: 'done.invoke.myActor';
      *   data: unknown;
      *   __tip: 'Declare the type in event types!';
      * }
      */
     internalEvents: {};
     /**
-     * Maps the name of the service to the event type
+     * Maps the name of the actor to the event type
      * of the done.invoke action
      *
      * key: 'invokeSrc'
@@ -69,12 +69,12 @@ export interface TypegenMeta extends TypegenEnabled {
     eventsCausingGuards: Record<string, string>;
     /**
      * Keeps track of which events lead to which
-     * services.
+     * actors.
      *
      * Key: 'EVENT_NAME'
-     * Value: 'serviceName' | 'otherServiceName'
+     * Value: 'actorName' | 'otherActorName'
      */
-    eventsCausingServices: Record<string, string>;
+    eventsCausingActors: Record<string, string>;
 }
 export interface ResolvedTypegenMeta extends TypegenMeta {
     resolved: TypegenMeta & {
@@ -89,42 +89,44 @@ export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta,
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;
+        actors: never;
         delays: never;
         guards: never;
-        services: never;
     };
 }
 export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
     '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
     resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
 }
-declare type GenerateServiceEvent<TServiceName, TEventType, TServiceMap extends ServiceMap> = TEventType extends any ? {
+declare type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
     type: TEventType;
-} & Prop<TServiceMap, TServiceName> : never;
-declare type GenerateServiceEvents<TServiceMap extends ServiceMap, TInvokeSrcNameMap> = string extends keyof TServiceMap ? never : Cast<{
-    [K in keyof TInvokeSrcNameMap]: GenerateServiceEvent<K, TInvokeSrcNameMap[K], TServiceMap>;
+} & Prop<TActorMap, TActorName> : never;
+declare 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 = {
     eventsCausingActions: Record<string, string>;
+    eventsCausingActors: Record<string, string>;
     eventsCausingDelays: Record<string, string>;
     eventsCausingGuards: Record<string, string>;
-    eventsCausingServices: Record<string, string>;
 };
-export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TServiceMap extends ServiceMap> {
+export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject, TActorMap extends ActorMap> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
-    resolved: TTypesMeta extends TypegenEnabled ? TTypesMeta & {
-        indexedActions: IndexByType<TAction>;
-        indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateServiceEvents<TServiceMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
-    } : TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
-        indexedActions: IndexByType<TAction>;
-        indexedEvents: Record<string, TEvent> & {
-            __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
-                data: any;
+    resolved: {
+        enabled: TTypesMeta & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActorMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+        };
+        disabled: TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
+            indexedActions: IndexByType<TAction>;
+            indexedEvents: Record<string, TEvent> & {
+                __XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__: {
+                    data: any;
+                };
             };
+            invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
         };
-        invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_DATA_HACK__'>;
-    };
+    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
 }
 export {};
-//# sourceMappingURL=typegenTypes.d.ts.map