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

package/dist/{actions-319cefe7.cjs.js → actions-d1dba4ac.cjs.js}

@@ -71,7 +71,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,
@@ -134,7 +135,6 @@ function execute$5(actorContext, params) {
     } : event);
   });
 }
-
 /**
  * Sends an event to an actor.
  *
@@ -217,7 +217,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
@@ -302,32 +301,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) {
@@ -460,23 +480,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;
@@ -496,482 +499,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";
@@ -1218,7 +745,7 @@ class Actor {
       return;
     }
     this.update(nextState);
-    if (event.type === stopSignalType) {
+    if (event.type === XSTATE_STOP) {
       this._stopProcedure();
       this._complete();
     }
@@ -1233,7 +760,7 @@ class Actor {
       return this;
     }
     this.mailbox.enqueue({
-      type: stopSignalType
+      type: XSTATE_STOP
     });
     return this;
   }
@@ -1448,6 +975,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,
@@ -1549,6 +1079,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)) {
@@ -1876,7 +1412,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;
   }
@@ -2365,7 +1901,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) {
@@ -2398,7 +1942,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 {
@@ -2410,7 +1954,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);
@@ -2701,13 +2245,11 @@ function execute$2(actorContext, actorRef) {
     actorContext.stopChild(actorRef);
   });
 }
-
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-
 function stop(actorRef) {
   function stop(_) {
   }
@@ -2739,7 +2281,6 @@ function execute$1({
     logger(value);
   }
 }
-
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -2854,7 +2395,6 @@ function resolve$3(actorContext, state, actionArgs, {
     } : state.children
   })];
 }
-
 /**
  * Updates the current context of the machine.
  *
@@ -2900,14 +2440,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(_) {
   }
@@ -2982,6 +2520,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.
@@ -2993,7 +2534,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
@@ -3001,8 +2542,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
@@ -3012,7 +2556,7 @@ function error(id, data) {
 }
 function createInitEvent(input) {
   return {
-    type: INIT_TYPE,
+    type: XSTATE_INIT,
     input
   };
 }
@@ -3025,6 +2569,8 @@ exports.NULL_EVENT = NULL_EVENT;
 exports.STATE_DELIMITER = STATE_DELIMITER;
 exports.SpecialTargets = SpecialTargets;
 exports.State = State;
+exports.XSTATE_INIT = XSTATE_INIT;
+exports.XSTATE_STOP = XSTATE_STOP;
 exports.after = after;
 exports.and = and;
 exports.assign = assign;
@@ -3033,24 +2579,19 @@ exports.choose = choose;
 exports.cloneState = cloneState;
 exports.constantPrefixes = constantPrefixes;
 exports.createActor = createActor;
-exports.createEmptyActor = createEmptyActor;
 exports.createInitEvent = createInitEvent;
 exports.createInvokeId = createInvokeId;
 exports.done = done;
 exports.doneInvoke = doneInvoke;
+exports.doneInvokeEventType = doneInvokeEventType;
 exports.error = error;
+exports.errorEventType = errorEventType;
 exports.escalate = escalate;
 exports.evaluateGuard = evaluateGuard;
-exports.flatten = flatten;
 exports.formatInitialTransition = formatInitialTransition;
 exports.formatTransition = formatTransition;
 exports.formatTransitions = formatTransitions;
 exports.forwardTo = forwardTo;
-exports.fromCallback = fromCallback;
-exports.fromEventObservable = fromEventObservable;
-exports.fromObservable = fromObservable;
-exports.fromPromise = fromPromise;
-exports.fromTransition = fromTransition;
 exports.getCandidates = getCandidates;
 exports.getConfiguration = getConfiguration;
 exports.getDelayedTransitions = getDelayedTransitions;
@@ -3059,11 +2600,10 @@ exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;
-exports.isActorRef = isActorRef;
 exports.isAtomicStateNode = isAtomicStateNode;
 exports.isErrorEvent = isErrorEvent;
 exports.isInFinalState = isInFinalState;
-exports.isSignal = isSignal;
+exports.isPromiseLike = isPromiseLike;
 exports.isStateId = isStateId;
 exports.log = log;
 exports.macrostep = macrostep;
@@ -3081,15 +2621,10 @@ exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
 exports.sendParent = sendParent;
 exports.sendTo = sendTo;
-exports.startSignal = startSignal;
-exports.startSignalType = startSignalType;
 exports.stateIn = stateIn;
 exports.stop = stop;
-exports.stopSignal = stopSignal;
-exports.stopSignalType = stopSignalType;
-exports.toActorRef = toActorRef;
+exports.symbolObservable = symbolObservable;
 exports.toArray = toArray;
-exports.toInvokeConfig = toInvokeConfig;
 exports.toObserver = toObserver;
 exports.toTransitionConfigArray = toTransitionConfigArray;
 exports.transitionNode = transitionNode;