xstate 5.0.0-beta.38 → 5.0.0-beta.40

package/dist/{raise-7faa9b3b.cjs.js → raise-27909189.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-b6f22ee2.cjs.js');
+var interpreter = require('./interpreter-586abde4.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -22,8 +22,8 @@ function resolveCancel(_, state, actionArgs, actionParams, {
   const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs, actionParams) : sendId;
   return [state, resolvedSendId];
 }
-function executeCancel(actorContext, resolvedSendId) {
-  actorContext.self.cancel(resolvedSendId);
+function executeCancel(actorScope, resolvedSendId) {
+  actorScope.self.cancel(resolvedSendId);
 }
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
@@ -42,7 +42,7 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
+function resolveSpawn(actorScope, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
@@ -61,19 +61,19 @@ function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
     actorRef = interpreter.createActor(referenced.src, {
       id: resolvedId,
       src: typeof src === 'string' ? src : undefined,
-      parent: actorContext?.self,
+      parent: actorScope?.self,
       systemId,
       input: typeof configuredInput === 'function' ? configuredInput({
         context: state.context,
         event: actionArgs.event,
-        self: actorContext?.self
+        self: actorScope?.self
       }) : configuredInput
     });
     if (syncSnapshot) {
       actorRef.subscribe({
         next: snapshot => {
           if (snapshot.status === 'active') {
-            actorContext.self.send({
+            actorScope.self.send({
               type: `xstate.snapshot.${id}`,
               snapshot
             });
@@ -93,21 +93,21 @@ function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
     actorRef
   }];
 }
-function executeSpawn(actorContext, {
+function executeSpawn(actorScope, {
   id,
   actorRef
 }) {
   if (!actorRef) {
     return;
   }
-  actorContext.defer(() => {
+  actorScope.defer(() => {
     if (actorRef.status === interpreter.ActorStatus.Stopped) {
       return;
     }
     try {
       actorRef.start?.();
     } catch (err) {
-      actorContext.self.send(interpreter.createErrorActorEvent(id, err));
+      actorScope.self.send(interpreter.createErrorActorEvent(id, err));
       return;
     }
   });
@@ -147,7 +147,7 @@ function resolveStop(_, state, args, actionParams, {
     children
   }), resolvedActorRef];
 }
-function executeStop(actorContext, actorRef) {
+function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
   }
@@ -155,20 +155,20 @@ function executeStop(actorContext, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorContext.system._unregister(actorRef);
+  actorScope.system._unregister(actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
   if (actorRef.status !== interpreter.ActorStatus.Running) {
-    actorContext.stopChild(actorRef);
+    actorScope.stopChild(actorRef);
     return;
   }
   // stopping a child enqueues a stop event in the child actor's mailbox
   // we need for all of the already enqueued events to be processed before we stop the child
   // the parent itself might want to send some events to a child (for example from exit actions on the invoking state)
   // and we don't want to ignore those events
-  actorContext.defer(() => {
-    actorContext.stopChild(actorRef);
+  actorScope.defer(() => {
+    actorScope.stopChild(actorRef);
   });
 }
 /**
@@ -731,15 +731,6 @@ function isDescendant(childStateNode, parentStateNode) {
   }
   return marker.parent === parentStateNode;
 }
-function getPathFromRootToNode(stateNode) {
-  const path = [];
-  let marker = stateNode.parent;
-  while (marker) {
-    path.unshift(marker);
-    marker = marker.parent;
-  }
-  return path;
-}
 function hasIntersection(s1, s2) {
   const set1 = new Set(s1);
   const set2 = new Set(s2);
@@ -779,17 +770,13 @@ function removeConflictingTransitions(enabledTransitions, configuration, history
   }
   return Array.from(filteredTransitions);
 }
-function findLCCA(stateNodes) {
-  const [head] = stateNodes;
-  let current = getPathFromRootToNode(head);
-  let candidates = [];
-  for (const stateNode of stateNodes) {
-    const path = getPathFromRootToNode(stateNode);
-    candidates = current.filter(sn => path.includes(sn));
-    current = candidates;
-    candidates = [];
+function findLeastCommonAncestor(stateNodes) {
+  const [head, ...tail] = stateNodes;
+  for (const ancestor of getProperAncestors(head, undefined)) {
+    if (tail.every(sn => isDescendant(sn, ancestor))) {
+      return ancestor;
+    }
   }
-  return current[current.length - 1];
 }
 function getEffectiveTargetStates(transition, historyValue) {
   if (!transition.target) {
@@ -821,8 +808,16 @@ function getTransitionDomain(transition, historyValue) {
   if (!transition.reenter && targetStates.every(target => target === transition.source || isDescendant(target, transition.source))) {
     return transition.source;
   }
-  const lcca = findLCCA(targetStates.concat(transition.source));
-  return lcca;
+  const lca = findLeastCommonAncestor(targetStates.concat(transition.source));
+  if (lca) {
+    return lca;
+  }
+
+  // at this point we know that it's a root transition since LCA couldn't be found
+  if (transition.reenter) {
+    return;
+  }
+  return transition.source.machine.root;
 }
 function computeExitSet(transitions, configuration, historyValue) {
   const statesToExit = new Set();
@@ -856,7 +851,7 @@ function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
  */
-function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
+function microstep(transitions, currentState, actorScope, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
@@ -867,17 +862,17 @@ function microstep(transitions, currentState, actorCtx, event, isInitial, intern
 
   // Exit states
   if (!isInitial) {
-    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
+    [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
+  nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
-  nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
+  nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
     if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
@@ -893,14 +888,14 @@ function microstep(transitions, currentState, actorCtx, event, isInitial, intern
     throw e;
   }
 }
-function getMachineOutput(state, event, actorCtx, rootNode, rootCompletionNode) {
+function getMachineOutput(state, event, actorScope, rootNode, rootCompletionNode) {
   if (!rootNode.output) {
     return;
   }
-  const doneStateEvent = interpreter.createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? interpreter.resolveOutput(rootCompletionNode.output, state.context, event, actorCtx.self) : undefined);
-  return interpreter.resolveOutput(rootNode.output, state.context, doneStateEvent, actorCtx.self);
+  const doneStateEvent = interpreter.createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? interpreter.resolveOutput(rootCompletionNode.output, state.context, event, actorScope.self) : undefined);
+  return interpreter.resolveOutput(rootNode.output, state.context, doneStateEvent, actorScope.self);
 }
-function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+function enterStates(currentState, event, actorScope, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
   const statesToEnter = new Set();
   // those are states that were directly targeted or indirectly targeted by the explicit target
@@ -930,13 +925,13 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, event, actorScope, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       let ancestorMarker = parent?.type === 'parallel' ? parent : parent?.parent;
       let rootCompletionNode = ancestorMarker || stateNodeToEnter;
       if (parent?.type === 'compound') {
-        internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
+        internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
       }
       while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
         completedNodes.add(ancestorMarker);
@@ -949,7 +944,7 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       }
       nextState = cloneState(nextState, {
         status: 'done',
-        output: getMachineOutput(nextState, event, actorCtx, currentState.configuration[0].machine.root, rootCompletionNode)
+        output: getMachineOutput(nextState, event, actorScope, currentState.configuration[0].machine.root, rootCompletionNode)
       });
     }
   }
@@ -974,7 +969,11 @@ function computeEntrySet(transitions, historyValue, statesForDefaultEntry, state
     }
     const targetStates = getEffectiveTargetStates(t, historyValue);
     for (const s of targetStates) {
-      addAncestorStatesToEnter(s, domain, statesToEnter, historyValue, statesForDefaultEntry);
+      const ancestors = getProperAncestors(s, domain);
+      if (domain?.type === 'parallel') {
+        ancestors.push(domain);
+      }
+      addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, !t.source.parent && t.reenter ? undefined : domain);
     }
   }
 }
@@ -987,7 +986,7 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
       for (const s of historyStateNodes) {
-        addAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
+        addProperAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
       }
     } else {
       const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
@@ -999,7 +998,7 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
       for (const s of historyDefaultTransition.target) {
-        addAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+        addProperAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
       }
     }
   } else {
@@ -1010,7 +1009,7 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
         statesForDefaultEntry.add(initialState);
       }
       addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
-      addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+      addProperAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
     } else {
       if (stateNode.type === 'parallel') {
         for (const child of getChildren(stateNode).filter(sn => !isHistoryNode(sn))) {
@@ -1026,10 +1025,11 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     }
   }
 }
-function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
-  const properAncestors = getProperAncestors(stateNode, toStateNode);
-  for (const anc of properAncestors) {
-    statesToEnter.add(anc);
+function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, reentrancyDomain) {
+  for (const anc of ancestors) {
+    if (!reentrancyDomain || isDescendant(anc, reentrancyDomain)) {
+      statesToEnter.add(anc);
+    }
     if (anc.type === 'parallel') {
       for (const child of getChildren(anc).filter(sn => !isHistoryNode(sn))) {
         if (![...statesToEnter].some(s => isDescendant(s, child))) {
@@ -1040,7 +1040,10 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
+function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
+  addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
+}
+function exitStates(currentState, event, actorScope, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
@@ -1064,12 +1067,12 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
+    nextState = resolveActionsAndContext(nextState, event, actorScope, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
   return [nextState, changedHistory || historyValue];
 }
-function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
+function resolveActionsAndContextWorker(currentState, event, actorScope, actions, extra, retries) {
   const {
     machine
   } = currentState;
@@ -1087,25 +1090,25 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
     const actionArgs = {
       context: intermediateState.context,
       event,
-      self: actorCtx?.self,
-      system: actorCtx?.system
+      self: actorScope?.self,
+      system: actorScope?.system
     };
     const actionParams = isInline || typeof action === 'string' ? undefined : 'params' in action ? typeof action.params === 'function' ? action.params({
       context: intermediateState.context,
       event
     }) : action.params : undefined;
     if (!('resolve' in resolvedAction)) {
-      if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
+      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
         resolvedAction(actionArgs, actionParams);
       } else {
-        actorCtx?.defer(() => {
+        actorScope?.defer(() => {
           resolvedAction(actionArgs, actionParams);
         });
       }
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, actionParams, resolvedAction,
+    const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateState, actionArgs, actionParams, resolvedAction,
     // this holds all params
     extra);
     intermediateState = nextState;
@@ -1113,36 +1116,36 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
       retries?.push([builtinAction, params]);
     }
     if ('execute' in builtinAction) {
-      if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
-        builtinAction.execute(actorCtx, params);
+      if (actorScope?.self.status === interpreter.ActorStatus.Running) {
+        builtinAction.execute(actorScope, params);
       } else {
-        actorCtx?.defer(builtinAction.execute.bind(null, actorCtx, params));
+        actorScope?.defer(builtinAction.execute.bind(null, actorScope, params));
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorCtx, actions, extra, retries);
+      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorScope, actions, extra, retries);
     }
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorScope, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorScope, actions, {
     internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
-    builtinAction.retryResolve(actorCtx, nextState, params);
+    builtinAction.retryResolve(actorScope, nextState, params);
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx, internalQueue = []) {
+function macrostep(state, event, actorScope, internalQueue = []) {
   let nextState = state;
   const states = [];
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = cloneState(stopChildren(nextState, event, actorCtx), {
+    nextState = cloneState(stopChildren(nextState, event, actorScope), {
       status: 'stopped'
     });
     states.push(nextState);
@@ -1157,7 +1160,7 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== interpreter.XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
+    nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
     states.push(nextState);
   }
   let shouldSelectEventlessTransitions = true;
@@ -1174,20 +1177,20 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
       nextEvent = internalQueue.shift();
       enabledTransitions = selectTransitions(nextEvent, nextState);
     }
-    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    nextState = microstep(enabledTransitions, nextState, actorScope, nextEvent, false, internalQueue);
     shouldSelectEventlessTransitions = nextState !== previousState;
     states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    stopChildren(nextState, nextEvent, actorCtx);
+    stopChildren(nextState, nextEvent, actorScope);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopChildren(nextState, event, actorCtx) {
-  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
+function stopChildren(nextState, event, actorScope) {
+  return resolveActionsAndContext(nextState, event, actorScope, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1468,9 +1471,9 @@ function resolveRaise(_, state, args, actionParams, {
     delay: resolvedDelay
   }];
 }
-function executeRaise(actorContext, params) {
+function executeRaise(actorScope, params) {
   if (typeof params.delay === 'number') {
-    actorContext.self.delaySend(params);
+    actorScope.self.delaySend(params);
     return;
   }
 }