xstate 4.10.0 → 4.14.0

package/es/types.d.ts

@@ -49,12 +49,12 @@ export interface AssignMeta<TContext, TEvent extends EventObject> {
     action: AssignAction<TContext, TEvent>;
     _event: SCXML.Event<TEvent>;
 }
-export declare type ActionFunction<TContext, TEvent extends EventObject> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>) => any | void;
+export declare type ActionFunction<TContext, TEvent extends EventObject> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>) => void;
 export interface ChooseConditon<TContext, TEvent extends EventObject> {
     cond?: Condition<TContext, TEvent>;
     actions: Actions<TContext, TEvent>;
 }
-export declare type Action<TContext, TEvent extends EventObject> = ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent, AnyEventObject> | RaiseAction<AnyEventObject> | ChooseAction<TContext, TEvent>;
+export declare type Action<TContext, TEvent extends EventObject> = ActionType | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent>;
 export declare type Actions<TContext, TEvent extends EventObject> = SingleOrArray<Action<TContext, TEvent>>;
 export declare type StateKey = string | State<any>;
 export interface StateValueMap {
@@ -67,11 +67,14 @@ export interface StateValueMap {
  * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
  */
 export declare type StateValue = string | StateValueMap;
-export declare type ExtractStateValue<TS extends StateSchema<any>, TSS = TS['states']> = TSS extends undefined ? never : {
-    [K in keyof TSS]?: (TSS[K] extends {
-        states: any;
-    } ? keyof TSS[K]['states'] : never) | ExtractStateValue<TSS[K]>;
-};
+declare type KeysWithStates<TStates extends Record<string, StateSchema> | undefined> = TStates extends object ? {
+    [K in keyof TStates]-?: TStates[K] extends {
+        states: object;
+    } ? K : never;
+}[keyof TStates] : never;
+export declare type ExtractStateValue<TSchema extends Required<Pick<StateSchema<any>, 'states'>>> = keyof TSchema['states'] | (KeysWithStates<TSchema['states']> extends never ? never : {
+    [K in KeysWithStates<TSchema['states']>]?: ExtractStateValue<TSchema['states'][K]>;
+});
 export interface HistoryValue {
     states: Record<string, HistoryValue | undefined>;
     current: StateValue | undefined;
@@ -113,8 +116,30 @@ export interface ActivityDefinition<TContext, TEvent extends EventObject> extend
     type: string;
 }
 export declare type Sender<TEvent extends EventObject> = (event: Event<TEvent>) => void;
+declare type ExcludeType<A> = {
+    [K in Exclude<keyof A, 'type'>]: A[K];
+};
+declare type ExtractExtraParameters<A, T> = A extends {
+    type: T;
+} ? ExcludeType<A> : never;
+declare type ExtractSimple<A> = A extends any ? {} extends ExcludeType<A> ? A : never : never;
+declare type NeverIfEmpty<T> = {} extends T ? never : T;
+export interface PayloadSender<TEvent extends EventObject> {
+    /**
+     * Send an event object or just the event type, if the event has no other payload
+     */
+    (event: TEvent | ExtractSimple<TEvent>['type']): void;
+    /**
+     * Send an event type and its payload
+     */
+    <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 = (callback: Sender<any>, onReceive: Receiver<EventObject>) => any;
+export interface InvokeMeta {
+    data: any;
+    src: InvokeSourceDefinition;
+}
 /**
  * Returns either a Promises or a callback handler (for streams of events) given the
  * machine's current `context` and `event` that invoked the service.
@@ -128,12 +153,12 @@ export declare type InvokeCallback = (callback: Sender<any>, onReceive: Receiver
  * @param context The current machine `context`
  * @param event The event that invoked the service
  */
-export declare type InvokeCreator<TContext, TEvent = AnyEventObject, TFinalContext = any> = (context: TContext, event: TEvent) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<any> | InvokeCallback;
+export declare type InvokeCreator<TContext, TEvent = AnyEventObject, TFinalContext = any> = (context: TContext, event: TEvent, meta: InvokeMeta) => PromiseLike<TFinalContext> | StateMachine<TFinalContext, any, any> | Subscribable<any> | InvokeCallback;
 export interface InvokeDefinition<TContext, TEvent extends EventObject> extends ActivityDefinition<TContext, TEvent> {
     /**
      * The source of the machine to be invoked, or the machine itself.
      */
-    src: string;
+    src: string | InvokeSourceDefinition;
     /**
      * If `true`, events sent to the parent service will be forwarded to the invoked service.
      *
@@ -152,7 +177,7 @@ export interface InvokeDefinition<TContext, TEvent extends EventObject> extends
      *
      * Data should be mapped to match the child machine's context shape.
      */
-    data?: Mapper<TContext, TEvent> | PropertyMapper<TContext, TEvent>;
+    data?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
 }
 export interface Delay {
     id: string;
@@ -186,18 +211,18 @@ declare type TransitionsConfigMap<TContext, TEvent extends EventObject> = {
 } & {
     '*'?: TransitionConfigOrTarget<TContext, TEvent>;
 };
-declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<{
-    [K in TEvent['type']]: TransitionConfig<TContext, TEvent extends {
-        type: K;
-    } ? TEvent : never> & {
-        event: K;
-    };
-}[TEvent['type']] | (TransitionConfig<TContext, TEvent> & {
+declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<(TEvent extends EventObject ? TransitionConfig<TContext, TEvent> & {
+    event: TEvent['type'];
+} : never) | (TransitionConfig<TContext, TEvent> & {
     event: '';
 }) | (TransitionConfig<TContext, TEvent> & {
     event: '*';
 })>;
 export declare type TransitionsConfig<TContext, TEvent extends EventObject> = TransitionsConfigMap<TContext, TEvent> | TransitionsConfigArray<TContext, TEvent>;
+export interface InvokeSourceDefinition {
+    [key: string]: any;
+    type: string;
+}
 export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
     /**
      * The unique identifier for the invoked machine. If not specified, this
@@ -207,7 +232,7 @@ export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
     /**
      * The source of the machine to be invoked, or the machine itself.
      */
-    src: string | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent, any>;
+    src: string | InvokeSourceDefinition | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent, any>;
     /**
      * If `true`, events sent to the parent service will be forwarded to the invoked service.
      *
@@ -226,7 +251,7 @@ export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
      *
      * Data should be mapped to match the child machine's context shape.
      */
-    data?: Mapper<TContext, TEvent> | PropertyMapper<TContext, TEvent>;
+    data?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
      */
@@ -235,7 +260,7 @@ export declare type InvokeConfig<TContext, TEvent extends EventObject> = {
      * The transition to take upon the invoked child machine sending an error event.
      */
     onError?: string | SingleOrArray<TransitionConfig<TContext, DoneInvokeEvent<any>>>;
-} | StateMachine<any, any, any>;
+};
 export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> {
     /**
      * The relative key of the state node, which represents its location in the overall state value.
@@ -279,7 +304,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The services to invoke upon entering this state node. These services will be stopped upon exiting this state node.
      */
-    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent>>;
+    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent> | StateMachine<any, any, any>>;
     /**
      * The mapping of event types to their potential transition(s).
      */
@@ -315,6 +340,11 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      * The delayed transitions are taken after the specified delay in an interpreter.
      */
     after?: DelayedTransitions<TContext, TEvent>;
+    /**
+     * An eventless transition that is always taken when this state node is active.
+     * Equivalent to a transition specified as an empty `''`' string in the `on` property.
+     */
+    always?: TransitionConfigOrTarget<TContext, TEvent>;
     /**
      * The activities to be started upon entering the state node,
      * and stopped upon exiting the state node.
@@ -337,7 +367,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      * The data will be evaluated with the current `context` and placed on the `.data` property
      * of the event.
      */
-    data?: Mapper<TContext, TEvent> | PropertyMapper<TContext, TEvent>;
+    data?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
     /**
      * The unique ID of the state node, which can be referenced as a transition target via the
      * `#id` syntax.
@@ -388,18 +418,18 @@ export interface FinalStateNodeConfig<TContext, TEvent extends EventObject> exte
      * The data to be sent with the "done.state.<id>" event. The data can be
      * static or dynamic (based on assigners).
      */
-    data?: Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent> | any;
+    data?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
 }
 export declare type SimpleOrStateNodeConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TStateSchema, TEvent>;
 export declare type ActionFunctionMap<TContext, TEvent extends EventObject> = Record<string, ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent>>;
 export declare type DelayFunctionMap<TContext, TEvent extends EventObject> = Record<string, DelayConfig<TContext, TEvent>>;
-export declare type ServiceConfig<TContext> = string | StateMachine<any, any, any> | InvokeCreator<TContext>;
+export declare type ServiceConfig<TContext, TEvent extends EventObject = AnyEventObject> = string | StateMachine<any, any, any> | InvokeCreator<TContext, TEvent>;
 export declare type DelayConfig<TContext, TEvent extends EventObject> = number | DelayExpr<TContext, TEvent>;
 export interface MachineOptions<TContext, TEvent extends EventObject> {
     guards: Record<string, ConditionPredicate<TContext, TEvent>>;
     actions: ActionFunctionMap<TContext, TEvent>;
     activities: Record<string, ActivityConfig<TContext, TEvent>>;
-    services: Record<string, ServiceConfig<TContext>>;
+    services: Record<string, ServiceConfig<TContext, TEvent>>;
     delays: DelayFunctionMap<TContext, TEvent>;
     /**
      * @private
@@ -434,7 +464,10 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';
     target: StateValue | undefined;
 }
-export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = any> extends StateNode<TContext, TStateSchema, TEvent, TTypestate> {
+export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}> extends StateNode<TContext, TStateSchema, TEvent, TTypestate> {
     id: string;
     states: StateNode<TContext, TStateSchema, TEvent>['states'];
 }
@@ -526,7 +559,7 @@ export interface NullEvent {
 }
 export interface ActivityActionObject<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Start | ActionTypes.Stop;
-    activity: ActivityDefinition<TContext, TEvent>;
+    activity: ActivityDefinition<TContext, TEvent> | undefined;
     exec: ActionFunction<TContext, TEvent> | undefined;
 }
 export interface InvokeActionObject<TContext, TEvent extends EventObject> extends ActivityActionObject<TContext, TEvent> {
@@ -554,6 +587,20 @@ export interface SendActionObject<TContext, TEvent extends EventObject, TSentEve
     delay?: number;
     id: string | number;
 }
+export interface StopAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+    type: ActionTypes.Stop;
+    activity: string | {
+        id: string;
+    } | Expr<TContext, TEvent, string | {
+        id: string;
+    }>;
+}
+export interface StopActionObject {
+    type: ActionTypes.Stop;
+    activity: {
+        id: string;
+    };
+}
 export declare type Expr<TContext, TEvent extends EventObject, T> = (context: TContext, event: TEvent) => T;
 export declare type ExprWithMeta<TContext, TEvent extends EventObject, T> = (context: TContext, event: TEvent, meta: SCXMLEventMeta<TEvent>) => T;
 export declare type SendExpr<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject> = ExprWithMeta<TContext, TEvent, TSentEvent>;
@@ -573,10 +620,10 @@ export declare type Assigner<TContext, TEvent extends EventObject> = (context: T
 export declare type PropertyAssigner<TContext, TEvent extends EventObject> = {
     [K in keyof TContext]?: ((context: TContext, event: TEvent, meta: AssignMeta<TContext, TEvent>) => TContext[K]) | TContext[K];
 };
-export declare type Mapper<TContext, TEvent extends EventObject> = (context: TContext, event: TEvent) => any;
-export declare type PropertyMapper<TContext, TEvent extends EventObject> = Partial<{
-    [key: string]: ((context: TContext, event: TEvent) => any) | any;
-}>;
+export declare type Mapper<TContext, TEvent extends EventObject, TParams extends {}> = (context: TContext, event: TEvent) => TParams;
+export declare type PropertyMapper<TContext, TEvent extends EventObject, TParams extends {}> = {
+    [K in keyof TParams]?: ((context: TContext, event: TEvent) => TParams[K]) | TParams[K];
+};
 export interface AnyAssignAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
     type: ActionTypes.Assign;
     assignment: any;
@@ -795,7 +842,7 @@ export declare namespace SCXML {
     }
 }
 export interface Unsubscribable {
-    unsubscribe(): any | void;
+    unsubscribe(): void;
 }
 export interface Subscribable<T> {
     subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Unsubscribable;

package/es/utils.d.ts

@@ -1,4 +1,4 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, StateMachine, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard } 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 } from './types';
 import { StateNode } from './StateNode';
 import { State } from '.';
 import { Actor } from './Actor';
@@ -39,7 +39,7 @@ export declare function pathsToStateValue(paths: string[][]): StateValue;
 export declare function flatten<T>(array: Array<T | T[]>): T[];
 export declare function toArrayStrict<T>(value: T[] | T): T[];
 export declare function toArray<T>(value: T[] | T | undefined): T[];
-export declare function mapContext<TContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent> | PropertyMapper<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>): any;
+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 partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
@@ -52,7 +52,7 @@ export declare function isArray(value: any): value is any[];
 export declare function isFunction(value: any): value is Function;
 export declare function isString(value: any): value is string;
 export declare function toGuard<TContext, TEvent extends EventObject>(condition?: Condition<TContext, TEvent>, guardMap?: Record<string, ConditionPredicate<TContext, TEvent>>): Guard<TContext, TEvent> | undefined;
-export declare function isObservable<T>(value: Subscribable<T> | any): value is Subscribable<T>;
+export declare function isObservable<T>(value: any): value is Subscribable<T>;
 export declare const symbolObservable: string | symbol;
 export declare function isMachine(value: any): value is StateMachine<any, any, any>;
 export declare function isActor(value: any): value is Actor;
@@ -65,4 +65,5 @@ export declare function toTransitionConfigArray<TContext, TEvent extends EventOb
 export declare function normalizeTarget<TContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, any, TEvent>> | undefined): Array<string | StateNode<TContext, any, TEvent>> | undefined;
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
 export declare function evaluateGuard<TContext, TEvent extends EventObject>(machine: StateNode<TContext, any, TEvent>, guard: Guard<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>): boolean;
+export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
 //# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -259,7 +259,7 @@ function mapContext(mapper, context, _event) {
   var result = {};
 
   try {
-    for (var _b = __values(keys(mapper)), _c = _b.next(); !_c.done; _c = _b.next()) {
+    for (var _b = __values(Object.keys(mapper)), _c = _b.next(); !_c.done; _c = _b.next()) {
       var key = _c.value;
       var subMapper = mapper[key];
 
@@ -530,7 +530,6 @@ function toSCXMLEvent(event, scxmlEvent) {
 function toTransitionConfigArray(event, configLike) {
   var transitions = toArrayStrict(configLike).map(function (transitionLike) {
     if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string' || isMachine(transitionLike)) {
-      // @ts-ignore until Type instantiation is excessively deep and possibly infinite bug is fixed
       return {
         target: transitionLike,
         event: event
@@ -588,4 +587,14 @@ function evaluateGuard(machine, guard, context, _event, state) {
   return condFn(context, _event.data, guardMeta);
 }
 
-export { evaluateGuard, flatten, getEventType, isArray, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };
+function toInvokeSource(src) {
+  if (typeof src === 'string') {
+    return {
+      type: src
+    };
+  }
+
+  return src;
+}
+
+export { evaluateGuard, flatten, getEventType, 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, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };

package/lib/Actor.d.ts

@@ -1,4 +1,4 @@
-import { EventObject, Subscribable, InvokeDefinition, AnyEventObject } from './types';
+import { EventObject, Subscribable, InvokeDefinition, AnyEventObject, StateMachine, Spawnable, SCXML } from './types';
 export interface Actor<TContext = any, TEvent extends EventObject = AnyEventObject> extends Subscribable<TContext> {
     id: string;
     send: (event: TEvent) => any;
@@ -8,14 +8,16 @@ export interface Actor<TContext = any, TEvent extends EventObject = AnyEventObje
     };
     meta?: InvokeDefinition<TContext, TEvent>;
     state?: any;
+    deferred?: boolean;
 }
 export declare function createNullActor(id: string): Actor;
 /**
- * Creates a null actor that is able to be invoked given the provided
+ * 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>): Actor;
+export declare function createInvocableActor<TC, TE extends EventObject>(invokeDefinition: InvokeDefinition<TC, TE>, machine: StateMachine<TC, any, TE>, context: TC, _event: SCXML.Event<TE>): Actor;
+export declare function createDeferredActor(entity: Spawnable, id: string, data?: any): Actor;
 export declare function isActor(item: any): item is Actor;
 //# sourceMappingURL=Actor.d.ts.map

package/lib/Actor.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isActor = exports.createDeferredActor = exports.createInvocableActor = exports.createNullActor = void 0;
+var utils_1 = require("./utils");
+var serviceScope = require("./serviceScope");
 function createNullActor(id) {
     return {
         id: id,
@@ -14,17 +17,35 @@ function createNullActor(id) {
 }
 exports.createNullActor = createNullActor;
 /**
- * Creates a null actor that is able to be invoked given the provided
+ * 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.
  */
-function createInvocableActor(invokeDefinition) {
-    var tempActor = createNullActor(invokeDefinition.id);
+function createInvocableActor(invokeDefinition, machine, context, _event) {
+    var _a;
+    var invokeSrc = utils_1.toInvokeSource(invokeDefinition.src);
+    var serviceCreator = (_a = machine === null || machine === void 0 ? void 0 : machine.options.services) === null || _a === void 0 ? void 0 : _a[invokeSrc.type];
+    var resolvedData = invokeDefinition.data
+        ? utils_1.mapContext(invokeDefinition.data, context, _event)
+        : undefined;
+    var tempActor = serviceCreator
+        ? createDeferredActor(serviceCreator, invokeDefinition.id, resolvedData)
+        : createNullActor(invokeDefinition.id);
     tempActor.meta = invokeDefinition;
     return tempActor;
 }
 exports.createInvocableActor = createInvocableActor;
+function createDeferredActor(entity, id, data) {
+    var tempActor = createNullActor(id);
+    tempActor.deferred = true;
+    if (utils_1.isMachine(entity)) {
+        // "mute" the existing service scope so potential spawned actors within the `.initialState` stay deferred here
+        tempActor.state = serviceScope.provide(undefined, function () { return (data ? entity.withContext(data) : entity).initialState; });
+    }
+    return tempActor;
+}
+exports.createDeferredActor = createDeferredActor;
 function isActor(item) {
     try {
         return typeof item.send === 'function';

package/lib/Machine.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMachine = exports.Machine = void 0;
 var StateNode_1 = require("./StateNode");
 function Machine(config, options, initialContext) {
     if (initialContext === void 0) { initialContext = config.context; }

package/lib/SimulatedClock.js

@@ -20,6 +20,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulatedClock = void 0;
 var SimulatedClock = /** @class */ (function () {
     function SimulatedClock() {
         this.timeouts = new Map();

package/lib/State.d.ts

@@ -2,7 +2,10 @@ import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, Event
 import { StateNode } from './StateNode';
 import { Actor } from './Actor';
 export declare function stateValuesEqual(a: StateValue | undefined, b: StateValue | undefined): boolean;
-export declare function isState<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = any>(state: object | string): state is State<TContext, TEvent, TStateSchema, TTypestate>;
+export declare function isState<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}>(state: object | string): state is State<TContext, TEvent, TStateSchema, TTypestate>;
 export declare function bindActionToState<TC, TE extends EventObject>(action: ActionObject<TC, TE>, state: State<TC, TE>): ActionObject<TC, TE>;
 export declare class State<TContext, TEvent extends EventObject = EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
     value: any;
@@ -11,7 +14,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
     value: StateValue;
     context: TContext;
     historyValue?: HistoryValue | undefined;
-    history?: State<TContext, TEvent, TStateSchema>;
+    history?: State<TContext, TEvent, TStateSchema, TTypestate>;
     actions: Array<ActionObject<TContext, TEvent>>;
     activities: ActivityMap;
     meta: any;

package/lib/State.js

@@ -42,6 +42,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = exports.bindActionToState = exports.isState = exports.stateValuesEqual = void 0;
 var constants_1 = require("./constants");
 var utils_1 = require("./utils");
 var stateUtils_1 = require("./stateUtils");

package/lib/StateNode.d.ts

@@ -1,6 +1,9 @@
 import { Event, StateValue, StateValueMap, MachineOptions, EventObject, HistoryValue, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, ActivityDefinition, StateNodeConfig, StateSchema, StateNodesConfig, InvokeDefinition, ActionObject, Mapper, PropertyMapper, SCXML, Typestate, TransitionDefinitionMap } from './types';
 import { State } from './State';
-declare class StateNode<TContext = any, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = any> {
+declare class StateNode<TContext = any, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}> {
     /**
      * The raw config used to create the machine.
      */
@@ -92,7 +95,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
     /**
      * The data sent with the "done.state._id_" event if this is a final state node.
      */
-    data?: Mapper<TContext, TEvent> | PropertyMapper<TContext, TEvent>;
+    doneData?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
     /**
      * The string delimiter for serializing the path to a string. The default is "."
      */
@@ -156,7 +159,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      *
      * @param state The state value or State instance
      */
-    getStateNodes(state: StateValue | State<TContext, TEvent>): Array<StateNode<TContext, any, TEvent>>;
+    getStateNodes(state: StateValue | State<TContext, TEvent, any, TTypestate>): Array<StateNode<TContext, any, TEvent>>;
     /**
      * Returns `true` if this state node explicitly handles the given event.
      *
@@ -170,7 +173,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      *
      * @param state The state to resolve
      */
-    resolveState(state: State<TContext, TEvent>): State<TContext, TEvent>;
+    resolveState(state: State<TContext, TEvent>): State<TContext, TEvent, TStateSchema, TTypestate>;
     private transitionLeafNode;
     private transitionCompoundNode;
     private transitionParallelNode;
@@ -190,10 +193,7 @@ declare class StateNode<TContext = any, TStateSchema extends StateSchema = any,
      * @param event The event that was sent at the current state
      * @param context The current context (extended state) of the current state
      */
-    transition(state: string | StateValueMap | State<TContext, TEvent, any, {
-        value: any;
-        context: TContext;
-    }> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>, context?: TContext): State<TContext, TEvent, TStateSchema, TTypestate>;
+    transition(state: string | StateValueMap | State<TContext, TEvent, any, TTypestate> | undefined, event: Event<TEvent> | SCXML.Event<TEvent>, context?: TContext): State<TContext, TEvent, TStateSchema, TTypestate>;
     private resolveRaisedTransition;
     private resolveTransition;
     /**