xstate 6.0.0-alpha.64 → 6.0.0-alpha.65

package/dist/{createActor-8493caa9.esm.js → createActor-4629a290.esm.js}

@@ -527,7 +527,8 @@ function withActorScope(args, actorScope) {
 }
 
 function execCustomEffect() {
-  return this.action?.(...this.args);
+  const result = this.action?.(...this.args);
+  return result;
 }
 function execEmitEffect(runtime = this.source.system) {
   return runtime.emitEvent(this.source, this.event);
@@ -1049,6 +1050,13 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     props[key] = guard(props[key]);
   }
   const enqueue = createEnqueueObject(props, guard((action, ...args) => {
+    // A named action is `undefined` when it has no implementation. Skip it:
+    // an `{ action, args }` record without a function would be emitted as
+    // an event. Speculative passes (`can()`, conflict resolution) run with
+    // `createActors: false`; warn only when the transition really runs.
+    if (typeof action !== 'function') {
+      return;
+    }
     pushBuiltInAction(actions, action, ...args);
   }));
   enqueueClosers.set(enqueue, () => {
@@ -2266,6 +2274,10 @@ function getDelayedTransitions(stateNode) {
   }));
 }
 function formatTransition(stateNode, descriptor, transitionConfig) {
+  const removedKey = getRemovedTransitionKey(transitionConfig);
+  if (removedKey) {
+    throw new Error(`Transition "${descriptor || 'always'}" in state "${stateNode.id}" uses ${removedKey}, which was removed in v6. Use a transition function.`);
+  }
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
   const target = resolveTarget(stateNode, normalizedTarget);
@@ -2276,14 +2288,46 @@ function formatTransition(stateNode, descriptor, transitionConfig) {
     source: stateNode,
     reenter,
     eventType: descriptor,
-    toJSON: () => ({
-      ...transition,
-      source: `#${stateNode.id}`,
-      target: target ? target.map(t => `#${t.id}`) : undefined
-    })
+    toJSON: () => transitionDefinitionToJSON(transition)
   };
   return transition;
 }
+function transitionDefinitionToJSON(transition) {
+  const {
+    definition: _,
+    ...serializableTransition
+  } = transition;
+  return {
+    ...serializableTransition,
+    source: `#${transition.source.id}`,
+    target: transition.target?.map(target => `#${target.id}`)
+  };
+}
+
+/**
+ * Returns the v5 key of a transition object that v6 would misread, in every
+ * build: `cond` is never read, so the transition would always be taken,
+ * transition `actions` would not run as written, and only a function `guard`
+ * can be called. Development builds explain each key earlier, in
+ * `diagnoseAuthorConfig`. Compiled configs (JSON, SCXML) never set them.
+ */
+function getRemovedTransitionKey(transitionConfig) {
+  const {
+    cond,
+    actions,
+    guard
+  } = transitionConfig;
+  if (cond !== undefined) {
+    return '"cond"';
+  }
+  if (actions !== undefined) {
+    return '"actions"';
+  }
+  if (guard !== undefined && typeof guard !== 'function') {
+    return 'an object-form "guard"';
+  }
+  return undefined;
+}
 function isStateNodeDescendantOf(stateNode, ancestor) {
   for (let current = stateNode.parent; current; current = current.parent) {
     if (current === ancestor) {
@@ -2626,12 +2670,18 @@ function removeConflictingTransitions(enabledTransitions, stateNodeSet, snapshot
 }
 function createTransitionResultResolver(snapshot, event, actorScope, resolveActions, selectionResults) {
   let cache;
-  return transition => {
-    if (!transition.to) {
-      return getTransitionResult(transition, snapshot, event, actorScope, {
-        resolveActions,
-        selectionResult: selectionResults?.get(transition)
-      });
+  return (transition, applied) => {
+    if (!transition.to && !applied) {
+      // An object transition's targets are static, so reading them must not
+      // run its `context` and `input` mappers
+      return {
+        targets: transition.target,
+        context: undefined,
+        reenter: transition.reenter,
+        actions: undefined,
+        internalEvents: undefined,
+        input: undefined
+      };
     }
     let result = cache?.get(transition);
     if (!result) {
@@ -2859,13 +2909,20 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         children: args.children,
         actions: args.actions,
         actors: args.actors,
+        guards: currentSnapshot.machine.sources.guards,
+        delays: currentSnapshot.machine.sources.delays,
         input,
         stateNode
       }, actorScope) : {
         ...args,
+        guards: currentSnapshot.machine.sources.guards,
+        delays: currentSnapshot.machine.sources.delays,
         input,
         stateNode
-      }, enqueue), '_special' in transitionFn ? {
+      },
+      // This function runs during action resolution, where enqueued
+      // effects are no longer collected.
+      enqueue), '_special' in transitionFn ? {
         _special: true
       } : {});
       return [[wrappedAction], undefined, undefined];
@@ -2903,7 +2960,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       }
       for (const exitStateNode of statesToExit) {
         const stateInput = getStateInput(currentSnapshot, exitStateNode.id);
-        const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, currentSnapshot.children, stateInput, 'exit', exitStateNode) : [[], undefined, undefined];
+        const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, nextState.children, stateInput, 'exit', exitStateNode) : [[], undefined, undefined];
         if (internalEvents?.length) {
           internalQueue.push(...internalEvents);
         }
@@ -2933,11 +2990,20 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
     let context = nextState.context;
     const transitionActions = [];
     const internalEvents = [];
+    const resolvedTransitions = [];
     for (const t of filteredTransitions) {
-      if (t.actions) {
-        transitionActions.push(...toArray(t.actions));
+      const res = getCurrentTransitionResult(t, true);
+      if (t.to) {
+        const resolvedTransition = {
+          ...t,
+          target: res.targets,
+          definition: t
+        };
+        resolvedTransition.toJSON = () => transitionDefinitionToJSON(resolvedTransition);
+        resolvedTransitions.push(resolvedTransition);
+      } else {
+        resolvedTransitions.push(t);
       }
-      const res = getCurrentTransitionResult(t);
       if (res.context !== undefined) {
         context = mergeContextPatch(context, res.context);
       }
@@ -3093,7 +3159,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         const {
           targets,
           input
-        } = getCurrentTransitionResult(transition);
+        } = getCurrentTransitionResult(transition, true);
         if (input && targets) {
           for (const targetNode of targets.filter(targetNode => enteredTargetsByTransition.get(transition)?.has(targetNode))) {
             stateInputMap[targetNode.id] = input;
@@ -3102,12 +3168,12 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         }
       }
       const completedNodes = new Set();
-      const children = {
-        ...nextState.children
-      };
       for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
         mutStateNodeSet.add(stateNodeToEnter);
         const actions = [];
+        // Read the children for each state: the entry actions of the states
+        // entered before this one may have spawned or stopped children.
+        let children = nextState.children;
 
         // Final states are inert, so (as in SCXML) their invocations never
         // start.
@@ -3146,7 +3212,10 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             args: [actor]
           });
           if (invokeDef.id) {
-            children[invokeDef.id] = actor;
+            children = {
+              ...children,
+              [invokeDef.id]: actor
+            };
           }
         }
         if (invoked) {
@@ -3266,7 +3335,12 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       nextStateNodesToExit.forEach(stateNode => {
         if (stateNode.exit) {
           const stateInput = getStateInput(nextState, stateNode.id);
-          const [exitActions,, nextInternalEvents] = getStateActionsAndContext(stateNode.exit, nextState.context, nextState.children, stateInput, 'exit', stateNode);
+          const [exitActions, nextContext, nextInternalEvents] = getStateActionsAndContext(stateNode.exit, nextState.context, nextState.children, stateInput, 'exit', stateNode);
+          if (nextContext) {
+            nextState = cloneMachineSnapshot(nextState, {
+              context: nextContext
+            });
+          }
           allExitActions.push(...exitActions);
           if (nextInternalEvents?.length) {
             internalQueue.push(...nextInternalEvents);
@@ -3287,14 +3361,14 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       // If context was changed (e.g. by entry actions during self-transition),
       // clone to ensure reference inequality for eventless transition re-evaluation
       if (nextState.context !== originalContext) {
-        return [nextState === currentSnapshot ? cloneMachineSnapshot(nextState) : nextState, executableActions];
+        return [nextState === currentSnapshot ? cloneMachineSnapshot(nextState) : nextState, executableActions, resolvedTransitions];
       }
-      return [nextState, executableActions];
+      return [nextState, executableActions, resolvedTransitions];
     }
     return [cloneMachineSnapshot(nextState, {
       _nodes: nextStateNodes,
       historyValue
-    }), executableActions];
+    }), executableActions, resolvedTransitions];
   }
 }
 
@@ -3404,6 +3478,15 @@ class InfiniteTransitionError extends Error {
   }
 }
 function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps = []) {
+  // A done, error or stopped snapshot processes no events, as in an actor:
+  // every event is unhandled. The initial macrostep passes `initialMicrosteps`
+  // and may start from a snapshot that is already done.
+  if (snapshot.status !== 'active' && !initialMicrosteps.length) {
+    return {
+      snapshot,
+      microsteps: [[snapshot, [], []]]
+    };
+  }
   let nextSnapshot = snapshot;
   const microsteps = initialMicrosteps.slice();
   // Whether a transition handled the external event. A handled event always
@@ -3472,6 +3555,7 @@ function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps
     };
   }
   function addMicrostep(step, transitions) {
+    transitions = step[2] ?? transitions;
     // collect microsteps; their transitions are surfaced on the enclosing
     // '@xstate.transition' event via its `microsteps[]` facet (there is no
     // standalone microstep event) and returned by `getMicrosteps()`
@@ -3882,6 +3966,17 @@ function isMachineSnapshot(value) {
   return !!value && typeof value === 'object' && 'machine' in value && 'value' in value;
 }
 
+/**
+ * The values that `snapshot.matches(...)` accepts for a state value: a state
+ * key, a dot-delimited path to a descendant state, or a partial state value.
+ * Non-literal state values accept any value.
+ */
+
+/**
+ * `unknown` if `matches(...)` accepts `TTestStateValue` for `TStateValue`,
+ * otherwise `never`. Non-literal test values are always accepted.
+ */
+
 /** @public */
 
 const machineSnapshotMatches = function matches(testValue) {
@@ -4382,7 +4477,14 @@ function getAllOwnEventDescriptors(snapshot) {
   return [...new Set([...snapshot.nodes.flatMap(sn => sn.ownEvents)])];
 }
 
-/** @internal Events synthesized from active transition descriptors. */
+/**
+ * Returns one event per transition of the active state nodes of `snapshot`,
+ * including the internal events for invoked actors (`xstate.done.actor`,
+ * `xstate.error.actor`) and delayed transitions (`xstate.after`). Graph
+ * traversal sends these when the `events` option is not given.
+ *
+ * @public
+ */
 function getAllOwnEvents(snapshot) {
   const events = snapshot.nodes.flatMap(stateNode => [...stateNode.transitions.values()].flatMap(transitions => transitions.map(transition => {
     const event = {
@@ -5931,7 +6033,10 @@ class Actor {
       const [nextSnapshot, effects] = nextState;
       if (nextSnapshot === previousSnapshot && !effects.length &&
       // State machine snapshots only; other logic may ignore events freely.
-      'machine' in previousSnapshot && !event.type.startsWith('xstate.')) {
+      'machine' in previousSnapshot && (
+      // `xstate.route` is sent by users, so a route that matches nothing is
+      // reported like any other unhandled event.
+      !event.type.startsWith('xstate.') || event.type === 'xstate.route')) {
         this._reportUnhandledEvent(event);
       }
       snapshot = nextSnapshot;