xstate 5.0.0-beta.49 → 5.0.0-beta.51

package/dist/{raise-8f9c4a5a.cjs.js → raise-d5633a02.cjs.js}

@@ -205,14 +205,10 @@ function matchesState(parentStateId, childStateId) {
   });
 }
 function toStatePath(stateId) {
-  try {
-    if (isArray(stateId)) {
-      return stateId;
-    }
-    return stateId.split(STATE_DELIMITER);
-  } catch (e) {
-    throw new Error(`'${stateId}' is not a valid state path.`);
+  if (isArray(stateId)) {
+    return stateId;
   }
+  return stateId.split(STATE_DELIMITER);
 }
 function toStateValue(stateValue) {
   if (isMachineSnapshot(stateValue)) {
@@ -451,7 +447,18 @@ class Actor {
     }
   }
   _initState(persistedState) {
-    this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+    try {
+      this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+    } catch (err) {
+      // if we get here then it means that we assign a value to this._state that is not of the correct type
+      // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
+      // so right now this is a lie of sorts
+      this._state = {
+        status: 'error',
+        output: undefined,
+        error: err
+      };
+    }
   }
   update(snapshot, event) {
     // Update state
@@ -460,17 +467,46 @@ class Actor {
     // Execute deferred effects
     let deferredFn;
     while (deferredFn = this._deferred.shift()) {
-      deferredFn();
-    }
-    for (const observer of this.observers) {
       try {
-        observer.next?.(snapshot);
+        deferredFn();
       } catch (err) {
-        reportUnhandledError(err);
+        // this error can only be caught when executing *initial* actions
+        // it's the only time when we call actions provided by the user through those deferreds
+        // when the actor is already running we always execute them synchronously while transitioning
+        // no "builtin deferred" should actually throw an error since they are either safe
+        // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox
+        this._deferred.length = 0;
+        this._state = {
+          ...snapshot,
+          status: 'error',
+          error: err
+        };
       }
     }
     switch (this._state.status) {
+      case 'active':
+        for (const observer of this.observers) {
+          try {
+            observer.next?.(snapshot);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
+        break;
       case 'done':
+        // next observers are meant to be notified about done snapshots
+        // this can be seen as something that is different from how observable work
+        // but with observables `complete` callback is called without any arguments
+        // it's more ergonomic for XState to treat a done snapshot as a "next" value
+        // and the completion event as something that is separate,
+        // something that merely follows emitting that done snapshot
+        for (const observer of this.observers) {
+          try {
+            observer.next?.(snapshot);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
         this._stopProcedure();
         this._complete();
         this._doneEvent = createDoneActorEvent(this.id, this._state.output);
@@ -479,11 +515,7 @@ class Actor {
         }
         break;
       case 'error':
-        this._stopProcedure();
         this._error(this._state.error);
-        if (this._parent) {
-          this.system._relay(this, this._parent, createErrorActorEvent(this.id, this._state.error));
-        }
         break;
     }
     this.system._sendInspectionEvent({
@@ -573,7 +605,7 @@ class Actor {
       this.subscribe({
         next: snapshot => {
           if (snapshot.status === 'active') {
-            this._parent.send({
+            this.system._relay(this, this._parent, {
               type: `xstate.snapshot.${this.id}`,
               snapshot
             });
@@ -602,18 +634,22 @@ class Actor {
         // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
         this.update(this._state, initEvent);
-      // fallthrough
-      case 'error':
         // TODO: rethink cleanup of observers, mailbox, etc
         return this;
+      case 'error':
+        this._error(this._state.error);
+        return this;
     }
     if (this.logic.start) {
       try {
         this.logic.start(this._state, this._actorScope);
       } catch (err) {
-        this._stopProcedure();
+        this._state = {
+          ...this._state,
+          status: 'error',
+          error: err
+        };
         this._error(err);
-        this._parent?.send(createErrorActorEvent(this.id, err));
         return this;
       }
     }
@@ -629,7 +665,6 @@ class Actor {
     return this;
   }
   _process(event) {
-    // TODO: reexamine what happens when an action (or a guard or smth) throws
     let nextState;
     let caughtError;
     try {
@@ -644,9 +679,12 @@ class Actor {
       const {
         err
       } = caughtError;
-      this._stopProcedure();
+      this._state = {
+        ...this._state,
+        status: 'error',
+        error: err
+      };
       this._error(err);
-      this._parent?.send(createErrorActorEvent(this.id, err));
       return;
     }
     this.update(nextState, event);
@@ -689,7 +727,7 @@ class Actor {
     }
     this.observers.clear();
   }
-  _error(err) {
+  _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
@@ -711,6 +749,18 @@ class Actor {
       reportUnhandledError(err);
     }
   }
+  _error(err) {
+    this._stopProcedure();
+    this._reportError(err);
+    if (this._parent) {
+      this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
+    }
+  }
+  // TODO: atm children don't belong entirely to the actor so
+  // in a way - it's not even super aware of them
+  // so we can't stop them from here but we really should!
+  // right now, they are being stopped within the machine's transition
+  // but that could throw and leave us with "orphaned" active actors
   _stopProcedure() {
     if (this._processingStatus !== ProcessingStatus.Running) {
       // Actor already stopped; do nothing
@@ -956,12 +1006,7 @@ function executeSpawn(actorScope, {
     if (actorRef._processingStatus === ProcessingStatus.Stopped) {
       return;
     }
-    try {
-      actorRef.start?.();
-    } catch (err) {
-      actorScope.self.send(createErrorActorEvent(id, err));
-      return;
-    }
+    actorRef.start();
   });
 }
 function spawnChild(...[src, {
@@ -1285,8 +1330,7 @@ function getDelayedTransitions(stateNode) {
     return [];
   }
   const mutateEntryExit = (delay, i) => {
-    const delayRef = typeof delay === 'function' ? `${stateNode.id}:delay[${i}]` : delay;
-    const afterEvent = createAfterEvent(delayRef, stateNode.id);
+    const afterEvent = createAfterEvent(delay, stateNode.id);
     const eventType = afterEvent.type;
     stateNode.entry.push(raise(afterEvent, {
       id: eventType,
@@ -1300,8 +1344,8 @@ function getDelayedTransitions(stateNode) {
     const resolvedTransition = typeof configTransition === 'string' ? {
       target: configTransition
     } : configTransition;
-    const resolvedDelay = !isNaN(+delay) ? +delay : delay;
-    const eventType = mutateEntryExit(resolvedDelay, i);
+    const resolvedDelay = Number.isNaN(+delay) ? delay : +delay;
+    const eventType = mutateEntryExit(resolvedDelay);
     return toArray(resolvedTransition).map(transition => ({
       ...transition,
       event: eventType,
@@ -2016,7 +2060,23 @@ function macrostep(state, event, actorScope, internalQueue = []) {
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
-    const transitions = selectTransitions(nextEvent, nextState);
+    const currentEvent = nextEvent;
+    const isErr = isErrorActorEvent(currentEvent);
+    const transitions = selectTransitions(currentEvent, nextState);
+    if (isErr && !transitions.length) {
+      // TODO: we should likely only allow transitions selected by very explicit descriptors
+      // `*` shouldn't be matched, likely `xstate.error.*` shouldnt be either
+      // similarly `xstate.error.actor.*` and `xstate.error.actor.todo.*` have to be considered too
+      nextState = cloneMachineSnapshot(state, {
+        status: 'error',
+        error: currentEvent.data
+      });
+      states.push(nextState);
+      return {
+        state: nextState,
+        microstates: states
+      };
+    }
     nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
     states.push(nextState);
   }
@@ -2284,7 +2344,6 @@ exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;
-exports.isErrorActorEvent = isErrorActorEvent;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;

package/dist/xstate.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var guards_dist_xstateGuards = require('./raise-8f9c4a5a.cjs.js');
-var send = require('./send-8ed5c8b2.cjs.js');
+var guards_dist_xstateGuards = require('./raise-d5633a02.cjs.js');
+var pure = require('./pure-c5f1b46c.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 class SimulatedClock {
@@ -458,17 +458,7 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (guards_dist_xstateGuards.isErrorActorEvent(event) && !guards_dist_xstateGuards.getAllOwnEventDescriptors(snapshot).some(nextEvent => nextEvent === event.type)) {
-      return guards_dist_xstateGuards.cloneMachineSnapshot(snapshot, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = guards_dist_xstateGuards.macrostep(snapshot, event, actorScope);
-    return nextState;
+    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope).state;
   }
 
   /**
@@ -507,7 +497,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorScope, [send.assign(assignment)], internalQueue);
+      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorScope, [pure.assign(assignment)], internalQueue);
     }
     return preInitial;
   }
@@ -726,15 +716,16 @@ exports.stateIn = guards_dist_xstateGuards.stateIn;
 exports.stop = guards_dist_xstateGuards.stop;
 exports.stopChild = guards_dist_xstateGuards.stopChild;
 exports.toObserver = guards_dist_xstateGuards.toObserver;
-exports.SpecialTargets = send.SpecialTargets;
-exports.assign = send.assign;
-exports.choose = send.choose;
-exports.escalate = send.escalate;
-exports.forwardTo = send.forwardTo;
-exports.log = send.log;
-exports.pure = send.pure;
-exports.sendParent = send.sendParent;
-exports.sendTo = send.sendTo;
+exports.SpecialTargets = pure.SpecialTargets;
+exports.assign = pure.assign;
+exports.choose = pure.choose;
+exports.enqueueActions = pure.enqueueActions;
+exports.escalate = pure.escalate;
+exports.forwardTo = pure.forwardTo;
+exports.log = pure.log;
+exports.pure = pure.pure;
+exports.sendParent = pure.sendParent;
+exports.sendTo = pure.sendTo;
 exports.SimulatedClock = SimulatedClock;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;

package/dist/xstate.cjs.mjs

@@ -12,6 +12,7 @@ export {
   createActor,
   createEmptyActor,
   createMachine,
+  enqueueActions,
   escalate,
   forwardTo,
   fromCallback,

package/dist/xstate.development.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
-var guards_dist_xstateGuards = require('./raise-495f4b9f.development.cjs.js');
-var send = require('./send-8d30b415.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-528386de.development.cjs.js');
+var pure = require('./pure-a0f16134.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
 class SimulatedClock {
@@ -461,17 +461,7 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (guards_dist_xstateGuards.isErrorActorEvent(event) && !guards_dist_xstateGuards.getAllOwnEventDescriptors(snapshot).some(nextEvent => nextEvent === event.type)) {
-      return guards_dist_xstateGuards.cloneMachineSnapshot(snapshot, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = guards_dist_xstateGuards.macrostep(snapshot, event, actorScope);
-    return nextState;
+    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope).state;
   }
 
   /**
@@ -510,7 +500,7 @@ class StateMachine {
         spawn,
         input: event.input
       });
-      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorScope, [send.assign(assignment)], internalQueue);
+      return guards_dist_xstateGuards.resolveActionsAndContext(preInitial, initEvent, actorScope, [pure.assign(assignment)], internalQueue);
     }
     return preInitial;
   }
@@ -732,15 +722,16 @@ exports.stateIn = guards_dist_xstateGuards.stateIn;
 exports.stop = guards_dist_xstateGuards.stop;
 exports.stopChild = guards_dist_xstateGuards.stopChild;
 exports.toObserver = guards_dist_xstateGuards.toObserver;
-exports.SpecialTargets = send.SpecialTargets;
-exports.assign = send.assign;
-exports.choose = send.choose;
-exports.escalate = send.escalate;
-exports.forwardTo = send.forwardTo;
-exports.log = send.log;
-exports.pure = send.pure;
-exports.sendParent = send.sendParent;
-exports.sendTo = send.sendTo;
+exports.SpecialTargets = pure.SpecialTargets;
+exports.assign = pure.assign;
+exports.choose = pure.choose;
+exports.enqueueActions = pure.enqueueActions;
+exports.escalate = pure.escalate;
+exports.forwardTo = pure.forwardTo;
+exports.log = pure.log;
+exports.pure = pure.pure;
+exports.sendParent = pure.sendParent;
+exports.sendTo = pure.sendTo;
 exports.SimulatedClock = SimulatedClock;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;

package/dist/xstate.development.cjs.mjs

@@ -12,6 +12,7 @@ export {
   createActor,
   createEmptyActor,
   createMachine,
+  enqueueActions,
   escalate,
   forwardTo,
   fromCallback,

package/dist/xstate.development.esm.js

@@ -1,8 +1,8 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as isErrorActorEvent, o as getAllOwnEventDescriptors, p as cloneMachineSnapshot, q as macrostep, s as transitionNode, u as resolveActionsAndContext, v as createInitEvent, w as microstep, x as getInitialStateNodes, y as isStateId, z as getStateNodeByPath, A as getPersistedState, B as resolveReferencedActor, C as createActor, $ as $$ACTOR_TYPE } from './raise-1873c645.development.esm.js';
-export { D as Actor, o as __unsafe_getAllOwnEventDescriptors, J as and, O as cancel, C as createActor, j as getStateNodes, E as interpret, F as isMachineSnapshot, G as matchesState, K as not, L as or, H as pathToStateValue, P as raise, T as spawnChild, M as stateIn, Q as stop, R as stopChild, I as toObserver } from './raise-1873c645.development.esm.js';
-import { a as assign } from './send-0a381ca2.development.esm.js';
-export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-0a381ca2.development.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as isStateId, w as getStateNodeByPath, x as getPersistedState, y as resolveReferencedActor, z as createActor, $ as $$ACTOR_TYPE } from './raise-acaa3884.development.esm.js';
+export { A as Actor, G as __unsafe_getAllOwnEventDescriptors, H as and, L as cancel, z as createActor, j as getStateNodes, B as interpret, C as isMachineSnapshot, D as matchesState, I as not, J as or, E as pathToStateValue, M as raise, O as spawnChild, K as stateIn, P as stop, Q as stopChild, F as toObserver } from './raise-acaa3884.development.esm.js';
+import { a as assign } from './pure-296f8ebd.development.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as enqueueActions, b as escalate, f as forwardTo, l as log, p as pure, s as sendParent, d as sendTo } from './pure-296f8ebd.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
 class SimulatedClock {
@@ -459,17 +459,7 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (isErrorActorEvent(event) && !getAllOwnEventDescriptors(snapshot).some(nextEvent => nextEvent === event.type)) {
-      return cloneMachineSnapshot(snapshot, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = macrostep(snapshot, event, actorScope);
-    return nextState;
+    return macrostep(snapshot, event, actorScope).state;
   }
 
   /**

package/dist/xstate.esm.js

@@ -1,8 +1,8 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as isErrorActorEvent, o as getAllOwnEventDescriptors, p as cloneMachineSnapshot, q as macrostep, s as transitionNode, u as resolveActionsAndContext, v as createInitEvent, w as microstep, x as getInitialStateNodes, y as isStateId, z as getStateNodeByPath, A as getPersistedState, B as resolveReferencedActor, C as createActor, $ as $$ACTOR_TYPE } from './raise-e4cc6d4f.esm.js';
-export { D as Actor, o as __unsafe_getAllOwnEventDescriptors, J as and, O as cancel, C as createActor, j as getStateNodes, E as interpret, F as isMachineSnapshot, G as matchesState, K as not, L as or, H as pathToStateValue, P as raise, T as spawnChild, M as stateIn, Q as stop, R as stopChild, I as toObserver } from './raise-e4cc6d4f.esm.js';
-import { a as assign } from './send-22880315.esm.js';
-export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-22880315.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as isStateId, w as getStateNodeByPath, x as getPersistedState, y as resolveReferencedActor, z as createActor, $ as $$ACTOR_TYPE } from './raise-4742bf04.esm.js';
+export { A as Actor, G as __unsafe_getAllOwnEventDescriptors, H as and, L as cancel, z as createActor, j as getStateNodes, B as interpret, C as isMachineSnapshot, D as matchesState, I as not, J as or, E as pathToStateValue, M as raise, O as spawnChild, K as stateIn, P as stop, Q as stopChild, F as toObserver } from './raise-4742bf04.esm.js';
+import { a as assign } from './pure-aefddc19.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as enqueueActions, b as escalate, f as forwardTo, l as log, p as pure, s as sendParent, d as sendTo } from './pure-aefddc19.esm.js';
 import '../dev/dist/xstate-dev.esm.js';
 
 class SimulatedClock {
@@ -456,17 +456,7 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (isErrorActorEvent(event) && !getAllOwnEventDescriptors(snapshot).some(nextEvent => nextEvent === event.type)) {
-      return cloneMachineSnapshot(snapshot, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = macrostep(snapshot, event, actorScope);
-    return nextState;
+    return macrostep(snapshot, event, actorScope).state;
   }
 
   /**