xstate 4.28.1 → 4.30.2

package/es/StateNode.js

@@ -50,8 +50,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) {
@@ -81,8 +81,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 : STATE_DELIMITER);
@@ -100,9 +100,9 @@ function () {
     this.states = this.config.states ? 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, __assign((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));
       return stateNode;
@@ -437,9 +437,10 @@ function () {
 
 
   StateNode.prototype.resolveState = function (state) {
-    var configuration = Array.from(getConfiguration([], this.getStateNodes(state.value)));
-    return new State(__assign(__assign({}, state), {
-      value: this.resolve(state.value),
+    var stateFromConfig = state instanceof State ? state : State.create(state);
+    var configuration = Array.from(getConfiguration([], this.getStateNodes(stateFromConfig.value)));
+    return new State(__assign(__assign({}, stateFromConfig), {
+      value: this.resolve(stateFromConfig.value),
       configuration: configuration,
       done: isInFinalState(configuration, this),
       tags: getTagsFromConfiguration(configuration)
@@ -1141,6 +1142,9 @@ function () {
   });
 
   StateNode.prototype.getInitialState = function (stateValue, context) {
+    this._init(); // TODO: this should be in the constructor (see note in constructor)
+
+
     var configuration = this.getStateNodes(stateValue);
     return this.resolveTransition({
       configuration: configuration,
@@ -1158,9 +1162,6 @@ function () {
      * entering the initial state.
      */
     get: function () {
-      this._init(); // TODO: this should be in the constructor (see note in constructor)
-
-
       var initialStateValue = this.initialStateValue;
 
       if (!initialStateValue) {

package/es/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, ChooseCondition, ChooseAction, AnyEventObject, Expr, Cast } 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, Cast, ActorRef, EventFrom } from './types';
 import * as actionTypes from './actionTypes';
 import { State } from './State';
 import { StateNode } from './StateNode';
-import { ActorRef, EventFrom, 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
@@ -151,5 +150,5 @@ export declare function forwardTo<TContext, TEvent extends EventObject>(target:
  */
 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<ChooseCondition<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 resolveActions<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent, any, 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/es/actions.js

@@ -1,8 +1,10 @@
 import { __assign, __read, __spreadArray } from './_virtual/_tslib.js';
 import { IS_PRODUCTION } from './environment.js';
-import { isFunction, toEventObject, getEventType, toSCXMLEvent, isString, partition, updateContext, flatten, toArray, toGuard, evaluateGuard, warn, isArray } from './utils.js';
+import { toSCXMLEvent, isString, isFunction, toEventObject, getEventType, partition, updateContext, flatten, toArray, toGuard, evaluateGuard, warn, isArray } from './utils.js';
 import { SpecialTargets, ActionTypes } from './types.js';
-import { send as send$1, update, assign as assign$1, init, raise as raise$1, log as log$1, cancel as cancel$1, error as error$1, stop as stop$1, pure as pure$1, choose as choose$1 } from './actionTypes.js';
+import { send as send$1, raise as raise$1, update, log as log$1, cancel as cancel$1, assign as assign$1, error as error$1, stop as stop$1, pure as pure$1, choose as choose$1, init } from './actionTypes.js';
+import * as actionTypes from './actionTypes.js';
+export { actionTypes };
 
 var initEvent = /*#__PURE__*/toSCXMLEvent({
   type: init
@@ -288,6 +290,9 @@ var assign = function (assignment) {
     assignment: assignment
   };
 };
+function isActionObject(action) {
+  return typeof action === 'object' && 'type' in action;
+}
 /**
  * Returns an event type that represents an implicit event that
  * is sent after the specified `delay`.
@@ -512,4 +517,4 @@ function resolveActions(machine, currentState, currentContext, _event, actions,
   return [resolvedActions, updatedContext];
 }
 
-export { after, assign, cancel, choose, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, log, pure, raise, resolveActions, resolveLog, resolveRaise, resolveSend, resolveStop, respond, send, sendParent, sendTo, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };
+export { after, assign, cancel, choose, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, isActionObject, log, pure, raise, resolveActions, resolveLog, resolveRaise, resolveSend, resolveStop, respond, send, sendParent, sendTo, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };

package/es/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/es/devTools.d.ts

@@ -1,13 +1,12 @@
-import { Interpreter } from '.';
 import { AnyInterpreter } from './types';
 declare type ServiceListener = (service: AnyInterpreter) => void;
 export interface XStateDevInterface {
-    register: (service: Interpreter<any>) => void;
-    unregister: (service: Interpreter<any>) => void;
+    register: (service: AnyInterpreter) => void;
+    unregister: (service: AnyInterpreter) => void;
     onRegister: (listener: ServiceListener) => {
         unsubscribe: () => void;
     };
-    services: Set<Interpreter<any>>;
+    services: Set<AnyInterpreter>;
 }
 export declare function getGlobal(): typeof globalThis | undefined;
 export declare function registerService(service: AnyInterpreter): void;

package/es/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/es/index.d.ts

@@ -3,32 +3,15 @@ import { mapState } from './mapState';
 import { StateNode } from './StateNode';
 import { State } from './State';
 import { Machine, createMachine } from './Machine';
-import { Actor } from './Actor';
-import { raise, send, sendParent, sendTo, sendUpdate, log, start, stop, assign, after, done, respond, doneInvoke, forwardTo, escalate, choose, pure } from './actions';
+import { Actor, toActorRef } from './Actor';
+import * as actions from './actions';
 import { interpret, Interpreter, spawn, InterpreterStatus } from './interpreter';
 import { matchState } from './match';
-import { createSchema } from './schema';
-declare const actions: {
-    raise: typeof raise;
-    send: typeof send;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    sendUpdate: typeof sendUpdate;
-    log: typeof log;
-    cancel: (sendId: string | number) => import("./types").CancelAction;
-    start: typeof start;
-    stop: typeof stop;
-    assign: <TContext, TEvent extends import("./types").EventObject = import("./types").EventObject>(assignment: import("./types").Assigner<TContext, TEvent> | import("./types").PropertyAssigner<TContext, TEvent>) => import("./types").AssignAction<TContext, TEvent>;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
-export { Actor, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema };
+import { createSchema, t } from './schema';
+declare const assign: <TContext, TEvent extends import("./types").EventObject = import("./types").EventObject>(assignment: import("./types").Assigner<TContext, TEvent> | import("./types").PropertyAssigner<TContext, TEvent>) => import("./types").AssignAction<TContext, TEvent>, send: typeof actions.send, sendParent: typeof actions.sendParent, sendUpdate: typeof actions.sendUpdate, forwardTo: typeof actions.forwardTo, doneInvoke: typeof actions.doneInvoke;
+export { Actor, toActorRef, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema, t };
 export * from './types';
+export * from './typegenTypes';
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/es/index.js

@@ -1,33 +1,22 @@
 export { matchesState } from './utils.js';
 export { mapState } from './mapState.js';
 export { ActionTypes, SpecialTargets } from './types.js';
-import { raise, send, sendParent, sendTo, sendUpdate, log, cancel, start, stop, assign, after, done, respond, forwardTo, escalate, choose, pure } from './actions.js';
-export { assign, doneInvoke, forwardTo, send, sendParent, sendUpdate } from './actions.js';
+import { assign as assign$1, send as send$1, sendParent as sendParent$1, sendUpdate as sendUpdate$1, forwardTo as forwardTo$1, doneInvoke as doneInvoke$1 } from './actions.js';
+import * as actions from './actions.js';
+export { actions };
 export { State } from './State.js';
+export { toActorRef } from './Actor.js';
 export { StateNode } from './StateNode.js';
 export { Machine, createMachine } from './Machine.js';
 export { Interpreter, InterpreterStatus, interpret, spawn } from './interpreter.js';
 export { matchState } from './match.js';
-export { createSchema } from './schema.js';
+export { createSchema, t } from './schema.js';
 
-var actions = {
-  raise: raise,
-  send: send,
-  sendParent: sendParent,
-  sendTo: sendTo,
-  sendUpdate: sendUpdate,
-  log: log,
-  cancel: cancel,
-  start: start,
-  stop: stop,
-  assign: assign,
-  after: after,
-  done: done,
-  respond: respond,
-  forwardTo: forwardTo,
-  escalate: escalate,
-  choose: choose,
-  pure: pure
-};
+var assign = assign$1,
+    send = send$1,
+    sendParent = sendParent$1,
+    sendUpdate = sendUpdate$1,
+    forwardTo = forwardTo$1,
+    doneInvoke = doneInvoke$1;
 
-export { actions };
+export { assign, doneInvoke, forwardTo, send, sendParent, sendUpdate };

package/es/interpreter.d.ts

@@ -1,9 +1,11 @@
-import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, Subscribable, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription } from './types';
+import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription, StateConfig, InteropSubscribable } from './types';
 import { State } from './State';
+import { symbolObservable } from './utils';
+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;
@@ -24,15 +26,21 @@ export declare enum InterpreterStatus {
 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, 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: Clock;
+        logger: any;
+        devTools: boolean;
+    };
     /**
      * The current state of the interpreted machine.
      */
@@ -72,9 +80,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, 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`.
@@ -82,56 +90,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(observer: Observer<State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>>): Subscription;
+    subscribe(nextListener?: (state: State<TContext, TEvent, any, TTypestate, TResolvedTypesMeta>) => void, errorListener?: (error: any) => void, completeListener?: () => void): 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> | StateConfig<TContext, TEvent> | 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> | StateConfig<TContext, TEvent> | 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.
      *
@@ -141,7 +149,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.
@@ -157,7 +165,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;
@@ -181,11 +189,11 @@ 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>;
+    [symbolObservable](): InteropSubscribable<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>>;
+export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE, any, any, any, any>, nameOrOptions?: string | SpawnOptions): ActorRefFrom<StateMachine<TC, any, TE, any, any, any, any>>;
 export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnOptions): ActorRef<any>;
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
@@ -196,6 +204,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, any, TResolvedTypesMeta> : 'Some implementations missing', options?: InterpreterOptions): Interpreter<TContext, TStateSchema, TEvent, TTypestate, TResolvedTypesMeta>;
 export {};
 //# sourceMappingURL=interpreter.d.ts.map

package/es/interpreter.js

@@ -1,11 +1,11 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
 import { IS_PRODUCTION } from './environment.js';
-import { warn, mapContext, isFunction, keys, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, interopSymbols, symbolObservable, isArray, toEventObject, isString, isActor, toObserver, uniqueId } from './utils.js';
+import { warn, mapContext, isFunction, keys, toSCXMLEvent, toInvokeSource, isMachine, isPromiseLike, isObservable, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } from './utils.js';
 import { ActionTypes, SpecialTargets } from './types.js';
 import { isInFinalState } from './stateUtils.js';
 import { errorPlatform, log, stop, start, cancel, send, update, error as error$1 } from './actionTypes.js';
 import { doneInvoke, initEvent, getActionFunction, error } from './actions.js';
-import { isState, State, bindActionToState } from './State.js';
+import { isStateConfig, State, bindActionToState } from './State.js';
 import { provide, consume } from './serviceScope.js';
 import { isSpawnedActor, createDeferredActor } from './Actor.js';
 import { Scheduler } from './scheduler.js';
@@ -459,7 +459,7 @@ function () {
     this.initialized = true;
     this.status = InterpreterStatus.Running;
     var resolvedState = initialState === undefined ? this.initialState : provide(this, function () {
-      return isState(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.from(initialState, _this.machine.context));
+      return isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.from(initialState, _this.machine.context));
     });
 
     if (this.options.devTools) {
@@ -997,6 +997,8 @@ function () {
   };
 
   Interpreter.prototype.spawnPromise = function (promise, id) {
+    var _a;
+
     var _this = this;
 
     var canceled = false;
@@ -1039,8 +1041,7 @@ function () {
         }
       }
     });
-
-    var actor = __assign({
+    var actor = (_a = {
       id: id,
       send: function () {
         return void 0;
@@ -1084,13 +1085,16 @@ function () {
       getSnapshot: function () {
         return resolvedData;
       }
-    }, interopSymbols);
-
+    }, _a[symbolObservable] = function () {
+      return this;
+    }, _a);
     this.children.set(id, actor);
     return actor;
   };
 
   Interpreter.prototype.spawnCallback = function (callback, id) {
+    var _a;
+
     var _this = this;
 
     var canceled = false;
@@ -1129,7 +1133,7 @@ function () {
       return this.spawnPromise(callbackStop, id);
     }
 
-    var actor = __assign({
+    var actor = (_a = {
       id: id,
       send: function (event) {
         return receivers.forEach(function (receiver) {
@@ -1137,10 +1141,11 @@ function () {
         });
       },
       subscribe: function (next) {
-        listeners.add(next);
+        var observer = toObserver(next);
+        listeners.add(observer.next);
         return {
           unsubscribe: function () {
-            listeners.delete(next);
+            listeners.delete(observer.next);
           }
         };
       },
@@ -1159,13 +1164,16 @@ function () {
       getSnapshot: function () {
         return emitted;
       }
-    }, interopSymbols);
-
+    }, _a[symbolObservable] = function () {
+      return this;
+    }, _a);
     this.children.set(id, actor);
     return actor;
   };
 
   Interpreter.prototype.spawnObservable = function (source, id) {
+    var _a;
+
     var _this = this;
 
     var emitted;
@@ -1188,8 +1196,7 @@ function () {
         origin: id
       }));
     });
-
-    var actor = __assign({
+    var actor = (_a = {
       id: id,
       send: function () {
         return void 0;
@@ -1208,8 +1215,9 @@ function () {
           id: id
         };
       }
-    }, interopSymbols);
-
+    }, _a[symbolObservable] = function () {
+      return this;
+    }, _a);
     this.children.set(id, actor);
     return actor;
   };
@@ -1237,7 +1245,9 @@ function () {
   };
 
   Interpreter.prototype.spawnEffect = function (id, dispose) {
-    this.children.set(id, __assign({
+    var _a;
+
+    this.children.set(id, (_a = {
       id: id,
       send: function () {
         return void 0;
@@ -1258,7 +1268,9 @@ function () {
           id: id
         };
       }
-    }, interopSymbols));
+    }, _a[symbolObservable] = function () {
+      return this;
+    }, _a));
   };
 
   Interpreter.prototype.attachDev = function () {
@@ -1299,9 +1311,7 @@ function () {
 
   Interpreter.prototype[symbolObservable] = function () {
     return this;
-  }; // this gets stripped by Babel to avoid having "undefined" property in environments without this non-standard Symbol
-  // it has to be here to be included in the generated .d.ts
-
+  };
 
   Interpreter.prototype.getSnapshot = function () {
     if (this.status === InterpreterStatus.NotStarted) {

package/es/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/es/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, ServiceMap } 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: {
+        <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>>;
+    };
 }
 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/es/schema.d.ts

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

package/es/schema.js

@@ -1,5 +1,6 @@
 function createSchema(schema) {
   return schema;
 }
+var t = createSchema;
 
-export { createSchema };
+export { createSchema, t };

package/es/scxml.d.ts

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