xstate 5.0.0-beta.33 → 5.0.0-beta.35

package/dist/{raise-4c6a5a96.development.cjs.js → raise-26e4d83c.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-0c630f66.development.cjs.js');
+var interpreter = require('./interpreter-d3567419.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -299,20 +299,6 @@ function evaluateGuard(guard, context, event, state) {
   );
 }
 
-function getOutput(configuration, context, event, self) {
-  const {
-    machine
-  } = configuration[0];
-  const {
-    root
-  } = machine;
-  if (!root.output) {
-    return undefined;
-  }
-  const finalChildStateNode = configuration.find(stateNode => stateNode.type === 'final' && stateNode.parent === machine.root);
-  const doneStateEvent = interpreter.createDoneStateEvent(finalChildStateNode.id, finalChildStateNode.output ? interpreter.resolveOutput(finalChildStateNode.output, context, event, self) : undefined);
-  return interpreter.resolveOutput(root.output, context, doneStateEvent, self);
-}
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
@@ -337,7 +323,7 @@ function getConfiguration(stateNodes) {
   for (const s of configuration) {
     // if previously active, add existing child nodes
     if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-      getInitialStateNodes(s).forEach(sn => configurationSet.add(sn));
+      getInitialStateNodesWithTheirAncestors(s).forEach(sn => configurationSet.add(sn));
     } else {
       if (s.type === 'parallel') {
         for (const child of getChildren(s)) {
@@ -345,7 +331,8 @@ function getConfiguration(stateNodes) {
             continue;
           }
           if (!configurationSet.has(child)) {
-            for (const initialStateNode of getInitialStateNodes(child)) {
+            const initialStates = getInitialStateNodesWithTheirAncestors(child);
+            for (const initialStateNode of initialStates) {
               configurationSet.add(initialStateNode);
             }
           }
@@ -405,14 +392,14 @@ function getStateValue(rootNode, configuration) {
   const config = getConfiguration(configuration);
   return getValueFromAdj(rootNode, getAdjList(config));
 }
-function isInFinalState(configuration, stateNode = configuration[0].machine.root) {
+function isInFinalState(configuration, stateNode) {
   if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(s => s.type === 'final' && configuration.includes(s));
+    return getChildren(stateNode).some(s => s.type === 'final' && configuration.has(s));
   }
   if (stateNode.type === 'parallel') {
     return getChildren(stateNode).every(sn => isInFinalState(configuration, sn));
   }
-  return false;
+  return stateNode.type === 'final';
 }
 const isStateId = str => str[0] === interpreter.STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
@@ -468,13 +455,7 @@ function getDelayedTransitions(stateNode) {
     stateNode.exit.push(cancel(eventType));
     return eventType;
   };
-  const delayedTransitions = interpreter.isArray(afterConfig) ? afterConfig.map((transition, i) => {
-    const eventType = mutateEntryExit(transition.delay, i);
-    return {
-      ...transition,
-      event: eventType
-    };
-  }) : Object.keys(afterConfig).flatMap((delay, i) => {
+  const delayedTransitions = Object.keys(afterConfig).flatMap((delay, i) => {
     const configTransition = afterConfig[delay];
     const resolvedTransition = typeof configTransition === 'string' ? {
       target: configTransition
@@ -562,43 +543,23 @@ function formatTransitions(stateNode) {
   return transitions;
 }
 function formatInitialTransition(stateNode, _target) {
-  if (typeof _target === 'string' || interpreter.isArray(_target)) {
-    const targets = interpreter.toArray(_target).map(t => {
-      // Resolve state string keys (which represent children)
-      // to their state node
-      const descStateNode = typeof t === 'string' ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
-      if (!descStateNode) {
-        throw new Error(`Initial state node "${t}" not found on parent state node #${stateNode.id}`);
-      }
-      if (!isDescendant(descStateNode, stateNode)) {
-        throw new Error(`Invalid initial target: state node #${descStateNode.id} is not a descendant of #${stateNode.id}`);
-      }
-      return descStateNode;
-    });
-    const resolvedTarget = resolveTarget(stateNode, targets);
-    const transition = {
-      source: stateNode,
-      actions: [],
-      eventType: null,
-      reenter: false,
-      target: resolvedTarget,
-      toJSON: () => ({
-        ...transition,
-        source: `#${stateNode.id}`,
-        target: resolvedTarget ? resolvedTarget.map(t => `#${t.id}`) : undefined
-      })
-    };
-    return transition;
+  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}`);
   }
-  return formatTransition(stateNode, '__INITIAL__', {
-    target: interpreter.toArray(_target.target).map(t => {
-      if (typeof t === 'string') {
-        return isStateId(t) ? t : `${interpreter.STATE_DELIMITER}${t}`;
-      }
-      return t;
-    }),
-    actions: _target.actions
-  });
+  const transition = {
+    source: stateNode,
+    actions: !_target || typeof _target === 'string' ? [] : interpreter.toArray(_target.actions),
+    eventType: null,
+    reenter: false,
+    target: resolvedTarget ? [resolvedTarget] : [],
+    toJSON: () => ({
+      ...transition,
+      source: `#${stateNode.id}`,
+      target: resolvedTarget ? [`#${resolvedTarget.id}`] : []
+    })
+  };
+  return transition;
 }
 function resolveTarget(stateNode, targets) {
   if (targets === undefined) {
@@ -641,6 +602,15 @@ function resolveHistoryTarget(stateNode) {
 function isHistoryNode(stateNode) {
   return stateNode.type === 'history';
 }
+function getInitialStateNodesWithTheirAncestors(stateNode) {
+  const states = getInitialStateNodes(stateNode);
+  for (const initialState of states) {
+    for (const ancestor of getProperAncestors(initialState, stateNode)) {
+      states.add(ancestor);
+    }
+  }
+  return states;
+}
 function getInitialStateNodes(stateNode) {
   const set = new Set();
   function iter(descStateNode) {
@@ -649,12 +619,7 @@ function getInitialStateNodes(stateNode) {
     }
     set.add(descStateNode);
     if (descStateNode.type === 'compound') {
-      for (const targetStateNode of descStateNode.initial.target) {
-        for (const a of getProperAncestors(targetStateNode, stateNode)) {
-          set.add(a);
-        }
-        iter(targetStateNode);
-      }
+      iter(descStateNode.initial.target[0]);
     } else if (descStateNode.type === 'parallel') {
       for (const child of getChildren(descStateNode)) {
         iter(child);
@@ -662,7 +627,7 @@ function getInitialStateNodes(stateNode) {
     }
   }
   iter(stateNode);
-  return [...set];
+  return set;
 }
 /**
  * Returns the child state node from its relative `stateKey`, or throws.
@@ -918,41 +883,37 @@ function microstep(transitions, currentState, actorCtx, event, isInitial) {
 }
 
 function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const actions = [];
   const 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: []
+  });
 
   // Exit states
   if (!isInitial) {
-    exitStates(filteredTransitions, mutConfiguration, historyValue, actions);
+    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
   }
 
   // Execute transition content
-  actions.push(...filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
 
   // Enter states
-  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorCtx);
+  nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
-  const done = isInFinalState(nextConfiguration);
-  if (done) {
-    const finalActions = nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit);
-    actions.push(...finalActions);
+  if (nextState.status === 'done') {
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
   }
   try {
-    const nextState = resolveActionsAndContext(actions, event, currentState, actorCtx);
-    const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
     internalQueue.push(...nextState._internalQueue);
-    return cloneState(currentState, {
+    return cloneState(nextState, {
       configuration: nextConfiguration,
       historyValue,
-      _internalQueue: internalQueue,
-      context: nextState.context,
-      status: done ? 'done' : currentState.status,
-      output,
-      children: nextState.children
+      _internalQueue: internalQueue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -960,7 +921,15 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
-function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorContext) {
+function getMachineOutput(state, event, actorCtx, 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);
+}
+function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+  let nextState = currentState;
   const statesToEnter = new Set();
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
@@ -969,36 +938,48 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
   if (isInitial) {
     statesForDefaultEntry.add(currentState.machine.root);
   }
+  const completedNodes = new Set();
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
     mutConfiguration.add(stateNodeToEnter);
-    for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
-    }
+    const actions = [];
 
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
+    for (const invokeDef of stateNodeToEnter.invoke) {
+      actions.push(invoke(invokeDef));
+    }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
-      for (const stateNode of statesForDefaultEntry) {
-        const initialActions = stateNode.initial.actions;
-        actions.push(...initialActions);
-      }
+      const initialActions = stateNodeToEnter.initial.actions;
+      actions.push(...initialActions);
     }
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
-      if (!parent.parent) {
+      if (completedNodes.has(parent)) {
         continue;
       }
-      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
-      if (parent.parent) {
-        const grandparent = parent.parent;
-        if (grandparent.type === 'parallel') {
-          if (getChildren(grandparent).every(parentNode => isInFinalState([...mutConfiguration], parentNode))) {
-            internalQueue.push(interpreter.createDoneStateEvent(grandparent.id));
-          }
+      completedNodes.add(parent);
+      let rootCompletionNode = parent?.type === 'parallel' ? parent : stateNodeToEnter;
+      let ancestorMarker = parent?.parent;
+      if (ancestorMarker) {
+        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;
         }
       }
+      if (ancestorMarker) {
+        continue;
+      }
+      nextState = cloneState(nextState, {
+        status: 'done',
+        output: getMachineOutput(nextState, event, actorCtx, currentState.configuration[0].machine.root, rootCompletionNode)
+      });
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1041,13 +1022,9 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     statesToEnter.add(stateNode);
     if (stateNode.type === 'compound') {
       statesForDefaultEntry.add(stateNode);
-      const initialStates = stateNode.initial.target;
-      for (const initialState of initialStates) {
-        addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
-      }
-      for (const initialState of initialStates) {
-        addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
-      }
+      const [initialState] = stateNode.initial.target;
+      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))) {
@@ -1072,7 +1049,8 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(transitions, mutConfiguration, historyValue, actions) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+  let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
 
@@ -1091,19 +1069,16 @@ function exitStates(transitions, mutConfiguration, historyValue, actions) {
     }
   }
   for (const s of statesToExit) {
-    actions.push(...s.exit, ...s.invoke.map(def => stop(def.id)));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
     mutConfiguration.delete(s);
   }
+  return nextState;
 }
-function resolveActionsAndContext(actions, event, currentState, actorCtx) {
+function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
     machine
   } = currentState;
-  // 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 intermediateState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let intermediateState = currentState;
   for (const action of actions) {
     const isInline = typeof action === 'function';
     const resolvedAction = isInline ? action :
@@ -1142,11 +1117,14 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction // this holds all params
-    );
-
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    // this holds all params
+    extra);
     intermediateState = nextState;
-    if ('execute' in resolvedAction) {
+    if ('retryResolve' in builtinAction) {
+      retries?.push([builtinAction, params]);
+    }
+    if ('execute' in builtinAction) {
       if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1154,11 +1132,21 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContext(actions, event, intermediateState, actorCtx);
+      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorCtx, actions, extra, retries);
     }
   }
   return intermediateState;
 }
+function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+  const retries = deferredActorIds ? [] : undefined;
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+    deferredActorIds
+  }, retries);
+  retries?.forEach(([builtinAction, params]) => {
+    builtinAction.retryResolve(actorCtx, nextState, params);
+  });
+  return nextState;
+}
 function macrostep(state, event, actorCtx) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
@@ -1218,7 +1206,7 @@ function stopStep(event, nextState, actorCtx) {
   for (const child of Object.values(nextState.children)) {
     actions.push(stop(child));
   }
-  return resolveActionsAndContext(actions, event, nextState, actorCtx);
+  return resolveActionsAndContext(nextState, event, actorCtx, actions);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1430,11 +1418,15 @@ function getPersistedState(state) {
     tags,
     machine,
     children,
+    context,
     ...jsonValues
   } = state;
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string') {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     childrenJson[id] = {
       state: child.getPersistedState?.(),
       src: child.src
@@ -1442,9 +1434,38 @@ function getPersistedState(state) {
   }
   return {
     ...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
   };
 }
+function persistContext(contextPart) {
+  let copy;
+  for (const key in contextPart) {
+    const value = contextPart[key];
+    if (value && typeof value === 'object') {
+      if ('sessionId' in value && 'send' in value && 'ref' in value) {
+        copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+          ...contextPart
+        };
+        copy[key] = {
+          xstate$$type: interpreter.$$ACTOR_TYPE,
+          id: value.id
+        };
+      } else {
+        const result = persistContext(value);
+        if (result !== value) {
+          copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+            ...contextPart
+          };
+          copy[key] = result;
+        }
+      }
+    }
+  }
+  return copy ?? contextPart;
+}
 
 function resolveRaise(_, state, args, {
   event: eventOrExpr,
@@ -1510,10 +1531,10 @@ exports.getCandidates = getCandidates;
 exports.getConfiguration = getConfiguration;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialConfiguration = getInitialConfiguration;
+exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
-exports.isAtomicStateNode = isAtomicStateNode;
 exports.isInFinalState = isInFinalState;
 exports.isStateId = isStateId;
 exports.macrostep = macrostep;