xstate 4.19.2 → 4.22.0

package/es/interpreter.d.ts

@@ -1,6 +1,5 @@
-import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate } from './types';
+import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, DoneEvent, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate, ActorRef, ActorRefFrom, Behavior, Subscription } from './types';
 import { State } from './State';
-import { ActorRefFrom, SpawnedActorRef, Subscription } from '.';
 export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
@@ -25,7 +24,7 @@ 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 SpawnedActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate>> {
+}> implements ActorRef<TEvent, State<TContext, TEvent, TStateSchema, TTypestate>> {
     machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * The default interpreter options:
@@ -64,7 +63,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * The globally unique process ID for this invocation.
      */
     sessionId: string;
-    children: Map<string | number, SpawnedActorRef<any>>;
+    children: Map<string | number, ActorRef<any>>;
     private forwardTo;
     private devTools?;
     /**
@@ -165,12 +164,13 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     private exec;
     private removeChild;
     private stopChild;
-    spawn(entity: Spawnable, name: string, options?: SpawnOptions): SpawnedActorRef<any>;
+    spawn(entity: Spawnable, name: string, options?: SpawnOptions): ActorRef<any>;
     spawnMachine<TChildContext, TChildStateSchema, TChildEvent extends EventObject>(machine: StateMachine<TChildContext, TChildStateSchema, TChildEvent>, options?: {
         id?: string;
         autoForward?: boolean;
         sync?: boolean;
-    }): SpawnedActorRef<TChildEvent, State<TChildContext, TChildEvent>>;
+    }): ActorRef<TChildEvent, State<TChildContext, TChildEvent>>;
+    private spawnBehavior;
     private spawnPromise;
     private spawnCallback;
     private spawnObservable;
@@ -183,8 +183,9 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     };
     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>>;
-export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnOptions): SpawnedActorRef<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.
  *

package/es/interpreter.js

@@ -1,6 +1,6 @@
 import { __values, __assign, __spreadArray, __read } from './_virtual/_tslib.js';
 import { IS_PRODUCTION } from './environment.js';
-import { warn, mapContext, isFunction, keys, toSCXMLEvent, toInvokeSource, isPromiseLike, isObservable, isMachine, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, uniqueId, toObserver } 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';
@@ -11,6 +11,7 @@ import { isSpawnedActor, createDeferredActor } from './Actor.js';
 import { Scheduler } from './scheduler.js';
 import { registry } from './registry.js';
 import { registerService, getGlobal } from './devTools.js';
+import { spawnBehavior } from './behaviors.js';
 var DEFAULT_SPAWN_OPTIONS = {
   sync: false,
   autoForward: false
@@ -830,24 +831,32 @@ function () {
             }
 
             var resolvedData = data ? mapContext(data, context, _event) : undefined;
+
+            if (typeof serviceCreator === 'string') {
+              // TODO: warn
+              return;
+            }
+
             var source = isFunction(serviceCreator) ? serviceCreator(context, _event.data, {
               data: resolvedData,
               src: invokeSource
             }) : serviceCreator;
 
-            if (isPromiseLike(source)) {
-              this.spawnPromise(Promise.resolve(source), id);
-            } else if (isFunction(source)) {
-              this.spawnCallback(source, id);
-            } else if (isObservable(source)) {
-              this.spawnObservable(source, id);
-            } else if (isMachine(source)) {
-              // TODO: try/catch here
-              this.spawnMachine(resolvedData ? source.withContext(resolvedData) : source, {
-                id: id,
+            if (!source) {
+              // TODO: warn?
+              return;
+            }
+
+            var options = void 0;
+
+            if (isMachine(source)) {
+              source = resolvedData ? source.withContext(resolvedData) : source;
+              options = {
                 autoForward: autoForward
-              });
-            } else ;
+              };
+            }
+
+            this.spawn(source, id, options);
           } else {
             this.spawnActivity(activity);
           }
@@ -917,6 +926,8 @@ function () {
       return this.spawnMachine(entity, __assign(__assign({}, options), {
         id: name
       }));
+    } else if (isBehavior(entity)) {
+      return this.spawnBehavior(entity, name);
     } else {
       throw new Error("Unable to spawn entity \"" + name + "\" of type \"" + typeof entity + "\".");
     }
@@ -962,11 +973,20 @@ function () {
     return actor;
   };
 
+  Interpreter.prototype.spawnBehavior = function (behavior, id) {
+    var actorRef = spawnBehavior(behavior, {
+      id: id,
+      parent: this
+    });
+    this.children.set(id, actorRef);
+    return actorRef;
+  };
+
   Interpreter.prototype.spawnPromise = function (promise, id) {
     var _this = this;
 
     var canceled = false;
-    var resolvedData = undefined;
+    var resolvedData;
     promise.then(function (response) {
       if (!canceled) {
         resolvedData = response;
@@ -1060,7 +1080,7 @@ function () {
     var canceled = false;
     var receivers = new Set();
     var listeners = new Set();
-    var emitted = undefined;
+    var emitted;
 
     var receive = function (e) {
       emitted = e;
@@ -1131,7 +1151,7 @@ function () {
   Interpreter.prototype.spawnObservable = function (source, id) {
     var _this = this;
 
-    var emitted = undefined;
+    var emitted;
     var subscription = source.subscribe(function (value) {
       emitted = value;
 
@@ -1263,6 +1283,10 @@ function () {
   };
 
   Interpreter.prototype.getSnapshot = function () {
+    if (this.status === InterpreterStatus.NotStarted) {
+      return this.initialState;
+    }
+
     return this._state;
   };
   /**

package/es/model.d.ts

@@ -1,4 +1,4 @@
-import type { AssignAction, Assigner, PropertyAssigner, ExtractEvent, EventObject } from './types';
+import type { AssignAction, Assigner, PropertyAssigner, ExtractEvent, EventObject, MachineConfig, StateMachine, MachineOptions } from './types';
 declare type AnyFunction = (...args: any[]) => any;
 declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
 declare type Compute<A extends any> = {
@@ -10,6 +10,7 @@ export interface Model<TContext, TEvent extends EventObject, TModelCreators = vo
     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'>;
     reset: () => AssignAction<TContext, any>;
+    createMachine: (config: MachineConfig<TContext, any, TEvent>, implementations?: Partial<MachineOptions<TContext, TEvent>>) => StateMachine<TContext, any, TEvent, any>;
 }
 export declare type ModelContextFrom<TModel extends Model<any, any, any>> = TModel extends Model<infer TContext, any, any> ? TContext : never;
 export declare type ModelEventsFrom<TModel extends Model<any, any, any>> = TModel extends Model<any, infer TEvent, any> ? TEvent : never;

package/es/stateUtils.d.ts

@@ -10,5 +10,6 @@ export declare function getValue<TC, TE extends EventObject>(rootNode: StateNode
 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 getMeta(configuration?: StateNode[]): Record<string, any>;
 export {};
 //# sourceMappingURL=stateUtils.d.ts.map

package/es/stateUtils.js

@@ -247,4 +247,18 @@ function isInFinalState(configuration, stateNode) {
   return false;
 }
 
-export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getValue, has, isInFinalState, isLeafNode, nextEvents };
+function getMeta(configuration) {
+  if (configuration === void 0) {
+    configuration = [];
+  }
+
+  return configuration.reduce(function (acc, stateNode) {
+    if (stateNode.meta !== undefined) {
+      acc[stateNode.id] = stateNode.meta;
+    }
+
+    return acc;
+  }, {});
+}
+
+export { getAdjList, getAllStateNodes, getChildren, getConfiguration, getMeta, getValue, has, isInFinalState, isLeafNode, nextEvents };

package/es/types.d.ts

@@ -134,7 +134,7 @@ export interface PayloadSender<TEvent extends EventObject> {
     <K extends TEvent['type']>(eventType: K, payload: NeverIfEmpty<ExtractExtraParameters<TEvent, K>>): void;
 }
 export declare type Receiver<TEvent extends EventObject> = (listener: (event: TEvent) => void) => void;
-export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject> = (callback: Sender<TEvent>, onReceive: Receiver<TEvent>) => any;
+export declare type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (callback: Sender<TSentEvent>, onReceive: Receiver<TEvent>) => (() => void) | Promise<any> | void;
 export interface InvokeMeta {
     data: any;
     src: InvokeSourceDefinition;
@@ -152,7 +152,7 @@ export interface InvokeMeta {
  * @param context The current machine `context`
  * @param event The event that invoked the service
  */
-export declare type InvokeCreator<TContext, TEvent extends EventObject = AnyEventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<TEvent>;
+export declare type InvokeCreator<TContext, TEvent extends EventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<any, TEvent> | Behavior<any>;
 export interface InvokeDefinition<TContext, TEvent extends EventObject> extends ActivityDefinition<TContext, TEvent> {
     /**
      * The source of the machine to be invoked, or the machine itself.
@@ -490,6 +490,8 @@ export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent
 }> extends StateNode<TContext, TStateSchema, TEvent, TTypestate> {
     id: string;
     states: StateNode<TContext, TStateSchema, TEvent>['states'];
+    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext): StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
+    withContext(context: TContext): StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
 }
 export declare type StateFrom<TMachine extends StateMachine<any, any, any>> = ReturnType<TMachine['transition']>;
 export interface ActionMap<TContext, TEvent extends EventObject> {
@@ -876,23 +878,42 @@ export interface Subscribable<T> {
     subscribe(observer: Observer<T>): Subscription;
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
-export declare type Spawnable = StateMachine<any, any, any> | Promise<any> | InvokeCallback | Subscribable<any>;
+export declare type Spawnable = StateMachine<any, any, any> | PromiseLike<any> | InvokeCallback | Subscribable<any> | Behavior<any>;
 export declare type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends {
     type: TEventType;
 } ? TEvent : never;
+export interface BaseActorRef<TEvent extends EventObject> {
+    send: (event: TEvent) => void;
+}
 export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Subscribable<TEmitted> {
     send: Sender<TEvent>;
-}
-export interface SpawnedActorRef<TEvent extends EventObject, TEmitted = any> extends ActorRef<TEvent, TEmitted> {
     id: string;
     getSnapshot: () => TEmitted | undefined;
     stop?: () => void;
     toJSON?: () => any;
 }
-export declare type ActorRefFrom<T extends StateMachine<any, any, any> | Promise<any>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? SpawnedActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+/**
+ * @deprecated Use `ActorRef` instead.
+ */
+export declare type SpawnedActorRef<TEvent extends EventObject, TEmitted = any> = ActorRef<TEvent, TEmitted>;
+export declare type ActorRefFrom<T extends StateMachine<any, any, any> | Promise<any> | Behavior<any>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+    /**
+     * @deprecated Use `.getSnapshot()` instead.
+     */
     state: State<TContext, TEvent, any, TTypestate>;
-} : T extends Promise<infer U> ? SpawnedActorRef<never, U> : never;
+} : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent, infer TEmitted> ? ActorRef<TEvent, TEmitted> : never;
 export declare type AnyInterpreter = Interpreter<any, any, any, any>;
 export declare type InterpreterFrom<T extends StateMachine<any, any, any, any>> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate> : never;
+export interface ActorContext<TEvent extends EventObject, TEmitted> {
+    parent?: ActorRef<any, any>;
+    self: ActorRef<TEvent, TEmitted>;
+    id: string;
+    observers: Set<Observer<TEmitted>>;
+}
+export interface Behavior<TEvent extends EventObject, TEmitted = any> {
+    transition: (state: TEmitted, event: TEvent, actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
+    initialState: TEmitted;
+    start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
+}
 export {};
 //# sourceMappingURL=types.d.ts.map

package/es/utils.d.ts

@@ -1,6 +1,6 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition } from './types';
+import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition, Observer, Behavior } from './types';
 import { StateNode } from './StateNode';
-import { Observer, State } from '.';
+import { State } from './State';
 import { Actor } from './Actor';
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
@@ -40,6 +40,7 @@ export declare function toArray<T>(value: T[] | T | undefined): T[];
 export declare function mapContext<TContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>, context: TContext, _event: SCXML.Event<TEvent>): any;
 export declare function isBuiltInEvent(eventType: EventType): boolean;
 export declare function isPromiseLike(value: any): value is PromiseLike<any>;
+export declare function isBehavior(value: any): value is Behavior<any, any>;
 export declare function partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
 export declare function updateHistoryStates(hist: HistoryValue, stateValue: StateValue): Record<string, HistoryValue | undefined>;
 export declare function updateHistoryValue(hist: HistoryValue, stateValue: StateValue): HistoryValue;

package/es/utils.js

@@ -301,6 +301,10 @@ function isPromiseLike(value) {
   return false;
 }
 
+function isBehavior(value) {
+  return value !== null && typeof value === 'object' && 'transition' in value && typeof value.transition === 'function';
+}
+
 function partition(items, predicate) {
   var e_6, _a;
 
@@ -617,4 +621,4 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   };
 }
 
-export { evaluateGuard, flatten, getEventType, isActor, isArray, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };
+export { evaluateGuard, flatten, getEventType, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };

package/lib/Actor.d.ts

@@ -1,5 +1,5 @@
 import { EventObject, Subscribable, InvokeDefinition, AnyEventObject, StateMachine, Spawnable, SCXML } from './types';
-import { ActorRef, SpawnedActorRef } from '.';
+import { ActorRef, BaseActorRef } from '.';
 export interface Actor<TContext = any, TEvent extends EventObject = AnyEventObject> extends Subscribable<TContext> {
     id: string;
     send: (event: TEvent) => any;
@@ -11,15 +11,16 @@ export interface Actor<TContext = any, TEvent extends EventObject = AnyEventObje
     state?: any;
     deferred?: boolean;
 }
-export declare function createNullActor(id: string): SpawnedActorRef<any>;
+export declare function createNullActor(id: string): ActorRef<any>;
 /**
  * Creates a deferred actor that is able to be invoked given the provided
  * invocation information in its `.meta` value.
  *
  * @param invokeDefinition The meta information needed to invoke the actor.
  */
-export declare function createInvocableActor<TC, TE extends EventObject>(invokeDefinition: InvokeDefinition<TC, TE>, machine: StateMachine<TC, any, TE, any>, context: TC, _event: SCXML.Event<TE>): SpawnedActorRef<any>;
-export declare function createDeferredActor(entity: Spawnable, id: string, data?: any): SpawnedActorRef<any, undefined>;
+export declare function createInvocableActor<TC, TE extends EventObject>(invokeDefinition: InvokeDefinition<TC, TE>, machine: StateMachine<TC, any, TE, any>, context: TC, _event: SCXML.Event<TE>): ActorRef<any>;
+export declare function createDeferredActor(entity: Spawnable, id: string, data?: any): ActorRef<any, undefined>;
 export declare function isActor(item: any): item is ActorRef<any>;
-export declare function isSpawnedActor(item: any): item is SpawnedActorRef<any>;
+export declare function isSpawnedActor(item: any): item is ActorRef<any>;
+export declare function toActorRef<TEvent extends EventObject, TEmitted = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TEmitted>;
 //# sourceMappingURL=Actor.d.ts.map

package/lib/Actor.js

@@ -1,6 +1,17 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSpawnedActor = exports.isActor = exports.createDeferredActor = exports.createInvocableActor = exports.createNullActor = void 0;
+exports.toActorRef = exports.isSpawnedActor = exports.isActor = exports.createDeferredActor = exports.createInvocableActor = exports.createNullActor = void 0;
 var utils_1 = require("./utils");
 var serviceScope = require("./serviceScope");
 function createNullActor(id) {
@@ -44,8 +55,8 @@ function createDeferredActor(entity, id, data) {
     tempActor.deferred = true;
     if (utils_1.isMachine(entity)) {
         // "mute" the existing service scope so potential spawned actors within the `.initialState` stay deferred here
-        // @ts-ignore
-        tempActor.state = serviceScope.provide(undefined, function () { return (data ? entity.withContext(data) : entity).initialState; });
+        var initialState_1 = (tempActor.state = serviceScope.provide(undefined, function () { return (data ? entity.withContext(data) : entity).initialState; }));
+        tempActor.getSnapshot = function () { return initialState_1; };
     }
     return tempActor;
 }
@@ -63,3 +74,7 @@ function isSpawnedActor(item) {
     return isActor(item) && 'id' in item;
 }
 exports.isSpawnedActor = isSpawnedActor;
+function toActorRef(actorRefLike) {
+    return __assign({ subscribe: function () { return ({ unsubscribe: function () { return void 0; } }); }, id: 'anonymous', getSnapshot: function () { return undefined; } }, actorRefLike);
+}
+exports.toActorRef = toActorRef;

package/lib/Machine.d.ts

@@ -1,13 +1,18 @@
 import { StateMachine, MachineOptions, DefaultContext, MachineConfig, StateSchema, EventObject, AnyEventObject, Typestate } from './types';
 import { Model, ModelContextFrom, ModelEventsFrom } from './model';
+/**
+ * @deprecated Use `createMachine(...)` instead.
+ */
 export declare function Machine<TContext = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>, initialContext?: TContext): StateMachine<TContext, any, TEvent>;
 export declare function Machine<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = AnyEventObject>(config: MachineConfig<TContext, TStateSchema, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>, initialContext?: TContext): StateMachine<TContext, TStateSchema, TEvent>;
 export declare function createMachine<TModel extends Model<any, any, any>, TContext = ModelContextFrom<TModel>, TEvent extends EventObject = ModelEventsFrom<TModel>, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
+}>(config: MachineConfig<TContext, any, TEvent> & {
+    context: TContext;
+}, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
 export declare function createMachine<TContext, TEvent extends EventObject = AnyEventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}>(config: MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
+}>(config: TContext extends Model<any, any, any> ? never : MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
 //# sourceMappingURL=Machine.d.ts.map

package/lib/Machine.js

@@ -4,16 +4,10 @@ exports.createMachine = exports.Machine = void 0;
 var StateNode_1 = require("./StateNode");
 function Machine(config, options, initialContext) {
     if (initialContext === void 0) { initialContext = config.context; }
-    var resolvedInitialContext = typeof initialContext === 'function'
-        ? initialContext()
-        : initialContext;
-    return new StateNode_1.StateNode(config, options, resolvedInitialContext);
+    return new StateNode_1.StateNode(config, options, initialContext);
 }
 exports.Machine = Machine;
 function createMachine(config, options) {
-    var resolvedInitialContext = typeof config.context === 'function'
-        ? config.context()
-        : config.context;
-    return new StateNode_1.StateNode(config, options, resolvedInitialContext);
+    return new StateNode_1.StateNode(config, options);
 }
 exports.createMachine = createMachine;

package/lib/State.js

@@ -114,7 +114,7 @@ var State = /** @class */ (function () {
         this.history = config.history;
         this.actions = config.actions || [];
         this.activities = config.activities || constants_1.EMPTY_ACTIVITY_MAP;
-        this.meta = config.meta || {};
+        this.meta = stateUtils_1.getMeta(config.configuration);
         this.events = config.events || [];
         this.matches = this.matches.bind(this);
         this.toStrings = this.toStrings.bind(this);

package/lib/StateNode.d.ts

@@ -11,7 +11,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     /**
      * The initial extended state
      */
-    context: Readonly<TContext>;
+    private _context;
     /**
      * The relative key of the state node, which represents its location in the overall state value.
      */
@@ -122,7 +122,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     /**
      * The initial extended state
      */
-    context?: Readonly<TContext>);
+    _context?: Readonly<TContext> | (() => Readonly<TContext>));
     private _init;
     /**
      * Clones this state machine with custom options and context.
@@ -130,13 +130,14 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * @param options Options (actions, guards, activities, services) to recursively merge with the existing options.
      * @param context Custom context (will override predefined context)
      */
-    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext | undefined): StateNode<TContext, TStateSchema, TEvent, TTypestate>;
+    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext): StateNode<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Clones this state machine with custom context.
      *
      * @param context Custom context (will override predefined context, not recursive)
      */
-    withContext(context: TContext): StateNode<TContext, TStateSchema, TEvent>;
+    withContext(context: TContext): StateNode<TContext, TStateSchema, TEvent, TTypestate>;
+    get context(): TContext;
     /**
      * The well-structured state node definition.
      */

package/lib/StateNode.js

@@ -99,13 +99,13 @@ var StateNode = /** @class */ (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
     ) {
         var _this = this;
-        if (context === void 0) { context = undefined; }
+        if (_context === void 0) { _context = config.context; }
         var _a;
         this.config = config;
-        this.context = context;
+        this._context = _context;
         /**
          * The order this state node appears. Corresponds to the implicit SCXML document order.
          */
@@ -255,7 +255,6 @@ var StateNode = /** @class */ (function () {
      * @param context Custom context (will override predefined context)
      */
     StateNode.prototype.withConfig = function (options, context) {
-        if (context === void 0) { context = this.context; }
         var _a = this.options, actions = _a.actions, activities = _a.activities, guards = _a.guards, services = _a.services, delays = _a.delays;
         return new StateNode(this.config, {
             actions: __assign(__assign({}, actions), options.actions),
@@ -263,7 +262,7 @@ var StateNode = /** @class */ (function () {
             guards: __assign(__assign({}, guards), options.guards),
             services: __assign(__assign({}, services), options.services),
             delays: __assign(__assign({}, delays), options.delays)
-        }, context);
+        }, context !== null && context !== void 0 ? context : this.context);
     };
     /**
      * Clones this state machine with custom context.
@@ -273,6 +272,13 @@ var StateNode = /** @class */ (function () {
     StateNode.prototype.withContext = function (context) {
         return new StateNode(this.config, this.options, context);
     };
+    Object.defineProperty(StateNode.prototype, "context", {
+        get: function () {
+            return utils_1.isFunction(this._context) ? this._context() : this._context;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(StateNode.prototype, "definition", {
         /**
          * The well-structured state node definition.
@@ -716,7 +722,7 @@ var StateNode = /** @class */ (function () {
             var resolvedStateValue = utils_1.isString(state)
                 ? this.resolve(utils_1.pathToStateValue(this.getResolvedPath(state)))
                 : this.resolve(state);
-            var resolvedContext = context ? context : this.machine.context;
+            var resolvedContext = context !== null && context !== void 0 ? context : this.machine.context;
             currentState = this.resolveState(State_1.State.from(resolvedStateValue, resolvedContext));
         }
         if (!environment_1.IS_PRODUCTION && _event.name === WILDCARD) {
@@ -817,12 +823,6 @@ var StateNode = /** @class */ (function () {
             : currentState
                 ? currentState.configuration
                 : [];
-        var meta = resolvedConfiguration.reduce(function (acc, stateNode) {
-            if (stateNode.meta !== undefined) {
-                acc[stateNode.id] = stateNode.meta;
-            }
-            return acc;
-        }, {});
         var isDone = stateUtils_1.isInFinalState(resolvedConfiguration, this);
         var nextState = new State_1.State({
             value: resolvedStateValue || currentState.value,
@@ -846,11 +846,6 @@ var StateNode = /** @class */ (function () {
                 : currentState
                     ? currentState.activities
                     : {},
-            meta: resolvedStateValue
-                ? meta
-                : currentState
-                    ? currentState.meta
-                    : undefined,
             events: [],
             configuration: resolvedConfiguration,
             transitions: stateTransition.transitions,
@@ -865,15 +860,27 @@ var StateNode = /** @class */ (function () {
         if (history) {
             delete history.history;
         }
-        if (!resolvedStateValue) {
+        // There are transient transitions if the machine is not in a final state
+        // and if some of the state nodes have transient ("always") transitions.
+        var isTransient = !isDone &&
+            (this._transient ||
+                configuration.some(function (stateNode) {
+                    return stateNode._transient;
+                }));
+        // If there are no enabled transitions, check if there are transient transitions.
+        // If there are transient transitions, continue checking for more transitions
+        // because an transient transition should be triggered even if there are no
+        // enabled transitions.
+        //
+        // If we're already working on an transient transition (by checking
+        // if the event is a NULL_EVENT), then stop to prevent an infinite loop.
+        //
+        // Otherwise, if there are no enabled nor transient transitions, we are done.
+        if (!willTransition && (!isTransient || _event.name === NULL_EVENT)) {
             return nextState;
         }
         var maybeNextState = nextState;
         if (!isDone) {
-            var isTransient = this._transient ||
-                configuration.some(function (stateNode) {
-                    return stateNode._transient;
-                });
             if (isTransient) {
                 maybeNextState = this.resolveRaisedTransition(maybeNextState, {
                     type: actionTypes.nullEvent

package/lib/behaviors.d.ts

@@ -0,0 +1,37 @@
+import { ActorContext, ActorRef, Behavior, EventObject } from '.';
+/**
+ * Returns an actor behavior from a reducer and its initial state.
+ *
+ * @param transition The pure reducer that returns the next state given the current state and event.
+ * @param initialState The initial state of the reducer.
+ * @returns An actor behavior
+ */
+export declare function fromReducer<TState, TEvent extends EventObject>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState>) => TState, initialState: TState): Behavior<TEvent, TState>;
+declare type PromiseEvents<T> = {
+    type: 'fulfill';
+    data: T;
+} | {
+    type: 'reject';
+    error: unknown;
+};
+declare type PromiseState<T> = {
+    status: 'pending';
+    data: undefined;
+    error: undefined;
+} | {
+    status: 'fulfilled';
+    data: T;
+    error: undefined;
+} | {
+    status: 'rejected';
+    data: undefined;
+    error: any;
+};
+export declare function fromPromise<T>(promiseFn: () => Promise<T>): Behavior<PromiseEvents<T>, PromiseState<T>>;
+interface SpawnBehaviorOptions {
+    id?: string;
+    parent?: ActorRef<any>;
+}
+export declare function spawnBehavior<TEvent extends EventObject, TEmitted>(behavior: Behavior<TEvent, TEmitted>, options?: SpawnBehaviorOptions): ActorRef<TEvent, TEmitted>;
+export {};
+//# sourceMappingURL=behaviors.d.ts.map