xstate 4.10.0 → 4.14.0

package/es/actions.d.ts

@@ -1,14 +1,15 @@
-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, ChooseConditon, ChooseAction, AnyEventObject } 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, ChooseConditon, ChooseAction, AnyEventObject, Expr } from './types';
 import * as actionTypes from './actionTypes';
 import { State } from './State';
 import { StateNode } from './StateNode';
+import { StopAction, StopActionObject } from '.';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
     type: ActionTypes;
 }>;
 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?: string | RaiseAction<AnyEventObject> | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | AssignAction<Required<TContext>, TEvent> | SendAction<TContext, TEvent, AnyEventObject> | ChooseAction<TContext, TEvent> | Action<TContext, TEvent>[] | undefined, actionFunctionMap?: Record<string, ActionFunction<TContext, TEvent> | ActionObject<TContext, TEvent>> | undefined) => ActionObject<TContext, TEvent>[];
+export declare const toActionObjects: <TContext, TEvent extends EventObject>(action?: string | ActionObject<TContext, TEvent> | ActionFunction<TContext, TEvent> | Action<TContext, TEvent>[] | undefined, actionFunctionMap?: Record<string, ActionObject<TContext, TEvent> | ActionFunction<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
@@ -16,7 +17,7 @@ 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, TEvent, TEvent>;
+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>;
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
@@ -77,9 +78,12 @@ export declare function start<TContext, TEvent extends EventObject>(activity: st
 /**
  * Stops an activity.
  *
- * @param activity The activity to stop.
+ * @param actorRef The activity to stop.
  */
-export declare function stop<TContext, TEvent extends EventObject>(activity: string | ActivityDefinition<TContext, TEvent>): ActivityActionObject<TContext, TEvent>;
+export declare function stop<TContext, TEvent extends EventObject>(actorRef: string | ActivityDefinition<TContext, TEvent> | 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;
 /**
  * Updates the current context of the machine.
  *

package/es/actions.js

@@ -1,8 +1,8 @@
-import { __assign, __read, __rest } from './_virtual/_tslib.js';
+import { __assign, __read } from './_virtual/_tslib.js';
 import { IS_PRODUCTION } from './environment.js';
 import { toSCXMLEvent, isFunction, toEventObject, getEventType, isString, partition, updateContext, flatten, toArray, toGuard, evaluateGuard, warn, isArray } from './utils.js';
 import { SpecialTargets, ActionTypes } from './types.js';
-import { send as send$1, update, assign as assign$1, init, raise as raise$1, log as log$1, cancel as cancel$1, error as error$1, pure as pure$1, choose as choose$1 } from './actionTypes.js';
+import { send as send$1, update, assign as assign$1, init, raise as raise$1, log as log$1, cancel as cancel$1, error as error$1, stop as stop$1, pure as pure$1, choose as choose$1 } from './actionTypes.js';
 var initEvent = /*#__PURE__*/toSCXMLEvent({
   type: init
 });
@@ -44,12 +44,10 @@ function toActionObject(action, actionFunctionMap) {
         exec: exec
       });
     } else if (exec) {
-      var type = action.type,
-          other = __rest(action, ["type"]);
-
-      actionObject = __assign(__assign({
-        type: type
-      }, exec), other);
+      var actionType = exec.type || action.type;
+      actionObject = __assign(__assign(__assign({}, exec), action), {
+        type: actionType
+      });
     } else {
       actionObject = action;
     }
@@ -262,18 +260,30 @@ function start(activity) {
 /**
  * Stops an activity.
  *
- * @param activity The activity to stop.
+ * @param actorRef The activity to stop.
  */
 
 
-function stop(activity) {
-  var activityDef = toActivityDefinition(activity);
+function stop(actorRef) {
+  var activity = isFunction(actorRef) ? actorRef : toActivityDefinition(actorRef);
   return {
     type: ActionTypes.Stop,
-    activity: activityDef,
+    activity: activity,
     exec: undefined
   };
 }
+
+function resolveStop(action, context, _event) {
+  var actorRefOrString = isFunction(action.activity) ? action.activity(context, _event.data) : action.activity;
+  var resolvedActorRef = typeof actorRefOrString === 'string' ? {
+    id: actorRefOrString
+  } : actorRefOrString;
+  var actionObject = {
+    type: ActionTypes.Stop,
+    activity: resolvedActorRef
+  };
+  return actionObject;
+}
 /**
  * Updates the current context of the machine.
  *
@@ -468,6 +478,11 @@ function resolveActions(machine, currentState, currentContext, _event, actions)
           return resolved[0];
         }
 
+      case stop$1:
+        {
+          return resolveStop(actionObject, updatedContext, _event);
+        }
+
       default:
         return toActionObject(actionObject, machine.options.actions);
     }
@@ -475,4 +490,4 @@ function resolveActions(machine, currentState, currentContext, _event, actions)
   return [resolvedActions, updatedContext];
 }
 
-export { after, assign, cancel, choose, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, log, pure, raise, resolveActions, resolveLog, resolveRaise, resolveSend, respond, send, sendParent, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };
+export { after, assign, cancel, choose, done, doneInvoke, error, escalate, forwardTo, getActionFunction, initEvent, log, pure, raise, resolveActions, resolveLog, resolveRaise, resolveSend, resolveStop, respond, send, sendParent, sendUpdate, start, stop, toActionObject, toActionObjects, toActivityDefinition };

package/es/index.d.ts

@@ -5,7 +5,7 @@ import { State } from './State';
 import { Machine, createMachine } from './Machine';
 import { Actor } from './Actor';
 import { raise, send, sendParent, sendUpdate, log, start, stop, assign, after, done, respond, doneInvoke, forwardTo, escalate, choose, pure } from './actions';
-import { interpret, Interpreter, spawn } from './interpreter';
+import { interpret, Interpreter, spawn, InterpreterStatus } from './interpreter';
 import { matchState } from './match';
 declare const actions: {
     raise: typeof raise;
@@ -25,6 +25,6 @@ declare const actions: {
     choose: typeof choose;
     pure: typeof pure;
 };
-export { Actor, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, matchState, spawn, doneInvoke, createMachine };
+export { Actor, Machine, StateNode, State, matchesState, mapState, actions, assign, send, sendParent, sendUpdate, forwardTo, interpret, Interpreter, InterpreterStatus, matchState, spawn, doneInvoke, createMachine };
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/es/index.js

@@ -6,7 +6,7 @@ export { assign, doneInvoke, forwardTo, send, sendParent, sendUpdate } from './a
 export { State } from './State.js';
 export { StateNode } from './StateNode.js';
 export { Machine, createMachine } from './Machine.js';
-export { Interpreter, interpret, spawn } from './interpreter.js';
+export { Interpreter, InterpreterStatus, interpret, spawn } from './interpreter.js';
 export { matchState } from './match.js';
 var actions = {
   raise: raise,

package/es/interpreter.d.ts

@@ -1,7 +1,10 @@
-import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, DoneEvent, Unsubscribable, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate } from './types';
+import { StateMachine, Event, EventObject, DefaultContext, StateSchema, StateValue, InterpreterOptions, SingleOrArray, DoneEvent, Unsubscribable, MachineOptions, SCXML, EventData, Observer, Spawnable, Typestate } from './types';
 import { State } from './State';
 import { Actor } from './Actor';
-export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = any> = (state: State<TContext, TEvent, TStateSchema, TTypestate>, event: TEvent) => void;
+export declare type StateListener<TContext, TEvent extends EventObject, TStateSchema extends StateSchema<TContext> = any, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}> = (state: State<TContext, TEvent, TStateSchema, TTypestate>, event: TEvent) => void;
 export declare type ContextListener<TContext = DefaultContext> = (context: TContext, prevContext: TContext | undefined) => void;
 export declare type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export declare type Listener = () => void;
@@ -14,7 +17,15 @@ interface SpawnOptions {
     autoForward?: boolean;
     sync?: boolean;
 }
-export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = any> implements Actor<State<TContext, TEvent, TStateSchema, TTypestate>, TEvent> {
+export declare enum InterpreterStatus {
+    NotStarted = 0,
+    Running = 1,
+    Stopped = 2
+}
+export declare class Interpreter<TContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}> implements Actor<State<TContext, TEvent, TStateSchema, TTypestate>, TEvent> {
     machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * The default interpreter options:
@@ -46,7 +57,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * Whether the service is started.
      */
     initialized: boolean;
-    private _status;
+    status: InterpreterStatus;
     parent?: Interpreter<any>;
     id: string;
     /**
@@ -81,36 +92,36 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      * Adds an event listener that is notified whenever an event is sent to the running interpreter.
      * @param listener The event listener
      */
-    onEvent(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent>;
+    onEvent(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds an event listener that is notified whenever a `send` event occurs.
      * @param listener The event listener
      */
-    onSend(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent>;
+    onSend(listener: EventListener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds a context listener that is notified whenever the state context changes.
      * @param listener The context listener
      */
-    onChange(listener: ContextListener<TContext>): Interpreter<TContext, TStateSchema, TEvent>;
+    onChange(listener: ContextListener<TContext>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds a listener that is notified when the machine is stopped.
      * @param listener The listener
      */
-    onStop(listener: Listener): Interpreter<TContext, TStateSchema, TEvent>;
+    onStop(listener: Listener): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Adds a state listener that is notified when the statechart has reached its final state.
      * @param listener The state listener
      */
-    onDone(listener: EventListener<DoneEvent>): Interpreter<TContext, TStateSchema, TEvent>;
+    onDone(listener: EventListener<DoneEvent>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Removes a listener.
      * @param listener The listener to remove
      */
-    off(listener: (...args: any[]) => void): Interpreter<TContext, TStateSchema, TEvent>;
+    off(listener: (...args: any[]) => void): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Alias for Interpreter.prototype.start
      */
-    init: (initialState?: string | State<TContext, TEvent, TStateSchema, TTypestate> | import("./types").StateValueMap | undefined) => Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+    init: (initialState?: string | import("./types").StateValueMap | State<TContext, TEvent, TStateSchema, TTypestate> | undefined) => Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Starts the interpreter from the given state, or the initial state.
      * @param initialState The state to start the statechart from
@@ -121,7 +132,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * This will also notify the `onStop` listeners.
      */
-    stop(): Interpreter<TContext, TStateSchema, TEvent>;
+    stop(): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
     /**
      * Sends an event to the running interpreter to trigger a transition.
      *
@@ -131,7 +142,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
      *
      * @param event The event(s) to send
      */
-    send: (event: TEvent | TEvent["type"] | Event<TEvent>[] | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate>;
+    send: (event: SingleOrArray<Event<TEvent>> | SCXML.Event<TEvent>, payload?: EventData | undefined) => State<TContext, TEvent, TStateSchema, TTypestate>;
     private batch;
     /**
      * Returns a send function bound to this interpreter instance.
@@ -171,7 +182,7 @@ export declare class Interpreter<TContext, TStateSchema extends StateSchema = an
         id: string;
     };
 }
-export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE>, nameOrOptions?: string | SpawnOptions): Interpreter<TC, any, TE>;
+export declare function spawn<TC, TE extends EventObject>(entity: StateMachine<TC, any, TE>, nameOrOptions?: string | SpawnOptions): Actor<State<TC, TE>, TE>;
 export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnOptions): Actor;
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
@@ -179,6 +190,9 @@ export declare function spawn(entity: Spawnable, nameOrOptions?: string | SpawnO
  * @param machine The machine to interpret
  * @param options Interpreter options
  */
-export declare function interpret<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = any>(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
+export declare function interpret<TContext = DefaultContext, TStateSchema extends StateSchema = any, TEvent extends EventObject = EventObject, TTypestate extends Typestate<TContext> = {
+    value: any;
+    context: TContext;
+}>(machine: StateMachine<TContext, TStateSchema, TEvent, TTypestate>, options?: Partial<InterpreterOptions>): Interpreter<TContext, TStateSchema, TEvent, TTypestate>;
 export {};
 //# sourceMappingURL=interpreter.d.ts.map