xstate 6.0.0-alpha.63 → 6.0.0-alpha.65

package/dist/{createActor-523a98c7.esm.js → createActor-4629a290.esm.js}

@@ -181,6 +181,20 @@ function reportUnhandledError(err) {
 
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
 
+// Runtime metadata stays outside pure snapshots. Timer objects survive unrelated
+// transitions; a cancelled/replaced timer gets a new object and a new deadline.
+const starts = new WeakMap();
+
+/** @internal */
+function getTimerStart(timer) {
+  return starts.get(timer) ?? timer.startedAt;
+}
+
+/** @internal */
+function recordTimerStart(timer, startedAt) {
+  starts.set(timer, startedAt);
+}
+
 function assertSendToEvent(event) {
   if (typeof event === 'string') {
     throw new Error(`Only event objects may be used with sendTo`);
@@ -238,6 +252,9 @@ function resolveRegisteredActorSource(actors, logic) {
   return cache.get(logic);
 }
 
+/** Static scheduling metadata on actor definitions, never on live actors. @internal */
+const systemLogicMetadata = Symbol('xstate.systemLogicMetadata');
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -256,7 +273,7 @@ id) {
     error: undefined,
     input
   }, []];
-  return {
+  const logic = {
     id,
     start: (state, {
       self,
@@ -320,6 +337,12 @@ id) {
     getPersistedSnapshot: snapshot => snapshot,
     restoreSnapshot: snapshot => snapshot
   };
+  Object.defineProperty(logic, systemLogicMetadata, {
+    value: {
+      kind: id
+    }
+  });
+  return logic;
 }
 
 /**
@@ -504,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);
@@ -1026,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, () => {
@@ -2243,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);
@@ -2253,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) {
@@ -2603,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) {
@@ -2836,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];
@@ -2880,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);
         }
@@ -2910,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);
       }
@@ -3070,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;
@@ -3079,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.
@@ -3123,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) {
@@ -3243,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);
@@ -3264,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];
   }
 }
 
@@ -3381,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
@@ -3449,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()`
@@ -3859,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) {
@@ -4050,7 +4168,7 @@ function getPersistedSnapshot(snapshot, options) {
   // readings (a simulated clock, a monotonic counter) are meaningless in any
   // other process, and restoring them under the wall clock would fire every
   // pending delay instantly. Pure-transition snapshots have no local
-  // schedule and persist no timestamp.
+  // schedule; durable executions record an accepted start separately.
   const scheduledTimers = snapshotActor?.system?._clock?.now ? undefined : snapshotActor?.system?._snapshot?._scheduledTimers;
   for (const id in timers) {
     const timer = timers[id];
@@ -4081,10 +4199,10 @@ function getPersistedSnapshot(snapshot, options) {
     // deadline. Derived from dueAt, not the scheduling moment, so repeated
     // persist/restore cycles keep the same deadline. Without a live schedule
     // (a restored-but-never-started actor, a pure-transition snapshot) the
-    // timer's carried-in start — which only a wall-clock actor ever stamped —
-    // passes through, so re-persisting cannot push the deadline back.
+    // timer's accepted durable start or carried-in start passes through,
+    // so re-persisting cannot push the deadline back.
     const scheduled = scheduledTimers?.[`${snapshotActor.sessionId}.${id}`];
-    const startedAt = scheduled ? scheduled.dueAt - timer.delay : timer.startedAt;
+    const startedAt = scheduled ? scheduled.dueAt - timer.delay : getTimerStart(timer);
     timersJson[id] = {
       id: timer.id,
       delay: timer.delay,
@@ -4359,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 = {
@@ -5908,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;
@@ -6228,4 +6356,4 @@ function createActor(logic, ...[options]) {
   return new Actor(logic, options);
 }
 
-export { parseGeneratedActorId as $, attachSnapshotActorRef as A, macrostep as B, isInertActorScope as C, setSnapshotActorRef as D, cloneMachineSnapshot as E, transitionNode as F, getTransitionResult as G, hasEffect as H, createErrorPlatformEvent as I, withActorSelf as J, resolveActionsWithContext as K, takeSpawnAllocationCounters as L, mergeActorIdCounters as M, NULL_EVENT as N, createInitEvent as O, createSpawnEffect as P, initialMicrostep as Q, createStartEffect as R, STATE_DELIMITER as S, toStatePath as T, isStateId as U, getStateNodeByPath as V, getPersistedSnapshot as W, XSTATE_TIMER as X, createRemoteActorRef as Y, resolveReferencedActor as Z, createInvokeTimeoutEvent as _, allocateChildId as a, ACTOR_REF_TYPE as a0, createActor as a1, parseDelayToMilliseconds as a2, isAtomicStateNode as a3, ProcessingStatus as a4, isActorRefLike as a5, createListenerLogic as a6, createSubscriptionLogic as a7, listenerLogic as a8, subscriptionLogic as a9, getActorIdPrefix as aA, getAllOwnEvents as aB, matchesEvent as aC, encodeAddressSegment as aD, getRootActorId as aE, RUNTIME_OPERATIONS as aF, withSystemInspector as aG, createTimerEffect as aH, getSnapshotActorRef as aI, withExecutionIdentity as aJ, Actor as aa, isMachineSnapshot as ab, InfiniteTransitionError as ac, getAllOwnEventDescriptors as ad, matchesState as ae, checkStateIn as af, pathToStateValue as ag, toObserver as ah, executeEffects as ai, isBuiltInExecutableAction as aj, deliverEvent as ak, runStep as al, stopActor as am, terminateActor as an, XSTATE_STOP as ao, createCustomEffect as ap, XSTATE_LOGIC_EFFECT_START as aq, XSTATE_LOGIC_EFFECT_RESOLVE as ar, XSTATE_LOGIC_EFFECT_REJECT as as, finalizeTransitionResult as at, createEmitEffect as au, createSendToEffect as av, XSTATE_INIT as aw, hasAmbientInspector as ax, getProperAncestors as ay, isRemoteActorRef as az, assertChildIdFree as b, reserveChildId as c, mapValues as d, createInvokeId as e, getEventDescriptorKey as f, getDelayedTransitions as g, getCandidates as h, evaluateCandidate as i, formatTransition as j, toTransitionConfigArray as k, createInvokeTimeoutEventId as l, matchesEventDescriptor as m, matchesActorSession as n, formatRouteTransitions as o, resolveStateValue as p, getAllStateNodes as q, resolveRegisteredActorSource as r, getStateNodes as s, toArray as t, createMachineSnapshot as u, isInFinalState as v, createInertActorScope as w, setInertActorScopeSnapshot as x, createDeadLetterEffect as y, beginSpawnAllocation as z };
+export { parseGeneratedActorId as $, attachSnapshotActorRef as A, macrostep as B, isInertActorScope as C, setSnapshotActorRef as D, cloneMachineSnapshot as E, transitionNode as F, getTransitionResult as G, hasEffect as H, createErrorPlatformEvent as I, withActorSelf as J, resolveActionsWithContext as K, takeSpawnAllocationCounters as L, mergeActorIdCounters as M, NULL_EVENT as N, createInitEvent as O, createSpawnEffect as P, initialMicrostep as Q, createStartEffect as R, STATE_DELIMITER as S, toStatePath as T, isStateId as U, getStateNodeByPath as V, getPersistedSnapshot as W, XSTATE_TIMER as X, createRemoteActorRef as Y, resolveReferencedActor as Z, createInvokeTimeoutEvent as _, allocateChildId as a, ACTOR_REF_TYPE as a0, createActor as a1, parseDelayToMilliseconds as a2, isAtomicStateNode as a3, ProcessingStatus as a4, isActorRefLike as a5, encodeAddressSegment as a6, systemLogicMetadata as a7, getActorIdPrefix as a8, finalizeTransitionResult as a9, createSendToEffect as aA, XSTATE_INIT as aB, hasAmbientInspector as aC, getProperAncestors as aD, isRemoteActorRef as aE, getAllOwnEvents as aF, matchesEvent as aG, getRootActorId as aH, RUNTIME_OPERATIONS as aI, withSystemInspector as aJ, createTimerEffect as aK, getSnapshotActorRef as aL, withExecutionIdentity as aM, getTimerStart as aN, recordTimerStart as aO, createDoneActorEvent as aa, createErrorActorEvent as ab, isMachineSnapshot as ac, listenerLogic as ad, subscriptionLogic as ae, createListenerLogic as af, createSubscriptionLogic as ag, Actor as ah, InfiniteTransitionError as ai, getAllOwnEventDescriptors as aj, matchesState as ak, checkStateIn as al, pathToStateValue as am, toObserver as an, executeEffects as ao, isBuiltInExecutableAction as ap, deliverEvent as aq, runStep as ar, stopActor as as, terminateActor as at, XSTATE_STOP as au, createCustomEffect as av, XSTATE_LOGIC_EFFECT_START as aw, XSTATE_LOGIC_EFFECT_RESOLVE as ax, XSTATE_LOGIC_EFFECT_REJECT as ay, createEmitEffect as az, assertChildIdFree as b, reserveChildId as c, mapValues as d, createInvokeId as e, getEventDescriptorKey as f, getDelayedTransitions as g, getCandidates as h, evaluateCandidate as i, formatTransition as j, toTransitionConfigArray as k, createInvokeTimeoutEventId as l, matchesEventDescriptor as m, matchesActorSession as n, formatRouteTransitions as o, resolveStateValue as p, getAllStateNodes as q, resolveRegisteredActorSource as r, getStateNodes as s, toArray as t, createMachineSnapshot as u, isInFinalState as v, createInertActorScope as w, setInertActorScopeSnapshot as x, createDeadLetterEffect as y, beginSpawnAllocation as z };