xstate 5.18.2 → 5.19.1

package/dist/{raise-b1e0b9a9.cjs.js → raise-60cebf03.cjs.js}

@@ -156,7 +156,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);
@@ -421,6 +421,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
@@ -541,10 +542,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);
+        }
       }
     };
 
@@ -1073,11 +1101,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);
   });
 }
 /**
@@ -1113,7 +1143,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;
@@ -1132,18 +1162,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, {
@@ -1153,11 +1185,13 @@ function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
     }
   }), {
     id,
-    actorRef
-  }];
+    systemId,
+    actorRef,
+    src,
+    input: resolvedInput
+  }, undefined];
 }
 function executeSpawn(actorScope, {
-  id,
   actorRef
 }) {
   if (!actorRef) {
@@ -1176,9 +1210,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;
@@ -1203,7 +1237,7 @@ function resolveStop(_, snapshot, args, actionParams, {
   }
   return [cloneMachineSnapshot(snapshot, {
     children
-  }), resolvedActorRef];
+  }), resolvedActorRef, undefined];
 }
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
@@ -1235,7 +1269,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;
@@ -1262,7 +1296,7 @@ function checkStateIn(snapshot, _, {
   return snapshot.matches(stateValue);
 }
 function stateIn(stateValue) {
-  function stateIn(args, params) {
+  function stateIn() {
     return false;
   }
   stateIn.check = checkStateIn;
@@ -1308,7 +1342,7 @@ function checkNot(snapshot, {
  * @returns A guard
  */
 function not(guard) {
-  function not(args, params) {
+  function not(_args, _params) {
     return false;
   }
   not.check = checkNot;
@@ -1354,7 +1388,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;
@@ -1400,7 +1434,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;
@@ -1578,7 +1612,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, {
@@ -1588,7 +1622,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
@@ -1673,7 +1707,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,
@@ -1783,7 +1819,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;
     }
@@ -2012,18 +2048,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;
@@ -2193,7 +2231,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);
@@ -2217,12 +2255,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
@@ -2234,10 +2274,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,
@@ -2248,30 +2286,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;
@@ -2283,11 +2304,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);
@@ -2306,7 +2328,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) {
@@ -2385,7 +2407,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);
@@ -2552,7 +2574,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;
@@ -2569,7 +2593,7 @@ function resolveRaise(_, snapshot, args, actionParams, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay
-  }];
+  }, undefined];
 }
 function executeRaise(actorScope, params) {
   const {
@@ -2592,7 +2616,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;