xstate 5.0.0-beta.26 → 5.0.0-beta.27

package/dist/{actions-cf69419d.development.esm.js → actions-9754d2ca.development.esm.js}

@@ -69,7 +69,8 @@ const TARGETLESS_KEY = '';
 const NULL_EVENT = '';
 const STATE_IDENTIFIER = '#';
 const WILDCARD = '*';
-const INIT_TYPE = 'xstate.init';
+const XSTATE_INIT = 'xstate.init';
+const XSTATE_STOP = 'xstate.stop';
 
 function resolve$8(actorContext, state, args, {
   to,
@@ -132,7 +133,6 @@ function execute$5(actorContext, params) {
     } : event);
   });
 }
-
 /**
  * Sends an event to an actor.
  *
@@ -228,7 +228,6 @@ function resolve$7(_, state, actionArgs, {
 function execute$4(actorContext, resolvedSendId) {
   actorContext.self.cancel(resolvedSendId);
 }
-
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent
@@ -316,32 +315,53 @@ class Mailbox {
   }
 }
 
-const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
-
 /**
- * Returns actor logic from a transition function and its initial state.
- *
- * A transition function is a function that takes the current state and an event and returns the next state.
+ * This function makes sure that unhandled errors are thrown in a separate macrotask.
+ * It allows those errors to be detected by global error handlers and reported to bug tracking services
+ * without interrupting our own stack of execution.
  *
- * @param transition The transition function that returns the next state given the current state and event.
- * @param initialState The initial state of the transition function.
- * @returns Actor logic
+ * @param err error to be thrown
  */
-function fromTransition(transition, initialState) {
-  return {
-    config: transition,
-    transition: (state, event, actorContext) => {
-      return transition(state, event, actorContext);
+function reportUnhandledError(err) {
+  setTimeout(() => {
+    throw err;
+  });
+}
+
+const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
+
+function createSystem() {
+  let sessionIdCounter = 0;
+  const children = new Map();
+  const keyedActors = new Map();
+  const reverseKeyedActors = new WeakMap();
+  const system = {
+    _bookId: () => `x:${sessionIdCounter++}`,
+    _register: (sessionId, actorRef) => {
+      children.set(sessionId, actorRef);
+      return sessionId;
+    },
+    _unregister: actorRef => {
+      children.delete(actorRef.sessionId);
+      const systemId = reverseKeyedActors.get(actorRef);
+      if (systemId !== undefined) {
+        keyedActors.delete(systemId);
+        reverseKeyedActors.delete(actorRef);
+      }
     },
-    getInitialState: (_, input) => {
-      return typeof initialState === 'function' ? initialState({
-        input
-      }) : initialState;
+    get: systemId => {
+      return keyedActors.get(systemId);
     },
-    getSnapshot: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
+    _set: (systemId, actorRef) => {
+      const existing = keyedActors.get(systemId);
+      if (existing && existing !== actorRef) {
+        throw new Error(`Actor with system ID '${systemId}' already exists.`);
+      }
+      keyedActors.set(systemId, actorRef);
+      reverseKeyedActors.set(actorRef, systemId);
+    }
   };
+  return system;
 }
 
 function matchesState(parentStateId, childStateId) {
@@ -477,23 +497,6 @@ function normalizeTarget(target) {
   }
   return toArray(target);
 }
-function toInvokeConfig(invocable, id) {
-  if (typeof invocable === 'object') {
-    if ('src' in invocable) {
-      return invocable;
-    }
-    if ('transition' in invocable) {
-      return {
-        id,
-        src: invocable
-      };
-    }
-  }
-  return {
-    id,
-    src: invocable
-  };
-}
 function toObserver(nextHandler, errorHandler, completionHandler) {
   const isObserver = typeof nextHandler === 'object';
   const self = isObserver ? nextHandler : undefined;
@@ -513,482 +516,6 @@ function resolveReferencedActor(referenced) {
   } : referenced : undefined;
 }
 
-function fromCallback(invokeCallback) {
-  return {
-    config: invokeCallback,
-    start: (_state, {
-      self
-    }) => {
-      self.send({
-        type: startSignalType
-      });
-    },
-    transition: (state, event, {
-      self,
-      id,
-      system
-    }) => {
-      if (event.type === startSignalType) {
-        const sendBack = eventForParent => {
-          if (state.canceled) {
-            return;
-          }
-          self._parent?.send(eventForParent);
-        };
-        const receive = newListener => {
-          state.receivers.add(newListener);
-        };
-        state.dispose = invokeCallback({
-          input: state.input,
-          system,
-          self: self,
-          sendBack,
-          receive
-        });
-        if (isPromiseLike(state.dispose)) {
-          state.dispose.then(resolved => {
-            self._parent?.send(doneInvoke(id, resolved));
-            state.canceled = true;
-          }, errorData => {
-            state.canceled = true;
-            self._parent?.send(error(id, errorData));
-          });
-        }
-        return state;
-      }
-      if (event.type === stopSignalType) {
-        state.canceled = true;
-        if (typeof state.dispose === 'function') {
-          state.dispose();
-        }
-        return state;
-      }
-      if (isSignal(event)) {
-        // TODO: unrecognized signal
-        return state;
-      }
-      state.receivers.forEach(receiver => receiver(event));
-      return state;
-    },
-    getInitialState: (_, input) => {
-      return {
-        canceled: false,
-        receivers: new Set(),
-        dispose: undefined,
-        input
-      };
-    },
-    getSnapshot: () => undefined,
-    getPersistedState: ({
-      input,
-      canceled
-    }) => ({
-      input,
-      canceled
-    })
-  };
-}
-
-function fromObservable(observableCreator) {
-  const nextEventType = '$$xstate.next';
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-  return {
-    config: observableCreator,
-    transition: (state, event, {
-      self,
-      id,
-      defer
-    }) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case nextEventType:
-          // match the exact timing of events sent by machines
-          // send actions are not executed immediately
-          defer(() => {
-            self._parent?.send({
-              type: `xstate.snapshot.${id}`,
-              data: event.data
-            });
-          });
-          return {
-            ...state,
-            data: event.data
-          };
-        case errorEventType:
-          return {
-            ...state,
-            status: 'error',
-            input: undefined,
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            subscription: undefined
-          };
-        case completeEventType:
-          return {
-            ...state,
-            status: 'done',
-            input: undefined,
-            subscription: undefined
-          };
-        case stopSignalType:
-          state.subscription.unsubscribe();
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined,
-            subscription: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    getInitialState: (_, input) => {
-      return {
-        subscription: undefined,
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state.subscription = observableCreator({
-        input: state.input,
-        system,
-        self
-      }).subscribe({
-        next: value => {
-          self.send({
-            type: nextEventType,
-            data: value
-          });
-        },
-        error: err => {
-          self.send({
-            type: errorEventType,
-            data: err
-          });
-        },
-        complete: () => {
-          self.send({
-            type: completeEventType
-          });
-        }
-      });
-    },
-    getSnapshot: state => state.data,
-    getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
-    restoreState: state => ({
-      ...state,
-      subscription: undefined
-    })
-  };
-}
-
-/**
- * Creates event observable logic that listens to an observable
- * that delivers event objects.
- *
- *
- * @param lazyObservable A function that creates an observable
- * @returns Event observable logic
- */
-
-function fromEventObservable(lazyObservable) {
-  const errorEventType = '$$xstate.error';
-  const completeEventType = '$$xstate.complete';
-
-  // TODO: event types
-  return {
-    config: lazyObservable,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case errorEventType:
-          return {
-            ...state,
-            status: 'error',
-            input: undefined,
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            subscription: undefined
-          };
-        case completeEventType:
-          return {
-            ...state,
-            status: 'done',
-            input: undefined,
-            subscription: undefined
-          };
-        case stopSignalType:
-          state.subscription.unsubscribe();
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined,
-            subscription: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    getInitialState: (_, input) => {
-      return {
-        subscription: undefined,
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      if (state.status === 'done') {
-        // Do not restart a completed observable
-        return;
-      }
-      state.subscription = lazyObservable({
-        input: state.input,
-        system,
-        self
-      }).subscribe({
-        next: value => {
-          self._parent?.send(value);
-        },
-        error: err => {
-          self.send({
-            type: errorEventType,
-            data: err
-          });
-        },
-        complete: () => {
-          self.send({
-            type: completeEventType
-          });
-        }
-      });
-    },
-    getSnapshot: _ => undefined,
-    getPersistedState: ({
-      status,
-      data,
-      input
-    }) => ({
-      status,
-      data,
-      input
-    }),
-    getStatus: state => state,
-    restoreState: state => ({
-      ...state,
-      subscription: undefined
-    })
-  };
-}
-
-const resolveEventType = '$$xstate.resolve';
-const rejectEventType = '$$xstate.reject';
-function fromPromise(
-// TODO: add types
-promiseCreator) {
-  // TODO: add event types
-  const logic = {
-    config: promiseCreator,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case resolveEventType:
-          return {
-            ...state,
-            status: 'done',
-            data: event.data,
-            input: undefined
-          };
-        case rejectEventType:
-          return {
-            ...state,
-            status: 'error',
-            data: event.data,
-            // TODO: if we keep this as `data` we should reflect this in the type
-            input: undefined
-          };
-        case stopSignalType:
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined
-          };
-        default:
-          return state;
-      }
-    },
-    start: (state, {
-      self,
-      system
-    }) => {
-      // TODO: determine how to allow customizing this so that promises
-      // can be restarted if necessary
-      if (state.status !== 'active') {
-        return;
-      }
-      const resolvedPromise = Promise.resolve(promiseCreator({
-        input: state.input,
-        system,
-        self
-      }));
-      resolvedPromise.then(response => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: resolveEventType,
-          data: response
-        });
-      }, errorData => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: rejectEventType,
-          data: errorData
-        });
-      });
-    },
-    getInitialState: (_, input) => {
-      return {
-        status: 'active',
-        data: undefined,
-        input
-      };
-    },
-    getSnapshot: state => state.data,
-    getStatus: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
-  };
-  return logic;
-}
-
-const startSignalType = 'xstate.init';
-const stopSignalType = 'xstate.stop';
-const startSignal = {
-  type: 'xstate.init'
-};
-const stopSignal = {
-  type: 'xstate.stop'
-};
-/**
- * An object that expresses the actor logic in reaction to received events,
- * as well as an optionally emitted stream of values.
- *
- * @template TReceived The received event
- * @template TSnapshot The emitted value
- */
-
-function isSignal(event) {
-  return event.type === startSignalType || event.type === stopSignalType;
-}
-function isActorRef(item) {
-  return !!item && typeof item === 'object' && typeof item.send === 'function';
-}
-
-// TODO: refactor the return type, this could be written in a better way
-// but it's best to avoid unneccessary breaking changes now
-// @deprecated use `interpret(actorLogic)` instead
-function toActorRef(actorRefLike) {
-  return {
-    subscribe: () => ({
-      unsubscribe: () => void 0
-    }),
-    id: 'anonymous',
-    sessionId: '',
-    getSnapshot: () => undefined,
-    // TODO: this isn't safe
-    [symbolObservable]: function () {
-      return this;
-    },
-    status: ActorStatus.Running,
-    stop: () => void 0,
-    ...actorRefLike
-  };
-}
-const emptyLogic = fromTransition(_ => undefined, undefined);
-function createEmptyActor() {
-  return createActor(emptyLogic);
-}
-
-/**
- * This function makes sure that unhandled errors are thrown in a separate macrotask.
- * It allows those errors to be detected by global error handlers and reported to bug tracking services
- * without interrupting our own stack of execution.
- *
- * @param err error to be thrown
- */
-function reportUnhandledError(err) {
-  setTimeout(() => {
-    throw err;
-  });
-}
-
-function createSystem() {
-  let sessionIdCounter = 0;
-  const children = new Map();
-  const keyedActors = new Map();
-  const reverseKeyedActors = new WeakMap();
-  const system = {
-    _bookId: () => `x:${sessionIdCounter++}`,
-    _register: (sessionId, actorRef) => {
-      children.set(sessionId, actorRef);
-      return sessionId;
-    },
-    _unregister: actorRef => {
-      children.delete(actorRef.sessionId);
-      const systemId = reverseKeyedActors.get(actorRef);
-      if (systemId !== undefined) {
-        keyedActors.delete(systemId);
-        reverseKeyedActors.delete(actorRef);
-      }
-    },
-    get: systemId => {
-      return keyedActors.get(systemId);
-    },
-    _set: (systemId, actorRef) => {
-      const existing = keyedActors.get(systemId);
-      if (existing && existing !== actorRef) {
-        throw new Error(`Actor with system ID '${systemId}' already exists.`);
-      }
-      keyedActors.set(systemId, actorRef);
-      reverseKeyedActors.set(actorRef, systemId);
-    }
-  };
-  return system;
-}
-
 let ActorStatus = /*#__PURE__*/function (ActorStatus) {
   ActorStatus[ActorStatus["NotStarted"] = 0] = "NotStarted";
   ActorStatus[ActorStatus["Running"] = 1] = "Running";
@@ -1235,7 +762,7 @@ class Actor {
       return;
     }
     this.update(nextState);
-    if (event.type === stopSignalType) {
+    if (event.type === XSTATE_STOP) {
       this._stopProcedure();
       this._complete();
     }
@@ -1250,7 +777,7 @@ class Actor {
       return this;
     }
     this.mailbox.enqueue({
-      type: stopSignalType
+      type: XSTATE_STOP
     });
     return this;
   }
@@ -1473,6 +1000,9 @@ function execute$3(actorContext, {
     }
   });
 }
+
+// we don't export this since it's an internal action that is not meant to be used in the user's code
+
 function invoke({
   id,
   systemId,
@@ -1585,6 +1115,12 @@ function evaluateGuard(guard, context, event, state) {
     event,
     guard: isInline ? undefined : typeof guard === 'string' ? {
       type: guard
+    } : typeof guard.params === 'function' ? {
+      type: guard.type,
+      params: guard.params({
+        context,
+        event
+      })
     } : guard
   };
   if (!('check' in resolved)) {
@@ -1923,7 +1459,7 @@ function resolveTarget(stateNode, targets) {
   });
 }
 function resolveHistoryTarget(stateNode) {
-  const normalizedTarget = normalizeTarget(stateNode.target);
+  const normalizedTarget = normalizeTarget(stateNode.config.target);
   if (!normalizedTarget) {
     return stateNode.parent.initial.target;
   }
@@ -2412,7 +1948,15 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       system: actorCtx?.system,
       action: isInline ? undefined : typeof action === 'string' ? {
         type: action
-      } : action
+      } : typeof action.params === 'function' ? {
+        type: action.type,
+        params: action.params({
+          context: intermediateState.context,
+          event
+        })
+      } :
+      // TS isn't able to narrow it down here
+      action
     };
     if (!('resolve' in resolved)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
@@ -2448,7 +1992,7 @@ function macrostep(state, event, actorCtx) {
   const states = [];
 
   // Handle stop event
-  if (event.type === stopSignalType) {
+  if (event.type === XSTATE_STOP) {
     nextState = stopStep(event, nextState, actorCtx);
     states.push(nextState);
     return {
@@ -2460,7 +2004,7 @@ function macrostep(state, event, actorCtx) {
 
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
-  if (nextEvent.type !== INIT_TYPE) {
+  if (nextEvent.type !== XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
     nextState = microstep(transitions, state, actorCtx, nextEvent, false);
     states.push(nextState);
@@ -2754,13 +2298,11 @@ function execute$2(actorContext, actorRef) {
     actorContext.stopChild(actorRef);
   });
 }
-
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-
 function stop(actorRef) {
   function stop(_) {
     {
@@ -2795,7 +2337,6 @@ function execute$1({
     logger(value);
   }
 }
-
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -2913,7 +2454,6 @@ function resolve$3(actorContext, state, actionArgs, {
     } : state.children
   })];
 }
-
 /**
  * Updates the current context of the machine.
  *
@@ -2962,14 +2502,12 @@ function execute(actorContext, params) {
     return;
   }
 }
-
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.
  *
  * @param eventType The event to raise.
  */
-
 function raise(eventOrExpr, options) {
   function raise(_) {
     {
@@ -3053,6 +2591,9 @@ function done(id, output) {
   eventObject.toString = () => type;
   return eventObject;
 }
+function doneInvokeEventType(invokeId) {
+  return `${ConstantPrefix.DoneInvoke}.${invokeId}`;
+}
 
 /**
  * Returns an event that represents that an invoked service has terminated.
@@ -3064,7 +2605,7 @@ function done(id, output) {
  * @param output The data to pass into the event
  */
 function doneInvoke(invokeId, output) {
-  const type = `${ConstantPrefix.DoneInvoke}.${invokeId}`;
+  const type = doneInvokeEventType(invokeId);
   const eventObject = {
     type,
     output
@@ -3072,8 +2613,11 @@ function doneInvoke(invokeId, output) {
   eventObject.toString = () => type;
   return eventObject;
 }
+function errorEventType(id) {
+  return `${ConstantPrefix.ErrorPlatform}.${id}`;
+}
 function error(id, data) {
-  const type = `${ConstantPrefix.ErrorPlatform}.${id}`;
+  const type = errorEventType(id);
   const eventObject = {
     type,
     data
@@ -3083,9 +2627,9 @@ function error(id, data) {
 }
 function createInitEvent(input) {
   return {
-    type: INIT_TYPE,
+    type: XSTATE_INIT,
     input
   };
 }
 
-export { fromObservable as $, microstep as A, isAtomicStateNode as B, isStateId as C, getStateNodeByPath as D, getPersistedState as E, resolveReferencedActor as F, createActor as G, matchesState as H, sendTo as I, sendParent as J, forwardTo as K, interpret as L, Actor as M, NULL_EVENT as N, ActorStatus as O, InterpreterStatus as P, doneInvoke as Q, cancel as R, STATE_DELIMITER as S, choose as T, log as U, pure as V, raise as W, stop as X, pathToStateValue as Y, toObserver as Z, fromPromise as _, toTransitionConfigArray as a, fromCallback as a0, fromEventObservable as a1, fromTransition as a2, stateIn as a3, not as a4, and as a5, or as a6, ConstantPrefix as a7, SpecialTargets as a8, startSignalType as a9, stopSignalType as aa, startSignal as ab, stopSignal as ac, isSignal as ad, isActorRef as ae, toActorRef as af, createEmptyActor as ag, constantPrefixes as ah, after as ai, done as aj, error as ak, escalate as al, formatTransition as b, memo as c, flatten as d, evaluateGuard as e, formatTransitions as f, createInvokeId as g, getDelayedTransitions as h, formatInitialTransition as i, getCandidates as j, toInvokeConfig as k, getConfiguration as l, mapValues as m, getStateNodes as n, isInFinalState as o, State as p, isErrorEvent as q, resolveStateValue as r, cloneState as s, toArray as t, macrostep as u, transitionNode as v, getInitialConfiguration as w, resolveActionsAndContext as x, assign as y, createInitEvent as z };
+export { stateIn as $, isStateId as A, getStateNodeByPath as B, getPersistedState as C, resolveReferencedActor as D, createActor as E, matchesState as F, Actor as G, ActorStatus as H, doneInvoke as I, interpret as J, InterpreterStatus as K, cancel as L, choose as M, NULL_EVENT as N, log as O, pure as P, raise as Q, forwardTo as R, STATE_DELIMITER as S, sendParent as T, sendTo as U, stop as V, pathToStateValue as W, toObserver as X, and as Y, not as Z, or as _, toTransitionConfigArray as a, ConstantPrefix as a0, SpecialTargets as a1, XSTATE_INIT as a2, isPromiseLike as a3, error as a4, XSTATE_STOP as a5, symbolObservable as a6, constantPrefixes as a7, after as a8, done as a9, doneInvokeEventType as aa, errorEventType as ab, escalate as ac, formatTransition as b, memo as c, createInvokeId as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, formatInitialTransition as h, getCandidates as i, getConfiguration as j, getStateNodes as k, isInFinalState as l, mapValues as m, State as n, isErrorEvent as o, cloneState as p, macrostep as q, resolveStateValue as r, transitionNode as s, toArray as t, getInitialConfiguration as u, resolveActionsAndContext as v, assign as w, createInitEvent as x, microstep as y, isAtomicStateNode as z };