xstate 6.0.0-alpha.21 → 6.0.0-alpha.23

package/dist/{StateMachine-1b155670.cjs.js → StateMachine-aad57180.cjs.js}

@@ -1,56 +1,127 @@
 'use strict';
 
-var dist_xstateActors = require('./index-e694228c.cjs.js');
+var dist_xstateActors = require('./index-434fac23.cjs.js');
 
-function createSpawner(actorScope, {
-  machine,
-  context
-}, event, spawnedChildren) {
-  const spawn = (src, options) => {
-    if (typeof src === 'string') {
-      const logic = dist_xstateActors.resolveReferencedActor(machine, src);
-      if (!logic) {
-        throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
-      }
-      const actor = dist_xstateActors.createActor(logic, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: typeof options?.input === 'function' ? options.input({
-          context,
-          event,
-          self: actorScope.self
-        }) : options?.input,
-        src,
-        registryKey: options?.registryKey
-      });
-      spawnedChildren[actor.id] = actor;
-      return actor;
-    } else {
-      const actor = dist_xstateActors.createActor(src, {
-        id: options?.id,
-        parent: actorScope.self,
-        syncSnapshot: options?.syncSnapshot,
-        input: options?.input,
-        src,
-        registryKey: options?.registryKey
-      });
-      return actor;
-    }
-  };
+function createSpawner(actorScope, actorSources, spawnedChildren) {
   return (src, options) => {
-    const actor = spawn(src, options); // TODO: fix types
-    spawnedChildren[actor.id] = actor;
-    actorScope.defer(() => {
-      if (actor._processingStatus === dist_xstateActors.ProcessingStatus.Stopped) {
-        return;
-      }
-      actor.start();
+    const referencedSrc = Object.entries(actorSources).find(([, logic]) => logic === src)?.[0];
+    const actor = actorScope.system.createActorRef(src, {
+      id: options?.id,
+      parent: actorScope.self,
+      syncSnapshot: options?.syncSnapshot,
+      input: options?.input,
+      src: referencedSrc ?? src,
+      registryKey: options?.registryKey
     });
+    spawnedChildren[actor.id] = actor;
     return actor;
   };
 }
 
+/** @internal */
+function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
+  actorScope.self._snapshot = snapshot;
+  if (attachActorRef && snapshot && typeof snapshot === 'object') {
+    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self);
+  }
+  return snapshot;
+}
+
+/** @internal */
+function isInertActorScope(actorScope) {
+  return !!actorScope.self.options?._inert;
+}
+
+/** @internal */
+function attachSnapshotActorRef(actorLogic, actorScope, snapshot) {
+  const snapshotScope = createInertActorScope(actorLogic, snapshot, actorScope.self);
+  return setInertActorScopeSnapshot(snapshotScope, snapshot);
+}
+
+/** @internal */
+function createInertActorScope(actorLogic, snapshot, sourceSelf) {
+  const snapshotRef = snapshot ? dist_xstateActors.getSnapshotActorRef(snapshot) : undefined;
+  const previousSelf = sourceSelf ?? snapshotRef?.actor;
+  const baseSystem = previousSelf?.system;
+  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, previousSelf, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const self = dist_xstateActors.createActor(actorLogic, {
+    _inert: true,
+    ...(previousSelf ? {
+      id: previousSelf.id
+    } : {}),
+    ...(system ? {
+      _systemRef: {
+        current: system
+      }
+    } : {})
+  });
+  if (previousSelf?._parent) {
+    self._parent = previousSelf._parent;
+  }
+  if (snapshot) {
+    self._snapshot = snapshot;
+  }
+  const actorScope = {
+    self: self,
+    defer: () => {},
+    id: self.id,
+    logger: self.system._logger,
+    sessionId: self.sessionId,
+    stopChild: child => child._stop(),
+    system: self.system,
+    emit: event => self.system.emitEvent(self, event),
+    actionExecutor: () => {}
+  };
+  return actorScope;
+}
+
+/** @deprecated Use `initialTransition(…)` instead. */
+function getInitialSnapshot(actorLogic, ...[input]) {
+  const actorScope = createInertActorScope(actorLogic);
+  return actorLogic.initialTransition(input, actorScope)[0];
+}
+
+/**
+ * Determines the next snapshot for the given `actorLogic` based on the given
+ * `snapshot` and `event`.
+ *
+ * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
+ * used.
+ *
+ * @deprecated Use `transition(…)` instead.
+ * @example
+ *
+ * ```ts
+ * import { getNextSnapshot } from 'xstate';
+ * import { trafficLightMachine } from './trafficLightMachine.ts';
+ *
+ * const nextSnapshot = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   undefined, // snapshot (or initial state if undefined)
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot.value);
+ * // => 'yellow'
+ *
+ * const nextSnapshot2 = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   nextSnapshot, // snapshot
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot2.value);
+ * // =>'red'
+ * ```
+ */
+function getNextSnapshot(actorLogic, snapshot, event) {
+  const actorScope = createInertActorScope(actorLogic, snapshot);
+  const transitionResult = actorLogic.transition(snapshot, event, actorScope);
+  const nextSnapshot = Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
+  setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
+  return nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorLogic, actorScope, nextSnapshot);
+}
+
 const cache = new WeakMap();
 function memo(object, key, fn) {
   let memoizedData = cache.get(object);
@@ -543,19 +614,37 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
+    const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
     if (fastSnapshot) {
-      return [fastSnapshot, []];
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+      }
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      return [returnedSnapshot, []];
     }
     const {
       snapshot: nextSnapshot,
       microsteps
-    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
-    return [nextSnapshot, this._collectEffects(microsteps)];
+    } = dist_xstateActors.macrostep(snapshot, event, resolvedActorScope, []);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+    }
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    return [returnedSnapshot, this._collectEffects(microsteps)];
+  }
+  _collectEffects(microsteps) {
+    return microsteps.flatMap(([, actions]) => actions);
   }
-  _collectEffects(microsteps, initialActions = []) {
-    const effects = [...initialActions, ...microsteps.flatMap(([, actions]) => actions)];
-    return [...effects, ...dist_xstateActors.deriveDeferredStarts(effects)];
+  _attachPureActorRef(snapshot, actorScope) {
+    if (isInertActorScope(actorScope)) {
+      return snapshot;
+    }
+    return attachSnapshotActorRef(this, actorScope, snapshot);
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -616,6 +705,9 @@ class StateMachine {
     return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
   }
   isInternalEventType(eventType) {
+    if (eventType === dist_xstateActors.XSTATE_TIMER) {
+      return true;
+    }
     for (const descriptor of this.internalEventDescriptors) {
       if (dist_xstateActors.matchesEventDescriptor(eventType, descriptor)) {
         return true;
@@ -682,10 +774,10 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this);
+    }, this, actorScope.self);
     if (typeof context === 'function') {
       const children = {};
-      const spawn = createSpawner(actorScope, preInitial, initEvent, children);
+      const spawn = createSpawner(actorScope, this.implementations.actorSources, children);
       const resolvedContext = context({
         spawn,
         input: initEvent.input,
@@ -715,30 +807,37 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
-    const preInitialState = this._getPreInitialState(actorScope, initEvent);
+    const preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
+    const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => dist_xstateActors.createSpawnEffect(actor));
     let nextState;
     let initialActions = [];
     let microsteps = [];
     let macroState;
     try {
-      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
       ({
         snapshot: macroState,
         microsteps
-      } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue));
+      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
     } catch (err) {
       if (!this.root.config.onError) {
         throw err;
       }
       const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
-      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, actorScope, []);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
       macroState = errorMacrostep.snapshot;
       microsteps = errorMacrostep.microsteps;
       initialActions = [];
     }
-    return [macroState, this._collectEffects(microsteps, initialActions)];
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+    }
+    const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+    return [returnedSnapshot, this._collectEffects(microsteps)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -766,7 +865,9 @@ class StateMachine {
   getPersistedSnapshot(snapshot, options) {
     return dist_xstateActors.getPersistedSnapshot(snapshot, options);
   }
-  restoreSnapshot(snapshot, _actorScope) {
+  restoreSnapshot(snapshot, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const persistedVersion = snapshot.version;
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
@@ -786,9 +887,9 @@ class StateMachine {
       if (!logic) {
         continue;
       }
-      const actor = dist_xstateActors.createActor(logic, {
+      const actor = resolvedActorScope.system.createActorRef(logic, {
         id: actorId,
-        parent: _actorScope.self,
+        parent: resolvedActorScope.self,
         syncSnapshot: actorData.syncSnapshot,
         snapshot: childState,
         src,
@@ -799,6 +900,19 @@ class StateMachine {
       actor._rehydrated = true;
       children[actorId] = actor;
     }
+    const timers = {};
+    const persistedTimers = snapshotData.timers ?? {};
+    for (const [id, timer] of Object.entries(persistedTimers)) {
+      const target = typeof timer.target === 'string' ? timer.target === 'self' ? 'self' : children[timer.target] : resolvedActorScope.self._parent;
+      if (!target) {
+        const targetDescription = typeof timer.target === 'string' ? timer.target : timer.target.type;
+        throw new Error(`Unable to restore timer '${id}': target actor '${targetDescription}' is unavailable.`);
+      }
+      timers[id] = {
+        ...timer,
+        target
+      };
+    }
     const reviveHistoryValue = historyValue => {
       if (!historyValue || typeof historyValue !== 'object') {
         return {};
@@ -834,11 +948,12 @@ class StateMachine {
     const restoredSnapshot = dist_xstateActors.createMachineSnapshot({
       ...persistedRest,
       children,
+      timers,
       _nodes: nodes,
       value: snapshotData.value,
       historyValue: revivedHistoryValue,
       _stateInputs: snapshotData.stateInputs ?? {}
-    }, this);
+    }, this, resolvedActorScope.self);
     const seen = new WeakSet();
     function reviveContext(contextPart) {
       if (seen.has(contextPart)) {
@@ -857,9 +972,18 @@ class StateMachine {
       }
     }
     reviveContext(restoredSnapshot.context);
-    return restoredSnapshot;
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+    }
+    return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }
 }
 
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;
+exports.attachSnapshotActorRef = attachSnapshotActorRef;
+exports.createInertActorScope = createInertActorScope;
+exports.getInitialSnapshot = getInitialSnapshot;
+exports.getNextSnapshot = getNextSnapshot;
+exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;