xstate 4.23.1 → 4.24.0

package/es/types.d.ts

@@ -2,6 +2,8 @@ import { StateNode } from './StateNode';
 import { State } from './State';
 import { Interpreter, Clock } from './interpreter';
 import { Model } from './model.types';
+declare type AnyFunction = (...args: any[]) => any;
+declare type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export declare type EventType = string;
 export declare type ActionType = string;
 export declare type MetaObject = Record<string, any>;
@@ -17,20 +19,22 @@ export interface EventObject {
 export interface AnyEventObject extends EventObject {
     [key: string]: any;
 }
-/**
- * The full definition of an action, with a string `type` and an
- * `exec` implementation function.
- */
-export interface ActionObject<TContext, TEvent extends EventObject> {
+export interface BaseActionObject {
     /**
      * The type of action that is executed.
      */
     type: string;
+    [other: string]: any;
+}
+/**
+ * The full definition of an action, with a string `type` and an
+ * `exec` implementation function.
+ */
+export interface ActionObject<TContext, TEvent extends EventObject> extends BaseActionObject {
     /**
      * The implementation for executing the action.
      */
     exec?: ActionFunction<TContext, TEvent>;
-    [other: string]: any;
 }
 export declare type DefaultContext = Record<string, any> | undefined;
 export declare type EventData = Record<string, any> & {
@@ -40,8 +44,8 @@ export declare type EventData = Record<string, any> & {
  * The specified string event types or the specified event objects.
  */
 export declare type Event<TEvent extends EventObject> = TEvent['type'] | TEvent;
-export interface ActionMeta<TContext, TEvent extends EventObject> extends StateMeta<TContext, TEvent> {
-    action: ActionObject<TContext, TEvent>;
+export interface ActionMeta<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> extends StateMeta<TContext, TEvent> {
+    action: TAction;
     _event: SCXML.Event<TEvent>;
 }
 export interface AssignMeta<TContext, TEvent extends EventObject> {
@@ -49,12 +53,22 @@ 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>) => void;
+export declare type ActionFunction<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> = (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent, TAction>) => 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>;
+/**
+ * Extracts action objects that have no extra properties.
+ */
+declare type SimpleActionsOf<T extends BaseActionObject> = ActionObject<any, any> extends T ? T : ExtractWithSimpleSupport<T>;
+/**
+ * Events that do not require payload
+ */
+export declare type SimpleEventsOf<TEvent extends EventObject> = ExtractWithSimpleSupport<TEvent>;
+export declare type BaseAction<TContext, TEvent extends EventObject, TAction extends BaseActionObject> = SimpleActionsOf<TAction>['type'] | TAction | RaiseAction<any> | SendAction<TContext, TEvent, any> | AssignAction<TContext, TEvent> | LogAction<TContext, TEvent> | CancelAction | StopAction<TContext, TEvent> | ChooseAction<TContext, TEvent> | ActionFunction<TContext, TEvent>;
+export declare type BaseActions<TContext, TEvent extends EventObject, TAction extends BaseActionObject> = SingleOrArray<BaseAction<TContext, TEvent, TAction>>;
 export declare type Actions<TContext, TEvent extends EventObject> = SingleOrArray<Action<TContext, TEvent>>;
 export declare type StateKey = string | State<any>;
 export interface StateValueMap {
@@ -122,13 +136,17 @@ declare type ExcludeType<A> = {
 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 ExtractWithSimpleSupport<T extends {
+    type: string;
+}> = T extends any ? {
+    type: T['type'];
+} extends T ? T : 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;
+    (event: TEvent | ExtractWithSimpleSupport<TEvent>['type']): void;
     /**
      * Send an event type and its payload
      */
@@ -194,8 +212,8 @@ export declare type SingleOrArray<T> = T[] | T;
 export declare type StateNodesConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
     [K in keyof TStateSchema['states']]: StateNode<TContext, TStateSchema['states'][K], TEvent>;
 };
-export declare type StatesConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
-    [K in keyof TStateSchema['states']]: StateNodeConfig<TContext, TStateSchema['states'][K], TEvent>;
+export declare type StatesConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = {
+    [K in keyof TStateSchema['states']]: StateNodeConfig<TContext, TStateSchema['states'][K], TEvent, TAction>;
 };
 export declare type StatesDefinition<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> = {
     [K in keyof TStateSchema['states']]: StateNodeDefinition<TContext, TStateSchema['states'][K], TEvent>;
@@ -261,7 +279,7 @@ export interface InvokeConfig<TContext, TEvent extends EventObject> {
      */
     onError?: string | SingleOrArray<TransitionConfig<TContext, DoneInvokeEvent<any>>>;
 }
-export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> {
+export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> {
     /**
      * The relative key of the state node, which represents its location in the overall state value.
      * This is automatically determined by the configuration shape via the key where it was defined.
@@ -285,12 +303,6 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
      *  - `'final'` - final state node
      */
     type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
-    /**
-     * The initial context (extended state) of the machine.
-     *
-     * Can be an object or a function that returns an object.
-     */
-    context?: TContext | (() => TContext);
     /**
      * Indicates whether the state node is a history state node, and what
      * type of history:
@@ -300,7 +312,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The mapping of state node keys to their state node configurations (recursive).
      */
-    states?: StatesConfig<TContext, TStateSchema, TEvent> | undefined;
+    states?: StatesConfig<TContext, TStateSchema, TEvent, TAction> | undefined;
     /**
      * The services to invoke upon entering this state node. These services will be stopped upon exiting this state node.
      */
@@ -318,7 +330,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The action(s) to be executed upon entering the state node.
      */
-    entry?: Actions<TContext, TEvent>;
+    entry?: BaseActions<TContext, TEvent, TAction>;
     /**
      * The action(s) to be executed upon exiting the state node.
      *
@@ -328,7 +340,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The action(s) to be executed upon exiting the state node.
      */
-    exit?: Actions<TContext, TEvent>;
+    exit?: BaseActions<TContext, TEvent, TAction>;
     /**
      * The potential transition(s) to be taken upon reaching a final child state node.
      *
@@ -348,6 +360,8 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The activities to be started upon entering the state node,
      * and stopped upon exiting the state node.
+     *
+     * @deprecated Use `invoke` instead.
      */
     activities?: SingleOrArray<Activity<TContext, TEvent>>;
     /**
@@ -406,6 +420,9 @@ export interface StateNodeDefinition<TContext, TStateSchema extends StateSchema,
     transitions: Array<TransitionDefinition<TContext, TEvent>>;
     entry: Array<ActionObject<TContext, TEvent>>;
     exit: Array<ActionObject<TContext, TEvent>>;
+    /**
+     * @deprecated
+     */
     activities: Array<ActivityDefinition<TContext, TEvent>>;
     meta: any;
     order: number;
@@ -432,13 +449,20 @@ export interface FinalStateNodeConfig<TContext, TEvent extends EventObject> exte
     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 ActionFunctionMap<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> = {
+    [K in TAction['type']]?: ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent, TAction extends {
+        type: K;
+    } ? TAction : never>;
+};
 export declare type DelayFunctionMap<TContext, TEvent extends EventObject> = Record<string, DelayConfig<TContext, TEvent>>;
 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> {
+export interface MachineOptions<TContext, TEvent extends EventObject, TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, TEvent>> {
     guards: Record<string, ConditionPredicate<TContext, TEvent>>;
-    actions: ActionFunctionMap<TContext, TEvent>;
+    actions: ActionFunctionMap<TContext, TEvent, TAction>;
+    /**
+     * @deprecated Use `services` instead.
+     */
     activities: Record<string, ActivityConfig<TContext, TEvent>>;
     services: Record<string, ServiceConfig<TContext, TEvent>>;
     delays: DelayFunctionMap<TContext, TEvent>;
@@ -451,7 +475,7 @@ export interface MachineOptions<TContext, TEvent extends EventObject> {
      */
     _key?: string;
 }
-export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject> extends StateNodeConfig<TContext, TStateSchema, TEvent> {
+export interface MachineConfig<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TAction extends BaseActionObject = ActionObject<TContext, TEvent>> extends StateNodeConfig<TContext, TStateSchema, TEvent, TAction> {
     /**
      * The initial context (extended state)
      */
@@ -495,13 +519,13 @@ export interface HistoryStateNode<TContext> extends StateNode<TContext> {
 export interface StateMachine<TContext, TStateSchema extends StateSchema, TEvent extends EventObject, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}> extends StateNode<TContext, TStateSchema, TEvent, TTypestate> {
+}, _TAction extends ActionObject<TContext, TEvent> = ActionObject<TContext, 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>;
+    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
+    withContext(context: TContext | (() => TContext)): StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
 }
-export declare type StateFrom<TMachine extends StateMachine<any, any, any>> = ReturnType<TMachine['transition']>;
+export declare type StateFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>)> = T extends StateMachine<any, any, any> ? ReturnType<T['transition']> : T extends (...args: any[]) => StateMachine<any, any, any> ? ReturnType<ReturnType<T>['transition']> : never;
 export interface ActionMap<TContext, TEvent extends EventObject> {
     onEntry: Array<Action<TContext, TEvent>>;
     actions: Array<Action<TContext, TEvent>>;
@@ -768,6 +792,9 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     historyValue?: HistoryValue | undefined;
     history?: State<TContext, TEvent>;
     actions?: Array<ActionObject<TContext, TEvent>>;
+    /**
+     * @deprecated
+     */
     activities?: ActivityMap;
     meta?: any;
     events?: TEvent[];
@@ -776,6 +803,7 @@ export interface StateConfig<TContext, TEvent extends EventObject> {
     children: Record<string, ActorRef<any>>;
     done?: boolean;
     tags?: Set<string>;
+    machine?: StateMachine<TContext, any, TEvent, any>;
 }
 export interface StateSchema<TC = any> {
     meta?: any;
@@ -904,14 +932,15 @@ 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> | Behavior<any>> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRef<TEvent, State<TContext, TEvent, any, TTypestate>> & {
+export declare type ActorRefWithDeprecatedState<TContext, TEvent extends EventObject, TTypestate extends Typestate<TContext>> = 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> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : never;
+};
+export declare type ActorRefFrom<T> = T extends StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends (...args: any[]) => StateMachine<infer TContext, any, infer TEvent, infer TTypestate> ? ActorRefWithDeprecatedState<TContext, TEvent, TTypestate> : T extends Promise<infer U> ? ActorRef<never, U> : T extends Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, TEmitted> : T extends (...args: any[]) => Behavior<infer TEvent1, infer TEmitted> ? ActorRef<TEvent1, 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 declare type InterpreterFrom<T extends StateMachine<any, any, any, any> | ((...args: any[]) => StateMachine<any, any, any, any>)> = T extends StateMachine<infer TContext, infer TStateSchema, infer TEvent, infer TTypestate> ? Interpreter<TContext, TStateSchema, TEvent, TTypestate> : T extends (...args: any[]) => 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>;
@@ -923,7 +952,8 @@ export interface Behavior<TEvent extends EventObject, TEmitted = any> {
     initialState: TEmitted;
     start?: (actorCtx: ActorContext<TEvent, TEmitted>) => TEmitted;
 }
-export declare type EventFrom<T> = T extends StateMachine<any, any, infer TEvent, any> ? TEvent : T extends Model<any, infer TEvent, any> ? TEvent : T extends State<any, infer TEvent, any, any> ? TEvent : T extends Interpreter<any, any, infer TEvent, any> ? TEvent : never;
-export declare type ContextFrom<T> = T extends StateMachine<infer TContext, any, any, any> ? TContext : T extends Model<infer TContext, any, any> ? TContext : T extends State<infer TContext, any, any, any> ? TContext : T extends Interpreter<infer TContext, any, any, any> ? TContext : never;
+export declare type EmittedFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TEmitted> ? TEmitted : R extends Behavior<infer _, infer TEmitted> ? TEmitted : R extends ActorContext<infer _, infer TEmitted> ? TEmitted : never : never;
+export declare type EventFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer __, infer TEvent, infer ____> ? TEvent : R extends Model<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer ___, infer ____> ? TEvent : R extends Interpreter<infer _, infer __, infer TEvent, infer ____> ? TEvent : never : never;
+export declare type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___> ? TContext : R extends Model<infer TContext, infer _, infer __, infer ___> ? TContext : R extends State<infer TContext, infer _, infer __, infer ___> ? TContext : R extends Interpreter<infer TContext, infer _, infer __, infer ___> ? TContext : never : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/es/utils.js

@@ -545,7 +545,7 @@ function evaluateGuard(machine, guard, context, _event, state) {
   }; // TODO: do not hardcode!
 
   if (guard.type === DEFAULT_GUARD_TYPE) {
-    return guard.predicate(context, _event.data, guardMeta);
+    return ((guards === null || guards === void 0 ? void 0 : guards[guard.name]) || guard.predicate)(context, _event.data, guardMeta);
   }
 
   var condFn = guards[guard.type];

package/lib/Machine.d.ts

@@ -1,18 +1,18 @@
-import { StateMachine, MachineOptions, DefaultContext, MachineConfig, StateSchema, EventObject, AnyEventObject, Typestate, EventFrom } from './types';
-import { Model, ModelContextFrom } from './model.types';
+import { StateMachine, MachineOptions, DefaultContext, MachineConfig, StateSchema, EventObject, AnyEventObject, Typestate, EventFrom, BaseActionObject } from './types';
+import { Model, ModelContextFrom, ModelActionsFrom } 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> = {
+export declare function createMachine<TModel extends Model<any, any, any, any>, TContext = ModelContextFrom<TModel>, TEvent extends EventObject = EventFrom<TModel>, TTypestate extends Typestate<TContext> = {
     value: any;
     context: TContext;
-}>(config: MachineConfig<TContext, any, TEvent> & {
+}, TAction extends BaseActionObject = ModelActionsFrom<TModel>>(config: MachineConfig<TContext, any, TEvent, TAction> & {
     context: TContext;
-}, options?: Partial<MachineOptions<TContext, TEvent>>): StateMachine<TContext, any, TEvent, TTypestate>;
+}, options?: Partial<MachineOptions<TContext, TEvent, TAction>>): 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>;
+}>(config: TContext extends Model<any, 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/State.d.ts

@@ -1,4 +1,4 @@
-import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, EventType, StateConfig, SCXML, StateSchema, TransitionDefinition, Typestate, ActorRef } from './types';
+import { StateValue, ActivityMap, EventObject, HistoryValue, ActionObject, EventType, StateConfig, SCXML, StateSchema, TransitionDefinition, Typestate, ActorRef, StateMachine, SimpleEventsOf } 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> = {
@@ -51,6 +51,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      */
     children: Record<string, ActorRef<any>>;
     tags: Set<string>;
+    machine: StateMachine<TContext, any, TEvent, TTypestate> | undefined;
     /**
      * Creates a new State instance for the given `stateValue` and `context`.
      * @param stateValue
@@ -87,7 +88,7 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * @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"> & {
+    toJSON(): Omit<this, "configuration" | "transitions" | "tags" | "machine"> & {
         tags: string[];
     };
     /**
@@ -105,5 +106,11 @@ export declare class State<TContext, TEvent extends EventObject = EventObject, T
      * @param tag
      */
     hasTag(tag: string): boolean;
+    /**
+     * Determines whether sending the `event` will cause a transition.
+     * @param event The event to test
+     * @returns Whether the event will cause a transition
+     */
+    can(event: TEvent | SimpleEventsOf<TEvent>['type']): boolean;
 }
 //# sourceMappingURL=State.d.ts.map

package/lib/State.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
 var constants = require('./constants.js');
+var environment = require('./environment.js');
 var utils = require('./utils.js');
 var stateUtils = require('./stateUtils.js');
 var actions = require('./actions.js');
@@ -93,7 +94,8 @@ function () {
     this.transitions = config.transitions;
     this.children = config.children;
     this.done = !!config.done;
-    this.tags = (_a = config.tags) !== null && _a !== void 0 ? _a : new Set();
+    this.tags = (_a = Array.isArray(config.tags) ? new Set(config.tags) : config.tags) !== null && _a !== void 0 ? _a : new Set();
+    this.machine = config.machine;
     Object.defineProperty(this, 'nextEvents', {
       get: function () {
         return stateUtils.nextEvents(_this.configuration);
@@ -221,7 +223,8 @@ function () {
         configuration = _a.configuration,
         transitions = _a.transitions,
         tags = _a.tags,
-        jsonValues = _tslib.__rest(_a, ["configuration", "transitions", "tags"]);
+        machine = _a.machine,
+        jsonValues = _tslib.__rest(_a, ["configuration", "transitions", "tags", "machine"]);
 
     return _tslib.__assign(_tslib.__assign({}, jsonValues), {
       tags: Array.from(tags)
@@ -245,6 +248,22 @@ function () {
   State.prototype.hasTag = function (tag) {
     return this.tags.has(tag);
   };
+  /**
+   * Determines whether sending the `event` will cause a transition.
+   * @param event The event to test
+   * @returns Whether the event will cause a transition
+   */
+
+
+  State.prototype.can = function (event) {
+    var _a;
+
+    if (environment.IS_PRODUCTION) {
+      utils.warn(!!this.machine, "state.can(...) used outside of a machine-created State object; this will always return false.");
+    }
+
+    return !!((_a = this.machine) === null || _a === void 0 ? void 0 : _a.transition(this, event).changed);
+  };
 
   return State;
 }();

package/lib/StateNode.d.ts

@@ -130,13 +130,13 @@ 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): StateNode<TContext, TStateSchema, TEvent, TTypestate>;
+    withConfig(options: Partial<MachineOptions<TContext, TEvent>>, context?: TContext | (() => 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>;
+    withContext(context: TContext | (() => TContext)): StateNode<TContext, TStateSchema, TEvent, TTypestate>;
     get context(): TContext;
     /**
      * The well-structured state node definition.

package/lib/StateNode.js

@@ -59,7 +59,7 @@ function () {
     var _this = this;
 
     if (_context === void 0) {
-      _context = config.context;
+      _context = 'context' in config ? config.context : undefined;
     }
 
     var _a;
@@ -928,7 +928,8 @@ function () {
       transitions: stateTransition.transitions,
       children: children,
       done: isDone,
-      tags: currentState === null || currentState === void 0 ? void 0 : currentState.tags
+      tags: currentState === null || currentState === void 0 ? void 0 : currentState.tags,
+      machine: this
     });
     var didUpdateContext = currentContext !== updatedContext;
     nextState.changed = _event.name === actionTypes.update || didUpdateContext; // Dispose of penultimate histories to prevent memory leaks

package/lib/actions.d.ts

@@ -9,7 +9,7 @@ export declare const initEvent: SCXML.Event<{
 }>;
 export declare function getActionFunction<TContext, TEvent extends EventObject>(actionType: ActionType, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | undefined;
 export declare function toActionObject<TContext, TEvent extends EventObject>(action: Action<TContext, TEvent>, actionFunctionMap?: ActionFunctionMap<TContext, TEvent>): ActionObject<TContext, TEvent>;
-export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined, actionFunctionMap?: ActionFunctionMap<TContext, TEvent> | undefined) => ActionObject<TContext, TEvent>[];
+export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined, actionFunctionMap?: ActionFunctionMap<TContext, TEvent, ActionObject<TContext, TEvent>> | undefined) => ActionObject<TContext, TEvent>[];
 export declare function toActivityDefinition<TContext, TEvent extends EventObject>(action: string | ActivityDefinition<TContext, TEvent>): ActivityDefinition<TContext, TEvent>;
 /**
  * Raises an event. This places the event in the internal event queue, so that

package/lib/actions.js

@@ -56,13 +56,6 @@ function toActionObject(action, actionFunctionMap) {
     }
   }
 
-  Object.defineProperty(actionObject, 'toString', {
-    value: function () {
-      return actionObject.type;
-    },
-    enumerable: false,
-    configurable: true
-  });
   return actionObject;
 }
 var toActionObjects = function (action, actionFunctionMap) {

package/lib/interpreter.js

@@ -898,9 +898,13 @@ function () {
   };
 
   Interpreter.prototype.removeChild = function (childId) {
+    var _a;
+
     this.children.delete(childId);
-    this.forwardTo.delete(childId);
-    delete this.state.children[childId];
+    this.forwardTo.delete(childId); // this.state might not exist at the time this is called,
+    // such as when a child is added then removed while initializing the state
+
+    (_a = this.state) === null || _a === void 0 ? true : delete _a.children[childId];
   };
 
   Interpreter.prototype.stopChild = function (childId) {