xstate 4.26.0-pr2674-202191175724 → 4.27.0

package/lib/interpreter.d.ts

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

package/lib/interpreter.js

@@ -90,14 +90,15 @@ function () {
       if (_this.status === exports.InterpreterStatus.Stopped) {
         // do nothing
         if (!environment.IS_PRODUCTION) {
-          utils.warn(false, "Event \"" + _event.name + "\" was sent to stopped service \"" + _this.machine.id + "\". This service has already reached its final state, and will not transition.\nEvent: " + JSON.stringify(_event.data));
+          utils.warn(false, "Event \"".concat(_event.name, "\" was sent to stopped service \"").concat(_this.machine.id, "\". This service has already reached its final state, and will not transition.\nEvent: ").concat(JSON.stringify(_event.data)));
         }
 
         return _this.state;
       }
 
       if (_this.status !== exports.InterpreterStatus.Running && !_this.options.deferEvents) {
-        throw new Error("Event \"" + _event.name + "\" was sent to uninitialized service \"" + _this.machine.id + "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.\nEvent: " + JSON.stringify(_event.data));
+        throw new Error("Event \"".concat(_event.name, "\" was sent to uninitialized service \"").concat(_this.machine.id // tslint:disable-next-line:max-line-length
+        , "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.\nEvent: ").concat(JSON.stringify(_event.data)));
       }
 
       _this.scheduler.schedule(function () {
@@ -119,12 +120,12 @@ function () {
 
       if (!target) {
         if (!isParent) {
-          throw new Error("Unable to send event to child '" + to + "' from service '" + _this.id + "'.");
+          throw new Error("Unable to send event to child '".concat(to, "' from service '").concat(_this.id, "'."));
         } // tslint:disable-next-line:no-console
 
 
         if (!environment.IS_PRODUCTION) {
-          utils.warn(false, "Service '" + _this.id + "' has no parent: unable to send event " + event.type);
+          utils.warn(false, "Service '".concat(_this.id, "' has no parent: unable to send event ").concat(event.type));
         }
 
         return;
@@ -133,7 +134,7 @@ function () {
       if ('machine' in target) {
         // Send SCXML events to machines
         target.send(_tslib.__assign(_tslib.__assign({}, event), {
-          name: event.name === actionTypes.error ? "" + actions.error(_this.id) : event.name,
+          name: event.name === actionTypes.error ? "".concat(actions.error(_this.id)) : event.name,
           origin: _this.sessionId
         }));
       } else {
@@ -179,7 +180,7 @@ function () {
   Object.defineProperty(Interpreter.prototype, "state", {
     get: function () {
       if (!environment.IS_PRODUCTION) {
-        utils.warn(this.status !== exports.InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '" + this.id + "'. Make sure the service is started first.");
+        utils.warn(this.status !== exports.InterpreterStatus.NotStarted, "Attempted to read state from uninitialized service '".concat(this.id, "'. Make sure the service is started first."));
       }
 
       return this._state;
@@ -619,11 +620,11 @@ function () {
     if (this.status === exports.InterpreterStatus.NotStarted && this.options.deferEvents) {
       // tslint:disable-next-line:no-console
       if (!environment.IS_PRODUCTION) {
-        utils.warn(false, events.length + " event(s) were sent to uninitialized service \"" + this.machine.id + "\" and are deferred. Make sure .start() is called for this service.\nEvent: " + JSON.stringify(event));
+        utils.warn(false, "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\" and are deferred. Make sure .start() is called for this service.\nEvent: ").concat(JSON.stringify(event)));
       }
     } else if (this.status !== exports.InterpreterStatus.Running) {
       throw new Error( // tslint:disable-next-line:max-line-length
-      events.length + " event(s) were sent to uninitialized service \"" + this.machine.id + "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.");
+      "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options."));
     }
 
     this.scheduler.schedule(function () {
@@ -643,7 +644,7 @@ function () {
         });
         batchedActions.push.apply(batchedActions, _tslib.__spreadArray([], _tslib.__read(nextState.actions.map(function (a) {
           return State.bindActionToState(a, nextState);
-        }))));
+        })), false));
         batchChanged = batchChanged || !!nextState.changed;
       };
 
@@ -716,7 +717,7 @@ function () {
         var child = this.children.get(id);
 
         if (!child) {
-          throw new Error("Unable to forward event '" + event + "' from interpreter '" + this.id + "' to nonexistant child '" + id + "'.");
+          throw new Error("Unable to forward event '".concat(event, "' from interpreter '").concat(this.id, "' to nonexistant child '").concat(id, "'."));
         }
 
         child.send(event);
@@ -803,6 +804,10 @@ function () {
 
       case actionTypes.start:
         {
+          if (this.status !== exports.InterpreterStatus.Running) {
+            return;
+          }
+
           var activity = action.activity; // If the activity will be stopped right after it's started
           // (such as in transient states)
           // don't bother starting the activity.
@@ -820,7 +825,7 @@ function () {
 
             if (!environment.IS_PRODUCTION) {
               utils.warn(!('forward' in activity), // tslint:disable-next-line:max-line-length
-              "`forward` property is deprecated (found in invocation of '" + activity.src + "' in in machine '" + this.machine.id + "'). " + "Please use `autoForward` instead.");
+              "`forward` property is deprecated (found in invocation of '".concat(activity.src, "' in in machine '").concat(this.machine.id, "'). ") + "Please use `autoForward` instead.");
             }
 
             var autoForward = 'autoForward' in activity ? activity.autoForward : !!activity.forward;
@@ -828,7 +833,7 @@ function () {
             if (!serviceCreator) {
               // tslint:disable-next-line:no-console
               if (!environment.IS_PRODUCTION) {
-                utils.warn(false, "No service found for invocation '" + activity.src + "' in machine '" + this.machine.id + "'.");
+                utils.warn(false, "No service found for invocation '".concat(activity.src, "' in machine '").concat(this.machine.id, "'."));
               }
 
               return;
@@ -843,7 +848,8 @@ function () {
 
             var source = utils.isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
               data: resolvedData,
-              src: invokeSource
+              src: invokeSource,
+              meta: activity.meta
             }) : serviceCreator;
 
             if (!source) {
@@ -888,7 +894,7 @@ function () {
 
       default:
         if (!environment.IS_PRODUCTION) {
-          utils.warn(false, "No implementation found for action type '" + action.type + "'");
+          utils.warn(false, "No implementation found for action type '".concat(action.type, "'"));
         }
 
         break;
@@ -937,7 +943,7 @@ function () {
     } else if (utils.isBehavior(entity)) {
       return this.spawnBehavior(entity, name);
     } else {
-      throw new Error("Unable to spawn entity \"" + name + "\" of type \"" + typeof entity + "\".");
+      throw new Error("Unable to spawn entity \"".concat(name, "\" of type \"").concat(typeof entity, "\"."));
     }
   };
 
@@ -1213,7 +1219,7 @@ function () {
 
     if (!implementation) {
       if (!environment.IS_PRODUCTION) {
-        utils.warn(false, "No implementation found for activity '" + activity.type + "'");
+        utils.warn(false, "No implementation found for activity '".concat(activity.type, "'"));
       } // tslint:disable-next-line:no-console
 
 
@@ -1345,7 +1351,7 @@ function spawn(entity, nameOrOptions) {
   return serviceScope.consume(function (service) {
     if (!environment.IS_PRODUCTION) {
       var isLazyEntity = utils.isMachine(entity) || utils.isFunction(entity);
-      utils.warn(!!service || isLazyEntity, "Attempted to spawn an Actor (ID: \"" + (utils.isMachine(entity) ? entity.id : 'undefined') + "\") outside of a service. This will have no effect.");
+      utils.warn(!!service || isLazyEntity, "Attempted to spawn an Actor (ID: \"".concat(utils.isMachine(entity) ? entity.id : 'undefined', "\") outside of a service. This will have no effect."));
     }
 
     if (service) {

package/lib/json.js

@@ -10,7 +10,7 @@ function stringifyFunction(fn) {
 }
 exports.stringifyFunction = stringifyFunction;
 function getStateNodeId(stateNode) {
-    return "#" + stateNode.id;
+    return "#".concat(stateNode.id);
 }
 // derive config from machine
 function machineToJSON(stateNode) {
@@ -21,7 +21,7 @@ function machineToJSON(stateNode) {
         key: stateNode.key,
         entry: stateNode.onEntry,
         exit: stateNode.onExit,
-        on: utils_1.mapValues(stateNode.on, function (transition) {
+        on: (0, utils_1.mapValues)(stateNode.on, function (transition) {
             return transition.map(function (t) {
                 return {
                     target: t.target ? t.target.map(getStateNodeId) : [],
@@ -43,7 +43,7 @@ function machineToJSON(stateNode) {
 exports.machineToJSON = machineToJSON;
 function stringify(machine) {
     return JSON.stringify(machineToJSON(machine), function (_, value) {
-        if (utils_1.isFunction(value)) {
+        if ((0, utils_1.isFunction)(value)) {
             return { $function: value.toString() };
         }
         return value;
@@ -63,14 +63,14 @@ exports.parse = parse;
 function jsonify(value) {
     Object.defineProperty(value, 'toJSON', {
         value: function () {
-            return utils_1.mapValues(value, function (subValue) {
-                if (utils_1.isFunction(subValue)) {
+            return (0, utils_1.mapValues)(value, function (subValue) {
+                if ((0, utils_1.isFunction)(subValue)) {
                     return stringifyFunction(subValue);
                 }
                 else if (typeof subValue === 'object' && !Array.isArray(subValue)) {
                     // mostly for assignments
-                    return utils_1.mapValues(subValue, function (subSubValue) {
-                        if (utils_1.isFunction(subSubValue)) {
+                    return (0, utils_1.mapValues)(subValue, function (subSubValue) {
+                        if ((0, utils_1.isFunction)(subSubValue)) {
                             return stringifyFunction(subSubValue);
                         }
                         return subSubValue;

package/lib/model.d.ts

@@ -1,5 +1,5 @@
-import type { Cast, EventObject, BaseActionObject, Prop, IsNever } from './types';
-import { UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators } from './model.types';
+import type { EventObject, BaseActionObject } from './types';
+import { Cast, UnionFromCreatorsReturnTypes, FinalModelCreators, Model, ModelCreators, Prop, IsNever } 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.js

@@ -26,10 +26,14 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModel = void 0;
@@ -43,26 +47,26 @@ function createModel(initialContext, creators) {
         initialContext: initialContext,
         assign: actions_1.assign,
         events: (eventCreators
-            ? utils_1.mapValues(eventCreators, function (fn, eventType) { return function () {
+            ? (0, utils_1.mapValues)(eventCreators, function (fn, eventType) { return function () {
                 var args = [];
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args)))), { type: eventType }));
+                return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), { type: eventType }));
             }; })
             : undefined),
         actions: actionCreators
-            ? utils_1.mapValues(actionCreators, function (fn, actionType) { return function () {
+            ? (0, utils_1.mapValues)(actionCreators, function (fn, actionType) { return function () {
                 var args = [];
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args)))), { type: actionType }));
+                return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args), false))), { type: actionType }));
             }; })
             : undefined,
-        reset: function () { return actions_1.assign(initialContext); },
+        reset: function () { return (0, actions_1.assign)(initialContext); },
         createMachine: function (config, implementations) {
-            return Machine_1.createMachine('context' in config ? config : __assign(__assign({}, config), { context: initialContext }), implementations);
+            return (0, Machine_1.createMachine)('context' in config ? config : __assign(__assign({}, config), { context: initialContext }), implementations);
         }
     };
     return model;

package/lib/model.types.d.ts

@@ -1,17 +1,18 @@
-import { AnyFunction, AssignAction, Assigner, BaseActionObject, Compute, EventObject, ExtractEvent, MachineConfig, Prop, PropertyAssigner, StateMachine } from './types';
-import { MaybeTypegenMachineOptions, ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from './typegenTypes';
+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;
 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: {
-        <TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, any, TEvent, TAction, TTypesMeta>, implementations?: MaybeTypegenMachineOptions<TContext, TEvent, TAction, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>): StateMachine<TContext, any, TEvent, {
-            value: any;
-            context: TContext;
-        }, TAction, ResolveTypegenMeta<TTypesMeta, TEvent, TAction>>;
-    };
+    createMachine: (config: MachineConfig<TContext, any, TEvent, TAction>, implementations?: Partial<MachineOptions<TContext, TEvent, TAction>>) => StateMachine<TContext, any, TEvent>;
 }
 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/patterns.js

@@ -34,10 +34,10 @@ function sequence(items, options) {
     var states = {};
     var nextEventObject = resolvedOptions.nextEvent === undefined
         ? undefined
-        : utils_1.toEventObject(resolvedOptions.nextEvent);
+        : (0, utils_1.toEventObject)(resolvedOptions.nextEvent);
     var prevEventObject = resolvedOptions.prevEvent === undefined
         ? undefined
-        : utils_1.toEventObject(resolvedOptions.prevEvent);
+        : (0, utils_1.toEventObject)(resolvedOptions.prevEvent);
     items.forEach(function (item, i) {
         var state = {
             on: {}

package/lib/registry.js

@@ -6,7 +6,7 @@ var children = /*#__PURE__*/new Map();
 var sessionIdIndex = 0;
 var registry = {
   bookId: function () {
-    return "x:" + sessionIdIndex++;
+    return "x:".concat(sessionIdIndex++);
   },
   register: function (id, actor) {
     children.set(id, actor);

package/lib/scxml.d.ts

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