xstate 5.0.0-beta.35 → 5.0.0-beta.37

package/dist/{raise-511399cc.esm.js → raise-21c417c1.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, X as XSTATE_STOP, u as XSTATE_INIT, W as WILDCARD, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-de5217bc.esm.js';
+import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, X as XSTATE_STOP, u as XSTATE_INIT, W as WILDCARD, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-8def682e.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -47,14 +47,17 @@ function resolveInvoke(actorContext, state, actionArgs, {
   input,
   syncSnapshot
 }) {
-  const referenced = resolveReferencedActor(state.machine.implementations.actors[src]);
+  const referenced = typeof src === 'string' ? resolveReferencedActor(state.machine, src) : {
+    src,
+    input: undefined
+  };
   let actorRef;
   if (referenced) {
     // TODO: inline `input: undefined` should win over the referenced one
     const configuredInput = input || referenced.input;
     actorRef = createActor(referenced.src, {
       id,
-      src,
+      src: typeof src === 'string' ? src : undefined,
       parent: actorContext?.self,
       systemId,
       input: typeof configuredInput === 'function' ? configuredInput({
@@ -151,11 +154,16 @@ function executeStop(actorContext, actorRef) {
   if (!actorRef) {
     return;
   }
+  // 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 !== ActorStatus.Running) {
     actorContext.stopChild(actorRef);
     return;
   }
-  // TODO: recheck why this one has to be deferred
+  // 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);
   });
@@ -179,7 +187,8 @@ function checkStateIn(state, _, {
   stateValue
 }) {
   if (typeof stateValue === 'string' && isStateId(stateValue)) {
-    return state.configuration.some(sn => sn.id === stateValue.slice(1));
+    const target = state.machine.getStateNodeById(stateValue);
+    return state.configuration.some(sn => sn === target);
   }
   return state.matches(stateValue);
 }
@@ -283,6 +292,9 @@ function getChildren(stateNode) {
 }
 function getProperAncestors(stateNode, toStateNode) {
   const ancestors = [];
+  if (toStateNode === stateNode) {
+    return ancestors;
+  }
 
   // add all ancestors
   let m = stateNode.parent;
@@ -559,12 +571,14 @@ function resolveTarget(stateNode, targets) {
     }
   });
 }
-function resolveHistoryTarget(stateNode) {
+function resolveHistoryDefaultTransition(stateNode) {
   const normalizedTarget = normalizeTarget(stateNode.config.target);
   if (!normalizedTarget) {
-    return stateNode.parent.initial.target;
+    return stateNode.parent.initial;
   }
-  return normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t);
+  return {
+    target: normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t)
+  };
 }
 function isHistoryNode(stateNode) {
   return stateNode.type === 'history';
@@ -791,9 +805,7 @@ function getEffectiveTargetStates(transition, historyValue) {
           targets.add(node);
         }
       } else {
-        for (const node of getEffectiveTargetStates({
-          target: resolveHistoryTarget(targetNode)
-        }, historyValue)) {
+        for (const node of getEffectiveTargetStates(resolveHistoryDefaultTransition(targetNode), historyValue)) {
           targets.add(node);
         }
       }
@@ -806,9 +818,9 @@ function getEffectiveTargetStates(transition, historyValue) {
 function getTransitionDomain(transition, historyValue) {
   const targetStates = getEffectiveTargetStates(transition, historyValue);
   if (!targetStates) {
-    return null;
+    return;
   }
-  if (!transition.reenter && transition.source.type !== 'parallel' && targetStates.every(targetStateNode => isDescendant(targetStateNode, transition.source))) {
+  if (!transition.reenter && targetStates.every(target => target === transition.source || isDescendant(target, transition.source))) {
     return transition.source;
   }
   const lcca = findLCCA(targetStates.concat(transition.source));
@@ -819,6 +831,9 @@ function computeExitSet(transitions, configuration, historyValue) {
   for (const t of transitions) {
     if (t.target?.length) {
       const domain = getTransitionDomain(t, historyValue);
+      if (t.reenter && t.source === domain) {
+        statesToExit.add(domain);
+      }
       for (const stateNode of configuration) {
         if (isDescendant(stateNode, domain)) {
           statesToExit.add(stateNode);
@@ -828,6 +843,17 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
+function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
+  if (previousConfiguration.length !== nextConfigurationSet.size) {
+    return false;
+  }
+  for (const node of previousConfiguration) {
+    if (!nextConfigurationSet.has(node)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -837,50 +863,36 @@ function computeExitSet(transitions, configuration, historyValue) {
  * @param currentState
  * @param mutConfiguration
  */
-
-function microstep(transitions, currentState, actorCtx, event, isInitial) {
-  const mutConfiguration = new Set(currentState.configuration);
+function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
-  const microstate = microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial);
-  return cloneState(microstate, {
-    value: {} // TODO: make optional
-  });
-}
-
-function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const historyValue = {
-    ...currentState.historyValue
-  };
+  const mutConfiguration = new Set(currentState.configuration);
+  let historyValue = currentState.historyValue;
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
-  const internalQueue = [...currentState._internalQueue];
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let nextState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
+    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
   nextState = enterStates(nextState, event, actorCtx, 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));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    internalQueue.push(...nextState._internalQueue);
+    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+      return nextState;
+    }
     return cloneState(nextState, {
       configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue
+      historyValue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -898,6 +910,9 @@ function getMachineOutput(state, event, actorCtx, rootNode, rootCompletionNode)
 function enterStates(currentState, event, actorCtx, 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
+  // in other words, those are states for which initial actions should be executed
+  // when we target `#deep_child` initial actions of its ancestors shouldn't be executed
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
 
@@ -919,23 +934,19 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
-      if (completedNodes.has(parent)) {
-        continue;
-      }
-      completedNodes.add(parent);
-      let rootCompletionNode = parent?.type === 'parallel' ? parent : stateNodeToEnter;
-      let ancestorMarker = parent?.parent;
-      if (ancestorMarker) {
+      let ancestorMarker = parent?.type === 'parallel' ? parent : parent?.parent;
+      let rootCompletionNode = ancestorMarker || stateNodeToEnter;
+      if (parent?.type === 'compound') {
         internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
-        while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
-          completedNodes.add(ancestorMarker);
-          internalQueue.push(createDoneStateEvent(ancestorMarker.id));
-          rootCompletionNode = ancestorMarker;
-          ancestorMarker = ancestorMarker.parent;
-        }
+      }
+      while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
+        completedNodes.add(ancestorMarker);
+        internalQueue.push(createDoneStateEvent(ancestorMarker.id));
+        rootCompletionNode = ancestorMarker;
+        ancestorMarker = ancestorMarker.parent;
       }
       if (ancestorMarker) {
         continue;
@@ -950,13 +961,24 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
+    const domain = getTransitionDomain(t, historyValue);
     for (const s of t.target || []) {
+      if (!isHistoryNode(s) && (
+      // if the target is different than the source then it will *definitely* be entered
+      t.source !== s ||
+      // we know that the domain can't lie within the source
+      // if it's different than the source then it's outside of it and it means that the target has to be entered as well
+      t.source !== domain ||
+      // reentering transitions always enter the target, even if it's the source itself
+      t.reenter)) {
+        statesToEnter.add(s);
+        statesForDefaultEntry.add(s);
+      }
       addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
     }
-    const ancestor = getTransitionDomain(t, historyValue);
     const targetStates = getEffectiveTargetStates(t, historyValue);
     for (const s of targetStates) {
-      addAncestorStatesToEnter(s, ancestor, statesToEnter, historyValue, statesForDefaultEntry);
+      addAncestorStatesToEnter(s, domain, statesToEnter, historyValue, statesForDefaultEntry);
     }
   }
 }
@@ -965,37 +987,42 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     if (historyValue[stateNode.id]) {
       const historyStateNodes = historyValue[stateNode.id];
       for (const s of historyStateNodes) {
+        statesToEnter.add(s);
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
       for (const s of historyStateNodes) {
         addAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
-        for (const stateForDefaultEntry of statesForDefaultEntry) {
-          statesForDefaultEntry.add(stateForDefaultEntry);
-        }
       }
     } else {
-      const targets = resolveHistoryTarget(stateNode);
-      for (const s of targets) {
+      const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
+      for (const s of historyDefaultTransition.target) {
+        statesToEnter.add(s);
+        if (historyDefaultTransition === stateNode.parent?.initial) {
+          statesForDefaultEntry.add(stateNode.parent);
+        }
         addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
       }
-      for (const s of targets) {
+      for (const s of historyDefaultTransition.target) {
         addAncestorStatesToEnter(s, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
-        for (const stateForDefaultEntry of statesForDefaultEntry) {
-          statesForDefaultEntry.add(stateForDefaultEntry);
-        }
       }
     }
   } else {
-    statesToEnter.add(stateNode);
     if (stateNode.type === 'compound') {
-      statesForDefaultEntry.add(stateNode);
       const [initialState] = stateNode.initial.target;
+      if (!isHistoryNode(initialState)) {
+        statesToEnter.add(initialState);
+        statesForDefaultEntry.add(initialState);
+      }
       addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
       addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
     } else {
       if (stateNode.type === 'parallel') {
         for (const child of getChildren(stateNode).filter(sn => !isHistoryNode(sn))) {
           if (![...statesToEnter].some(s => isDescendant(s, child))) {
+            if (!isHistoryNode(child)) {
+              statesToEnter.add(child);
+              statesForDefaultEntry.add(child);
+            }
             addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
           }
         }
@@ -1010,16 +1037,18 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     if (anc.type === 'parallel') {
       for (const child of getChildren(anc).filter(sn => !isHistoryNode(sn))) {
         if (![...statesToEnter].some(s => isDescendant(s, child))) {
+          statesToEnter.add(child);
           addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
         }
       }
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
+  let changedHistory;
 
   // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
   for (const exitStateNode of statesToExit) {
@@ -1032,14 +1061,17 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
           return sn.parent === exitStateNode;
         };
       }
-      historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory ??= {
+        ...historyValue
+      };
+      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
-  return nextState;
+  return [nextState, changedHistory || historyValue];
 }
 function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
@@ -1104,9 +1136,10 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+    internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
@@ -1114,13 +1147,13 @@ function resolveActionsAndContext(currentState, event, actorCtx, actions, deferr
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx) {
+function macrostep(state, event, actorCtx, internalQueue = []) {
   let nextState = state;
   const states = [];
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopChildren(nextState, event, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -1133,44 +1166,37 @@ function macrostep(state, event, actorCtx) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
+    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
     states.push(nextState);
   }
+  let shouldSelectEventlessTransitions = true;
   while (nextState.status === 'active') {
-    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextState, nextEvent) : [];
+
+    // eventless transitions should always be selected after selecting *regular* transitions
+    // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
+    const previousState = enabledTransitions.length ? nextState : undefined;
     if (!enabledTransitions.length) {
-      if (!nextState._internalQueue.length) {
+      if (!internalQueue.length) {
         break;
-      } else {
-        nextEvent = nextState._internalQueue[0];
-        const transitions = selectTransitions(nextEvent, nextState);
-        nextState = microstep(transitions, nextState, actorCtx, nextEvent, false);
-        nextState._internalQueue.shift();
-        states.push(nextState);
       }
-    } else {
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false);
-      states.push(nextState);
+      nextEvent = internalQueue.shift();
+      enabledTransitions = selectTransitions(nextEvent, nextState);
     }
+    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    shouldSelectEventlessTransitions = nextState !== previousState;
+    states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextEvent, nextState, actorCtx);
+    stopChildren(nextState, nextEvent, actorCtx);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopStep(event, nextState, actorCtx) {
-  const actions = [];
-  for (const stateNode of nextState.configuration.sort((a, b) => b.order - a.order)) {
-    actions.push(...stateNode.exit);
-  }
-  for (const child of Object.values(nextState.children)) {
-    actions.push(stop(child));
-  }
-  return resolveActionsAndContext(nextState, event, actorCtx, actions);
+function stopChildren(nextState, event, actorCtx) {
+  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1179,7 +1205,7 @@ function selectEventlessTransitions(nextState, event) {
   const enabledTransitionSet = new Set();
   const atomicStates = nextState.configuration.filter(isAtomicStateNode);
   for (const stateNode of atomicStates) {
-    loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, null))) {
+    loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, undefined))) {
       if (!s.always) {
         continue;
       }
@@ -1276,11 +1302,9 @@ class State {
     this.error = void 0;
     this.context = void 0;
     this.historyValue = {};
-    this._internalQueue = void 0;
     this.configuration = void 0;
     this.children = void 0;
     this.context = config.context;
-    this._internalQueue = config._internalQueue ?? [];
     this.historyValue = config.historyValue || {};
     this.matches = this.matches.bind(this);
     this.toStrings = this.toStrings.bind(this);
@@ -1429,6 +1453,8 @@ function resolveRaise(_, state, args, {
   event: eventOrExpr,
   id,
   delay
+}, {
+  internalQueue
 }) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
@@ -1442,9 +1468,10 @@ function resolveRaise(_, state, args, {
   } else {
     resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
   }
-  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
-    _internalQueue: state._internalQueue.concat(resolvedEvent)
-  }) : state, {
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [state, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay