xstate 5.18.2 → 5.19.1

package/dist/{raise-0f7cf128.esm.js → raise-c17ec2bc.esm.js}

@@ -154,7 +154,7 @@ function toStatePath(stateId) {
   if (isArray(stateId)) {
     return stateId;
   }
-  let result = [];
+  const result = [];
   let segment = '';
   for (let i = 0; i < stateId.length; i++) {
     const char = stateId.charCodeAt(i);
@@ -419,6 +419,7 @@ function createSystem(rootActor, options) {
   return system;
 }
 
+let executingCustomAction = false;
 const $$ACTOR_TYPE = 1;
 
 // those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
@@ -539,10 +540,37 @@ class Actor {
         if (!listeners && !wildcardListener) {
           return;
         }
-        const allListeners = new Set([...(listeners ? listeners.values() : []), ...(wildcardListener ? wildcardListener.values() : [])]);
-        for (const handler of Array.from(allListeners)) {
+        const allListeners = [...(listeners ? listeners.values() : []), ...(wildcardListener ? wildcardListener.values() : [])];
+        for (const handler of allListeners) {
           handler(emittedEvent);
         }
+      },
+      actionExecutor: action => {
+        const exec = () => {
+          this._actorScope.system._sendInspectionEvent({
+            type: '@xstate.action',
+            actorRef: this,
+            action: {
+              type: action.type,
+              params: action.params
+            }
+          });
+          if (!action.exec) {
+            return;
+          }
+          const saveExecutingCustomAction = executingCustomAction;
+          try {
+            executingCustomAction = true;
+            action.exec(action.info, action.params);
+          } finally {
+            executingCustomAction = saveExecutingCustomAction;
+          }
+        };
+        if (this._processingStatus === ProcessingStatus.Running) {
+          exec();
+        } else {
+          this._deferred.push(exec);
+        }
       }
     };
 
@@ -1071,11 +1099,13 @@ function resolveCancel(_, snapshot, actionArgs, actionParams, {
   sendId
 }) {
   const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs, actionParams) : sendId;
-  return [snapshot, resolvedSendId];
+  return [snapshot, {
+    sendId: resolvedSendId
+  }, undefined];
 }
-function executeCancel(actorScope, resolvedSendId) {
+function executeCancel(actorScope, params) {
   actorScope.defer(() => {
-    actorScope.system.scheduler.cancel(actorScope.self, resolvedSendId);
+    actorScope.system.scheduler.cancel(actorScope.self, params.sendId);
   });
 }
 /**
@@ -1111,7 +1141,7 @@ function executeCancel(actorScope, resolvedSendId) {
  * @param sendId The `id` of the `sendTo(...)` action to cancel.
  */
 function cancel(sendId) {
-  function cancel(args, params) {
+  function cancel(_args, _params) {
   }
   cancel.type = 'xstate.cancel';
   cancel.sendId = sendId;
@@ -1130,18 +1160,20 @@ function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
   const logic = typeof src === 'string' ? resolveReferencedActor(snapshot.machine, src) : src;
   const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
+  let resolvedInput = undefined;
   if (logic) {
+    resolvedInput = typeof input === 'function' ? input({
+      context: snapshot.context,
+      event: actionArgs.event,
+      self: actorScope.self
+    }) : input;
     actorRef = createActor(logic, {
       id: resolvedId,
       src,
       parent: actorScope.self,
       syncSnapshot,
       systemId,
-      input: typeof input === 'function' ? input({
-        context: snapshot.context,
-        event: actionArgs.event,
-        self: actorScope.self
-      }) : input
+      input: resolvedInput
     });
   }
   return [cloneMachineSnapshot(snapshot, {
@@ -1151,11 +1183,13 @@ function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
     }
   }), {
     id,
-    actorRef
-  }];
+    systemId,
+    actorRef,
+    src,
+    input: resolvedInput
+  }, undefined];
 }
 function executeSpawn(actorScope, {
-  id,
   actorRef
 }) {
   if (!actorRef) {
@@ -1174,9 +1208,9 @@ function spawnChild(...[src, {
   input,
   syncSnapshot = false
 } = {}]) {
-  function spawnChild(args, params) {
+  function spawnChild(_args, _params) {
   }
-  spawnChild.type = 'snapshot.spawnChild';
+  spawnChild.type = 'xstate.spawnChild';
   spawnChild.id = id;
   spawnChild.systemId = systemId;
   spawnChild.src = src;
@@ -1201,7 +1235,7 @@ function resolveStop(_, snapshot, args, actionParams, {
   }
   return [cloneMachineSnapshot(snapshot, {
     children
-  }), resolvedActorRef];
+  }), resolvedActorRef, undefined];
 }
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
@@ -1233,7 +1267,7 @@ function executeStop(actorScope, actorRef) {
  * @param actorRef The actor to stop.
  */
 function stopChild(actorRef) {
-  function stop(args, params) {
+  function stop(_args, _params) {
   }
   stop.type = 'xstate.stopChild';
   stop.actorRef = actorRef;
@@ -1260,7 +1294,7 @@ function checkStateIn(snapshot, _, {
   return snapshot.matches(stateValue);
 }
 function stateIn(stateValue) {
-  function stateIn(args, params) {
+  function stateIn() {
     return false;
   }
   stateIn.check = checkStateIn;
@@ -1306,7 +1340,7 @@ function checkNot(snapshot, {
  * @returns A guard
  */
 function not(guard) {
-  function not(args, params) {
+  function not(_args, _params) {
     return false;
   }
   not.check = checkNot;
@@ -1352,7 +1386,7 @@ function checkAnd(snapshot, {
  * @returns A guard action object
  */
 function and(guards) {
-  function and(args, params) {
+  function and(_args, _params) {
     return false;
   }
   and.check = checkAnd;
@@ -1398,7 +1432,7 @@ function checkOr(snapshot, {
  * @returns A guard action object
  */
 function or(guards) {
-  function or(args, params) {
+  function or(_args, _params) {
     return false;
   }
   or.check = checkOr;
@@ -1576,7 +1610,7 @@ function getDelayedTransitions(stateNode) {
   if (!afterConfig) {
     return [];
   }
-  const mutateEntryExit = (delay, i) => {
+  const mutateEntryExit = delay => {
     const afterEvent = createAfterEvent(delay, stateNode.id);
     const eventType = afterEvent.type;
     stateNode.entry.push(raise(afterEvent, {
@@ -1586,7 +1620,7 @@ function getDelayedTransitions(stateNode) {
     stateNode.exit.push(cancel(eventType));
     return eventType;
   };
-  const delayedTransitions = Object.keys(afterConfig).flatMap((delay, i) => {
+  const delayedTransitions = Object.keys(afterConfig).flatMap(delay => {
     const configTransition = afterConfig[delay];
     const resolvedTransition = typeof configTransition === 'string' ? {
       target: configTransition
@@ -1671,7 +1705,9 @@ function formatTransitions(stateNode) {
 function formatInitialTransition(stateNode, _target) {
   const resolvedTarget = typeof _target === 'string' ? stateNode.states[_target] : _target ? stateNode.states[_target.target] : undefined;
   if (!resolvedTarget && _target) {
-    throw new Error(`Initial state node "${_target}" not found on parent state node #${stateNode.id}`);
+    throw new Error(
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-base-to-string
+    `Initial state node "${_target}" not found on parent state node #${stateNode.id}`);
   }
   const transition = {
     source: stateNode,
@@ -1781,7 +1817,7 @@ function getStateNodeByPath(stateNode, statePath) {
   if (typeof statePath === 'string' && isStateId(statePath)) {
     try {
       return stateNode.machine.getStateNodeById(statePath);
-    } catch (e) {
+    } catch {
       // try individual paths
       // throw e;
     }
@@ -2010,18 +2046,20 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
 
   // Exit states
   if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue);
+    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue);
+  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue, undefined);
 
   // Enter states
   nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
   const nextStateNodes = [...mutStateNodeSet];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue, undefined);
   }
+
+  // eslint-disable-next-line no-useless-catch
   try {
     if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) {
       return nextState;
@@ -2191,7 +2229,7 @@ function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultE
 function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
   addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
 }
-function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue) {
+function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue, _actionExecutor) {
   let nextSnapshot = currentSnapshot;
   const statesToExit = computeExitSet(transitions, mutStateNodeSet, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
@@ -2215,12 +2253,14 @@ function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNod
     }
   }
   for (const s of statesToExit) {
-    nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, [...s.exit, ...s.invoke.map(def => stopChild(def.id))], internalQueue);
+    nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, [...s.exit, ...s.invoke.map(def => stopChild(def.id))], internalQueue, undefined);
     mutStateNodeSet.delete(s);
   }
   return [nextSnapshot, changedHistory || historyValue];
 }
-let executingCustomAction = false;
+function getAction(machine, actionType) {
+  return machine.implementations.actions[actionType];
+}
 function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, extra, retries) {
   const {
     machine
@@ -2232,10 +2272,8 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
     // the existing type of `.actions` assumes non-nullable `TExpressionAction`
     // it's fine to cast this here to get a common type and lack of errors in the rest of the code
     // our logic below makes sure that we call those 2 "variants" correctly
-    machine.implementations.actions[typeof action === 'string' ? action : action.type];
-    if (!resolvedAction) {
-      continue;
-    }
+
+    getAction(machine, typeof action === 'string' ? action : action.type);
     const actionArgs = {
       context: intermediateSnapshot.context,
       event,
@@ -2246,30 +2284,13 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
       context: intermediateSnapshot.context,
       event
     }) : action.params : undefined;
-    function executeAction() {
-      actorScope.system._sendInspectionEvent({
-        type: '@xstate.action',
-        actorRef: actorScope.self,
-        action: {
-          type: typeof action === 'string' ? action : typeof action === 'object' ? action.type : action.name || '(anonymous)',
-          params: actionParams
-        }
+    if (!resolvedAction || !('resolve' in resolvedAction)) {
+      actorScope.actionExecutor({
+        type: typeof action === 'string' ? action : typeof action === 'object' ? action.type : action.name || '(anonymous)',
+        info: actionArgs,
+        params: actionParams,
+        exec: resolvedAction
       });
-      try {
-        executingCustomAction = resolvedAction;
-        resolvedAction(actionArgs, actionParams);
-      } finally {
-        executingCustomAction = false;
-      }
-    }
-    if (!('resolve' in resolvedAction)) {
-      if (actorScope.self._processingStatus === ProcessingStatus.Running) {
-        executeAction();
-      } else {
-        actorScope.defer(() => {
-          executeAction();
-        });
-      }
       continue;
     }
     const builtinAction = resolvedAction;
@@ -2281,11 +2302,12 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
       retries?.push([builtinAction, params]);
     }
     if ('execute' in builtinAction) {
-      if (actorScope.self._processingStatus === ProcessingStatus.Running) {
-        builtinAction.execute(actorScope, params);
-      } else {
-        actorScope.defer(builtinAction.execute.bind(null, actorScope, params));
-      }
+      actorScope.actionExecutor({
+        type: builtinAction.type,
+        info: actionArgs,
+        params,
+        exec: builtinAction.execute.bind(null, actorScope, params)
+      });
     }
     if (actions) {
       intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions, extra, retries);
@@ -2304,7 +2326,7 @@ function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, i
   });
   return nextState;
 }
-function macrostep(snapshot, event, actorScope, internalQueue = []) {
+function macrostep(snapshot, event, actorScope, internalQueue) {
   let nextSnapshot = snapshot;
   const microstates = [];
   function addMicrostate(microstate, event, transitions) {
@@ -2383,7 +2405,7 @@ function macrostep(snapshot, event, actorScope, internalQueue = []) {
   };
 }
 function stopChildren(nextState, event, actorScope) {
-  return resolveActionsAndContext(nextState, event, actorScope, Object.values(nextState.children).map(child => stopChild(child)), []);
+  return resolveActionsAndContext(nextState, event, actorScope, Object.values(nextState.children).map(child => stopChild(child)), [], undefined);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -2550,7 +2572,9 @@ function resolveRaise(_, snapshot, args, actionParams, {
 }) {
   const delaysMap = snapshot.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
-    throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
+    throw new Error(
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    `Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
   }
   const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
   let resolvedDelay;
@@ -2567,7 +2591,7 @@ function resolveRaise(_, snapshot, args, actionParams, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay
-  }];
+  }, undefined];
 }
 function executeRaise(actorScope, params) {
   const {
@@ -2590,7 +2614,7 @@ function executeRaise(actorScope, params) {
  * @param eventType The event to raise.
  */
 function raise(eventOrExpr, options) {
-  function raise(args, params) {
+  function raise(_args, _params) {
   }
   raise.type = 'xstate.raise';
   raise.event = eventOrExpr;

package/dist/xstate.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var guards_dist_xstateGuards = require('./raise-b1e0b9a9.cjs.js');
-var log = require('./log-98fcce74.cjs.js');
+var guards_dist_xstateGuards = require('./raise-60cebf03.cjs.js');
+var log = require('./log-a019fbd0.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 /**
@@ -224,10 +224,10 @@ class StateNode {
         systemId
       } = invokeConfig;
       const resolvedId = invokeConfig.id ?? guards_dist_xstateGuards.createInvokeId(this.id, i);
-      const resolvedSrc = typeof src === 'string' ? src : `xstate.invoke.${guards_dist_xstateGuards.createInvokeId(this.id, i)}`;
+      const sourceName = typeof src === 'string' ? src : `xstate.invoke.${guards_dist_xstateGuards.createInvokeId(this.id, i)}`;
       return {
         ...invokeConfig,
-        src: resolvedSrc,
+        src: sourceName,
         id: resolvedId,
         systemId: systemId,
         toJSON() {
@@ -239,7 +239,7 @@ class StateNode {
           return {
             ...invokeDefValues,
             type: 'xstate.invoke',
-            src: resolvedSrc,
+            src: sourceName,
             id: resolvedId
           };
         }
@@ -422,7 +422,7 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope).snapshot;
+    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope, []).snapshot;
   }
 
   /**
@@ -433,7 +433,7 @@ class StateMachine {
    * @param event The received event
    */
   microstep(snapshot, event, actorScope) {
-    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope).microstates;
+    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope, []).microstates;
   }
   getTransitionData(snapshot, event) {
     return guards_dist_xstateGuards.transitionNode(this.root, snapshot.value, snapshot, event) || [];
@@ -463,7 +463,7 @@ class StateMachine {
         input: event.input,
         self
       });
-      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorScope, [log.assign(assignment)], internalQueue);
+      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorScope, [log.assign(assignment)], internalQueue, undefined);
     }
     return preInitial;
   }
@@ -541,13 +541,13 @@ class StateMachine {
       children,
       _nodes: Array.from(guards_dist_xstateGuards.getAllStateNodes(guards_dist_xstateGuards.getStateNodes(this.root, snapshot.value)))
     }, this);
-    let seen = new Set();
+    const seen = new Set();
     function reviveContext(contextPart, children) {
       if (seen.has(contextPart)) {
         return;
       }
       seen.add(contextPart);
-      for (let key in contextPart) {
+      for (const key in contextPart) {
         const value = contextPart[key];
         if (value && typeof value === 'object') {
           if ('xstate$$type' in value && value.xstate$$type === guards_dist_xstateGuards.$$ACTOR_TYPE) {
@@ -563,10 +563,6 @@ class StateMachine {
   }
 }
 
-// this is not 100% accurate since we can't make parallel regions required in the result
-// `TTestValue` doesn't encode this information anyhow for us to be able to do that
-// this is fine for most practical use cases anyway though
-
 /**
  * Creates a state machine (statechart) with the given configuration.
  *
@@ -624,10 +620,13 @@ function createInertActorScope(actorLogic) {
     sessionId: '',
     stopChild: () => {},
     system: self.system,
-    emit: () => {}
+    emit: () => {},
+    actionExecutor: () => {}
   };
   return inertActorScope;
 }
+
+/** @deprecated Use `initialTransition(…)` instead. */
 function getInitialSnapshot(actorLogic, ...[input]) {
   const actorScope = createInertActorScope(actorLogic);
   return actorLogic.getInitialSnapshot(actorScope, input);
@@ -640,6 +639,7 @@ function getInitialSnapshot(actorLogic, ...[input]) {
  * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
  * used.
  *
+ * @deprecated Use `transition(…)` instead.
  * @example
  *
  * ```ts
@@ -694,6 +694,9 @@ function setup({
   };
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class SimulatedClock {
   constructor() {
     this.timeouts = new Map();
@@ -794,6 +797,39 @@ function toPromise(actor) {
   });
 }
 
+/**
+ * Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
+ * `nextSnapshot` and `actions` to execute.
+ *
+ * This is a pure function that does not execute `actions`.
+ */
+function transition(logic, snapshot, event) {
+  const executableActions = [];
+  const actorScope = createInertActorScope(logic);
+  actorScope.actionExecutor = action => {
+    executableActions.push(action);
+  };
+  const nextSnapshot = logic.transition(snapshot, event, actorScope);
+  return [nextSnapshot, executableActions];
+}
+
+/**
+ * Given actor `logic` and optional `input`, returns a tuple of the
+ * `nextSnapshot` and `actions` to execute from the initial transition (no
+ * previous state).
+ *
+ * This is a pure function that does not execute `actions`.
+ */
+function initialTransition(logic, ...[input]) {
+  const executableActions = [];
+  const actorScope = createInertActorScope(logic);
+  actorScope.actionExecutor = action => {
+    executableActions.push(action);
+  };
+  const nextSnapshot = logic.getInitialSnapshot(actorScope, input);
+  return [nextSnapshot, executableActions];
+}
+
 const defaultWaitForOptions = {
   timeout: Infinity // much more than 10 seconds
 };
@@ -829,6 +865,7 @@ function waitFor(actorRef, predicate, options) {
       signal
     } = resolvedOptions;
     if (signal?.aborted) {
+      // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
       rej(signal.reason);
       return;
     }
@@ -857,6 +894,7 @@ function waitFor(actorRef, predicate, options) {
      * `abort` event
      */
     let abortListener;
+    // eslint-disable-next-line prefer-const
     let sub; // avoid TDZ when disposing synchronously
 
     // See if the current snapshot already matches the predicate
@@ -870,6 +908,7 @@ function waitFor(actorRef, predicate, options) {
       abortListener = () => {
         dispose();
         // XState does not "own" the signal, so we should reject with its reason (if any)
+        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
         rej(signal.reason);
       };
       signal.addEventListener('abort', abortListener);
@@ -878,6 +917,7 @@ function waitFor(actorRef, predicate, options) {
       next: checkEmitted,
       error: err => {
         dispose();
+        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
         rej(err);
       },
       complete: () => {
@@ -930,6 +970,8 @@ exports.assertEvent = assertEvent;
 exports.createMachine = createMachine;
 exports.getInitialSnapshot = getInitialSnapshot;
 exports.getNextSnapshot = getNextSnapshot;
+exports.initialTransition = initialTransition;
 exports.setup = setup;
 exports.toPromise = toPromise;
+exports.transition = transition;
 exports.waitFor = waitFor;

package/dist/xstate.cjs.mjs

@@ -23,6 +23,7 @@ export {
   getInitialSnapshot,
   getNextSnapshot,
   getStateNodes,
+  initialTransition,
   interpret,
   isMachineSnapshot,
   log,
@@ -40,5 +41,6 @@ export {
   stopChild,
   toObserver,
   toPromise,
+  transition,
   waitFor
 } from "./xstate.cjs.js";