xstate 5.15.0 → 5.17.0

package/dist/{raise-bad6a97b.development.cjs.js → State-a2464a1e.development.cjs.js}

@@ -326,7 +326,9 @@ function createSystem(rootActor, options) {
       const timeout = timerMap[scheduledEventId];
       delete timerMap[scheduledEventId];
       delete system._snapshot._scheduledEvents[scheduledEventId];
-      clock.clearTimeout(timeout);
+      if (timeout !== undefined) {
+        clock.clearTimeout(timeout);
+      }
     },
     cancelAll: actorRef => {
       for (const scheduledEventId in system._snapshot._scheduledEvents) {
@@ -423,6 +425,7 @@ function createSystem(rootActor, options) {
 }
 
 const $$ACTOR_TYPE = 1;
+
 // those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
 let ProcessingStatus = /*#__PURE__*/function (ProcessingStatus) {
   ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
@@ -1071,10 +1074,14 @@ function createActor(logic, ...[options]) {
  * options, if any.
  *
  * @deprecated Use `createActor` instead
+ * @alias
  */
 const interpret = createActor;
 
-/** @deprecated Use `Actor` instead. */
+/**
+ * @deprecated Use `Actor` instead.
+ * @alias
+ */
 
 function resolveCancel(_, snapshot, actionArgs, actionParams, {
   sendId
@@ -1132,144 +1139,6 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
-  id,
-  systemId,
-  src,
-  input,
-  syncSnapshot
-}) {
-  const logic = typeof src === 'string' ? resolveReferencedActor(snapshot.machine, src) : src;
-  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
-  let actorRef;
-  if (logic) {
-    actorRef = createActor(logic, {
-      id: resolvedId,
-      src,
-      parent: actorScope.self,
-      syncSnapshot,
-      systemId,
-      input: typeof input === 'function' ? input({
-        context: snapshot.context,
-        event: actionArgs.event,
-        self: actorScope.self
-      }) : input
-    });
-  }
-  if (!actorRef) {
-    console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
-  }
-  return [cloneMachineSnapshot(snapshot, {
-    children: {
-      ...snapshot.children,
-      [resolvedId]: actorRef
-    }
-  }), {
-    id,
-    actorRef
-  }];
-}
-function executeSpawn(actorScope, {
-  id,
-  actorRef
-}) {
-  if (!actorRef) {
-    return;
-  }
-  actorScope.defer(() => {
-    if (actorRef._processingStatus === ProcessingStatus.Stopped) {
-      return;
-    }
-    actorRef.start();
-  });
-}
-function spawnChild(...[src, {
-  id,
-  systemId,
-  input,
-  syncSnapshot = false
-} = {}]) {
-  function spawnChild(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  spawnChild.type = 'snapshot.spawnChild';
-  spawnChild.id = id;
-  spawnChild.systemId = systemId;
-  spawnChild.src = src;
-  spawnChild.input = input;
-  spawnChild.syncSnapshot = syncSnapshot;
-  spawnChild.resolve = resolveSpawn;
-  spawnChild.execute = executeSpawn;
-  return spawnChild;
-}
-
-function resolveStop(_, snapshot, args, actionParams, {
-  actorRef
-}) {
-  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
-  const resolvedActorRef = typeof actorRefOrString === 'string' ? snapshot.children[actorRefOrString] : actorRefOrString;
-  let children = snapshot.children;
-  if (resolvedActorRef) {
-    children = {
-      ...children
-    };
-    delete children[resolvedActorRef.id];
-  }
-  return [cloneMachineSnapshot(snapshot, {
-    children
-  }), resolvedActorRef];
-}
-function executeStop(actorScope, 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
-  actorScope.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._processingStatus !== ProcessingStatus.Running) {
-    actorScope.stopChild(actorRef);
-    return;
-  }
-  // stopping a child enqueues a stop event in the child actor's mailbox
-  // we need for all of the already enqueued events to be processed before we stop the child
-  // the parent itself might want to send some events to a child (for example from exit actions on the invoking state)
-  // and we don't want to ignore those events
-  actorScope.defer(() => {
-    actorScope.stopChild(actorRef);
-  });
-}
-/**
- * Stops a child actor.
- *
- * @param actorRef The actor to stop.
- */
-function stopChild(actorRef) {
-  function stop(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  stop.type = 'xstate.stopChild';
-  stop.actorRef = actorRef;
-  stop.resolve = resolveStop;
-  stop.execute = executeStop;
-  return stop;
-}
-
-/**
- * Stops a child actor.
- *
- * @deprecated Use `stopChild(...)` instead
- */
-const stop = stopChild;
-
 function checkStateIn(snapshot, _, {
   stateValue
 }) {
@@ -1466,6 +1335,211 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
+function resolveRaise(_, snapshot, args, actionParams, {
+  event: eventOrExpr,
+  id,
+  delay
+}, {
+  internalQueue
+}) {
+  const delaysMap = snapshot.machine.implementations.delays;
+  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, actionParams) : eventOrExpr;
+  let resolvedDelay;
+  if (typeof delay === 'string') {
+    const configDelay = delaysMap && delaysMap[delay];
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
+  } else {
+    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
+  }
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [snapshot, {
+    event: resolvedEvent,
+    id,
+    delay: resolvedDelay
+  }];
+}
+function executeRaise(actorScope, params) {
+  const {
+    event,
+    delay,
+    id
+  } = params;
+  if (typeof delay === 'number') {
+    actorScope.defer(() => {
+      const self = actorScope.self;
+      actorScope.system.scheduler.schedule(self, self, event, delay, id);
+    });
+    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) {
+  if (exports.executingCustomAction) {
+    console.warn('Custom actions should not call `raise()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
+  }
+  function raise(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  raise.type = 'xstate.raise';
+  raise.event = eventOrExpr;
+  raise.id = options?.id;
+  raise.delay = options?.delay;
+  raise.resolve = resolveRaise;
+  raise.execute = executeRaise;
+  return raise;
+}
+
+function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
+  id,
+  systemId,
+  src,
+  input,
+  syncSnapshot
+}) {
+  const logic = typeof src === 'string' ? resolveReferencedActor(snapshot.machine, src) : src;
+  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
+  let actorRef;
+  if (logic) {
+    actorRef = createActor(logic, {
+      id: resolvedId,
+      src,
+      parent: actorScope.self,
+      syncSnapshot,
+      systemId,
+      input: typeof input === 'function' ? input({
+        context: snapshot.context,
+        event: actionArgs.event,
+        self: actorScope.self
+      }) : input
+    });
+  }
+  if (!actorRef) {
+    console.warn(`Actor type '${src}' not found in machine '${actorScope.id}'.`);
+  }
+  return [cloneMachineSnapshot(snapshot, {
+    children: {
+      ...snapshot.children,
+      [resolvedId]: actorRef
+    }
+  }), {
+    id,
+    actorRef
+  }];
+}
+function executeSpawn(actorScope, {
+  id,
+  actorRef
+}) {
+  if (!actorRef) {
+    return;
+  }
+  actorScope.defer(() => {
+    if (actorRef._processingStatus === ProcessingStatus.Stopped) {
+      return;
+    }
+    actorRef.start();
+  });
+}
+function spawnChild(...[src, {
+  id,
+  systemId,
+  input,
+  syncSnapshot = false
+} = {}]) {
+  function spawnChild(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  spawnChild.type = 'snapshot.spawnChild';
+  spawnChild.id = id;
+  spawnChild.systemId = systemId;
+  spawnChild.src = src;
+  spawnChild.input = input;
+  spawnChild.syncSnapshot = syncSnapshot;
+  spawnChild.resolve = resolveSpawn;
+  spawnChild.execute = executeSpawn;
+  return spawnChild;
+}
+
+function resolveStop(_, snapshot, args, actionParams, {
+  actorRef
+}) {
+  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
+  const resolvedActorRef = typeof actorRefOrString === 'string' ? snapshot.children[actorRefOrString] : actorRefOrString;
+  let children = snapshot.children;
+  if (resolvedActorRef) {
+    children = {
+      ...children
+    };
+    delete children[resolvedActorRef.id];
+  }
+  return [cloneMachineSnapshot(snapshot, {
+    children
+  }), resolvedActorRef];
+}
+function executeStop(actorScope, 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
+  actorScope.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._processingStatus !== ProcessingStatus.Running) {
+    actorScope.stopChild(actorRef);
+    return;
+  }
+  // stopping a child enqueues a stop event in the child actor's mailbox
+  // we need for all of the already enqueued events to be processed before we stop the child
+  // the parent itself might want to send some events to a child (for example from exit actions on the invoking state)
+  // and we don't want to ignore those events
+  actorScope.defer(() => {
+    actorScope.stopChild(actorRef);
+  });
+}
+/**
+ * Stops a child actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+function stopChild(actorRef) {
+  function stop(args, params) {
+    {
+      throw new Error(`This isn't supposed to be called`);
+    }
+  }
+  stop.type = 'xstate.stopChild';
+  stop.actorRef = actorRef;
+  stop.resolve = resolveStop;
+  stop.execute = executeStop;
+  return stop;
+}
+
+/**
+ * Stops a child actor.
+ *
+ * @deprecated Use `stopChild(...)` instead
+ * @alias
+ */
+const stop = stopChild;
+
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
@@ -2590,72 +2664,6 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, snapshot, args, actionParams, {
-  event: eventOrExpr,
-  id,
-  delay
-}, {
-  internalQueue
-}) {
-  const delaysMap = snapshot.machine.implementations.delays;
-  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, actionParams) : eventOrExpr;
-  let resolvedDelay;
-  if (typeof delay === 'string') {
-    const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
-  } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
-  }
-  if (typeof resolvedDelay !== 'number') {
-    internalQueue.push(resolvedEvent);
-  }
-  return [snapshot, {
-    event: resolvedEvent,
-    id,
-    delay: resolvedDelay
-  }];
-}
-function executeRaise(actorScope, params) {
-  const {
-    event,
-    delay,
-    id
-  } = params;
-  if (typeof delay === 'number') {
-    actorScope.defer(() => {
-      const self = actorScope.self;
-      actorScope.system.scheduler.schedule(self, self, event, delay, id);
-    });
-    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) {
-  if (exports.executingCustomAction) {
-    console.warn('Custom actions should not call `raise()` directly, as it is not imperative. See https://stately.ai/docs/actions#built-in-actions for more details.');
-  }
-  function raise(args, params) {
-    {
-      throw new Error(`This isn't supposed to be called`);
-    }
-  }
-  raise.type = 'xstate.raise';
-  raise.event = eventOrExpr;
-  raise.id = options?.id;
-  raise.delay = options?.delay;
-  raise.resolve = resolveRaise;
-  raise.execute = executeRaise;
-  return raise;
-}
-
 exports.$$ACTOR_TYPE = $$ACTOR_TYPE;
 exports.Actor = Actor;
 exports.NULL_EVENT = NULL_EVENT;