xstate 4.20.1 → 4.23.1

package/lib/Actor.js

@@ -1,80 +1,99 @@
-"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.toActorRef = exports.isSpawnedActor = exports.isActor = exports.createDeferredActor = exports.createInvocableActor = exports.createNullActor = void 0;
-var utils_1 = require("./utils");
-var serviceScope = require("./serviceScope");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('./_virtual/_tslib.js');
+var utils = require('./utils.js');
+var serviceScope = require('./serviceScope.js');
+
 function createNullActor(id) {
-    return {
-        id: id,
-        send: function () { return void 0; },
-        subscribe: function () { return ({
-            unsubscribe: function () { return void 0; }
-        }); },
-        getSnapshot: function () { return undefined; },
-        toJSON: function () { return ({
-            id: id
-        }); }
-    };
+  return {
+    id: id,
+    send: function () {
+      return void 0;
+    },
+    subscribe: function () {
+      return {
+        unsubscribe: function () {
+          return void 0;
+        }
+      };
+    },
+    getSnapshot: function () {
+      return undefined;
+    },
+    toJSON: function () {
+      return {
+        id: id
+      };
+    }
+  };
 }
-exports.createNullActor = createNullActor;
-/**
- * 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.
+/**
+ * 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, 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);
-    // @ts-ignore
-    tempActor.meta = invokeDefinition;
-    return tempActor;
+  var _a;
+
+  var invokeSrc = utils.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.mapContext(invokeDefinition.data, context, _event) : undefined;
+  var tempActor = serviceCreator ? createDeferredActor(serviceCreator, invokeDefinition.id, resolvedData) : createNullActor(invokeDefinition.id); // @ts-ignore
+
+  tempActor.meta = invokeDefinition;
+  return tempActor;
 }
-exports.createInvocableActor = createInvocableActor;
 function createDeferredActor(entity, id, data) {
-    var tempActor = createNullActor(id);
-    // @ts-ignore
-    tempActor.deferred = true;
-    if (utils_1.isMachine(entity)) {
-        // "mute" the existing service scope so potential spawned actors within the `.initialState` stay deferred here
-        var initialState_1 = (tempActor.state = serviceScope.provide(undefined, function () { return (data ? entity.withContext(data) : entity).initialState; }));
-        tempActor.getSnapshot = function () { return initialState_1; };
-    }
-    return tempActor;
+  var tempActor = createNullActor(id); // @ts-ignore
+
+  tempActor.deferred = true;
+
+  if (utils.isMachine(entity)) {
+    // "mute" the existing service scope so potential spawned actors within the `.initialState` stay deferred here
+    var initialState_1 = tempActor.state = serviceScope.provide(undefined, function () {
+      return (data ? entity.withContext(data) : entity).initialState;
+    });
+
+    tempActor.getSnapshot = function () {
+      return initialState_1;
+    };
+  }
+
+  return tempActor;
 }
-exports.createDeferredActor = createDeferredActor;
 function isActor(item) {
-    try {
-        return typeof item.send === 'function';
-    }
-    catch (e) {
-        return false;
-    }
+  try {
+    return typeof item.send === 'function';
+  } catch (e) {
+    return false;
+  }
 }
-exports.isActor = isActor;
 function isSpawnedActor(item) {
-    return isActor(item) && 'id' in 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);
+  return _tslib.__assign({
+    subscribe: function () {
+      return {
+        unsubscribe: function () {
+          return void 0;
+        }
+      };
+    },
+    id: 'anonymous',
+    getSnapshot: function () {
+      return undefined;
+    }
+  }, actorRefLike);
 }
+
+exports.createDeferredActor = createDeferredActor;
+exports.createInvocableActor = createInvocableActor;
+exports.createNullActor = createNullActor;
+exports.isActor = isActor;
+exports.isSpawnedActor = isSpawnedActor;
 exports.toActorRef = toActorRef;

package/lib/Machine.d.ts

@@ -1,15 +1,18 @@
-import { StateMachine, MachineOptions, DefaultContext, MachineConfig, StateSchema, EventObject, AnyEventObject, Typestate } from './types';
-import { Model, ModelContextFrom, ModelEventsFrom } from './model';
-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> & {
-    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: TContext extends Model<any, any, any> ? never : MachineConfig<TContext, any, TEvent>, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
+import { StateMachine, MachineOptions, DefaultContext, MachineConfig, StateSchema, EventObject, AnyEventObject, Typestate, EventFrom } from './types';
+import { Model, ModelContextFrom } from './model.types';
+/**
+ * @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 = EventFrom<TModel>, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}>(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: 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

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMachine = exports.Machine = void 0;
-var StateNode_1 = require("./StateNode");
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var StateNode = require('./StateNode.js');
+
 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);
+  if (initialContext === void 0) {
+    initialContext = config.context;
+  }
+
+  return new StateNode.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.StateNode(config, options);
 }
+
+exports.Machine = Machine;
 exports.createMachine = createMachine;

package/lib/SimulatedClock.d.ts

@@ -1,17 +1,17 @@
-import { Clock } from './interpreter';
-export interface SimulatedClock extends Clock {
-    start(speed: number): void;
-    increment(ms: number): void;
-    set(ms: number): void;
-}
-export declare class SimulatedClock implements SimulatedClock {
-    private timeouts;
-    private _now;
-    private _id;
-    now(): number;
-    private getId;
-    setTimeout(fn: (...args: any[]) => void, timeout: number): number;
-    clearTimeout(id: number): void;
-    private flushTimeouts;
-}
+import { Clock } from './interpreter';
+export interface SimulatedClock extends Clock {
+    start(speed: number): void;
+    increment(ms: number): void;
+    set(ms: number): void;
+}
+export declare class SimulatedClock implements SimulatedClock {
+    private timeouts;
+    private _now;
+    private _id;
+    now(): number;
+    private getId;
+    setTimeout(fn: (...args: any[]) => void, timeout: number): number;
+    clearTimeout(id: number): void;
+    private flushTimeouts;
+}
 //# sourceMappingURL=SimulatedClock.d.ts.map

package/lib/State.d.ts

@@ -1,109 +1,109 @@
-import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, EventType, StateConfig, SCXML, StateSchema, TransitionDefinition, Typestate, ActorRef } from './types';
-import { StateNode } from './StateNode';
-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> = {
-    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, any, any>): ActionObject<TC, TE>;
-export declare class State<TContext, TEvent extends EventObject = EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
-    value: any;
-    context: TContext;
-}> {
-    value: StateValue;
-    context: TContext;
-    historyValue?: HistoryValue | undefined;
-    history?: State<TContext, TEvent, TStateSchema, TTypestate>;
-    actions: Array<ActionObject<TContext, TEvent>>;
-    activities: ActivityMap;
-    meta: any;
-    events: TEvent[];
-    event: TEvent;
-    _event: SCXML.Event<TEvent>;
-    _sessionid: string | null;
-    /**
-     * Indicates whether the state has changed from the previous state. A state is considered "changed" if:
-     *
-     * - Its value is not equal to its previous value, or:
-     * - It has any new actions (side-effects) to execute.
-     *
-     * An initial state (with no history) will return `undefined`.
-     */
-    changed: boolean | undefined;
-    /**
-     * Indicates whether the state is a final state.
-     */
-    done: boolean | undefined;
-    /**
-     * The enabled state nodes representative of the state value.
-     */
-    configuration: Array<StateNode<TContext, any, TEvent, any>>;
-    /**
-     * The next events that will cause a transition from the current state.
-     */
-    nextEvents: EventType[];
-    /**
-     * The transition definitions that resulted in this state.
-     */
-    transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    /**
-     * An object mapping actor IDs to spawned actors/invoked services.
-     */
-    children: Record<string, ActorRef<any>>;
-    tags: Set<string>;
-    /**
-     * Creates a new State instance for the given `stateValue` and `context`.
-     * @param stateValue
-     * @param context
-     */
-    static from<TC, TE extends EventObject = EventObject>(stateValue: State<TC, TE, any, any> | StateValue, context?: TC | undefined): State<TC, TE, any, any>;
-    /**
-     * Creates a new State instance for the given `config`.
-     * @param config The state config
-     */
-    static create<TC, TE extends EventObject = EventObject>(config: StateConfig<TC, TE>): State<TC, TE>;
-    /**
-     * Creates a new `State` instance for the given `stateValue` and `context` with no actions (side-effects).
-     * @param stateValue
-     * @param context
-     */
-    static inert<TC, TE extends EventObject = EventObject>(stateValue: State<TC, TE> | StateValue, context: TC): State<TC, TE>;
-    /**
-     * Creates a new State instance.
-     * @param value The state value
-     * @param context The extended state
-     * @param historyValue The tree representing historical values of the state nodes
-     * @param history The previous state
-     * @param actions An array of action objects to execute as side-effects
-     * @param activities A mapping of activities and whether they are started (`true`) or stopped (`false`).
-     * @param meta
-     * @param events Internal event queue. Should be empty with run-to-completion semantics.
-     * @param configuration
-     */
-    constructor(config: StateConfig<TContext, TEvent>);
-    /**
-     * Returns an array of all the string leaf state node paths.
-     * @param stateValue
-     * @param delimiter The character(s) that separate each subpath in the string state node path.
-     */
-    toStrings(stateValue?: StateValue, delimiter?: string): string[];
-    toJSON(): Omit<this, "configuration" | "transitions" | "tags"> & {
-        tags: string[];
-    };
-    /**
-     * Whether the current state value is a subset of the given parent state value.
-     * @param parentStateValue
-     */
-    matches<TSV extends TTypestate['value']>(parentStateValue: TSV): this is State<(TTypestate extends any ? {
-        value: TSV;
-        context: any;
-    } extends TTypestate ? TTypestate : never : never)['context'], TEvent, TStateSchema, TTypestate> & {
-        value: TSV;
-    };
-    /**
-     * Whether the current state configuration has a state node with the specified `tag`.
-     * @param tag
-     */
-    hasTag(tag: string): boolean;
-}
+import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, EventType, StateConfig, SCXML, StateSchema, TransitionDefinition, Typestate, ActorRef } from './types';
+import { StateNode } from './StateNode';
+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> = {
+    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, any, any>): ActionObject<TC, TE>;
+export declare class State<TContext, TEvent extends EventObject = EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}> {
+    value: StateValue;
+    context: TContext;
+    historyValue?: HistoryValue | undefined;
+    history?: State<TContext, TEvent, TStateSchema, TTypestate>;
+    actions: Array<ActionObject<TContext, TEvent>>;
+    activities: ActivityMap;
+    meta: any;
+    events: TEvent[];
+    event: TEvent;
+    _event: SCXML.Event<TEvent>;
+    _sessionid: string | null;
+    /**
+     * Indicates whether the state has changed from the previous state. A state is considered "changed" if:
+     *
+     * - Its value is not equal to its previous value, or:
+     * - It has any new actions (side-effects) to execute.
+     *
+     * An initial state (with no history) will return `undefined`.
+     */
+    changed: boolean | undefined;
+    /**
+     * Indicates whether the state is a final state.
+     */
+    done: boolean | undefined;
+    /**
+     * The enabled state nodes representative of the state value.
+     */
+    configuration: Array<StateNode<TContext, any, TEvent, any>>;
+    /**
+     * The next events that will cause a transition from the current state.
+     */
+    nextEvents: EventType[];
+    /**
+     * The transition definitions that resulted in this state.
+     */
+    transitions: Array<TransitionDefinition<TContext, TEvent>>;
+    /**
+     * An object mapping actor IDs to spawned actors/invoked services.
+     */
+    children: Record<string, ActorRef<any>>;
+    tags: Set<string>;
+    /**
+     * Creates a new State instance for the given `stateValue` and `context`.
+     * @param stateValue
+     * @param context
+     */
+    static from<TC, TE extends EventObject = EventObject>(stateValue: State<TC, TE, any, any> | StateValue, context?: TC | undefined): State<TC, TE, any, any>;
+    /**
+     * Creates a new State instance for the given `config`.
+     * @param config The state config
+     */
+    static create<TC, TE extends EventObject = EventObject>(config: StateConfig<TC, TE>): State<TC, TE>;
+    /**
+     * Creates a new `State` instance for the given `stateValue` and `context` with no actions (side-effects).
+     * @param stateValue
+     * @param context
+     */
+    static inert<TC, TE extends EventObject = EventObject>(stateValue: State<TC, TE> | StateValue, context: TC): State<TC, TE>;
+    /**
+     * Creates a new State instance.
+     * @param value The state value
+     * @param context The extended state
+     * @param historyValue The tree representing historical values of the state nodes
+     * @param history The previous state
+     * @param actions An array of action objects to execute as side-effects
+     * @param activities A mapping of activities and whether they are started (`true`) or stopped (`false`).
+     * @param meta
+     * @param events Internal event queue. Should be empty with run-to-completion semantics.
+     * @param configuration
+     */
+    constructor(config: StateConfig<TContext, TEvent>);
+    /**
+     * Returns an array of all the string leaf state node paths.
+     * @param stateValue
+     * @param delimiter The character(s) that separate each subpath in the string state node path.
+     */
+    toStrings(stateValue?: StateValue, delimiter?: string): string[];
+    toJSON(): Omit<this, "configuration" | "transitions" | "tags"> & {
+        tags: string[];
+    };
+    /**
+     * Whether the current state value is a subset of the given parent state value.
+     * @param parentStateValue
+     */
+    matches<TSV extends TTypestate['value']>(parentStateValue: TSV): this is State<(TTypestate extends any ? {
+        value: TSV;
+        context: any;
+    } extends TTypestate ? TTypestate : never : never)['context'], TEvent, TStateSchema, TTypestate> & {
+        value: TSV;
+    };
+    /**
+     * Whether the current state configuration has a state node with the specified `tag`.
+     * @param tag
+     */
+    hasTag(tag: string): boolean;
+}
 //# sourceMappingURL=State.d.ts.map