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

package/dist/{raise-21c417c1.esm.js → raise-c989c7fb.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, X as XSTATE_STOP, u as XSTATE_INIT, W as WILDCARD, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-8def682e.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, X as XSTATE_STOP, u as XSTATE_INIT, W as WILDCARD, v as createAfterEvent, w as flatten, e as matchesState, $ as $$ACTOR_TYPE } from './interpreter-c80ce92e.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) {
   }
   cancel.type = 'xstate.cancel';
   cancel.sendId = sendId;
@@ -40,7 +40,7 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveInvoke(actorContext, state, actionArgs, {
+function resolveSpawn(actorContext, state, actionArgs, _actionParams, {
   id,
   systemId,
   src,
@@ -51,12 +51,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,
@@ -76,23 +77,21 @@ function resolveInvoke(actorContext, state, actionArgs, {
             });
           }
         },
-        error: () => {
-          /* TODO */
-        }
+        error: () => {}
       });
     }
   }
   return [cloneState(state, {
     children: {
       ...state.children,
-      [id]: actorRef
+      [resolvedId]: actorRef
     }
   }), {
     id,
     actorRef
   }];
 }
-function executeInvoke(actorContext, {
+function executeSpawn(actorContext, {
   id,
   actorRef
 }) {
@@ -111,33 +110,29 @@ 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(_) {
-  }
-  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;
+  syncSnapshot = false
+} = {}]) {
+  function spawn(args, params) {
+  }
+  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) {
@@ -154,6 +149,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) {
@@ -174,7 +175,7 @@ function executeStop(actorContext, actorRef) {
  * @param actorRef The actor to stop.
  */
 function stop(actorRef) {
-  function stop(_) {
+  function stop(args, params) {
   }
   stop.type = 'xstate.stop';
   stop.actorRef = actorRef;
@@ -193,7 +194,7 @@ function checkStateIn(state, _, {
   return state.matches(stateValue);
 }
 function stateIn(stateValue) {
-  function stateIn(_) {
+  function stateIn(args, params) {
     return false;
   }
   stateIn.check = checkStateIn;
@@ -209,7 +210,7 @@ function checkNot(state, {
   return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  function not(_) {
+  function not(args, params) {
     return false;
   }
   not.check = checkNot;
@@ -225,7 +226,7 @@ function checkAnd(state, {
   return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  function and(_) {
+  function and(args, params) {
     return false;
   }
   and.check = checkAnd;
@@ -241,7 +242,7 @@ function checkOr(state, {
   return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  function or(_) {
+  function or(args, params) {
     return false;
   }
   or.check = checkOr;
@@ -264,22 +265,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
@@ -857,11 +853,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) {
@@ -928,7 +919,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;
@@ -1092,31 +1086,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;
@@ -1153,7 +1140,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,
@@ -1410,17 +1399,17 @@ function getPersistedState(state) {
   for (const id in children) {
     const child = children[id];
     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;
@@ -1449,7 +1438,7 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, state, args, {
+function resolveRaise(_, state, args, actionParams, {
   event: eventOrExpr,
   id,
   delay
@@ -1460,13 +1449,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);
@@ -1490,7 +1479,7 @@ function executeRaise(actorContext, params) {
  * @param eventType The event to raise.
  */
 function raise(eventOrExpr, options) {
-  function raise(_) {
+  function raise(args, params) {
   }
   raise.type = 'xstate.raise';
   raise.event = eventOrExpr;
@@ -1501,4 +1490,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 };

package/dist/{send-4cc29786.cjs.js → send-34160163.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-800296d7.cjs.js');
-var interpreter = require('./interpreter-97aff8d2.cjs.js');
+var guards_dist_xstateGuards = require('./raise-7faa9b3b.cjs.js');
+var interpreter = require('./interpreter-b6f22ee2.cjs.js');
 
 function createSpawner(actorContext, {
   machine,
@@ -41,9 +41,7 @@ function createSpawner(actorContext, {
               });
             }
           },
-          error: () => {
-            /* TODO */
-          }
+          error: () => {}
         });
       }
       return actorRef;
@@ -67,9 +65,7 @@ function createSpawner(actorContext, {
               });
             }
           },
-          error: () => {
-            /* TODO */
-          }
+          error: () => {}
         });
       }
       return actorRef;
@@ -93,7 +89,7 @@ function createSpawner(actorContext, {
   };
 }
 
-function resolveAssign(actorContext, state, actionArgs, {
+function resolveAssign(actorContext, state, actionArgs, actionParams, {
   assignment
 }) {
   if (!state.context) {
@@ -103,18 +99,17 @@ function resolveAssign(actorContext, state, actionArgs, {
   const assignArgs = {
     context: state.context,
     event: actionArgs.event,
-    action: actionArgs.action,
     spawn: createSpawner(actorContext, state, actionArgs.event, spawnedChildren),
     self: actorContext?.self,
     system: actorContext?.system
   };
   let partialUpdate = {};
   if (typeof assignment === 'function') {
-    partialUpdate = assignment(assignArgs);
+    partialUpdate = assignment(assignArgs, actionParams);
   } else {
     for (const key of Object.keys(assignment)) {
       const propAssignment = assignment[key];
-      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs) : propAssignment;
+      partialUpdate[key] = typeof propAssignment === 'function' ? propAssignment(assignArgs, actionParams) : propAssignment;
     }
   }
   const updatedContext = Object.assign({}, state.context, partialUpdate);
@@ -132,7 +127,7 @@ function resolveAssign(actorContext, state, actionArgs, {
  * @param assignment An object that represents the partial context to update.
  */
 function assign(assignment) {
-  function assign(_) {
+  function assign(args, params) {
   }
   assign.type = 'xstate.assign';
   assign.assignment = assignment;
@@ -140,7 +135,7 @@ function assign(assignment) {
   return assign;
 }
 
-function resolveChoose(_, state, actionArgs, {
+function resolveChoose(_, state, actionArgs, _actionParams, {
   branches
 }) {
   const matchedActions = branches.find(condition => {
@@ -149,7 +144,7 @@ function resolveChoose(_, state, actionArgs, {
   return [state, undefined, interpreter.toArray(matchedActions)];
 }
 function choose(branches) {
-  function choose(_) {
+  function choose(args, params) {
   }
   choose.type = 'xstate.choose';
   choose.branches = branches;
@@ -157,12 +152,12 @@ function choose(branches) {
   return choose;
 }
 
-function resolveLog(_, state, actionArgs, {
+function resolveLog(_, state, actionArgs, actionParams, {
   value,
   label
 }) {
   return [state, {
-    value: typeof value === 'function' ? value(actionArgs) : value,
+    value: typeof value === 'function' ? value(actionArgs, actionParams) : value,
     label
   }];
 }
@@ -193,7 +188,7 @@ function log(value = ({
   context,
   event
 }), label) {
-  function log(_) {
+  function log(args, params) {
   }
   log.type = 'xstate.log';
   log.value = value;
@@ -203,7 +198,7 @@ function log(value = ({
   return log;
 }
 
-function resolvePure(_, state, args, {
+function resolvePure(_, state, args, _actionParams, {
   get
 }) {
   return [state, undefined, interpreter.toArray(get({
@@ -212,7 +207,7 @@ function resolvePure(_, state, args, {
   }))];
 }
 function pure(getActions) {
-  function pure(_) {
+  function pure(args, params) {
   }
   pure.type = 'xstate.pure';
   pure.get = getActions;
@@ -221,6 +216,9 @@ function pure(getActions) {
 }
 
 /**
+ *
+ * @remarks
+ *
  * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
  * It especially is a problem when the union has a function member, like here:
  *
@@ -241,7 +239,10 @@ function pure(getActions) {
 /**
  * The string or object representing the state value relative to the parent state node.
  *
+ * @remarks
+ *
  * - For a child atomic state node, this is a string, e.g., `"pending"`.
+ *
  * - For complex state nodes, this is an object, e.g., `{ success: "someChildState" }`.
  */
 
@@ -255,7 +256,7 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   return SpecialTargets;
 }({});
 
-function resolveSendTo(actorContext, state, args, {
+function resolveSendTo(actorContext, state, args, actionParams, {
   to,
   event: eventOrExpr,
   id,
@@ -265,15 +266,15 @@ function resolveSendTo(actorContext, state, args, {
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ 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;
   }
-  const resolvedTarget = typeof to === 'function' ? to(args) : to;
+  const resolvedTarget = typeof to === 'function' ? to(args, actionParams) : to;
   let targetActorRef;
   if (typeof resolvedTarget === 'string') {
     if (resolvedTarget === SpecialTargets.Parent) {
@@ -331,7 +332,7 @@ function executeSendTo(actorContext, params) {
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  */
 function sendTo(to, eventOrExpr, options) {
-  function sendTo(_) {
+  function sendTo(args, params) {
   }
   sendTo.type = 'xstate.sendTo';
   sendTo.to = to;