xstate 4.35.4 → 4.36.0

package/es/interpreter.js

@@ -1,10 +1,10 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
 import { SpecialTargets, ActionTypes } from './types.js';
 import { isStateConfig, State, bindActionToState } from './State.js';
-import { raise, send, errorPlatform, update, error as error$1, log, stop, start, cancel } from './actionTypes.js';
+import { errorPlatform, update, error as error$1, log, stop, start, cancel, send, raise } from './actionTypes.js';
 import { initEvent, doneInvoke, toActionObjects, resolveActions, error, getActionFunction } from './actions.js';
 import { IS_PRODUCTION } from './environment.js';
-import { warn, mapContext, toObserver, isFunction, toSCXMLEvent, flatten, isPromiseLike, isObservable, isMachine, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, toInvokeSource, uniqueId } from './utils.js';
+import { warn, mapContext, toObserver, isFunction, toSCXMLEvent, flatten, isRaisableAction, isPromiseLike, isObservable, isMachine, isBehavior, reportUnhandledExceptionOnInvocation, symbolObservable, isArray, toEventObject, isString, isActor, toInvokeSource, uniqueId } from './utils.js';
 import { Scheduler } from './scheduler.js';
 import { createDeferredActor, isSpawnedActor } from './Actor.js';
 import { registry } from './registry.js';
@@ -112,7 +112,7 @@ function () {
 
     this.sendTo = function (event, to, immediate) {
       var isParent = _this.parent && (to === SpecialTargets.Parent || _this.parent.id === to);
-      var target = isParent ? _this.parent : isString(to) ? _this.children.get(to) || registry.get(to) : isActor(to) ? to : undefined;
+      var target = isParent ? _this.parent : isString(to) ? to === SpecialTargets.Internal ? _this : _this.children.get(to) || registry.get(to) : isActor(to) ? to : undefined;
 
       if (!target) {
         if (!isParent) {
@@ -185,6 +185,16 @@ function () {
       }
 
       switch (action.type) {
+        case raise:
+          {
+            // if raise action reached the interpreter then it's a delayed one
+            var sendAction_1 = action;
+
+            _this.defer(sendAction_1);
+
+            break;
+          }
+
         case send:
           var sendAction = action;
 
@@ -288,8 +298,9 @@ function () {
           }
 
         case log:
-          var label = action.label,
-              value = action.value;
+          var _a = action,
+              label = _a.label,
+              value = _a.value;
 
           if (label) {
             _this.logger(label, value);
@@ -475,11 +486,12 @@ function () {
         return sn.type === 'final' && sn.parent === _this.machine;
       });
       var doneData = finalChildStateNode && finalChildStateNode.doneData ? mapContext(finalChildStateNode.doneData, state.context, _event) : undefined;
+      this._doneEvent = doneInvoke(this.id, doneData);
 
       try {
         for (var _l = __values(this.doneListeners), _m = _l.next(); !_m.done; _m = _l.next()) {
           var listener = _m.value;
-          listener(doneInvoke(this.id, doneData));
+          listener(this._doneEvent);
         }
       } catch (e_5_1) {
         e_5 = {
@@ -601,7 +613,12 @@ function () {
 
 
   Interpreter.prototype.onDone = function (listener) {
-    this.doneListeners.add(listener);
+    if (this.status === InterpreterStatus.Stopped && this._doneEvent) {
+      listener(this._doneEvent);
+    } else {
+      this.doneListeners.add(listener);
+    }
+
     return this;
   };
   /**
@@ -818,7 +835,7 @@ function () {
           historyValue: undefined,
           history: _this.state,
           actions: resolvedActions.filter(function (action) {
-            return action.type !== raise && (action.type !== send || !!action.to && action.to !== SpecialTargets.Internal);
+            return !isRaisableAction(action);
           }),
           activities: {},
           events: [],
@@ -979,13 +996,17 @@ function () {
   Interpreter.prototype.defer = function (sendAction) {
     var _this = this;
 
-    this.delayedEventsMap[sendAction.id] = this.clock.setTimeout(function () {
-      if (sendAction.to) {
+    var timerId = this.clock.setTimeout(function () {
+      if ('to' in sendAction && sendAction.to) {
         _this.sendTo(sendAction._event, sendAction.to, true);
       } else {
         _this.send(sendAction._event);
       }
     }, sendAction.delay);
+
+    if (sendAction.id) {
+      this.delayedEventsMap[sendAction.id] = timerId;
+    }
   };
 
   Interpreter.prototype.cancel = function (sendId) {

package/es/model.types.d.ts

@@ -5,7 +5,7 @@ declare type SimplisticExtractEvent<TEvent extends EventObject, TEventType exten
 } ? TEvent : never;
 export interface Model<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TModelCreators = void> {
     initialContext: TContext;
-    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, SimplisticExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, SimplisticExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, SimplisticExtractEvent<TEvent, TEventType>>;
+    assign: <TEventType extends TEvent['type'] = TEvent['type']>(assigner: Assigner<TContext, SimplisticExtractEvent<TEvent, TEventType>> | PropertyAssigner<TContext, SimplisticExtractEvent<TEvent, TEventType>>, eventType?: TEventType) => AssignAction<TContext, SimplisticExtractEvent<TEvent, TEventType>, TEvent>;
     events: Prop<TModelCreators, 'events'>;
     actions: Prop<TModelCreators, 'actions'>;
     reset: () => AssignAction<TContext, any>;

package/es/types.d.ts

@@ -43,16 +43,20 @@ export interface BaseActionObject {
      */
     type: string;
     [other: string]: any;
+    [notAnArrayLike: number]: never;
 }
 /**
  * The full definition of an action, with a string `type` and an
  * `exec` implementation function.
  */
-export interface ActionObject<TContext, TEvent extends EventObject> extends BaseActionObject {
+export interface ActionObject<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TAction extends BaseActionObject = BaseActionObject> {
+    type: string;
     /**
      * The implementation for executing the action.
      */
-    exec?: ActionFunction<TContext, TEvent> | undefined;
+    exec?: ActionFunction<TContext, TExpressionEvent, BaseActionObject, TEvent> | undefined;
+    /** @deprecated an internal signature that doesn't exist at runtime. Its existence helps TS to choose a better code path in the inference algorithm  */
+    (arg: TContext, ev: TExpressionEvent, meta: ActionMeta<TContext, TEvent, TAction>): void;
 }
 export declare type DefaultContext = Record<string, any> | undefined;
 export declare type EventData = Record<string, any> & {
@@ -71,14 +75,14 @@ export interface AssignMeta<TContext, TEvent extends EventObject> {
     action: AssignAction<TContext, TEvent>;
     _event: SCXML.Event<TEvent>;
 }
-export declare type ActionFunction<TContext, TEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject> = {
-    bivarianceHack(context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent, TAction>): void;
+export declare type ActionFunction<TContext, TExpressionEvent extends EventObject, TAction extends BaseActionObject = BaseActionObject, TEvent extends EventObject = TExpressionEvent> = {
+    bivarianceHack(context: TContext, event: TExpressionEvent, meta: ActionMeta<TContext, TEvent, TAction>): void;
 }['bivarianceHack'];
 export interface ChooseCondition<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>;
+export declare type Action<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = ActionType | BaseActionObject | ActionObject<TContext, TExpressionEvent, TEvent> | ActionFunction<TContext, TExpressionEvent, BaseActionObject, TEvent>;
 /**
  * Extracts action objects that have no extra properties.
  */
@@ -87,9 +91,9 @@ declare type SimpleActionsOf<T extends BaseActionObject> = ActionObject<any, any
  * 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 BaseAction<TContext, TExpressionEvent extends EventObject, TAction extends BaseActionObject, TEvent extends EventObject = TExpressionEvent> = SimpleActionsOf<TAction>['type'] | TAction | RaiseAction<TContext, TExpressionEvent, TEvent> | SendAction<TContext, TExpressionEvent, TEvent> | AssignAction<TContext, TExpressionEvent, TEvent> | LogAction<TContext, TExpressionEvent, TEvent> | CancelAction<TContext, TExpressionEvent, TEvent> | StopAction<TContext, TExpressionEvent, TEvent> | ChooseAction<TContext, TExpressionEvent, TEvent> | PureAction<TContext, TExpressionEvent, TEvent> | ActionFunction<TContext, TExpressionEvent, TAction, TEvent>;
+export declare type BaseActions<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TAction extends BaseActionObject> = SingleOrArray<BaseAction<TContext, TExpressionEvent, TAction, TEvent>>;
+export declare type Actions<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent>>;
 export declare type StateKey = string | AnyState;
 export interface StateValueMap {
     [key: string]: StateValue;
@@ -121,9 +125,9 @@ export interface GuardMeta<TContext, TEvent extends EventObject> extends StateMe
 export declare type Condition<TContext, TEvent extends EventObject> = string | ConditionPredicate<TContext, TEvent> | Guard<TContext, TEvent>;
 export declare type TransitionTarget<TContext, TEvent extends EventObject> = SingleOrArray<string | StateNode<TContext, any, TEvent>>;
 export declare type TransitionTargets<TContext> = Array<string | StateNode<TContext, any>>;
-export interface TransitionConfig<TContext, TEvent extends EventObject> {
-    cond?: Condition<TContext, TEvent>;
-    actions?: Actions<TContext, TEvent>;
+export interface TransitionConfig<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> {
+    cond?: Condition<TContext, TExpressionEvent>;
+    actions?: BaseActions<TContext, TExpressionEvent, TEvent, BaseActionObject>;
     in?: StateValue;
     internal?: boolean;
     target?: TransitionTarget<TContext, TEvent> | undefined;
@@ -237,9 +241,9 @@ export declare type StatesDefinition<TContext, TStateSchema extends StateSchema,
     [K in keyof TStateSchema['states']]: StateNodeDefinition<TContext, TStateSchema['states'][K] & {}, TEvent>;
 };
 export declare type TransitionConfigTarget<TContext, TEvent extends EventObject> = string | undefined | StateNode<TContext, any, TEvent>;
-export declare type TransitionConfigOrTarget<TContext, TEvent extends EventObject> = SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TEvent>>;
+export declare type TransitionConfigOrTarget<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = SingleOrArray<TransitionConfigTarget<TContext, TEvent> | TransitionConfig<TContext, TExpressionEvent, TEvent>>;
 export declare type TransitionsConfigMap<TContext, TEvent extends EventObject> = {
-    [K in TEvent['type'] | '' | '*']?: K extends '' | '*' ? TransitionConfigOrTarget<TContext, TEvent> : TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>>;
+    [K in TEvent['type'] | '' | '*']?: K extends '' | '*' ? TransitionConfigOrTarget<TContext, TEvent> : TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent>;
 };
 declare type TransitionsConfigArray<TContext, TEvent extends EventObject> = Array<(TEvent extends EventObject ? TransitionConfig<TContext, TEvent> & {
     event: TEvent['type'];
@@ -346,7 +350,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The action(s) to be executed upon entering the state node.
      */
-    entry?: BaseActions<TContext, TEvent, TAction>;
+    entry?: BaseActions<TContext, TEvent, TEvent, TAction>;
     /**
      * The action(s) to be executed upon exiting the state node.
      *
@@ -356,7 +360,7 @@ export interface StateNodeConfig<TContext, TStateSchema extends StateSchema, TEv
     /**
      * The action(s) to be executed upon exiting the state node.
      */
-    exit?: BaseActions<TContext, TEvent, TAction>;
+    exit?: BaseActions<TContext, TEvent, TEvent, TAction>;
     /**
      * The potential transition(s) to be taken upon reaching a final child state node.
      *
@@ -488,7 +492,7 @@ export declare type DelayFunctionMap<TContext, TEvent extends EventObject> = Rec
 export declare type ServiceConfig<TContext, TEvent extends EventObject = AnyEventObject> = string | AnyStateMachine | InvokeCreator<TContext, TEvent>;
 export declare type DelayConfig<TContext, TEvent extends EventObject> = number | DelayExpr<TContext, TEvent>;
 declare type MachineOptionsActions<TContext, TResolvedTypesMeta, TEventsCausingActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActions'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>> = {
-    [K in keyof TEventsCausingActions]?: ActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedActions, K>, BaseActionObject>>;
+    [K in keyof TEventsCausingActions]?: ActionObject<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>, Cast<Prop<TIndexedActions, K>, BaseActionObject>> | ActionFunction<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActions[K]>, EventObject>, Cast<Prop<TIndexedActions, K>, BaseActionObject>, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
 };
 declare type MachineOptionsDelays<TContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>> = {
     [K in keyof TEventsCausingDelays]?: DelayConfig<TContext, Cast<Prop<TIndexedEvents, TEventsCausingDelays[K]>, EventObject>>;
@@ -644,13 +648,17 @@ export declare enum ActionTypes {
     Pure = "xstate.pure",
     Choose = "xstate.choose"
 }
-export interface RaiseAction<TEvent extends EventObject> {
+export interface RaiseAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
     type: ActionTypes.Raise;
-    event: TEvent['type'];
+    event: TEvent | SendExpr<TContext, TExpressionEvent, TEvent>;
+    delay: number | string | undefined | DelayExpr<TContext, TExpressionEvent>;
+    id: string | number | undefined;
 }
-export interface RaiseActionObject<TEvent extends EventObject> {
+export interface RaiseActionObject<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends RaiseAction<TContext, TExpressionEvent, TEvent> {
     type: ActionTypes.Raise;
     _event: SCXML.Event<TEvent>;
+    delay: number | undefined;
+    id: string | number | undefined;
 }
 export interface DoneInvokeEvent<TData> extends EventObject {
     data: TData;
@@ -685,14 +693,16 @@ export interface InvokeActionObject<TContext, TEvent extends EventObject> extend
 }
 export declare type DelayExpr<TContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, number>;
 export declare type LogExpr<TContext, TEvent extends EventObject> = ExprWithMeta<TContext, TEvent, any>;
-export interface LogAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface LogAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
+    type: ActionTypes.Log;
     label: string | undefined;
-    expr: string | LogExpr<TContext, TEvent>;
+    expr: string | LogExpr<TContext, TExpressionEvent>;
 }
 export interface LogActionObject<TContext, TEvent extends EventObject> extends LogAction<TContext, TEvent> {
     value: any;
 }
-export interface SendAction<TContext, TEvent extends EventObject, TSentEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface SendAction<TContext, TEvent extends EventObject, TSentEvent extends EventObject> extends ActionObject<TContext, TEvent, TSentEvent> {
+    type: ActionTypes.Send;
     to: string | number | ActorRef<any> | ExprWithMeta<TContext, TEvent, string | number | ActorRef<any>> | undefined;
     event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>;
     delay?: number | string | DelayExpr<TContext, TEvent>;
@@ -705,11 +715,11 @@ export interface SendActionObject<TContext, TEvent extends EventObject, TSentEve
     delay?: number;
     id: string | number;
 }
-export interface StopAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface StopAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
     type: ActionTypes.Stop;
     activity: string | {
         id: string;
-    } | Expr<TContext, TEvent, string | {
+    } | Expr<TContext, TExpressionEvent, string | {
         id: string;
     }>;
 }
@@ -726,12 +736,15 @@ export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
 }
-export interface SendActionOptions<TContext, TEvent extends EventObject> {
+export interface SendActionOptions<TContext, TEvent extends EventObject> extends RaiseActionOptions<TContext, TEvent> {
+    to?: string | ActorRef<any> | ExprWithMeta<TContext, TEvent, string | ActorRef<any>>;
+}
+export interface RaiseActionOptions<TContext, TEvent extends EventObject> {
     id?: string | number;
     delay?: number | string | DelayExpr<TContext, TEvent>;
-    to?: string | ActorRef<any> | ExprWithMeta<TContext, TEvent, string | ActorRef<any>>;
 }
-export interface CancelAction extends ActionObject<any, any> {
+export interface CancelAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
+    type: ActionTypes.Cancel;
     sendId: string | number;
 }
 export declare type Assigner<TContext, TEvent extends EventObject> = (context: TContext, event: TEvent, meta: AssignMeta<TContext, TEvent>) => Partial<TContext>;
@@ -747,19 +760,19 @@ export interface AnyAssignAction<TContext, TEvent extends EventObject> extends A
     type: ActionTypes.Assign;
     assignment: any;
 }
-export interface AssignAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface AssignAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
     type: ActionTypes.Assign;
-    assignment: Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent>;
+    assignment: Assigner<TContext, TExpressionEvent> | PropertyAssigner<TContext, TExpressionEvent>;
 }
-export interface PureAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface PureAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
     type: ActionTypes.Pure;
     get: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent> | ActionObject<TContext, TEvent>['type']> | undefined;
 }
-export interface ChooseAction<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
+export interface ChooseAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> extends ActionObject<TContext, TExpressionEvent, TEvent> {
     type: ActionTypes.Choose;
     conds: Array<ChooseCondition<TContext, TEvent>>;
 }
-export interface TransitionDefinition<TContext, TEvent extends EventObject> extends TransitionConfig<TContext, TEvent> {
+export interface TransitionDefinition<TContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent, any>, 'actions'> {
     target: Array<StateNode<TContext, any, TEvent>> | undefined;
     source: StateNode<TContext, any, TEvent>;
     actions: Array<ActionObject<TContext, TEvent>>;

package/es/utils.d.ts

@@ -1,8 +1,8 @@
-import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition, Observer, Behavior } from './types';
+import { Event, StateValue, ActionType, Action, EventObject, PropertyMapper, Mapper, EventType, HistoryValue, AssignAction, Condition, Subscribable, ConditionPredicate, SCXML, StateLike, EventData, TransitionConfig, TransitionConfigTarget, NullEvent, SingleOrArray, Guard, InvokeSourceDefinition, Observer, Behavior, RaiseActionObject, SendActionObject } from './types';
 import { StateNode } from './StateNode';
 import { State } from './State';
 import { Actor } from './Actor';
-import { AnyStateMachine } from '.';
+import { ActionObject, AnyStateMachine } from '.';
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
 export declare function getEventType<TEvent extends EventObject = EventObject>(event: Event<TEvent>): TEvent['type'];
@@ -69,4 +69,5 @@ export declare function evaluateGuard<TContext, TEvent extends EventObject>(mach
 export declare function toInvokeSource(src: string | InvokeSourceDefinition): InvokeSourceDefinition;
 export declare function toObserver<T>(nextHandler?: Partial<Observer<T>> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;
+export declare function isRaisableAction<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(action: ActionObject<TContext, TExpressionEvent, TEvent>): action is RaiseActionObject<TContext, TExpressionEvent, TEvent> | SendActionObject<TContext, TExpressionEvent, TEvent>;
 //# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -1,4 +1,6 @@
 import { __values, __spreadArray, __read, __assign } from './_virtual/_tslib.js';
+import { SpecialTargets } from './types.js';
+import { raise, send } from './actionTypes.js';
 import { DEFAULT_GUARD_TYPE, TARGETLESS_KEY, STATE_DELIMITER } from './constants.js';
 import { IS_PRODUCTION } from './environment.js';
 
@@ -618,5 +620,8 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
 function createInvokeId(stateNodeId, index) {
   return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 }
+function isRaisableAction(action) {
+  return (action.type === raise || action.type === send && action.to === SpecialTargets.Internal) && typeof action.delay !== 'number';
+}
 
-export { createInvokeId, evaluateGuard, flatten, getActionType, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, pathsToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };
+export { createInvokeId, evaluateGuard, flatten, getActionType, getEventType, interopSymbols, isActor, isArray, isBehavior, isBuiltInEvent, isFunction, isMachine, isObservable, isPromiseLike, isRaisableAction, isStateLike, isString, keys, mapContext, mapFilterValues, mapValues, matchesState, nestedPath, normalizeTarget, partition, path, pathToStateValue, pathsToStateValue, reportUnhandledExceptionOnInvocation, symbolObservable, toArray, toArrayStrict, toEventObject, toGuard, toInvokeSource, toObserver, toSCXMLEvent, toStatePath, toStatePaths, toStateValue, toTransitionConfigArray, uniqueId, updateContext, updateHistoryStates, updateHistoryValue, warn };

package/lib/State.d.ts

@@ -91,7 +91,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, "machine" | "configuration" | "transitions" | "tags" | "toStrings" | "toJSON" | "matches" | "hasTag" | "can"> & {
+    toJSON(): Omit<this, "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "toJSON" | "matches" | "hasTag" | "can"> & {
         tags: string[];
     };
     /**

package/lib/StateNode.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
 var utils = require('./utils.js');
-var types = require('./types.js');
 var State = require('./State.js');
 var actionTypes = require('./actionTypes.js');
 var actions = require('./actions.js');
@@ -759,7 +758,9 @@ function () {
       };
     }).concat({
       type: 'state_done',
-      actions: doneEvents.map(actions.raise)
+      actions: doneEvents.map(function (event) {
+        return actions.raise(event);
+      })
     });
     var exitActions = Array.from(exitStates).map(function (stateNode) {
       return {
@@ -780,7 +781,7 @@ function () {
       }).map(function (stateNode) {
         return stateNode.onExit;
       })), this.machine.options.actions).filter(function (action) {
-        return action.type !== actionTypes.raise && (action.type !== actionTypes.send || !!action.to && action.to !== types.SpecialTargets.Internal);
+        return !utils.isRaisableAction(action);
       });
       return actions$1.concat({
         type: 'stop',
@@ -917,9 +918,7 @@ function () {
         resolvedActions = _e[0],
         updatedContext = _e[1];
 
-    var _f = _tslib.__read(utils.partition(resolvedActions, function (action) {
-      return action.type === actionTypes.raise || action.type === actionTypes.send && action.to === types.SpecialTargets.Internal;
-    }), 2),
+    var _f = _tslib.__read(utils.partition(resolvedActions, utils.isRaisableAction), 2),
         raisedEvents = _f[0],
         nonRaisedActions = _f[1];
 

package/lib/actions.d.ts

@@ -1,4 +1,4 @@
-import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject, Cast, EventFrom, AnyActorRef, PredictableActionArgumentsExec } from './types';
+import { Action, Event, EventObject, SingleOrArray, SendAction, SendActionOptions, CancelAction, ActionObject, ActionType, Assigner, PropertyAssigner, AssignAction, ActionFunction, ActionFunctionMap, ActivityActionObject, ActionTypes, ActivityDefinition, RaiseAction, RaiseActionObject, DoneEvent, ErrorPlatformEvent, DoneEventObject, SendExpr, SendActionObject, PureAction, LogExpr, LogAction, LogActionObject, DelayFunctionMap, SCXML, ExprWithMeta, ChooseCondition, ChooseAction, AnyEventObject, Expr, StopAction, StopActionObject, Cast, EventFrom, AnyActorRef, PredictableActionArgumentsExec, RaiseActionOptions, NoInfer, BaseActionObject, LowInfer } from './types';
 import * as actionTypes from './actionTypes';
 import { State } from './State';
 import { StateNode } from './StateNode';
@@ -8,7 +8,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, import("./types").BaseActionObject> | undefined) => ActionObject<TContext, TEvent>[];
+export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent, TEvent>> | undefined, actionFunctionMap?: ActionFunctionMap<TContext, TEvent, BaseActionObject> | undefined) => ActionObject<TContext, TEvent, TEvent, BaseActionObject>[];
 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
@@ -16,19 +16,21 @@ export declare function toActivityDefinition<TContext, TEvent extends EventObjec
  *
  * @param eventType The event to raise.
  */
-export declare function raise<TContext, TEvent extends EventObject>(event: Event<TEvent>): RaiseAction<TEvent> | SendAction<TContext, AnyEventObject, TEvent>;
-export declare function resolveRaise<TEvent extends EventObject>(action: RaiseAction<TEvent>): RaiseActionObject<TEvent>;
+export declare function raise<TContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(event: NoInfer<Event<TEvent>> | SendExpr<TContext, TExpressionEvent, TEvent>, options?: RaiseActionOptions<TContext, TExpressionEvent>): RaiseAction<TContext, TExpressionEvent, TEvent>;
+export declare function resolveRaise<TContext, TEvent extends EventObject, TExpressionEvent extends EventObject>(action: RaiseAction<TContext, TExpressionEvent, TEvent>, ctx: TContext, _event: SCXML.Event<TExpressionEvent>, delaysMap?: DelayFunctionMap<TContext, TEvent>): RaiseActionObject<TContext, TExpressionEvent, TEvent>;
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.
  *
+ * @deprecated Use the `sendTo(...)` action creator instead.
+ *
  * @param event The event to send.
  * @param options Options to pass into the send event:
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-export declare function send<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<TSentEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, TSentEvent>;
+export declare function send<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<AnyEventObject> | SendExpr<TContext, TEvent, AnyEventObject>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, TSentEvent>;
 export declare function resolveSend<TContext, TEvent extends EventObject, TSentEvent extends EventObject>(action: SendAction<TContext, TEvent, TSentEvent>, ctx: TContext, _event: SCXML.Event<TEvent>, delaysMap?: DelayFunctionMap<TContext, TEvent>): SendActionObject<TContext, TEvent, TSentEvent>;
 /**
  * Sends an event to this machine's parent.
@@ -36,7 +38,7 @@ export declare function resolveSend<TContext, TEvent extends EventObject, TSentE
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<TSentEvent> | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, TSentEvent>;
+export declare function sendParent<TContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: Event<AnyEventObject> | SendExpr<TContext, TEvent, AnyEventObject>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, TSentEvent>;
 declare type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;
@@ -52,13 +54,11 @@ declare type InferEvent<E extends EventObject> = {
  * @param options Send action options
  * @returns An XState send action object
  */
-export declare function sendTo<TContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: string | TActor | ((ctx: TContext) => TActor), event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, any>;
+export declare function sendTo<TContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: string | TActor | ((ctx: TContext, event: TEvent) => TActor), event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): SendAction<TContext, TEvent, any>;
 /**
  * Sends an update event to this machine's parent.
  */
-export declare function sendUpdate<TContext, TEvent extends EventObject>(): SendAction<TContext, TEvent, {
-    type: ActionTypes.Update;
-}>;
+export declare function sendUpdate<TContext, TEvent extends EventObject>(): SendAction<TContext, TEvent, AnyEventObject>;
 /**
  * Sends an event back to the sender of the original event.
  *
@@ -75,7 +75,7 @@ export declare function respond<TContext, TEvent extends EventObject, TSentEvent
  * @param label The label to give to the logged expression.
  */
 export declare function log<TContext, TEvent extends EventObject>(expr?: string | LogExpr<TContext, TEvent>, label?: string): LogAction<TContext, TEvent>;
-export declare const resolveLog: <TContext, TEvent extends EventObject>(action: LogAction<TContext, TEvent>, ctx: TContext, _event: SCXML.Event<TEvent>) => LogActionObject<TContext, TEvent>;
+export declare const resolveLog: <TContext, TEvent extends EventObject>(action: LogAction<TContext, TEvent, TEvent>, ctx: TContext, _event: SCXML.Event<TEvent>) => LogActionObject<TContext, TEvent>;
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent
@@ -83,7 +83,7 @@ export declare const resolveLog: <TContext, TEvent extends EventObject>(action:
  *
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
-export declare const cancel: (sendId: string | number) => CancelAction;
+export declare const cancel: <TContext, TEvent extends EventObject>(sendId: string | number) => CancelAction<TContext, TEvent, TEvent>;
 /**
  * Starts an activity.
  *
@@ -95,7 +95,7 @@ export declare function start<TContext, TEvent extends EventObject>(activity: st
  *
  * @param actorRef The activity to stop.
  */
-export declare function stop<TContext, TEvent extends EventObject>(actorRef: string | ActivityDefinition<TContext, TEvent> | Expr<TContext, TEvent, string | {
+export declare function stop<TContext, TEvent extends EventObject>(actorRef: string | Expr<TContext, TEvent, string | {
     id: string;
 }>): StopAction<TContext, TEvent>;
 export declare function resolveStop<TContext, TEvent extends EventObject>(action: StopAction<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>): StopActionObject;
@@ -104,7 +104,7 @@ export declare function resolveStop<TContext, TEvent extends EventObject>(action
  *
  * @param assignment An object that represents the partial context to update.
  */
-export declare const assign: <TContext, TEvent extends EventObject = EventObject>(assignment: Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent>) => AssignAction<TContext, TEvent>;
+export declare const assign: <TContext, TExpressionEvent extends EventObject = EventObject, TEvent extends EventObject = TExpressionEvent>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent>) => AssignAction<TContext, TExpressionEvent, TEvent>;
 export declare function isActionObject<TContext, TEvent extends EventObject>(action: Action<TContext, TEvent>): action is ActionObject<TContext, TEvent>;
 /**
  * Returns an event type that represents an implicit event that
@@ -133,7 +133,7 @@ export declare function done(id: string, data?: any): DoneEventObject;
  */
 export declare function doneInvoke(id: string, data?: any): DoneEvent;
 export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
-export declare function pure<TContext, TEvent extends EventObject>(getActions: (context: TContext, event: TEvent) => SingleOrArray<ActionObject<TContext, TEvent> | ActionObject<TContext, TEvent>['type']> | undefined): PureAction<TContext, TEvent>;
+export declare function pure<TContext, TEvent extends EventObject>(getActions: (context: TContext, event: TEvent) => SingleOrArray<BaseActionObject | BaseActionObject['type'] | ActionObject<TContext, TEvent>> | undefined): PureAction<TContext, TEvent>;
 /**
  * Forwards (sends) an event to a specified service.
  *