xstate 5.0.0-beta.37 → 5.0.0-beta.38

package/dist/{raise-e342a840.development.esm.js → raise-42073973.development.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, W as WILDCARD, X as XSTATE_STOP, u as XSTATE_INIT, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-1c52b23c.development.esm.js';
+import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, W as WILDCARD, X as XSTATE_STOP, u as XSTATE_INIT, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-4005eb36.development.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -14,10 +14,10 @@ function memo(object, key, fn) {
   return memoizedData[key];
 }
 
-function resolveCancel(_, state, actionArgs, {
+function resolveCancel(_, state, actionArgs, actionParams, {
   sendId
 }) {
-  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs) : sendId;
+  const resolvedSendId = typeof sendId === 'function' ? sendId(actionArgs, actionParams) : sendId;
   return [state, resolvedSendId];
 }
 function executeCancel(actorContext, resolvedSendId) {
@@ -31,7 +31,7 @@ function executeCancel(actorContext, resolvedSendId) {
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
 function cancel(sendId) {
-  function cancel(_) {
+  function cancel(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -43,7 +43,7 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveInvoke(actorContext, state, actionArgs, {
+function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
@@ -54,12 +54,13 @@ function resolveInvoke(actorContext, state, actionArgs, {
     src,
     input: undefined
   };
+  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
   let actorRef;
   if (referenced) {
     // TODO: inline `input: undefined` should win over the referenced one
     const configuredInput = input || referenced.input;
     actorRef = createActor(referenced.src, {
-      id,
+      id: resolvedId,
       src: typeof src === 'string' ? src : undefined,
       parent: actorContext?.self,
       systemId,
@@ -79,9 +80,7 @@ function resolveInvoke(actorContext, state, actionArgs, {
             });
           }
         },
-        error: () => {
-          /* TODO */
-        }
+        error: () => {}
       });
     }
   }
@@ -91,14 +90,14 @@ function resolveInvoke(actorContext, state, actionArgs, {
   return [cloneState(state, {
     children: {
       ...state.children,
-      [id]: actorRef
+      [resolvedId]: actorRef
     }
   }), {
     id,
     actorRef
   }];
 }
-function executeInvoke(actorContext, {
+function executeSpawn(actorContext, {
   id,
   actorRef
 }) {
@@ -117,36 +116,32 @@ function executeInvoke(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({
+function spawn(...[src, {
   id,
   systemId,
-  src,
   input,
-  onSnapshot
-}) {
-  function invoke(_) {
+  syncSnapshot = false
+} = {}]) {
+  function spawn(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
   }
-  invoke.type = 'xstate.invoke';
-  invoke.id = id;
-  invoke.systemId = systemId;
-  invoke.src = src;
-  invoke.input = input;
-  invoke.syncSnapshot = !!onSnapshot;
-  invoke.resolve = resolveInvoke;
-  invoke.execute = executeInvoke;
-  return invoke;
+  spawn.type = 'xstate.spawn';
+  spawn.id = id;
+  spawn.systemId = systemId;
+  spawn.src = src;
+  spawn.input = input;
+  spawn.syncSnapshot = syncSnapshot;
+  spawn.resolve = resolveSpawn;
+  spawn.execute = executeSpawn;
+  return spawn;
 }
 
-function resolveStop(_, state, args, {
+function resolveStop(_, state, args, actionParams, {
   actorRef
 }) {
-  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args) : actorRef;
+  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
   const resolvedActorRef = typeof actorRefOrString === 'string' ? state.children[actorRefOrString] : actorRefOrString;
   let children = state.children;
   if (resolvedActorRef) {
@@ -163,6 +158,12 @@ function executeStop(actorContext, actorRef) {
   if (!actorRef) {
     return;
   }
+
+  // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
+  // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
+  // this could throw on `systemId` collision, for example, when dealing with reentering transitions
+  actorContext.system._unregister(actorRef);
+
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
   if (actorRef.status !== ActorStatus.Running) {
@@ -183,7 +184,7 @@ function executeStop(actorContext, actorRef) {
  * @param actorRef The actor to stop.
  */
 function stop(actorRef) {
-  function stop(_) {
+  function stop(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -205,7 +206,7 @@ function checkStateIn(state, _, {
   return state.matches(stateValue);
 }
 function stateIn(stateValue) {
-  function stateIn(_) {
+  function stateIn(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -223,7 +224,7 @@ function checkNot(state, {
   return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  function not(_) {
+  function not(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -241,7 +242,7 @@ function checkAnd(state, {
   return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  function and(_) {
+  function and(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -259,7 +260,7 @@ function checkOr(state, {
   return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  function or(_) {
+  function or(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -284,22 +285,17 @@ function evaluateGuard(guard, context, event, state) {
   }
   const guardArgs = {
     context,
-    event,
-    guard: isInline ? undefined : typeof guard === 'string' ? {
-      type: guard
-    } : typeof guard.params === 'function' ? {
-      type: guard.type,
-      params: guard.params({
-        context,
-        event
-      })
-    } : guard
+    event
   };
+  const guardParams = isInline || typeof guard === 'string' ? undefined : 'params' in guard ? typeof guard.params === 'function' ? guard.params({
+    context,
+    event
+  }) : guard.params : undefined;
   if (!('check' in resolved)) {
     // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
     // inline guards expect `TExpressionGuard` to be set to `undefined`
     // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
-    return resolved(guardArgs);
+    return resolved(guardArgs, guardParams);
   }
   const builtinGuard = resolved;
   return builtinGuard.check(state, guardArgs, resolved // this holds all params
@@ -888,11 +884,6 @@ function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
- *
- * @private
- * @param transitions
- * @param currentState
- * @param mutConfiguration
  */
 function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
@@ -959,7 +950,10 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
     for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
+      actions.push(spawn(invokeDef.src, {
+        ...invokeDef,
+        syncSnapshot: !!invokeDef.onSnapshot
+      }));
     }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
       const initialActions = stateNodeToEnter.initial.actions;
@@ -1123,31 +1117,24 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
-      system: actorCtx?.system,
-      action: isInline ? undefined : typeof action === 'string' ? {
-        type: 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
+      system: actorCtx?.system
     };
+    const actionParams = isInline || typeof action === 'string' ? undefined : 'params' in action ? typeof action.params === 'function' ? action.params({
+      context: intermediateState.context,
+      event
+    }) : action.params : undefined;
     if (!('resolve' in resolvedAction)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolvedAction(actionArgs);
+        resolvedAction(actionArgs, actionParams);
       } else {
         actorCtx?.defer(() => {
-          resolvedAction(actionArgs);
+          resolvedAction(actionArgs, actionParams);
         });
       }
       continue;
     }
     const builtinAction = resolvedAction;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, actionParams, resolvedAction,
     // this holds all params
     extra);
     intermediateState = nextState;
@@ -1187,7 +1174,9 @@ function macrostep(state, event, actorCtx, internalQueue = []) {
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextState = stopChildren(nextState, event, actorCtx);
+    nextState = cloneState(stopChildren(nextState, event, actorCtx), {
+      status: 'stopped'
+    });
     states.push(nextState);
     return {
       state: nextState,
@@ -1450,17 +1439,17 @@ function getPersistedState(state) {
       throw new Error('An inline child actor cannot be persisted.');
     }
     childrenJson[id] = {
-      state: child.getPersistedState?.(),
-      src: child.src
+      state: child.getPersistedState(),
+      src: child.src,
+      systemId: child._systemId
     };
   }
-  return {
+  const persisted = {
     ...jsonValues,
-    // TODO: this makes `PersistedMachineState`'s type kind of a lie
-    // it doesn't truly use `TContext` but rather some kind of a derived form of it
     context: persistContext(context),
     children: childrenJson
   };
+  return persisted;
 }
 function persistContext(contextPart) {
   let copy;
@@ -1489,7 +1478,7 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, state, args, {
+function resolveRaise(_, state, args, actionParams, {
   event: eventOrExpr,
   id,
   delay
@@ -1500,13 +1489,13 @@ function resolveRaise(_, state, args, {
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
   }
-  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args) : eventOrExpr;
+  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
   let resolvedDelay;
   if (typeof delay === 'string') {
     const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args) : configDelay;
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
   } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
+    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
   }
   if (typeof resolvedDelay !== 'number') {
     internalQueue.push(resolvedEvent);
@@ -1530,7 +1519,7 @@ function executeRaise(actorContext, params) {
  * @param eventType The event to raise.
  */
 function raise(eventOrExpr, options) {
-  function raise(_) {
+  function raise(args, params) {
     {
       throw new Error(`This isn't supposed to be called`);
     }
@@ -1544,4 +1533,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { raise as A, stop as B, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, getInitialStateNodes as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };
+export { raise as A, stop as B, spawn as C, State as S, formatTransition as a, formatInitialTransition as b, getCandidates as c, getConfiguration as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getStateNodes as h, isInFinalState as i, cloneState as j, macrostep as k, getInitialConfiguration as l, memo as m, resolveActionsAndContext as n, microstep as o, getInitialStateNodes as p, isStateId as q, resolveStateValue as r, getStateNodeByPath as s, transitionNode as t, getPersistedState as u, and as v, not as w, or as x, stateIn as y, cancel as z };