xstate 6.0.0-alpha.47 → 6.0.0-alpha.49

package/dist/declarations/src/fsm/createFSMActor.d.ts

@@ -0,0 +1,67 @@
+import type { ActorOptions, AnyActorLogic, EventFromLogic, InputFrom, Observer, SnapshotFrom } from "../types.js";
+/** A compact actor runtime for logic returned by `createFSM(...)`. */
+export declare class FSMActor<TLogic extends AnyActorLogic> {
+    readonly logic: TLogic;
+    private readonly options;
+    private _snapshot;
+    private _effects;
+    private _queue;
+    private _processing;
+    private _observers;
+    private _listeners;
+    private _trigger;
+    private _restored;
+    _processingStatus: any;
+    readonly id: string;
+    readonly sessionId: string;
+    readonly address: string;
+    readonly ref: this;
+    readonly src: string | AnyActorLogic;
+    readonly system: any;
+    readonly _parent: any;
+    constructor(logic: TLogic, options?: ActorOptions<TLogic>);
+    private get self();
+    private get logger();
+    private defer;
+    private get emit();
+    private stopChild;
+    private actionExecutor;
+    start(): this;
+    send(event: EventFromLogic<TLogic>): void;
+    _send(event: EventFromLogic<TLogic>): void;
+    private flush;
+    private runEffects;
+    getSnapshot(): SnapshotFrom<TLogic>;
+    getPersistedSnapshot(options?: unknown): import("../types.js").Snapshot<unknown>;
+    toJSON(): {
+        xstate$type: string;
+        id: string;
+        address: string;
+        src: string | undefined;
+    };
+    _stop(): this;
+    stop(): this;
+    subscribe(observerOrNext?: Observer<SnapshotFrom<TLogic>> | ((snapshot: SnapshotFrom<TLogic>) => void), error?: (error: unknown) => void, complete?: () => void): {
+        unsubscribe(): void;
+    };
+    on(type: string, handler: (event: any) => void): {
+        unsubscribe: () => boolean;
+    };
+    _emit(event: any): void;
+    _terminate(termination: any): void;
+    private fail;
+    private notify;
+    _isRunning(): boolean;
+    _inspectTransition(): void;
+    get trigger(): any;
+    select<T>(selector: (snapshot: SnapshotFrom<TLogic>) => T, equal?: (a: T, b: T) => boolean): {
+        get: () => T;
+        subscribe: (observerOrNext: Observer<T> | ((value: T) => void)) => {
+            unsubscribe(): void;
+        };
+    };
+    [Symbol.observable](): this;
+}
+export declare function createFSMActor<TLogic extends AnyActorLogic>(logic: TLogic, options?: ActorOptions<TLogic> & {
+    [K in undefined extends InputFrom<TLogic> ? never : 'input']: unknown;
+}): FSMActor<TLogic>;

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

@@ -0,0 +1,2 @@
+export { createFSMActor, FSMActor } from "./createFSMActor.js";
+export { createFSM, type FSMActorLogic, type FSMConfig, type FSMSnapshot } from "../fsm.js";

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

@@ -1,5 +1,4 @@
-import { createTransitionEnqueue } from "./transitionActions.js";
-import type { ActorLogic, EventObject, MachineContext, LogicalTimer, NonReducibleUnknown, Snapshot } from "./types.js";
+import type { ActorLogic, EnqueueObject, EventObject, MachineContext, LogicalTimer, NonReducibleUnknown, Snapshot } from "./types.js";
 export type FSMSnapshot<TContext extends MachineContext, TState extends string, TInput = unknown> = Snapshot<undefined> & {
     value: TState;
     context: TContext;
@@ -31,7 +30,7 @@ type FSMArgs<TContext extends MachineContext, TEvent extends EventObject, TState
 };
 type FSMAction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput> & {
     input: Record<string, unknown> | undefined;
-}, enq: ReturnType<typeof createTransitionEnqueue>) => void | {
+}, enq: EnqueueObject<TEvent, EventObject>) => void | {
     context?: FSMContextPatch<TContext>;
 };
 type FSMGuard<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput>) => boolean;
@@ -52,14 +51,16 @@ type FSMTarget<TContext extends MachineContext> = {
 type FSMObjectTarget<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = Omit<FSMTarget<TContext>, 'context'> & {
     context?: FSMContextPatch<TContext> | FSMContextMapper<TContext, TEvent, TState, TInput>;
 };
-type FSMTransitionFunction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput>, enq: ReturnType<typeof createTransitionEnqueue>) => void | false | FSMTarget<TContext>;
+type FSMTransitionFunction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput>, enq: EnqueueObject<TEvent, EventObject>) => void | false | FSMTarget<TContext>;
 type FSMTransition<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = FSMObjectTarget<TContext, TEvent, TState, TInput> | (FSMObjectTarget<TContext, TEvent, TState, TInput> & {
     guard?: FSMGuard<TContext, TEvent, TState, TInput>;
     actions?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
 }) | FSMTransitionFunction<TContext, TEvent, TState, TInput>;
 type FSMStateConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = {
+    type?: 'final';
     entry?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
     exit?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
+    always?: FSMTransition<TContext, TEvent, TState, TInput> | Array<FSMTransition<TContext, TEvent, TState, TInput>>;
     on?: Record<string, FSMTransition<TContext, TEvent, TState, TInput> | Array<FSMTransition<TContext, TEvent, TState, TInput>>>;
 };
 export type FSMConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput = NonReducibleUnknown> = {

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

@@ -0,0 +1 @@
+export { createMachineFromSCXML, type SCXMLConversionOptions } from "./scxml.js";

package/dist/declarations/src/scxml/runtime.d.ts

@@ -0,0 +1,251 @@
+import { AnyActorLogic, AnyEventObject, AnyStateMachine, EventObject, MachineContext, MetaObject } from "../types.js";
+export interface RaiseJSON {
+    type: '@xstate.raise';
+    event: EventObject;
+    id?: string;
+    delay?: number;
+}
+export interface CancelJSON {
+    type: '@xstate.cancel';
+    id: string;
+}
+interface LogJSON {
+    type: '@xstate.log';
+    args: any[];
+}
+export interface ScxmlLogJSON {
+    type: 'scxml.log';
+    label?: string;
+    expr?: string;
+}
+interface EmitJSON {
+    type: '@xstate.emit';
+    event: AnyEventObject;
+}
+interface AssignJSON {
+    type: '@xstate.assign';
+    context: MachineContext;
+}
+interface ScxmlAssignJSON {
+    type: 'scxml.assign';
+    /** SCXML location attribute - the context property to assign to */
+    location: string;
+    /** SCXML expr attribute - expression to evaluate */
+    expr: string;
+}
+export interface ScxmlRaiseJSON {
+    type: 'scxml.raise';
+    /** Event type, or undefined if using eventexpr */
+    event?: string;
+    /** Expression to evaluate for event type */
+    eventexpr?: string;
+    /** Params with expressions to evaluate */
+    params?: Array<{
+        name: string;
+        expr?: string;
+        location?: string;
+    }>;
+    namelist?: string[];
+    id?: string;
+    idlocation?: string;
+    delay?: number;
+    /** Expression for delay */
+    delayexpr?: string;
+    /** Static target (e.g. '#_parent') */
+    target?: string;
+    /** Expression for target */
+    targetexpr?: string;
+    processorType?: string;
+    content?: ScxmlContentJSON;
+}
+export interface ScxmlXmlJSON {
+    name: string;
+    attributes?: Record<string, string>;
+    children?: ScxmlXmlJSON[];
+}
+export interface ScxmlContentJSON {
+    expr?: string;
+    text?: string;
+    xml?: ScxmlXmlJSON;
+}
+interface ScxmlScriptJSON {
+    type: 'scxml.script';
+    /** The script code to execute */
+    code: string;
+    global?: boolean;
+}
+export interface ScxmlForeachJSON {
+    type: 'scxml.foreach';
+    array: string;
+    item: string;
+    index?: string;
+    actions: ActionJSON[];
+}
+export interface ScxmlCancelJSON {
+    type: 'scxml.cancel';
+    sendidexpr: string;
+}
+export interface ScxmlDonedataJSON {
+    params?: Array<{
+        name: string;
+        expr: string;
+    }>;
+    contentExpr?: string;
+    contentText?: string;
+}
+export interface ScxmlDataJSON {
+    id: string;
+    expr?: string;
+    content?: string;
+    src?: string;
+    xml?: ScxmlXmlJSON;
+}
+/**
+ * Isolated executable-content block. Errors in nested actions stop this block
+ * but do not propagate to the surrounding action list. Used to model SCXML's
+ * separate <onentry>/<onexit> blocks: each is its own block per spec.
+ */
+interface ScxmlBlockJSON {
+    type: 'scxml.block';
+    actions: ActionJSON[];
+}
+interface ScxmlDatamodelJSON {
+    type: 'scxml.datamodel';
+    data: ScxmlDataJSON[];
+}
+interface ScxmlForwardJSON {
+    type: 'scxml.forward';
+    invokeId: string;
+}
+interface ScxmlFinalizeJSON {
+    type: 'scxml.finalize';
+    invokeId: string;
+    actions: ActionJSON[];
+}
+interface ScxmlIfJSON {
+    type: 'scxml.if';
+    branches: Array<{
+        cond?: string;
+        actions: ActionJSON[];
+    }>;
+}
+interface CustomActionJSON {
+    type: string;
+    params?: unknown;
+}
+export type ActionJSON = CustomActionJSON | RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON | ScxmlAssignJSON | ScxmlRaiseJSON | ScxmlScriptJSON | ScxmlIfJSON | ScxmlForeachJSON | ScxmlCancelJSON | ScxmlLogJSON | ScxmlBlockJSON | ScxmlDatamodelJSON | ScxmlForwardJSON | ScxmlFinalizeJSON | ExpressionJSON | CodeJSON;
+export interface GuardJSON {
+    type: string;
+    params?: unknown;
+}
+interface ExpressionJSON {
+    '@expr': string;
+    '@lang'?: string;
+}
+interface CodeJSON {
+    '@code': string;
+    '@lang'?: string;
+}
+type ResolvableJSON = ExpressionJSON | CodeJSON;
+type ConditionJSON = GuardJSON | ResolvableJSON;
+interface ChoiceBranchJSON {
+    when?: ConditionJSON;
+    target: string | string[];
+    context?: MachineContext;
+    input?: unknown;
+    description?: string;
+    reenter?: boolean;
+    meta?: MetaObject;
+}
+export interface InvokeJSON {
+    id?: string;
+    registryKey?: string;
+    src: string;
+    input?: unknown;
+    onDone?: TransitionConfigJSON | TransitionConfigJSON[];
+    onError?: TransitionConfigJSON | TransitionConfigJSON[];
+    onSnapshot?: TransitionConfigJSON | TransitionConfigJSON[];
+    timeout?: number | string | ResolvableJSON;
+    onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
+}
+export interface TransitionJSON {
+    target?: string | string[];
+    matches?: Record<string, unknown>;
+    context?: MachineContext;
+    actions?: ActionJSON[];
+    guard?: ConditionJSON;
+    description?: string;
+    reenter?: boolean;
+    meta?: MetaObject;
+    input?: unknown;
+}
+type TransitionConfigJSON = TransitionJSON | ResolvableJSON;
+export interface StateNodeJSON {
+    id?: string;
+    key?: string;
+    type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
+    initial?: string;
+    states?: Record<string, StateNodeJSON>;
+    on?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    onError?: TransitionConfigJSON | TransitionConfigJSON[];
+    after?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    always?: TransitionConfigJSON | TransitionConfigJSON[];
+    choice?: ChoiceBranchJSON[] | ResolvableJSON;
+    /**
+     * JSON route config. Unlike the authoring API (a function), the JSON layer
+     * allows an object form whose `guard` may be a named guard reference (string)
+     * resolved against the machine's `guards` sources.
+     */
+    route?: {
+        description?: string;
+        reenter?: boolean;
+        meta?: MetaObject;
+        guard?: string;
+        input?: Record<string, unknown>;
+    } | ResolvableJSON;
+    invoke?: InvokeJSON | InvokeJSON[];
+    entry?: ActionJSON | ActionJSON[];
+    exit?: ActionJSON | ActionJSON[];
+    meta?: MetaObject;
+    description?: string;
+    tags?: string[];
+    input?: unknown;
+    timeout?: number | string | ResolvableJSON;
+    onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
+    history?: 'shallow' | 'deep';
+    target?: string | [string, ...string[]];
+    output?: unknown;
+    context?: Record<string, unknown>;
+    _scxmlDonedata?: ScxmlDonedataJSON;
+}
+export interface ScxmlIR extends StateNodeJSON {
+    '@exprLang'?: string;
+    version?: string;
+    actions?: Record<string, ActionJSON | ActionJSON[]>;
+    guards?: Record<string, {
+        when: ConditionJSON;
+    }>;
+    actors?: Record<string, unknown>;
+    delays?: Record<string, number | string | {
+        duration: number | string | ResolvableJSON;
+    }>;
+    schemas?: Record<string, unknown>;
+}
+type EvaluatorSlot = 'context' | 'guard' | 'choice' | 'action' | 'actionParams' | 'transition' | 'input' | 'output' | 'delay' | 'transitionContext' | 'unknown';
+type EvaluatorKind = 'expr' | 'code';
+interface EvaluatorArgs {
+    source: string;
+    kind: EvaluatorKind;
+    slot: EvaluatorSlot;
+    scope: Record<string, unknown>;
+    path: string;
+}
+interface MachineSources {
+    actions?: Record<string, (...args: any[]) => unknown>;
+    guards?: Record<string, (...args: any[]) => boolean>;
+    actors?: Record<string, AnyActorLogic>;
+    delays?: Record<string, number | ((...args: any[]) => number)>;
+    evaluators?: Record<string, (args: EvaluatorArgs) => unknown>;
+}
+export declare function createMachineFromSCXMLConfig(json: ScxmlIR, sources?: MachineSources): AnyStateMachine;
+export {};

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

@@ -0,0 +1,19 @@
+import { ScxmlIR } from "./runtime.js";
+import { AnyStateMachine } from "../types.js";
+export declare function sanitizeStateId(id: string): string;
+export interface SCXMLConversionOptions {
+    resolveResource?: (src: string, kind: 'data' | 'script' | 'invoke') => string;
+}
+/**
+ * Converts an SCXML string to a JSON representation that can be used with
+ * the SCXML runtime compiler.
+ */
+export declare function compileSCXML(xml: string, options?: SCXMLConversionOptions): ScxmlIR;
+/**
+ * Creates an XState machine from an SCXML document.
+ *
+ * Expressions and external resources are evaluated using SCXML semantics.
+ * Only create machines from trusted SCXML because ECMAScript expressions and
+ * script elements execute JavaScript in the current environment.
+ */
+export declare function createMachineFromSCXML(xml: string, options?: SCXMLConversionOptions): AnyStateMachine;

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

@@ -495,6 +495,7 @@ export type InitialTransitionDefinition = {
         context: MachineContext;
         event: EventObject;
     }) => Record<string, unknown>);
+    to?: ((...args: any[]) => any) | undefined;
 };
 export type TransitionDefinitionMap<TContext extends MachineContext, TEvent extends EventObject> = {
     [K in EventDescriptor<TEvent>]: Array<TransitionDefinition<TContext, ExtractEvent<TEvent, K>>>;

package/dist/{effectDescriptor-8be60443.esm.js → effectDescriptor-30c9a744.esm.js}

@@ -1,4 +1,4 @@
-import { aa as createInertActorScope, ab as setInertActorScopeSnapshot, f as finalizeTransitionResult, ac as attachSnapshotActorRef, K as createInitEvent, az as hasAmbientInspector, a as beginSpawnAllocation, ad as macrostep, ao as createSpawnEffect, ap as initialMicrostep, j as isAtomicStateNode, aA as getProperAncestors, aB as isRemoteActorRef, aC as getActorIdPrefix } from './createActor-915ea40c.esm.js';
+import { a5 as createInertActorScope, a6 as setInertActorScopeSnapshot, E as finalizeTransitionResult, a8 as attachSnapshotActorRef, y as createInitEvent, aw as hasAmbientInspector, a7 as beginSpawnAllocation, a9 as macrostep, al as createSpawnEffect, am as initialMicrostep, i as isAtomicStateNode, ax as getProperAncestors, ay as isRemoteActorRef, az as getActorIdPrefix } from './createActor-268165d4.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-fbe67d5a.development.esm.js → effectDescriptor-39d22100.development.esm.js}

@@ -1,4 +1,4 @@
-import { aa as createInertActorScope, ab as setInertActorScopeSnapshot, f as finalizeTransitionResult, ac as attachSnapshotActorRef, K as createInitEvent, az as hasAmbientInspector, a as beginSpawnAllocation, ad as macrostep, ao as createSpawnEffect, ap as initialMicrostep, j as isAtomicStateNode, aA as getProperAncestors, aB as isRemoteActorRef, aC as getActorIdPrefix } from './createActor-ff132afa.development.esm.js';
+import { a5 as createInertActorScope, a6 as setInertActorScopeSnapshot, E as finalizeTransitionResult, a8 as attachSnapshotActorRef, y as createInitEvent, aw as hasAmbientInspector, a7 as beginSpawnAllocation, a9 as macrostep, al as createSpawnEffect, am as initialMicrostep, i as isAtomicStateNode, ax as getProperAncestors, ay as isRemoteActorRef, az as getActorIdPrefix } from './createActor-88709f74.development.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-3c699328.development.cjs.js → effectDescriptor-7ff6802f.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-6736cbbe.development.cjs.js');
+var createActor = require('./createActor-a1e0dffb.development.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-a7e2d4d1.cjs.js → effectDescriptor-be348e50.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-bfe8b6bd.cjs.js');
+var createActor = require('./createActor-b4dd05ae.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {