xstate 4.20.2 → 4.22.0

package/es/types.d.ts

@@ -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, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<any, 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.
@@ -878,7 +878,7 @@ 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;
@@ -896,13 +896,24 @@ export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Su
  * @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>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+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> ? ActorRef<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/Machine.d.ts

@@ -1,5 +1,8 @@
 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> = {

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/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, 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) {

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

package/lib/behaviors.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnBehavior = exports.fromPromise = exports.fromReducer = void 0;
+var actions_1 = require("./actions");
+var Actor_1 = require("./Actor");
+var utils_1 = require("./utils");
+/**
+ * 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
+ */
+function fromReducer(transition, initialState) {
+    return {
+        transition: transition,
+        initialState: initialState
+    };
+}
+exports.fromReducer = fromReducer;
+function fromPromise(promiseFn) {
+    var initialState = {
+        error: undefined,
+        data: undefined,
+        status: 'pending'
+    };
+    return {
+        transition: function (state, event, _a) {
+            var parent = _a.parent, id = _a.id, observers = _a.observers;
+            switch (event.type) {
+                case 'fulfill':
+                    parent === null || parent === void 0 ? void 0 : parent.send(actions_1.doneInvoke(id, event.data));
+                    return {
+                        error: undefined,
+                        data: event.data,
+                        status: 'fulfilled'
+                    };
+                case 'reject':
+                    parent === null || parent === void 0 ? void 0 : parent.send(actions_1.error(id, event.error));
+                    observers.forEach(function (observer) {
+                        observer.error(event.error);
+                    });
+                    return {
+                        error: event.error,
+                        data: undefined,
+                        status: 'rejected'
+                    };
+                default:
+                    return state;
+            }
+        },
+        initialState: initialState,
+        start: function (_a) {
+            var self = _a.self;
+            promiseFn().then(function (data) {
+                self.send({ type: 'fulfill', data: data });
+            }, function (reason) {
+                self.send({ type: 'reject', error: reason });
+            });
+            return initialState;
+        }
+    };
+}
+exports.fromPromise = fromPromise;
+function spawnBehavior(behavior, options) {
+    if (options === void 0) { options = {}; }
+    var state = behavior.initialState;
+    var observers = new Set();
+    var mailbox = [];
+    var flushing = false;
+    var flush = function () {
+        if (flushing) {
+            return;
+        }
+        flushing = true;
+        while (mailbox.length > 0) {
+            var event_1 = mailbox.shift();
+            state = behavior.transition(state, event_1, actorCtx);
+            observers.forEach(function (observer) { return observer.next(state); });
+        }
+        flushing = false;
+    };
+    var actor = Actor_1.toActorRef({
+        id: options.id,
+        send: function (event) {
+            mailbox.push(event);
+            flush();
+        },
+        getSnapshot: function () { return state; },
+        subscribe: function (next, handleError, complete) {
+            var observer = utils_1.toObserver(next, handleError, complete);
+            observers.add(observer);
+            observer.next(state);
+            return {
+                unsubscribe: function () {
+                    observers.delete(observer);
+                }
+            };
+        }
+    });
+    var actorCtx = {
+        parent: options.parent,
+        self: actor,
+        id: options.id || 'anonymous',
+        observers: observers
+    };
+    state = behavior.start ? behavior.start(actorCtx) : state;
+    return actor;
+}
+exports.spawnBehavior = spawnBehavior;

package/lib/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 { ActorRef, ActorRefFrom, Subscription } from '.';
 export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
@@ -171,6 +170,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
         autoForward?: boolean;
         sync?: boolean;
     }): ActorRef<TChildEvent, State<TChildContext, TChildEvent>>;
+    private spawnBehavior;
     private spawnPromise;
     private spawnCallback;
     private spawnObservable;
@@ -183,6 +183,7 @@ 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): ActorRef<any>;
 /**

package/lib/interpreter.js

@@ -56,6 +56,7 @@ var stateUtils_1 = require("./stateUtils");
 var registry_1 = require("./registry");
 var devTools_1 = require("./devTools");
 var serviceScope = require("./serviceScope");
+var behaviors_1 = require("./behaviors");
 var DEFAULT_SPAWN_OPTIONS = { sync: false, autoForward: false };
 var InterpreterStatus;
 (function (InterpreterStatus) {
@@ -725,31 +726,28 @@ var Interpreter = /** @class */ (function () {
                     var resolvedData = data
                         ? utils_1.mapContext(data, context, _event)
                         : undefined;
+                    if (typeof serviceCreator === 'string') {
+                        // TODO: warn
+                        return;
+                    }
                     var source = utils_1.isFunction(serviceCreator)
                         ? serviceCreator(context, _event.data, {
                             data: resolvedData,
                             src: invokeSource
                         })
                         : serviceCreator;
-                    if (utils_1.isPromiseLike(source)) {
-                        this.spawnPromise(Promise.resolve(source), id);
-                    }
-                    else if (utils_1.isFunction(source)) {
-                        this.spawnCallback(source, id);
-                    }
-                    else if (utils_1.isObservable(source)) {
-                        this.spawnObservable(source, id);
+                    if (!source) {
+                        // TODO: warn?
+                        return;
                     }
-                    else if (utils_1.isMachine(source)) {
-                        // TODO: try/catch here
-                        this.spawnMachine(resolvedData ? source.withContext(resolvedData) : source, {
-                            id: id,
+                    var options = void 0;
+                    if (utils_1.isMachine(source)) {
+                        source = resolvedData ? source.withContext(resolvedData) : source;
+                        options = {
                             autoForward: autoForward
-                        });
-                    }
-                    else {
-                        // service is string
+                        };
                     }
+                    this.spawn(source, id, options);
                 }
                 else {
                     this.spawnActivity(activity);
@@ -808,6 +806,9 @@ var Interpreter = /** @class */ (function () {
         else if (utils_1.isMachine(entity)) {
             return this.spawnMachine(entity, __assign(__assign({}, options), { id: name }));
         }
+        else if (utils_1.isBehavior(entity)) {
+            return this.spawnBehavior(entity, name);
+        }
         else {
             throw new Error("Unable to spawn entity \"" + name + "\" of type \"" + typeof entity + "\".");
         }
@@ -838,10 +839,15 @@ var Interpreter = /** @class */ (function () {
             .start();
         return actor;
     };
+    Interpreter.prototype.spawnBehavior = function (behavior, id) {
+        var actorRef = behaviors_1.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;
@@ -912,7 +918,7 @@ var Interpreter = /** @class */ (function () {
         var canceled = false;
         var receivers = new Set();
         var listeners = new Set();
-        var emitted = undefined;
+        var emitted;
         var receive = function (e) {
             emitted = e;
             listeners.forEach(function (listener) { return listener(e); });
@@ -962,7 +968,7 @@ var Interpreter = /** @class */ (function () {
     };
     Interpreter.prototype.spawnObservable = function (source, id) {
         var _this = this;
-        var emitted = undefined;
+        var emitted;
         var subscription = source.subscribe(function (value) {
             emitted = value;
             _this.send(utils_1.toSCXMLEvent(value, { origin: id }));

package/lib/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/lib/model.js

@@ -34,6 +34,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModel = void 0;
 var actions_1 = require("./actions");
+var Machine_1 = require("./Machine");
 var utils_1 = require("./utils");
 function createModel(initialContext, creators) {
     var eventCreators = creators === null || creators === void 0 ? void 0 : creators.events;
@@ -49,7 +50,10 @@ function createModel(initialContext, creators) {
                 return (__assign(__assign({}, fn.apply(void 0, __spreadArray([], __read(args)))), { type: eventType }));
             }; })
             : undefined),
-        reset: function () { return actions_1.assign(initialContext); }
+        reset: function () { return actions_1.assign(initialContext); },
+        createMachine: function (config, implementations) {
+            return Machine_1.createMachine('context' in config ? config : __assign(__assign({}, config), { context: initialContext }), implementations);
+        }
     };
     return model;
 }

package/lib/types.d.ts

@@ -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, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<EventObject> | InvokeCallback<any, 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.
@@ -878,7 +878,7 @@ 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;
@@ -896,13 +896,24 @@ export interface ActorRef<TEvent extends EventObject, TEmitted = any> extends Su
  * @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>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+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> ? ActorRef<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/lib/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/lib/utils.js

@@ -43,7 +43,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from) {
     return to;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toObserver = exports.toInvokeSource = exports.evaluateGuard = exports.reportUnhandledExceptionOnInvocation = exports.normalizeTarget = exports.toTransitionConfigArray = exports.toSCXMLEvent = exports.toEventObject = exports.uniqueId = exports.isActor = exports.isMachine = exports.symbolObservable = exports.isObservable = exports.toGuard = exports.isString = exports.isFunction = exports.isArray = exports.warn = exports.updateContext = exports.updateHistoryValue = exports.updateHistoryStates = exports.partition = exports.isPromiseLike = exports.isBuiltInEvent = exports.mapContext = exports.toArray = exports.toArrayStrict = exports.flatten = exports.pathsToStateValue = exports.toStatePaths = exports.nestedPath = exports.path = exports.mapFilterValues = exports.mapValues = exports.pathToStateValue = exports.toStateValue = exports.isStateLike = exports.toStatePath = exports.getActionType = exports.getEventType = exports.matchesState = exports.keys = void 0;
+exports.toObserver = exports.toInvokeSource = exports.evaluateGuard = exports.reportUnhandledExceptionOnInvocation = exports.normalizeTarget = exports.toTransitionConfigArray = exports.toSCXMLEvent = exports.toEventObject = exports.uniqueId = exports.isActor = exports.isMachine = exports.symbolObservable = exports.isObservable = exports.toGuard = exports.isString = exports.isFunction = exports.isArray = exports.warn = exports.updateContext = exports.updateHistoryValue = exports.updateHistoryStates = exports.partition = exports.isBehavior = exports.isPromiseLike = exports.isBuiltInEvent = exports.mapContext = exports.toArray = exports.toArrayStrict = exports.flatten = exports.pathsToStateValue = exports.toStatePaths = exports.nestedPath = exports.path = exports.mapFilterValues = exports.mapValues = exports.pathToStateValue = exports.toStateValue = exports.isStateLike = exports.toStatePath = exports.getActionType = exports.getEventType = exports.matchesState = exports.keys = void 0;
 var constants_1 = require("./constants");
 var environment_1 = require("./environment");
 function keys(value) {
@@ -345,6 +345,13 @@ function isPromiseLike(value) {
     return false;
 }
 exports.isPromiseLike = isPromiseLike;
+function isBehavior(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'transition' in value &&
+        typeof value.transition === 'function');
+}
+exports.isBehavior = isBehavior;
 function partition(items, predicate) {
     var e_6, _a;
     var _b = __read([[], []], 2), truthy = _b[0], falsy = _b[1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xstate",
-  "version": "4.20.2",
+  "version": "4.22.0",
   "description": "Finite State Machines and Statecharts for the Modern Web.",
   "main": "lib/index.js",
   "module": "es/index.js",