xstate 4.25.0 → 4.27.0-pr2674-2021926101023

package/lib/StateNode.js

@@ -54,8 +54,8 @@ function () {
   /**
    * The initial extended state
    */
-  _context // TODO: this is unsafe, but we're removing it in v5 anyway
-  ) {
+  _context, // TODO: this is unsafe, but we're removing it in v5 anyway
+  _stateInfo) {
     var _this = this;
 
     if (_context === void 0) {
@@ -85,8 +85,8 @@ function () {
     this.idMap = {};
     this.tags = [];
     this.options = Object.assign(createDefaultOptions(), options);
-    this.parent = this.options._parent;
-    this.key = this.config.key || this.options._key || this.config.id || '(machine)';
+    this.parent = _stateInfo === null || _stateInfo === void 0 ? void 0 : _stateInfo.parent;
+    this.key = this.config.key || (_stateInfo === null || _stateInfo === void 0 ? void 0 : _stateInfo.key) || this.config.id || '(machine)';
     this.machine = this.parent ? this.parent.machine : this;
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
     this.delimiter = this.config.delimiter || (this.parent ? this.parent.delimiter : constants.STATE_DELIMITER);
@@ -94,6 +94,7 @@ function () {
     this.version = this.parent ? this.parent.version : this.config.version;
     this.type = this.config.type || (this.config.parallel ? 'parallel' : this.config.states && utils.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.schema = this.parent ? this.machine.schema : (_a = this.config.schema) !== null && _a !== void 0 ? _a : {};
+    this.description = this.config.description;
 
     if (!environment.IS_PRODUCTION) {
       utils.warn(!('parallel' in this.config), "The \"parallel\" property is deprecated and will be removed in version 4.1. " + (this.config.parallel ? "Replace with `type: 'parallel'`" : "Use `type: '" + this.type + "'`") + " in the config for state node '" + this.id + "' instead.");
@@ -103,9 +104,9 @@ function () {
     this.states = this.config.states ? utils.mapValues(this.config.states, function (stateConfig, key) {
       var _a;
 
-      var stateNode = new StateNode(stateConfig, {
-        _parent: _this,
-        _key: key
+      var stateNode = new StateNode(stateConfig, {}, undefined, {
+        parent: _this,
+        key: key
       });
       Object.assign(_this.idMap, _tslib.__assign((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));
       return stateNode;
@@ -271,7 +272,9 @@ function () {
         meta: this.meta,
         order: this.order || -1,
         data: this.doneData,
-        invoke: this.invoke
+        invoke: this.invoke,
+        description: this.description,
+        tags: this.tags
       };
     },
     enumerable: false,
@@ -445,7 +448,8 @@ function () {
     return new State.State(_tslib.__assign(_tslib.__assign({}, state), {
       value: this.resolve(state.value),
       configuration: configuration,
-      done: stateUtils.isInFinalState(configuration, this)
+      done: stateUtils.isInFinalState(configuration, this),
+      tags: stateUtils.getTagsFromConfiguration(configuration)
     }));
   };
 
@@ -978,9 +982,7 @@ function () {
     maybeNextState.changed = changed; // Preserve original history after raised events
 
     maybeNextState.history = history;
-    maybeNextState.tags = new Set(utils.flatten(maybeNextState.configuration.map(function (sn) {
-      return sn.tags;
-    })));
+    maybeNextState.tags = stateUtils.getTagsFromConfiguration(maybeNextState.configuration);
     return maybeNextState;
   };
   /**

package/lib/actions.d.ts

@@ -1,15 +1,14 @@
-import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseConditon, ChooseAction, AnyEventObject, Expr } from './types';
+import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject } from './types';
 import * as actionTypes from './actionTypes';
 import { State } from './State';
 import { StateNode } from './StateNode';
-import { StopAction, StopActionObject } from '.';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
     type: ActionTypes;
 }>;
 export declare function getActionFunction<TContext, TEvent extends EventObject>(actionType: ActionType, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | undefined;
 export declare function toActionObject<TContext, TEvent extends EventObject>(action: Action<TContext, TEvent>, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): ActionObject<TContext, TEvent>;
-export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined, actionFunctionMap?: ActionFunctionMap<TContext, TEvent, ActionObject<TContext, TEvent>> | undefined) => ActionObject<TContext, TEvent>[];
+export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined, actionFunctionMap?: ActionFunctionMap<TContext, TEvent, import("./types").BaseActionObject> | undefined) => ActionObject<TContext, TEvent>[];
 export declare function toActivityDefinition<TContext, TEvent extends EventObject>(action: string | ActivityDefinition<TContext, TEvent>): ActivityDefinition<TContext, TEvent>;
 /**
  * Raises an event. This places the event in the internal event queue, so that
@@ -134,6 +133,6 @@ export declare function forwardTo<TContext, TEvent extends EventObject>(target:
  * @param options Options to pass into the send action creator.
  */
 export declare function escalate<TContext, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, AnyEventObject>;
-export declare function choose<TContext, TEvent extends EventObject>(conds: Array<ChooseConditon<TContext, TEvent>>): ChooseAction<TContext, TEvent>;
-export declare function resolveActions<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any>, currentState: State<TContext, TEvent> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actions: Array<ActionObject<TContext, TEvent>>, preserveActionOrder?: boolean): [Array<ActionObject<TContext, TEvent>>, TContext];
+export declare function choose<TContext, TEvent extends EventObject>(conds: Array<ChooseCondition<TContext, TEvent>>): ChooseAction<TContext, TEvent>;
+export declare function resolveActions<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, any>, currentState: State<TContext, TEvent> | undefined, currentContext: TContext, _event: SCXML.Event<TEvent>, actions: Array<ActionObject<TContext, TEvent>>, preserveActionOrder?: boolean): [Array<ActionObject<TContext, TEvent>>, TContext];
 //# sourceMappingURL=actions.d.ts.map

package/lib/behaviors.d.ts

@@ -1,4 +1,4 @@
-import { ActorContext, ActorRef, Behavior, EventObject } from '.';
+import { ActorContext, ActorRef, Behavior, EventObject } from './types';
 /**
  * Returns an actor behavior from a reducer and its initial state.
  *

package/lib/devTools.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { Interpreter } from '.';
 import { AnyInterpreter } from './types';
+import { Interpreter } from './interpreter';
 declare type ServiceListener = (service: AnyInterpreter) => void;
 export interface XStateDevInterface {
     register: (service: Interpreter<any>) => void;

package/lib/each.d.ts

@@ -1,4 +1,4 @@
-import { EventObject, SingleOrArray, ActionObject } from '.';
+import { EventObject, SingleOrArray, ActionObject } from './types';
 export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
 export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, index: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
 //# sourceMappingURL=each.d.ts.map

package/lib/index.d.ts

@@ -28,4 +28,5 @@ declare const actions: {
 };
 export { Actor, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema };
 export * from './types';
+export * from './typegenTypes';
 //# sourceMappingURL=index.d.ts.map

package/lib/interpreter.d.ts

@@ -1,9 +1,10 @@
 import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, Subscribable, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription } from './types';
 import { State } from './State';
+import { AreAllImplementationsAssumedToBeProvided, TypegenDisabled } from './typegenTypes';
 export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}> = (state: State<TContext, TEvent, TStateSchema, TTypestate>, event: TEvent) => void;
+}, TResolvedTypesMeta = TypegenDisabled> = (state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, event: TEvent) => void;
 export declare type ContextListener<TContext = DefaultContext> = (context: TContext, prevContext: TContext | undefined) => void;
 export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export declare type Listener = () => void;
@@ -29,15 +30,24 @@ declare global {
 export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate>> {
-    machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
+}, TResolvedTypesMeta = TypegenDisabled> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>> {
+    machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta>;
     /**
      * The default interpreter options:
      *
      * - `clock` uses the global `setTimeout` and `clearTimeout` functions
      * - `logger` uses the global `console.log()` method
      */
-    static defaultOptions: InterpreterOptions;
+    static defaultOptions: {
+        execute: boolean;
+        deferEvents: boolean;
+        clock: {
+            setTimeout: (fn: any, ms: any) => number;
+            clearTimeout: (id: any) => void;
+        };
+        logger: any;
+        devTools: boolean;
+    };
     /**
      * The current state of the interpreted machine.
      */
@@ -77,9 +87,9 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param machine The machine to be interpreted
      * @param options Interpreter options
      */
-    constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>);
-    get initialState(): State<TContext, TEvent, TStateSchema, TTypestate>;
-    get state(): State<TContext, TEvent, TStateSchema, TTypestate>;
+    constructor(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta>, options?: InterpreterOptions);
+    get initialState(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
+    get state(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
     static interpret: typeof interpret;
     /**
      * Executes the actions of the given state, with that state's `context` and `event`.
@@ -87,56 +97,56 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * @param state The state whose actions will be executed
      * @param actionsConfig The action implementations to use
      */
-    execute(state: State<TContext, TEvent, TStateSchema, TTypestate>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
+    execute(state: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>, actionsConfig?: MachineOptions<TContext, TEvent>['actions']): void;
     private update;
-    onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate>): this;
-    subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
-    subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate>>): Subscription;
+    onTransition(listener: StateListener<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>): this;
+    subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    subscribe(observer: Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>): Subscription;
     /**
      * Adds an event listener that is notified whenever an event is sent to the running interpreter.
      * @param listener The event listener
      */
-    onEvent(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    onEvent(listener: EventListener): this;
     /**
      * Adds an event listener that is notified whenever a `send` event occurs.
      * @param listener The event listener
      */
-    onSend(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    onSend(listener: EventListener): this;
     /**
      * Adds a context listener that is notified whenever the state context changes.
      * @param listener The context listener
      */
-    onChange(listener: ContextListener<TContext>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    onChange(listener: ContextListener<TContext>): this;
     /**
      * Adds a listener that is notified when the machine is stopped.
      * @param listener The listener
      */
-    onStop(listener: Listener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    onStop(listener: Listener): 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>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    onDone(listener: EventListener<DoneEvent>): this;
     /**
      * Removes a listener.
      * @param listener The listener to remove
      */
-    off(listener: (...args: any[]) => void): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    off(listener: (...args: any[]) => void): this;
     /**
      * Alias for Interpreter.prototype.start
      */
-    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate> | undefined) => Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    init: (initialState?: StateValue | State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | undefined) => 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, TStateSchema, TTypestate> | StateValue): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    start(initialState?: State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta> | StateValue): this;
     /**
      * Stops the interpreter and unsubscribe all listeners.
      *
      * This will also notify the `onStop` listeners.
      */
-    stop(): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    stop(): this;
     /**
      * Sends an event to the running interpreter to trigger a transition.
      *
@@ -146,7 +156,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event(s) to send
      */
-    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate>;
+    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
     private batch;
     /**
      * Returns a send function bound to this interpreter instance.
@@ -162,7 +172,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event to determine the next state
      */
-    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate>;
+    nextState(event: Event<TEvent> | SCXML.Event<TEvent>): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
     private forward;
     private defer;
     private cancel;
@@ -186,8 +196,8 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     toJSON(): {
         id: string;
     };
-    [Symbol.observable](): Subscribable<State<TContext, TEvent, TStateSchema, TTypestate>>;
-    getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate>;
+    [Symbol.observable](): Subscribable<State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>>;
+    getSnapshot(): State<TContext, TEvent, TStateSchema, TTypestate, TResolvedTypesMeta>;
 }
 export declare function spawn<T extends Behavior<any, any>>(entity: T, nameOrOptions?: string | SpawnOptions): ActorRefFrom<T>;
 export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE>, nameOrOptions?: string | SpawnOptions): ActorRefFrom<StateMachine<TC, any, TE>>;
@@ -201,6 +211,6 @@ export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnO
 export declare function interpret<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}>(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+}, TResolvedTypesMeta = TypegenDisabled>(machine: AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends true ? StateMachine<TContext, TStateSchema, TEvent, TTypestate, any, TResolvedTypesMeta> : 'Some implementations missing', options?: InterpreterOptions): Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
 export {};
 //# sourceMappingURL=interpreter.d.ts.map

package/lib/interpreter.js

@@ -843,7 +843,8 @@ function () {
 
             var source = utils.isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
               data: resolvedData,
-              src: invokeSource
+              src: invokeSource,
+              meta: activity.meta
             }) : serviceCreator;
 
             if (!source) {

package/lib/model.d.ts

@@ -1,5 +1,5 @@
-import type { EventObject, BaseActionObject } from './types';
-import { Cast, UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators, Prop, IsNever } from './model.types';
+import type { Cast, EventObject, BaseActionObject, Prop, IsNever } from './types';
+import { UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators } from './model.types';
 export declare function createModel<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject>(initialContext: TContext): Model<TContext, TEvent, TAction, void>;
 export declare function createModel<TContext, 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>;
 //# sourceMappingURL=model.d.ts.map

package/lib/model.types.d.ts

@@ -1,18 +1,17 @@
-import { EventObject, Assigner, ExtractEvent, PropertyAssigner, AssignAction, MachineConfig, MachineOptions, StateMachine, BaseActionObject } from './types';
-export declare type AnyFunction = (...args: any[]) => any;
-export declare type IsNever<T> = [T] extends [never] ? true : false;
-export declare type Cast<T extends any, TCastType extends any> = T extends TCastType ? T : TCastType;
-export declare type Compute<A extends any> = {
-    [K in keyof A]: A[K];
-} & unknown;
-export declare type Prop<T, K> = K extends keyof T ? T[K] : never;
+import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, ExtractEvent, MachineConfig, Prop, PropertyAssigner, StateMachine, InternalMachineOptions } from './types';
+import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
 export interface Model<TContext, 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>>;
     events: Prop<TModelCreators, 'events'>;
     actions: Prop<TModelCreators, 'actions'>;
     reset: () => AssignAction<TContext, any>;
-    createMachine: (config: MachineConfig<TContext, any, TEvent, TAction>, implementations?: Partial<MachineOptions<TContext, TEvent, TAction>>) => StateMachine<TContext, any, TEvent>;
+    createMachine: {
+        <TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, any, TEvent, TAction, TTypesMeta>, implementations?: InternalMachineOptions<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>): StateMachine<TContext, any, TEvent, {
+            value: any;
+            context: TContext;
+        }, TAction, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>;
+    };
 }
 export declare type ModelContextFrom<TModel extends Model<any, any, any, any>> = TModel extends Model<infer TContext, any, any, any> ? TContext : never;
 export declare type ModelEventsFrom<TModel extends Model<any, any, any, any> | undefined> = TModel extends Model<any, infer TEvent, any, any> ? TEvent : EventObject;

package/lib/scxml.d.ts

@@ -1,6 +1,6 @@
-import { StateNode } from './index';
+import { StateMachine } from './index';
 export interface ScxmlToMachineOptions {
     delimiter?: string;
 }
-export declare function toMachine(xml: string, options: ScxmlToMachineOptions): StateNode;
+export declare function toMachine(xml: string, options: ScxmlToMachineOptions): StateMachine<any, any, any>;
 //# sourceMappingURL=scxml.d.ts.map

package/lib/stateUtils.d.ts

@@ -1,15 +1,17 @@
-import { EventObject, StateNode, StateValue } from '.';
+import { EventObject, StateValue } from './types';
+import { StateNode } from './StateNode';
 declare type Configuration<TC, TE extends EventObject> = Iterable<StateNode<TC, any, TE>>;
 declare type AdjList<TC, TE extends EventObject> = Map<StateNode<TC, any, TE>, Array<StateNode<TC, any, TE>>>;
-export declare const isLeafNode: (stateNode: StateNode<any, any, any, any>) => boolean;
+export declare const isLeafNode: (stateNode: StateNode<any, any, any, any, any>) => boolean;
 export declare function getChildren<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE>): Array<StateNode<TC, any, TE>>;
-export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any>): Array<StateNode<TC, any, TE, any>>;
-export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any>>): Iterable<StateNode<TC, any, TE, any>>;
+export declare function getAllStateNodes<TC, TE extends EventObject>(stateNode: StateNode<TC, any, TE, any, any>): Array<StateNode<TC, any, TE, any, any>>;
+export declare function getConfiguration<TC, TE extends EventObject>(prevStateNodes: Iterable<StateNode<TC, any, TE, any, any>>, stateNodes: Iterable<StateNode<TC, any, TE, any, any>>): Iterable<StateNode<TC, any, TE, any, any>>;
 export declare function getAdjList<TC, TE extends EventObject>(configuration: Configuration<TC, TE>): AdjList<TC, TE>;
 export declare function getValue<TC, TE extends EventObject>(rootNode: StateNode<TC, any, TE, any>, configuration: Configuration<TC, TE>): StateValue;
 export declare function has<T>(iterable: Iterable<T>, item: T): boolean;
 export declare function nextEvents<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE>>): Array<TE['type']>;
-export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any>>, stateNode: StateNode<TC, any, TE, any>): boolean;
+export declare function isInFinalState<TC, TE extends EventObject>(configuration: Array<StateNode<TC, any, TE, any, any>>, stateNode: StateNode<TC, any, TE, any, any>): boolean;
 export declare function getMeta(configuration?: StateNode[]): Record<string, any>;
+export declare function getTagsFromConfiguration(configuration: StateNode<any, any, any, any>[]): Set<string>;
 export {};
 //# sourceMappingURL=stateUtils.d.ts.map

package/lib/stateUtils.js

@@ -256,12 +256,18 @@ function getMeta(configuration) {
     return acc;
   }, {});
 }
+function getTagsFromConfiguration(configuration) {
+  return new Set(utils.flatten(configuration.map(function (sn) {
+    return sn.tags;
+  })));
+}
 
 exports.getAdjList = getAdjList;
 exports.getAllStateNodes = getAllStateNodes;
 exports.getChildren = getChildren;
 exports.getConfiguration = getConfiguration;
 exports.getMeta = getMeta;
+exports.getTagsFromConfiguration = getTagsFromConfiguration;
 exports.getValue = getValue;
 exports.has = has;
 exports.isInFinalState = isInFinalState;

package/lib/typegenTypes.d.ts

@@ -0,0 +1,92 @@
+import { ActionObject, ActionFunction, Cast, ConditionPredicate, BaseActionObject, DelayConfig, EventObject, InvokeCreator, IndexByType, IsNever, MachineOptions, Prop, Values } from './types';
+export interface TypegenDisabled {
+    '@@xstate/typegen': false;
+}
+export interface TypegenEnabled {
+    '@@xstate/typegen': true;
+}
+export interface TypegenMeta extends TypegenEnabled {
+    matchesStates: string;
+    tags: string;
+    missingImplementations: {
+        actions: string;
+        delays: string;
+        guards: string;
+        services: string;
+    };
+    internalEvents: {};
+    invokeSrcNameMap: Record<string, string>;
+    eventsCausingActions: Record<string, string>;
+    eventsCausingDelays: Record<string, string>;
+    eventsCausingGuards: Record<string, string>;
+    eventsCausingServices: Record<string, string>;
+}
+export interface ResolvedTypegenMeta extends TypegenMeta {
+    indexedActions: Record<string, BaseActionObject>;
+    indexedEvents: Record<string, EventObject>;
+}
+export declare type TypegenConstraint = TypegenEnabled | TypegenDisabled;
+export declare type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<TResolvedTypesMeta, 'missingImplementations'>> = TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
+    [K in keyof TMissingImplementations]: TMissingImplementations[K];
+}>> extends true ? true : false : true;
+export declare type MarkAllImplementationsAsProvided<TResolvedTypesMeta> = TResolvedTypesMeta & {
+    missingImplementations: {
+        actions: never;
+        delays: never;
+        guards: never;
+        services: never;
+    };
+};
+declare type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
+declare type AllowAllEvents = {
+    eventsCausingActions: Record<string, string>;
+    eventsCausingDelays: Record<string, string>;
+    eventsCausingGuards: Record<string, string>;
+    eventsCausingServices: Record<string, string>;
+};
+export declare type ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends BaseActionObject> = TTypesMeta extends TypegenEnabled ? TTypesMeta & {
+    indexedActions: IndexByType<TAction>;
+    indexedEvents: MergeWithInternalEvents<IndexByType<TEvent>, Prop<TTypesMeta, 'internalEvents'>>;
+} : MarkAllImplementationsAsProvided<TypegenDisabled> & 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__'>;
+};
+export declare type TypegenMachineOptionsActions<TContext, TResolvedTypesMeta, TEventsCausingActions = Prop<TResolvedTypesMeta, 'eventsCausingActions'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>, TIndexedActions = Prop<TResolvedTypesMeta, 'indexedActions'>> = {
+    [K in keyof TEventsCausingActions]?: ActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedActions, K>, BaseActionObject>>;
+};
+export declare type TypegenMachineOptionsDelays<TContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<TResolvedTypesMeta, 'eventsCausingDelays'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>> = {
+    [K in keyof TEventsCausingDelays]?: DelayConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingDelays[K]>, EventObject>>;
+};
+export declare type TypegenMachineOptionsGuards<TContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<TResolvedTypesMeta, 'eventsCausingGuards'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>> = {
+    [K in keyof TEventsCausingGuards]?: ConditionPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
+};
+export declare type TypegenMachineOptionsServices<TContext, TResolvedTypesMeta, TEventsCausingServices = Prop<TResolvedTypesMeta, 'eventsCausingServices'>, TIndexedEvents = Prop<TResolvedTypesMeta, 'indexedEvents'>, TInvokeSrcNameMap = Prop<TResolvedTypesMeta, 'invokeSrcNameMap'>> = {
+    [K in keyof TEventsCausingServices]?: InvokeCreator<TContext, Cast<Prop<TIndexedEvents, TEventsCausingServices[K]>, EventObject>, Prop<Prop<TIndexedEvents, Prop<TInvokeSrcNameMap, K>>, 'data'>>;
+};
+declare type MakeKeysRequired<T extends string> = {
+    [K in T]: unknown;
+};
+declare type MaybeMakeMissingImplementationsRequired<TImplementationType, TMissingImplementationsForType, TRequireMissingImplementations> = TRequireMissingImplementations extends true ? IsNever<TMissingImplementationsForType> extends true ? {} : {
+    [K in Cast<TImplementationType, string>]: MakeKeysRequired<Cast<TMissingImplementationsForType, string>>;
+} : {};
+declare type GenerateActionsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'actions', Prop<TMissingImplementations, 'actions'>, TRequireMissingImplementations> & {
+    actions?: TypegenMachineOptionsActions<TContext, TResolvedTypesMeta>;
+};
+declare type GenerateDelaysConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'delays', Prop<TMissingImplementations, 'delays'>, TRequireMissingImplementations> & {
+    delays?: TypegenMachineOptionsDelays<TContext, TResolvedTypesMeta>;
+};
+declare type GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
+    guards?: TypegenMachineOptionsGuards<TContext, TResolvedTypesMeta>;
+};
+declare type GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = MaybeMakeMissingImplementationsRequired<'services', Prop<TMissingImplementations, 'services'>, TRequireMissingImplementations> & {
+    services?: TypegenMachineOptionsServices<TContext, TResolvedTypesMeta>;
+};
+export declare type TypegenMachineOptions<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations = Prop<TResolvedTypesMeta, 'missingImplementations'>> = GenerateActionsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateServicesConfigPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>;
+export declare type MaybeTypegenMachineOptions<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TResolvedTypesMeta = TypegenDisabled, TRequireMissingImplementations extends boolean = false> = TResolvedTypesMeta extends TypegenEnabled ? TypegenMachineOptions<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : MachineOptions<TContext, TEvent, TAction>;
+export {};
+//# sourceMappingURL=typegenTypes.d.ts.map

package/lib/typegenTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });