xstate 4.35.4 → 4.36.0

package/lib/actions.js

@@ -83,28 +83,40 @@ function toActivityDefinition(action) {
  * @param eventType The event to raise.
  */
 
-function raise(event) {
-  if (!utils.isString(event)) {
-    return send(event, {
-      to: types.SpecialTargets.Internal
-    });
-  }
-
+function raise(event, options) {
   return {
     type: actionTypes.raise,
-    event: event
+    event: typeof event === 'function' ? event : utils.toEventObject(event),
+    delay: options ? options.delay : undefined,
+    id: options === null || options === void 0 ? void 0 : options.id
   };
 }
-function resolveRaise(action) {
-  return {
-    type: actionTypes.raise,
-    _event: utils.toSCXMLEvent(action.event)
+function resolveRaise(action, ctx, _event, delaysMap) {
+  var meta = {
+    _event: _event
   };
+  var resolvedEvent = utils.toSCXMLEvent(utils.isFunction(action.event) ? action.event(ctx, _event.data, meta) : action.event);
+  var resolvedDelay;
+
+  if (utils.isString(action.delay)) {
+    var configDelay = delaysMap && delaysMap[action.delay];
+    resolvedDelay = utils.isFunction(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
+  } else {
+    resolvedDelay = utils.isFunction(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
+  }
+
+  return _tslib.__assign(_tslib.__assign({}, action), {
+    type: actionTypes.raise,
+    _event: resolvedEvent,
+    delay: resolvedDelay
+  });
 }
 /**
  * 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()`).
@@ -118,6 +130,8 @@ function send(event, options) {
     type: actionTypes.send,
     event: utils.isFunction(event) ? event : utils.toEventObject(event),
     delay: options ? options.delay : undefined,
+    // TODO: don't auto-generate IDs here like that
+    // there is too big chance of the ID collision
     id: options && options.id !== undefined ? options.id : utils.isFunction(event) ? event.name : utils.getEventType(event)
   };
 }
@@ -480,23 +494,30 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
     switch (actionObject.type) {
       case actionTypes.raise:
         {
-          return resolveRaise(actionObject);
+          var raisedAction = resolveRaise(actionObject, updatedContext, _event, machine.options.delays);
+
+          if (predictableExec && typeof raisedAction.delay === 'number') {
+            predictableExec(raisedAction, updatedContext, _event);
+          }
+
+          return raisedAction;
         }
 
       case actionTypes.send:
         var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init
 
         if (!environment.IS_PRODUCTION) {
-          // warn after resolving as we can create better contextual message here
-          utils.warn(!utils.isString(actionObject.delay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
-          "No delay reference for delay expression '".concat(actionObject.delay, "' was found on machine '").concat(machine.id, "'"));
+          var configuredDelay = actionObject.delay; // warn after resolving as we can create better contextual message here
+
+          utils.warn(!utils.isString(configuredDelay) || typeof sendAction.delay === 'number', // tslint:disable-next-line:max-line-length
+          "No delay reference for delay expression '".concat(configuredDelay, "' was found on machine '").concat(machine.id, "'"));
         }
 
         if (predictableExec && sendAction.to !== types.SpecialTargets.Internal) {
           if (blockType === 'entry') {
             deferredToBlockEnd.push(sendAction);
           } else {
-            predictableExec === null || predictableExec === void 0 ? void 0 : predictableExec(sendAction, updatedContext, _event);
+            predictableExec(sendAction, updatedContext, _event);
           }
         }
 
@@ -575,7 +596,8 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
           predictableExec(resolvedActionObject, updatedContext, _event);
         } else if (exec_1 && preservedContexts) {
           var contextIndex_1 = preservedContexts.length - 1;
-          resolvedActionObject = _tslib.__assign(_tslib.__assign({}, resolvedActionObject), {
+
+          var wrapped = _tslib.__assign(_tslib.__assign({}, resolvedActionObject), {
             exec: function (_ctx) {
               var args = [];
 
@@ -586,6 +608,8 @@ function resolveActions(machine, currentState, currentContext, _event, actionBlo
               exec_1.apply(void 0, _tslib.__spreadArray([preservedContexts[contextIndex_1]], _tslib.__read(args), false));
             }
           });
+
+          resolvedActionObject = wrapped;
         }
 
         return resolvedActionObject;

package/lib/index.d.ts

@@ -13,7 +13,7 @@ export * from './typegenTypes';
 export * from './types';
 export { matchesState, toEventObject, toObserver, toSCXMLEvent } from './utils';
 export { Actor, toActorRef, Machine, StateNode, State, mapState, actions, assign, send, sendTo, sendParent, sendUpdate, raise, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine, createSchema, t };
-declare const assign: <TContext, TEvent extends import("./types").EventObject = import("./types").EventObject>(assignment: import("./types").Assigner<TContext, TEvent> | import("./types").PropertyAssigner<TContext, TEvent>) => import("./types").AssignAction<TContext, TEvent>, send: typeof actions.send, sendTo: typeof actions.sendTo, sendParent: typeof actions.sendParent, sendUpdate: typeof actions.sendUpdate, forwardTo: typeof actions.forwardTo, doneInvoke: typeof actions.doneInvoke, raise: typeof actions.raise;
+declare const assign: <TContext, TExpressionEvent extends import("./types").EventObject = import("./types").EventObject, TEvent extends import("./types").EventObject = TExpressionEvent>(assignment: import("./types").Assigner<import("./types").LowInfer<TContext>, TExpressionEvent> | import("./types").PropertyAssigner<import("./types").LowInfer<TContext>, TExpressionEvent>) => import("./types").AssignAction<TContext, TExpressionEvent, TEvent>, send: typeof actions.send, sendTo: typeof actions.sendTo, sendParent: typeof actions.sendParent, sendUpdate: typeof actions.sendUpdate, forwardTo: typeof actions.forwardTo, doneInvoke: typeof actions.doneInvoke, raise: typeof actions.raise;
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/lib/interpreter.d.ts

@@ -75,6 +75,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
     private forwardTo;
     private _outgoingQueue;
     private devTools?;
+    private _doneEvent?;
     /**
      * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
      *

package/lib/interpreter.js

@@ -116,7 +116,7 @@ function () {
 
     this.sendTo = function (event, to, immediate) {
       var isParent = _this.parent && (to === types.SpecialTargets.Parent || _this.parent.id === to);
-      var target = isParent ? _this.parent : utils.isString(to) ? _this.children.get(to) || registry.registry.get(to) : utils.isActor(to) ? to : undefined;
+      var target = isParent ? _this.parent : utils.isString(to) ? to === types.SpecialTargets.Internal ? _this : _this.children.get(to) || registry.registry.get(to) : utils.isActor(to) ? to : undefined;
 
       if (!target) {
         if (!isParent) {
@@ -189,6 +189,16 @@ function () {
       }
 
       switch (action.type) {
+        case actionTypes.raise:
+          {
+            // if raise action reached the interpreter then it's a delayed one
+            var sendAction_1 = action;
+
+            _this.defer(sendAction_1);
+
+            break;
+          }
+
         case actionTypes.send:
           var sendAction = action;
 
@@ -292,8 +302,9 @@ function () {
           }
 
         case actionTypes.log:
-          var label = action.label,
-              value = action.value;
+          var _a = action,
+              label = _a.label,
+              value = _a.value;
 
           if (label) {
             _this.logger(label, value);
@@ -479,11 +490,12 @@ function () {
         return sn.type === 'final' && sn.parent === _this.machine;
       });
       var doneData = finalChildStateNode && finalChildStateNode.doneData ? utils.mapContext(finalChildStateNode.doneData, state.context, _event) : undefined;
+      this._doneEvent = actions.doneInvoke(this.id, doneData);
 
       try {
         for (var _l = _tslib.__values(this.doneListeners), _m = _l.next(); !_m.done; _m = _l.next()) {
           var listener = _m.value;
-          listener(actions.doneInvoke(this.id, doneData));
+          listener(this._doneEvent);
         }
       } catch (e_5_1) {
         e_5 = {
@@ -605,7 +617,12 @@ function () {
 
 
   Interpreter.prototype.onDone = function (listener) {
-    this.doneListeners.add(listener);
+    if (this.status === exports.InterpreterStatus.Stopped && this._doneEvent) {
+      listener(this._doneEvent);
+    } else {
+      this.doneListeners.add(listener);
+    }
+
     return this;
   };
   /**
@@ -822,7 +839,7 @@ function () {
           historyValue: undefined,
           history: _this.state,
           actions: resolvedActions.filter(function (action) {
-            return action.type !== actionTypes.raise && (action.type !== actionTypes.send || !!action.to && action.to !== types.SpecialTargets.Internal);
+            return !utils.isRaisableAction(action);
           }),
           activities: {},
           events: [],
@@ -983,13 +1000,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/lib/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/lib/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/lib/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/lib/utils.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('./_virtual/_tslib.js');
+var types = require('./types.js');
+var actionTypes = require('./actionTypes.js');
 var constants = require('./constants.js');
 var environment = require('./environment.js');
 
@@ -622,6 +624,9 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
 function createInvokeId(stateNodeId, index) {
   return "".concat(stateNodeId, ":invocation[").concat(index, "]");
 }
+function isRaisableAction(action) {
+  return (action.type === actionTypes.raise || action.type === actionTypes.send && action.to === types.SpecialTargets.Internal) && typeof action.delay !== 'number';
+}
 
 exports.createInvokeId = createInvokeId;
 exports.evaluateGuard = evaluateGuard;
@@ -637,6 +642,7 @@ exports.isFunction = isFunction;
 exports.isMachine = isMachine;
 exports.isObservable = isObservable;
 exports.isPromiseLike = isPromiseLike;
+exports.isRaisableAction = isRaisableAction;
 exports.isStateLike = isStateLike;
 exports.isString = isString;
 exports.keys = keys;

package/package.json

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

package/es/each.d.ts

@@ -1,4 +0,0 @@
-import { EventObject, SingleOrArray, ActionObject } from './types';
-export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
-export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, index: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
-//# sourceMappingURL=each.d.ts.map

package/es/each.js

@@ -1,13 +0,0 @@
-function each(collection, item, indexOrActions, maybeActions) {
-  var actions = maybeActions || indexOrActions;
-  var index = maybeActions ? indexOrActions : undefined;
-  return {
-    type: 'xstate.foreach',
-    collection: collection,
-    item: item,
-    index: index,
-    actions: actions
-  };
-}
-
-export { each };

package/lib/each.d.ts

@@ -1,4 +0,0 @@
-import { EventObject, SingleOrArray, ActionObject } from './types';
-export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
-export declare function each<TContext, TEvent extends EventObject>(collection: keyof TContext, item: keyof TContext, index: keyof TContext, actions: SingleOrArray<ActionObject<TContext, TEvent>>): ActionObject<TContext, TEvent>;
-//# sourceMappingURL=each.d.ts.map

package/lib/each.js

@@ -1,17 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function each(collection, item, indexOrActions, maybeActions) {
-  var actions = maybeActions || indexOrActions;
-  var index = maybeActions ? indexOrActions : undefined;
-  return {
-    type: 'xstate.foreach',
-    collection: collection,
-    item: item,
-    index: index,
-    actions: actions
-  };
-}
-
-exports.each = each;