xstate 6.0.0-alpha.2 → 6.0.0-alpha.20

package/dist/{StateMachine-8d22a79c.development.cjs.js → StateMachine-6661eb0d.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-f6ef20d1.development.cjs.js');
+var dist_xstateActors = require('./index-49293864.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -22,7 +22,7 @@ function createSpawner(actorScope, {
           self: actorScope.self
         }) : options?.input,
         src,
-        systemId: options?.systemId
+        registryKey: options?.registryKey
       });
       spawnedChildren[actor.id] = actor;
       return actor;
@@ -33,7 +33,7 @@ function createSpawner(actorScope, {
         syncSnapshot: options?.syncSnapshot,
         input: options?.input,
         src,
-        systemId: options?.systemId
+        registryKey: options?.registryKey
       });
       return actor;
     }
@@ -173,7 +173,7 @@ class StateNode {
     this.invoke = dist_xstateActors.toArray(this.config.invoke).map((invokeConfig, i) => {
       const {
         src,
-        systemId
+        registryKey
       } = invokeConfig;
       const invokeId = dist_xstateActors.createInvokeId(this.id, i);
       const resolvedId = invokeConfig.id ?? invokeId;
@@ -186,7 +186,7 @@ class StateNode {
         src: sourceName,
         logic: src,
         id: resolvedId,
-        systemId
+        registryKey
       };
     });
   }
@@ -252,11 +252,13 @@ function validateStateNodeConfig(stateNode) {
     return;
   }
   if (typeof config.choice !== 'function') {
-    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.`);
+    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.` );
   }
-  for (const key of CHOICE_CONFIG_KEYS) {
-    if (config[key] !== undefined) {
-      throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+  {
+    for (const key of CHOICE_CONFIG_KEYS) {
+      if (config[key] !== undefined) {
+        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+      }
     }
   }
 }
@@ -264,11 +266,13 @@ function formatChoiceTransitions(stateNode) {
   const choice = stateNode.config.choice;
   const validateChoiceResult = result => {
     if (!result || result.target === undefined) {
-      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
+      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.` );
     }
-    for (const key of ['actions', 'to', 'context']) {
-      if (result[key] !== undefined) {
-        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+    {
+      for (const key of ['actions', 'to']) {
+        if (result[key] !== undefined) {
+          throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+        }
       }
     }
     return result;
@@ -290,7 +294,7 @@ function formatTransitions(stateNode) {
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
       if (descriptor === dist_xstateActors.NULL_EVENT) {
-        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.' );
       }
       const transitionsConfig = stateNode.config.on[descriptor];
       transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
@@ -300,6 +304,10 @@ function formatTransitions(stateNode) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
     transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
   }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+  }
   const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => dist_xstateActors.formatTransition(stateNode, descriptor, {
     to: (_args, enq) => {
       enq.cancel(timeoutEventType);
@@ -386,7 +394,7 @@ function formatInitialTransition(stateNode, _target) {
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
   const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
   if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}`);
+    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}` );
   }
   const transition = {
     source: stateNode,
@@ -397,6 +405,45 @@ function formatInitialTransition(stateNode, _target) {
 }
 
 const STATE_IDENTIFIER = '#';
+let emptyCanActor;
+let emptyCanActorScope;
+function getEmptyCanActor() {
+  // A minimal inert actor used purely as the `self`/`parent` argument when
+  // dry-running transitions for `snapshot.can(...)`. Intentionally not built
+  // on `createLogic` so `can()` does not pull that machinery into bundles.
+  return emptyCanActor ??= dist_xstateActors.createActor({
+    transition: snapshot => [snapshot, []],
+    initialTransition: () => [{
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }, []],
+    getInitialSnapshot: () => ({
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }),
+    getPersistedSnapshot: snapshot => snapshot
+  });
+}
+function getEmptyCanActorScope() {
+  if (emptyCanActorScope) {
+    return emptyCanActorScope;
+  }
+  const actor = getEmptyCanActor();
+  emptyCanActorScope = {
+    self: actor,
+    logger: () => {},
+    id: '',
+    sessionId: '',
+    defer: () => {},
+    system: actor.system,
+    stopChild: () => {},
+    emit: () => {},
+    actionExecutor: () => {}
+  };
+  return emptyCanActorScope;
+}
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
   config, implementations) {
@@ -424,7 +471,7 @@ class StateMachine {
     this._json = void 0;
     this.id = config.id || '(machine)';
     this.implementations = {
-      actors: config.actors ?? {},
+      actorSources: config.actorSources ?? {},
       actions: config.actions ?? {},
       delays: config.delays ?? {},
       guards: config.guards ?? {},
@@ -433,7 +480,7 @@ class StateMachine {
     {
       // The `@xstate.` prefix is reserved for built-in serialized action and
       // guard descriptors — user implementation names must not collide.
-      for (const kind of ['actions', 'guards', 'actors', 'delays']) {
+      for (const kind of ['actions', 'guards', 'actorSources', 'delays']) {
         for (const key of Object.keys(this.implementations[kind])) {
           if (key.startsWith('@xstate.')) {
             throw new Error(`Invalid ${kind} name '${key}': the '@xstate.' prefix is reserved for built-in descriptors.`);
@@ -449,6 +496,7 @@ class StateMachine {
       ...this.config.options
     };
     this.transition = this.transition.bind(this);
+    this.initialTransition = this.initialTransition.bind(this);
     this.getInitialSnapshot = this.getInitialSnapshot.bind(this);
     this.getPersistedSnapshot = this.getPersistedSnapshot.bind(this);
     this.restoreSnapshot = this.restoreSnapshot.bind(this);
@@ -462,23 +510,20 @@ class StateMachine {
     this.root._refreshEventMetadata();
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
-    if (!('output' in this.root) && Object.values(this.states).some(state => state.type === 'final' && 'output' in state)) {
-      console.warn('Missing `machine.output` declaration (top-level final state with output detected)');
-    }
   }
 
   /**
    * Clones this state machine with the provided implementations.
    *
-   * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
-   *   recursively merge with the existing options.
+   * @param implementations Options (`actions`, `guards`, `actorSources`,
+   *   `delays`) to recursively merge with the existing options.
    * @returns A new `StateMachine` instance with the provided implementations.
    */
   provide(implementations) {
     const {
       actions,
       guards,
-      actors,
+      actorSources,
       delays
     } = this.implementations;
     const provided = new StateMachine(this.config, {
@@ -490,9 +535,9 @@ class StateMachine {
         ...guards,
         ...implementations.guards
       },
-      actors: {
-        ...actors,
-        ...implementations.actors
+      actorSources: {
+        ...actorSources,
+        ...implementations.actorSources
       },
       delays: {
         ...delays,
@@ -527,7 +572,56 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return dist_xstateActors.macrostep(snapshot, event, actorScope, []).snapshot;
+    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    if (fastSnapshot) {
+      return [fastSnapshot, []];
+    }
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
+    return [nextSnapshot, this._collectEffects(microsteps)];
+  }
+  _collectEffects(microsteps, initialActions = []) {
+    const effects = [...initialActions, ...microsteps.flatMap(([, actions]) => actions)];
+    return [...effects, ...dist_xstateActors.deriveDeferredStarts(effects)];
+  }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return dist_xstateActors.cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
   }
 
   /**
@@ -559,6 +653,49 @@ class StateMachine {
     return false;
   }
 
+  /**
+   * Determines whether sending the `event` to the given snapshot would select a
+   * non-forbidden transition. Backs `snapshot.can(...)`; lives here so that
+   * non-machine bundles don't pay for the transition-resolution machinery.
+   *
+   * @internal
+   */
+  _canTransition(snapshot, event) {
+    const emptyActor = getEmptyCanActor();
+    const emptyActorScope = getEmptyCanActorScope();
+    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    if (!transitionData?.length) {
+      return false;
+    }
+
+    // Check that at least one transition is not forbidden
+    for (const transition of transitionData) {
+      if (transition.target !== undefined) {
+        return true;
+      }
+      const res = dist_xstateActors.getTransitionResult(transition, snapshot, event, emptyActorScope, {
+        resolveActions: false
+      });
+      if (res.targets?.length || res.context || dist_xstateActors.hasEffect(transition, snapshot.context, event, snapshot, emptyActor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns the error event that the actor should transition with to recover
+   * from an execution error, if any active state node declares `onError`.
+   *
+   * @internal
+   */
+  getExecutionErrorEvent(snapshot, error) {
+    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+      return undefined;
+    }
+    return dist_xstateActors.createErrorPlatformEvent('execution', error);
+  }
+
   /**
    * The initial state _before_ evaluating any microsteps. This "pre-initial"
    * state is provided to initial actions executed in the initial state.
@@ -582,9 +719,9 @@ class StateMachine {
         spawn,
         input: initEvent.input,
         self: actorScope.self,
-        actors: this.implementations.actors
+        actorSources: this.implementations.actorSources
       });
-      const nextState = dist_xstateActors.resolveAndExecuteActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = dist_xstateActors.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -604,14 +741,33 @@ class StateMachine {
    * `ActorRef`.
    */
   getInitialSnapshot(actorScope, input) {
+    return this.initialTransition(input, actorScope)[0];
+  }
+  initialTransition(input, actorScope) {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState
-    } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
-    return macroState;
+    let nextState;
+    let initialActions = [];
+    let microsteps = [];
+    let macroState;
+    try {
+      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      ({
+        snapshot: macroState,
+        microsteps
+      } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue));
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, actorScope, []);
+      macroState = errorMacrostep.snapshot;
+      microsteps = errorMacrostep.microsteps;
+      initialActions = [];
+    }
+    return [macroState, this._collectEffects(microsteps, initialActions)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -665,7 +821,7 @@ class StateMachine {
         syncSnapshot: actorData.syncSnapshot,
         snapshot: childState,
         src,
-        systemId: actorData.systemId
+        registryKey: actorData.registryKey
       });
       // Mark so `start()` knows to start this child (freshly invoked/spawned
       // children are started via deferred `@xstate.start` actions instead).
@@ -712,7 +868,8 @@ class StateMachine {
       children,
       _nodes: nodes,
       value: snapshotData.value,
-      historyValue: revivedHistoryValue
+      historyValue: revivedHistoryValue,
+      _stateInputs: snapshotData.stateInputs ?? {}
     }, this);
     const seen = new WeakSet();
     function reviveContext(contextPart) {