xstate 5.0.0-beta.8 → 5.0.0

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

@@ -1,33 +1,26 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
-import { State } from './State.ts';
-import { NULL_EVENT } from './constants.ts';
-import type { StateNode } from './StateNode.ts';
-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>;
+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 StateNodeIterable<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+type AnyStateNodeIterable = StateNodeIterable<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;
-export declare function isInFinalState(configuration: Array<AnyStateNode>, stateNode?: AnyStateNode): boolean;
+export declare const isAtomicStateNode: (stateNode: StateNode<any, any>) => 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'], 
-/**
- * If `true`, will use SCXML event partial token matching semantics
- * without the need for the ".*" suffix
- */
-partialMatch?: boolean): Array<TransitionDefinition<any, TEvent>>;
+export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type']): Array<TransitionDefinition<any, TEvent>>;
 /**
  * All delayed transitions from the config.
  */
-export declare function getDelayedTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<TContext, TEvent>>;
-export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, transitionConfig: TransitionConfig<TContext, TEvent> & {
-    event: TEvent['type'] | typeof NULL_EVENT | '*';
-}): AnyTransitionDefinition;
-export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Array<AnyTransitionDefinition>;
-export declare function formatInitialTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, _target: SingleOrArray<string> | InitialTransitionConfig<TContext, TEvent>): InitialTransitionDefinition<TContext, TEvent>;
-export declare function resolveTarget(stateNode: AnyStateNode, targets: Array<string | AnyStateNode> | undefined): Array<AnyStateNode> | undefined;
-export declare function getInitialStateNodes(stateNode: AnyStateNode): Array<AnyStateNode>;
+export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<MachineContext, EventObject>>;
+export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: AnyTransitionConfig): AnyTransitionDefinition;
+export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Map<string, TransitionDefinition<TContext, TEvent>[]>;
+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>;
+export declare function resolveTarget(stateNode: AnyStateNode, targets: ReadonlyArray<string | AnyStateNode> | undefined): ReadonlyArray<AnyStateNode> | undefined;
+export declare function getInitialStateNodesWithTheirAncestors(stateNode: AnyStateNode): Set<AnyStateNode>;
+export declare function getInitialStateNodes(stateNode: AnyStateNode): Set<AnyStateNode>;
 /**
  * Returns the child state node from its relative `stateKey`, or throws.
  */
@@ -41,29 +34,22 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
 /**
  * Returns the state nodes represented by the current state value.
  *
- * @param state The state value or State instance
+ * @param stateValue The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, any>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, snapshot: 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, snapshot: 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, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, stateNodeSet: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * 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, 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: AnyActorContext | undefined): {
-    state: typeof state;
-    microstates: Array<typeof state>;
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentSnapshot: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
+export declare function resolveActionsAndContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyMachineSnapshot;
+export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
+    snapshot: typeof snapshot;
+    microstates: Array<typeof snapshot>;
 };
 /**
  * Resolves a partial state value with its full representation in the state node's machine.
@@ -72,5 +58,4 @@ export declare function macrostep<TMachine extends AnyStateMachine>(state: State
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
 export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
-export declare function getInitialConfiguration(rootNode: AnyStateNode): AnyStateNode[];
 export {};

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

@@ -1,2 +1,26 @@
-import { ActorSystem, ActorSystemInfo } from './types.js';
-export declare function createSystem<T extends ActorSystemInfo>(): ActorSystem<T>;
+import { AnyEventObject, ActorSystem, ActorSystemInfo, AnyActorRef, Snapshot } from "./types.js";
+export declare function createSystem<T extends ActorSystemInfo>(rootActor: AnyActorRef): ActorSystem<T>;
+export interface BaseInspectionEventProperties {
+    rootId: string;
+    /**
+     * The relevant actorRef for the inspection event.
+     * - For snapshot events, this is the `actorRef` of the snapshot.
+     * - For event events, this is the target `actorRef` (recipient of event).
+     * - For actor events, this is the `actorRef` of the registered actor.
+     */
+    actorRef: AnyActorRef;
+}
+export interface InspectedSnapshotEvent extends BaseInspectionEventProperties {
+    type: '@xstate.snapshot';
+    event: AnyEventObject;
+    snapshot: Snapshot<unknown>;
+}
+export interface InspectedEventEvent extends BaseInspectionEventProperties {
+    type: '@xstate.event';
+    sourceRef: AnyActorRef | undefined;
+    event: AnyEventObject;
+}
+export interface InspectedActorEvent extends BaseInspectionEventProperties {
+    type: '@xstate.actor';
+}
+export type InspectionEvent = InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent;

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

@@ -1,4 +1,4 @@
-import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
+import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ParameterizedObject, ProvidedActor, OutputFrom, AnyActorLogic, IndexByProp } from "./types.js";
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -27,20 +27,21 @@ export interface TypegenMeta extends TypegenEnabled {
     /**
      * A map for the internal events of the machine.
      *
-     * key: 'done.invoke.myActor'
+     * ```js
+     * key: 'xstate.done.actor.myActor'
      * value: {
-     *   type: 'done.invoke.myActor';
+     *   type: 'xstate.done.actor.myActor';
      *   data: unknown;
      *   __tip: 'Declare the type in event types!';
      * }
+     * ```
      */
     internalEvents: {};
     /**
-     * Maps the name of the actor to the event type
-     * of the done.invoke action
+     * Maps the src of the invoked actor to the event type that includes its known id
      *
      * key: 'invokeSrc'
-     * value: 'done.invoke.invokeName'
+     * value: 'xstate.done.actor.invokeName'
      */
     invokeSrcNameMap: Record<string, string>;
     /**
@@ -78,14 +79,23 @@ export interface TypegenMeta extends TypegenEnabled {
 }
 export interface ResolvedTypegenMeta extends TypegenMeta {
     resolved: TypegenMeta & {
+        indexedActors: Record<string, ProvidedActor>;
         indexedActions: Record<string, ParameterizedObject>;
         indexedEvents: Record<string, EventObject>;
+        indexedGuards: Record<string, ParameterizedObject>;
+        indexedDelays: Record<string, ParameterizedObject>;
     };
 }
 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;
+export type MissingImplementationsError<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<[
+    'Some implementations missing',
+    Values<{
+        [K in keyof TMissingImplementations]: TMissingImplementations[K];
+    }>
+]>;
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;
@@ -98,12 +108,10 @@ export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
     '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
     resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
 }
-type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
-    type: TEventType;
-} & Prop<TActorMap, TActorName> : never;
-type GenerateActorEvents<TActorMap extends ActorMap, TInvokeSrcNameMap> = string extends keyof TActorMap ? never : Cast<{
-    [K in keyof TInvokeSrcNameMap]: GenerateActorEvent<K, TInvokeSrcNameMap[K], TActorMap>;
-}[keyof TInvokeSrcNameMap], EventObject>;
+type GenerateActorEvents<TActor extends ProvidedActor, TInvokeSrcNameMap> = string extends TActor['src'] ? never : TActor extends any ? {
+    type: TActor['id'] extends string ? `xstate.done.actor.${TActor['id']}` : TActor['src'] extends keyof TInvokeSrcNameMap ? `xstate.done.actor.${TInvokeSrcNameMap[TActor['src']] & string}` : `xstate.done.actor.${string}`;
+    output: OutputFrom<TActor['logic']>;
+} : never;
 type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
 type AllowAllEvents = {
     eventsCausingActions: Record<string, string>;
@@ -111,22 +119,32 @@ type AllowAllEvents = {
     eventsCausingDelays: Record<string, string>;
     eventsCausingGuards: Record<string, string>;
 };
-export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends ParameterizedObject, TActorMap extends ActorMap> {
+type IndexParameterizedImplementation<TParameterizedImplementation extends ParameterizedObject, TCausingLookup> = string extends TParameterizedImplementation['type'] ? IsNever<TCausingLookup> extends true ? never : Record<keyof TCausingLookup, ParameterizedObject> : IndexByType<TParameterizedImplementation>;
+type WrapIntoParameterizedObject<T extends string> = T extends any ? {
+    type: T;
+} : never;
+export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
     resolved: {
         enabled: TTypesMeta & {
-            indexedActions: IndexByType<TAction>;
-            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActorMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+            indexedActions: IndexParameterizedImplementation<TAction, Prop<TTypesMeta, 'eventsCausingActions'>>;
+            indexedActors: string extends TActor['src'] ? Record<keyof Prop<TTypesMeta, 'eventsCausingActors'>, {
+                logic: AnyActorLogic;
+            }> : IndexByProp<TActor, 'src'>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActor, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+            indexedGuards: IndexParameterizedImplementation<TGuard, Prop<TTypesMeta, 'eventsCausingGuards'>>;
+            indexedDelays: IndexParameterizedImplementation<WrapIntoParameterizedObject<TDelay>, Prop<TTypesMeta, 'eventsCausingDelays'>>;
+            tags: string extends TTag ? Prop<TTypesMeta, 'tags'> : TTag;
         };
         disabled: TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
             indexedActions: IndexByType<TAction>;
-            indexedEvents: Record<string, TEvent> & {
-                __XSTATE_ALLOW_ANY_INVOKE_OUTPUT_HACK__: {
-                    output: any;
-                };
-            };
-            invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_OUTPUT_HACK__'>;
+            indexedActors: IndexByProp<TActor, 'src'>;
+            indexedEvents: Record<string, TEvent>;
+            indexedGuards: IndexByType<TGuard>;
+            indexedDelays: IndexByType<WrapIntoParameterizedObject<TDelay>>;
+            invokeSrcNameMap: Record<string, string>;
+            tags: TTag;
         };
-    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
+    }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta['@@xstate/typegen'] extends true ? 'enabled' : 'disabled'];
 }
 export {};