xstate 5.0.0-beta.36 → 5.0.0-beta.38

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-69605bf0.cjs.js');
+var interpreter = require('./interpreter-b6f22ee2.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -16,10 +16,10 @@ function memo(object, key, fn) {
   return memoizedData[key];
 }
 
-function resolveCancel(_, state, actionArgs, {
+function resolveCancel(_, state, actionArgs, actionParams, {
   sendId
 }) {
-  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
+  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs, actionParams) : sendId;
   return [state, resolvedSendId];
 }
 function executeCancel(actorContext, resolvedSendId) {
@@ -33,7 +33,7 @@ function executeCancel(actorContext, resolvedSendId) {
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
 function cancel(sendId) {
-  function cancel(_) {
+  function cancel(args, params) {
   }
   cancel.type = 'xstate.cancel';
   cancel.sendId = sendId;
@@ -42,21 +42,25 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveInvoke(actorContext, state, actionArgs, {
+function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
   input,
   syncSnapshot
 }) {
-  const referenced = interpreter.resolveReferencedActor(state.machine.implementations.actors[src]);
+  const referenced = typeof src === 'string' ? interpreter.resolveReferencedActor(state.machine, src) : {
+    src,
+    input: undefined
+  };
+  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
   if (referenced) {
     // TODO: inline `input: undefined` should win over the referenced one
     const configuredInput = input || referenced.input;
     actorRef = interpreter.createActor(referenced.src, {
-      id,
-      src,
+      id: resolvedId,
+      src: typeof src === 'string' ? src : undefined,
       parent: actorContext?.self,
       systemId,
       input: typeof configuredInput === 'function' ? configuredInput({
@@ -75,23 +79,21 @@ function resolveInvoke(actorContext, state, actionArgs, {
             });
           }
         },
-        error: () => {
-          /* TODO */
-        }
+        error: () => {}
       });
     }
   }
   return [cloneState(state, {
     children: {
       ...state.children,
-      [id]: actorRef
+      [resolvedId]: actorRef
     }
   }), {
     id,
     actorRef
   }];
 }
-function executeInvoke(actorContext, {
+function executeSpawn(actorContext, {
   id,
   actorRef
 }) {
@@ -110,33 +112,29 @@ function executeInvoke(actorContext, {
     }
   });
 }
-
-// we don't export this since it's an internal action that is not meant to be used in the user's code
-
-function invoke({
+function spawn(...[src, {
   id,
   systemId,
-  src,
   input,
-  onSnapshot
-}) {
-  function invoke(_) {
-  }
-  invoke.type = 'xstate.invoke';
-  invoke.id = id;
-  invoke.systemId = systemId;
-  invoke.src = src;
-  invoke.input = input;
-  invoke.syncSnapshot = !!onSnapshot;
-  invoke.resolve = resolveInvoke;
-  invoke.execute = executeInvoke;
-  return invoke;
+  syncSnapshot = false
+} = {}]) {
+  function spawn(args, params) {
+  }
+  spawn.type = 'xstate.spawn';
+  spawn.id = id;
+  spawn.systemId = systemId;
+  spawn.src = src;
+  spawn.input = input;
+  spawn.syncSnapshot = syncSnapshot;
+  spawn.resolve = resolveSpawn;
+  spawn.execute = executeSpawn;
+  return spawn;
 }
 
-function resolveStop(_, state, args, {
+function resolveStop(_, state, args, actionParams, {
   actorRef
 }) {
-  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args) : actorRef;
+  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
   const resolvedActorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
   let children = state.children;
   if (resolvedActorRef) {
@@ -153,11 +151,22 @@ function executeStop(actorContext, actorRef) {
   if (!actorRef) {
     return;
   }
+
+  // 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);
+
+  // 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);
     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);
   });
@@ -168,7 +177,7 @@ function executeStop(actorContext, actorRef) {
  * @param actorRef The actor to stop.
  */
 function stop(actorRef) {
-  function stop(_) {
+  function stop(args, params) {
   }
   stop.type = 'xstate.stop';
   stop.actorRef = actorRef;
@@ -181,12 +190,13 @@ 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);
 }
 function stateIn(stateValue) {
-  function stateIn(_) {
+  function stateIn(args, params) {
     return false;
   }
   stateIn.check = checkStateIn;
@@ -202,7 +212,7 @@ function checkNot(state, {
   return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  function not(_) {
+  function not(args, params) {
     return false;
   }
   not.check = checkNot;
@@ -218,7 +228,7 @@ function checkAnd(state, {
   return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  function and(_) {
+  function and(args, params) {
     return false;
   }
   and.check = checkAnd;
@@ -234,7 +244,7 @@ function checkOr(state, {
   return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  function or(_) {
+  function or(args, params) {
     return false;
   }
   or.check = checkOr;
@@ -257,22 +267,17 @@ function evaluateGuard(guard, context, event, state) {
   }
   const guardArgs = {
     context,
-    event,
-    guard: isInline ? undefined : typeof guard === 'string' ? {
-      type: guard
-    } : typeof guard.params === 'function' ? {
-      type: guard.type,
-      params: guard.params({
-        context,
-        event
-      })
-    } : guard
+    event
   };
+  const guardParams = isInline || typeof guard === 'string' ? undefined : 'params' in guard ? typeof guard.params === 'function' ? guard.params({
+    context,
+    event
+  }) : guard.params : undefined;
   if (!('check' in resolved)) {
     // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
     // inline guards expect `TExpressionGuard` to be set to `undefined`
     // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
-    return resolved(guardArgs);
+    return resolved(guardArgs, guardParams);
   }
   const builtinGuard = resolved;
   return builtinGuard.check(state, guardArgs, resolved // this holds all params
@@ -285,6 +290,9 @@ function getChildren(stateNode) {
 }
 function getProperAncestors(stateNode, toStateNode) {
   const ancestors = [];
+  if (toStateNode === stateNode) {
+    return ancestors;
+  }
 
   // add all ancestors
   let m = stateNode.parent;
@@ -561,12 +569,14 @@ function resolveTarget(stateNode, targets) {
     }
   });
 }
-function resolveHistoryTarget(stateNode) {
+function resolveHistoryDefaultTransition(stateNode) {
   const normalizedTarget = interpreter.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';
@@ -793,9 +803,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);
         }
       }
@@ -808,9 +816,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));
@@ -821,6 +829,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);
@@ -844,11 +855,6 @@ function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
  */
 function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
@@ -897,6 +903,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);
 
@@ -912,7 +921,10 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
     for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
+      actions.push(spawn(invokeDef.src, {
+        ...invokeDef,
+        syncSnapshot: !!invokeDef.onSnapshot
+      }));
     }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
       const initialActions = stateNodeToEnter.initial.actions;
@@ -921,20 +933,16 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
     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(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
-        while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
-          completedNodes.add(ancestorMarker);
-          internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
-          rootCompletionNode = ancestorMarker;
-          ancestorMarker = ancestorMarker.parent;
-        }
+      }
+      while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
+        completedNodes.add(ancestorMarker);
+        internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
+        rootCompletionNode = ancestorMarker;
+        ancestorMarker = ancestorMarker.parent;
       }
       if (ancestorMarker) {
         continue;
@@ -949,13 +957,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);
     }
   }
 }
@@ -964,37 +983,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);
           }
         }
@@ -1009,6 +1033,7 @@ 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);
         }
       }
@@ -1063,31 +1088,24 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
-      system: actorCtx?.system,
-      action: isInline ? undefined : typeof action === 'string' ? {
-        type: action
-      } : typeof action.params === 'function' ? {
-        type: action.type,
-        params: action.params({
-          context: intermediateState.context,
-          event
-        })
-      } :
-      // TS isn't able to narrow it down here
-      action
+      system: actorCtx?.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) {
-        resolvedAction(actionArgs);
+        resolvedAction(actionArgs, actionParams);
       } else {
         actorCtx?.defer(() => {
-          resolvedAction(actionArgs);
+          resolvedAction(actionArgs, actionParams);
         });
       }
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, actionParams, resolvedAction,
     // this holds all params
     extra);
     intermediateState = nextState;
@@ -1124,7 +1142,9 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = stopChildren(nextState, event, actorCtx);
+    nextState = cloneState(stopChildren(nextState, event, actorCtx), {
+      status: 'stopped'
+    });
     states.push(nextState);
     return {
       state: nextState,
@@ -1176,7 +1196,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;
       }
@@ -1381,17 +1401,17 @@ function getPersistedState(state) {
   for (const id in children) {
     const child = children[id];
     childrenJson[id] = {
-      state: child.getPersistedState?.(),
-      src: child.src
+      state: child.getPersistedState(),
+      src: child.src,
+      systemId: child._systemId
     };
   }
-  return {
+  const persisted = {
     ...jsonValues,
-    // TODO: this makes `PersistedMachineState`'s type kind of a lie
-    // it doesn't truly use `TContext` but rather some kind of a derived form of it
     context: persistContext(context),
     children: childrenJson
   };
+  return persisted;
 }
 function persistContext(contextPart) {
   let copy;
@@ -1420,7 +1440,7 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, state, args, {
+function resolveRaise(_, state, args, actionParams, {
   event: eventOrExpr,
   id,
   delay
@@ -1431,13 +1451,13 @@ function resolveRaise(_, state, args, {
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
   }
-  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
+  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
   let resolvedDelay;
   if (typeof delay === 'string') {
     const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
   } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
+    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
   }
   if (typeof resolvedDelay !== 'number') {
     internalQueue.push(resolvedEvent);
@@ -1461,7 +1481,7 @@ function executeRaise(actorContext, params) {
  * @param eventType The event to raise.
  */
 function raise(eventOrExpr, options) {
-  function raise(_) {
+  function raise(args, params) {
   }
   raise.type = 'xstate.raise';
   raise.event = eventOrExpr;
@@ -1498,6 +1518,7 @@ exports.or = or;
 exports.raise = raise;
 exports.resolveActionsAndContext = resolveActionsAndContext;
 exports.resolveStateValue = resolveStateValue;
+exports.spawn = spawn;
 exports.stateIn = stateIn;
 exports.stop = stop;
 exports.transitionNode = transitionNode;