xstate 6.0.0-alpha.15 → 6.0.0-alpha.16

package/dist/{StateMachine-e3b1aa2d.cjs.js → StateMachine-18299be7.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-0d940f2c.cjs.js');
+var dist_xstateActors = require('./index-64839116.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -66,7 +66,6 @@ function memo(object, key, fn) {
 }
 
 const EMPTY_OBJECT = {};
-const CHOICE_CONFIG_KEYS = ['invoke', 'after', 'on', 'entry', 'exit', 'always', 'states', 'initial', 'onDone', 'timeout', 'onTimeout', 'history', 'target', 'output'];
 class StateNode {
   constructor(/** The raw config used to create the machine. */
   config, options) {
@@ -246,30 +245,17 @@ class StateNode {
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
   if (stateNode.type !== 'choice') {
-    if (config.choice !== undefined) {
-      throw new Error(`State "${stateNode.id}" has \`choice\`, but \`choice\` can only be used with \`type: 'choice'\`.`);
-    }
     return;
   }
   if (typeof config.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}\`.`);
-    }
+    throw new Error(`Missing \`choice\` function on "${stateNode.id}"`);
   }
 }
 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.`);
-    }
-    for (const key of ['actions', 'to']) {
-      if (result[key] !== undefined) {
-        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
-      }
+      throw new Error(`Choice "${stateNode.id}" has no target`);
     }
     return result;
   };
@@ -290,7 +276,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 event transition key');
       }
       const transitionsConfig = stateNode.config.on[descriptor];
       transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
@@ -300,6 +286,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 +376,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 "${targetString}" not found on "#${stateNode.id}"`);
   }
   const transition = {
     source: stateNode,
@@ -642,11 +632,26 @@ class StateMachine {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
+    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, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {

package/dist/{StateMachine-8dbd20ad.esm.js → StateMachine-4a0a8848.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE } from './index-2635a437.esm.js';
+import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE, a4 as createErrorPlatformEvent } from './index-9fc97b9e.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -64,7 +64,6 @@ function memo(object, key, fn) {
 }
 
 const EMPTY_OBJECT = {};
-const CHOICE_CONFIG_KEYS = ['invoke', 'after', 'on', 'entry', 'exit', 'always', 'states', 'initial', 'onDone', 'timeout', 'onTimeout', 'history', 'target', 'output'];
 class StateNode {
   constructor(/** The raw config used to create the machine. */
   config, options) {
@@ -244,30 +243,17 @@ class StateNode {
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
   if (stateNode.type !== 'choice') {
-    if (config.choice !== undefined) {
-      throw new Error(`State "${stateNode.id}" has \`choice\`, but \`choice\` can only be used with \`type: 'choice'\`.`);
-    }
     return;
   }
   if (typeof config.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}\`.`);
-    }
+    throw new Error(`Missing \`choice\` function on "${stateNode.id}"`);
   }
 }
 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.`);
-    }
-    for (const key of ['actions', 'to']) {
-      if (result[key] !== undefined) {
-        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
-      }
+      throw new Error(`Choice "${stateNode.id}" has no target`);
     }
     return result;
   };
@@ -288,7 +274,7 @@ function formatTransitions(stateNode) {
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
       if (descriptor === NULL_EVENT) {
-        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+        throw new Error('Null event transition key');
       }
       const transitionsConfig = stateNode.config.on[descriptor];
       transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => formatTransition(stateNode, descriptor, transition)));
@@ -298,6 +284,10 @@ function formatTransitions(stateNode) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
     transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => formatTransition(stateNode, descriptor, transition)));
   }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => formatTransition(stateNode, descriptor, transition)));
+  }
   const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => formatTransition(stateNode, descriptor, {
     to: (_args, enq) => {
       enq.cancel(timeoutEventType);
@@ -384,7 +374,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 "${targetString}" not found on "#${stateNode.id}"`);
   }
   const transition = {
     source: stateNode,
@@ -640,11 +630,26 @@ class StateMachine {
     const initEvent = createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = macrostep(nextState, initEvent, actorScope, internalQueue);
+    let nextState;
+    let initialActions = [];
+    let microsteps = [];
+    let macroState;
+    try {
+      [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      ({
+        snapshot: macroState,
+        microsteps
+      } = macrostep(nextState, initEvent, actorScope, internalQueue));
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = createErrorPlatformEvent('execution', err);
+      const errorMacrostep = macrostep(preInitialState, errorEvent, actorScope, []);
+      macroState = errorMacrostep.snapshot;
+      microsteps = errorMacrostep.microsteps;
+      initialActions = [];
+    }
     return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {

package/dist/{StateMachine-98411dc5.development.cjs.js → StateMachine-7572fbeb.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-07b19ed0.development.cjs.js');
+var dist_xstateActors = require('./index-4a0afbfa.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -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']) {
-      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,
@@ -656,11 +664,26 @@ class StateMachine {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
+    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, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {

package/dist/{StateMachine-0fa9c094.development.esm.js → StateMachine-dfe616b4.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE } from './index-362125ce.development.esm.js';
+import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE, a4 as createErrorPlatformEvent } from './index-5d18ec0c.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -250,11 +250,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}\`.`);
+      }
     }
   }
 }
@@ -262,11 +264,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']) {
-      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;
@@ -288,7 +292,7 @@ function formatTransitions(stateNode) {
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
       if (descriptor === 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 => formatTransition(stateNode, descriptor, transition)));
@@ -298,6 +302,10 @@ function formatTransitions(stateNode) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
     transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => formatTransition(stateNode, descriptor, transition)));
   }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => formatTransition(stateNode, descriptor, transition)));
+  }
   const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => formatTransition(stateNode, descriptor, {
     to: (_args, enq) => {
       enq.cancel(timeoutEventType);
@@ -384,7 +392,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,
@@ -654,11 +662,26 @@ class StateMachine {
     const initEvent = createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = macrostep(nextState, initEvent, actorScope, internalQueue);
+    let nextState;
+    let initialActions = [];
+    let microsteps = [];
+    let macroState;
+    try {
+      [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      ({
+        snapshot: macroState,
+        microsteps
+      } = macrostep(nextState, initEvent, actorScope, internalQueue));
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = createErrorPlatformEvent('execution', err);
+      const errorMacrostep = macrostep(preInitialState, errorEvent, actorScope, []);
+      macroState = errorMacrostep.snapshot;
+      microsteps = errorMacrostep.microsteps;
+      initialActions = [];
+    }
     return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {

package/dist/declarations/src/createActor.d.ts

@@ -58,6 +58,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     private _deferred;
     private _pendingEffects?;
     private _setErrorSnapshot;
+    private _tryHandleExecutionError;
     private _next;
     private update;
     private _flushInitialEffects;

package/dist/declarations/src/createMachineFromConfig.d.ts

@@ -145,6 +145,7 @@ export interface StateNodeJSON {
     initial?: string;
     states?: Record<string, StateNodeJSON>;
     on?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    onError?: TransitionConfigJSON | TransitionConfigJSON[];
     after?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
     always?: TransitionConfigJSON | TransitionConfigJSON[];
     choice?: ChoiceBranchJSON[] | ResolvableJSON;

package/dist/declarations/src/transitionActions.d.ts

@@ -1,4 +1,6 @@
-import type { AnyAction, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, SpecialExecutableAction } from "./types.js";
+import type { AnyAction, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, MachineContext, SpecialExecutableAction } from "./types.js";
+export declare function mergeContextPatch(context: MachineContext, patch: MachineContext): MachineContext;
 export declare function createTransitionEnqueue(actorScope: AnyActorScope, actions: any[], internalEvents: EventObject[], actorSubscriptions?: boolean, createActors?: boolean): EnqueueObject<any, any>;
 export declare function isBuiltInExecutableAction(action: ExecutableActionObject): action is SpecialExecutableAction;
 export declare function resolveActionsWithContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: AnyAction[]): [AnyMachineSnapshot, ExecutableActionObject[]];
+export declare function createEnqueueObject(props: Partial<EnqueueObject<any, any>>, action: <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>) => void): EnqueueObject<any, any>;

package/dist/declarations/src/types.d.ts

@@ -328,20 +328,23 @@ export type AnyInvokeConfig = InvokeConfig<any, any, any, any, any, any, any, an
 export type AnyStateNodeConfig = Next_StateNodeConfig<any, any, any, any, any, any, any, any, any, any, any, any>;
 export type AnyStateNode = StateNode<any, any> | StateNode<never, EventObject> | StateNode<any, EventObject> | StateNode<never, any>;
 export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any, any, any>;
-export type AnyStateMachine = StateMachine<any, // context
-any, // event
-any, // children
-any, // state value
-any, // tag
-any, // input
-any, // output
-any, // emitted
-any, // TMeta
-any, // TStateSchema,
-any, // TActionMap,
-any, // TActorMap
-any, // TGuardMap
-any>;
+export interface AnyStateMachine extends AnyActorLogic {
+    id: string;
+    root: AnyStateNode;
+    options?: {
+        maxIterations?: number;
+    };
+    states: StateNodesConfig<any, any>;
+    events: Array<EventDescriptor<any>>;
+    implementations: Implementations;
+    config: any;
+    version?: string;
+    provide(implementations: any): AnyStateMachine;
+    resolveState(config: any): any;
+    getTransitionData(snapshot: any, event: any, actor: AnyActorRef): AnyTransitionDefinition[];
+    getStateNodeById(stateId: string): AnyStateNode;
+    getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
+}
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
 export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent>;
 export type InitialContext<TContext extends MachineContext, TActorMap extends Implementations['actorSources'], TInput, TEvent extends EventObject> = TContext | ContextFactory<TContext, TActorMap, TInput, TEvent>;
@@ -410,6 +413,11 @@ export interface ErrorActorEvent<TErrorData = unknown, TId extends string = stri
     error: TErrorData;
     actorId: TId;
 }
+export interface ErrorPlatformEvent<TErrorData = unknown, TKind extends string = string> extends EventObject {
+    type: `xstate.error.${TKind}`;
+    error: TErrorData;
+}
+export type ErrorEvent = ErrorActorEvent | ErrorPlatformEvent;
 export interface SnapshotEvent<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>> extends EventObject {
     type: `xstate.snapshot.${string}`;
     snapshot: TSnapshot;
@@ -869,19 +877,30 @@ in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem
      * @returns The a representation of the internal state to be persisted.
      */
     getPersistedSnapshot: (snapshot: TSnapshot, options?: unknown) => Snapshot<unknown>;
+    /**
+     * Executes the non-action effects returned from `transition` (e.g. the
+     * effects produced by `createLogic`-based actors). Actor logic that never
+     * returns such effects can omit this.
+     */
+    executeEffects?: (effects: readonly unknown[], actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => void;
+}
+export interface AnyActorLogic {
+    config?: unknown;
+    transition(snapshot: any, event: any, actorScope: any): ActorLogicTransitionResult<any>;
+    initialTransition(input: any, actorScope: any): ActorLogicTransitionResult<any>;
+    getInitialSnapshot(actorScope: any, input: any): any;
+    restoreSnapshot?(persistedState: Snapshot<unknown>, actorScope: any): any;
+    start?(snapshot: any, actorScope: any): void;
+    getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
+    executeEffects?(effects: readonly unknown[], actorScope: any): void;
 }
-export type AnyActorLogic = ActorLogic<any, // snapshot
-any, // event
-any, // input
-any, // system
-any>;
 export type UnknownActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
 AnyActorSystem, any>;
 export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer TSnapshot, infer _, infer __> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? TSnapshot : R extends ActorScope<infer TSnapshot, infer _TEvent, infer _TEmitted, infer _TSystem> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? TEvent : never;
-export type EmittedFrom<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? TEmitted : never;
+export type EmittedFrom<TLogic extends AnyActorLogic> = TLogic extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer TEmitted, infer _TMeta, infer _TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TEmitted : [TLogic] extends [AnyStateMachine] ? AnyEventObject : TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? TEmitted : AnyEventObject;
 type ResolveEventType<T> = T extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TEvent : R extends ActorRef<infer _TSnapshot, infer TEvent, infer _TEmitted> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
 export type ContextFrom<T> = T extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TContext : T extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TContext : T extends Actor<infer TActorLogic> ? TActorLogic extends AnyStateMachine ? ContextFrom<TActorLogic> : never : never;
@@ -927,6 +946,7 @@ export type StateSchema = {
     entry?: unknown;
     exit?: unknown;
     onDone?: unknown;
+    onError?: unknown;
     after?: unknown;
     always?: unknown;
     choice?: unknown;

package/dist/declarations/src/types.v6.d.ts

@@ -1,6 +1,6 @@
 import { StandardSchemaV1 } from "./schema.types.js";
 import { MachineSnapshot } from "./State.js";
-import { Action, ActorLogic, ActorRef, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorActorEvent, EventDescriptor, EventObject, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, OutputFrom, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry } from "./types.js";
+import { Action, ActorLogic, ActorRef, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorActorEvent, EventDescriptor, ErrorEvent, EventObject, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, OutputFrom, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry } from "./types.js";
 import { MachineContext, Mapper } from "./types.js";
 import { LowInfer } from "./types.js";
 import { DoneStateEvent } from "./types.js";
@@ -277,6 +277,7 @@ interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent ext
     entry?: never;
     exit?: never;
     onDone?: never;
+    onError?: never;
     after?: never;
     timeout?: never;
     onTimeout?: never;
@@ -341,6 +342,11 @@ interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent ex
      * node's `on` property.
      */
     onDone?: Next_TransitionConfigOrTarget<TContext, DoneStateEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
+    /**
+     * The transition to take when an `xstate.error.*` event is raised while this
+     * state node or one of its descendants is active.
+     */
+    onError?: Next_TransitionConfigOrTarget<TContext, ErrorEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
     /**
      * The mapping (or array) of delays (in milliseconds) to their potential
      * transition(s). The delayed transitions are taken after the specified delay

package/dist/declarations/src/utils.d.ts

@@ -1,5 +1,5 @@
 import type { StateNode } from "./StateNode.js";
-import type { AnyActor, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, AnyTransitionConfigFunction, ErrorActorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, OutputArg, SingleOrArray, StateValue, TransitionConfigTarget } from "./types.js";
+import type { AnyActor, AnyEventObject, AnyMachineSnapshot, AnyStateMachine, AnyTransitionConfig, AnyTransitionConfigFunction, ErrorEvent, EventObject, MachineContext, Mapper, NonReducibleUnknown, Observer, OutputArg, SingleOrArray, StateValue, TransitionConfigTarget } from "./types.js";
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
 export declare function checkStateIn(snapshot: AnyMachineSnapshot, stateValue: StateValue): boolean;
 export declare function toStatePath(stateId: string | string[]): string[];
@@ -10,7 +10,7 @@ export declare function mapValues<P, O extends Record<string, unknown>>(collecti
 export declare function toArray<T>(value: readonly T[] | T | undefined): readonly T[];
 export declare function resolveOutput<TContext extends MachineContext, TExpressionEvent extends EventObject>(mapper: Mapper<TContext, TExpressionEvent, unknown, EventObject> | NonReducibleUnknown, context: TContext, event: TExpressionEvent, self: AnyActor): unknown;
 export declare function getEventOutput<TEvent extends EventObject>(event: TEvent): OutputArg<TEvent>['output'];
-export declare function isErrorActorEvent(event: AnyEventObject): event is ErrorActorEvent;
+export declare function isErrorEvent(event: AnyEventObject): event is ErrorEvent;
 export declare function toTransitionConfigArray(configLike: SingleOrArray<AnyTransitionConfig | TransitionConfigTarget | AnyTransitionConfigFunction>): Array<AnyTransitionConfig>;
 export declare function normalizeTarget<TContext extends MachineContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined): ReadonlyArray<string | StateNode<TContext, TEvent>> | undefined;
 export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;