xstate 5.0.0-beta.35 → 5.0.0-beta.36

package/dist/declarations/src/State.d.ts

@@ -27,7 +27,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     error: unknown;
     context: TContext;
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
-    _internalQueue: Array<TEvent>;
     /**
      * The enabled state nodes representative of the state value.
      */

package/dist/declarations/src/stateUtils.d.ts

@@ -50,9 +50,9 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param currentState
  * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: AnyState, actorCtx: AnyActorContext, event: TEvent, isInitial: boolean): AnyState;
-export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorCtx: AnyActorContext, actions: UnknownAction[], deferredActorIds?: string[]): AnyState;
-export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyState, actorCtx: AnyActorContext, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyState;
+export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorCtx: AnyActorContext, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyState;
+export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext, internalQueue?: AnyEventObject[]): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

package/dist/declarations/src/types.d.ts

@@ -554,7 +554,6 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     error?: unknown;
     tags?: Set<string>;
     machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any>;
-    _internalQueue?: Array<TEvent>;
 }
 export interface ActorOptions<TLogic extends AnyActorLogic> {
     /**

package/dist/{raise-26e4d83c.development.cjs.js → raise-106ea558.development.cjs.js}

@@ -861,6 +861,17 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
+function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
+  if (previousConfiguration.length !== nextConfigurationSet.size) {
+    return false;
+  }
+  for (const node of previousConfiguration) {
+    if (!nextConfigurationSet.has(node)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -870,50 +881,36 @@ function computeExitSet(transitions, configuration, historyValue) {
  * @param currentState
  * @param mutConfiguration
  */
-
-function microstep(transitions, currentState, actorCtx, event, isInitial) {
-  const mutConfiguration = new Set(currentState.configuration);
+function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
-  const microstate = microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial);
-  return cloneState(microstate, {
-    value: {} // TODO: make optional
-  });
-}
-
-function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const historyValue = {
-    ...currentState.historyValue
-  };
+  const mutConfiguration = new Set(currentState.configuration);
+  let historyValue = currentState.historyValue;
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
-  const internalQueue = [...currentState._internalQueue];
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let nextState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
+    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
   nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    internalQueue.push(...nextState._internalQueue);
+    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+      return nextState;
+    }
     return cloneState(nextState, {
       configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue
+      historyValue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -952,7 +949,7 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       if (completedNodes.has(parent)) {
@@ -1049,10 +1046,11 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
+  let changedHistory;
 
   // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
   for (const exitStateNode of statesToExit) {
@@ -1065,14 +1063,17 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
           return sn.parent === exitStateNode;
         };
       }
-      historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory ??= {
+        ...historyValue
+      };
+      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
-  return nextState;
+  return [nextState, changedHistory || historyValue];
 }
 function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
@@ -1137,9 +1138,10 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+    internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
@@ -1147,7 +1149,7 @@ function resolveActionsAndContext(currentState, event, actorCtx, actions, deferr
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx) {
+function macrostep(state, event, actorCtx, internalQueue = []) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
   }
@@ -1156,7 +1158,7 @@ function macrostep(state, event, actorCtx) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopChildren(nextState, event, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -1169,44 +1171,37 @@ function macrostep(state, event, actorCtx) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== interpreter.XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
+    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
     states.push(nextState);
   }
+  let shouldSelectEventlessTransitions = true;
   while (nextState.status === 'active') {
-    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextState, nextEvent) : [];
+
+    // eventless transitions should always be selected after selecting *regular* transitions
+    // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
+    const previousState = enabledTransitions.length ? nextState : undefined;
     if (!enabledTransitions.length) {
-      if (!nextState._internalQueue.length) {
+      if (!internalQueue.length) {
         break;
-      } else {
-        nextEvent = nextState._internalQueue[0];
-        const transitions = selectTransitions(nextEvent, nextState);
-        nextState = microstep(transitions, nextState, actorCtx, nextEvent, false);
-        nextState._internalQueue.shift();
-        states.push(nextState);
       }
-    } else {
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false);
-      states.push(nextState);
+      nextEvent = internalQueue.shift();
+      enabledTransitions = selectTransitions(nextEvent, nextState);
     }
+    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    shouldSelectEventlessTransitions = nextState !== previousState;
+    states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextEvent, nextState, actorCtx);
+    stopChildren(nextState, nextEvent, actorCtx);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopStep(event, nextState, actorCtx) {
-  const actions = [];
-  for (const stateNode of nextState.configuration.sort((a, b) => b.order - a.order)) {
-    actions.push(...stateNode.exit);
-  }
-  for (const child of Object.values(nextState.children)) {
-    actions.push(stop(child));
-  }
-  return resolveActionsAndContext(nextState, event, actorCtx, actions);
+function stopChildren(nextState, event, actorCtx) {
+  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1312,11 +1307,9 @@ class State {
     this.error = void 0;
     this.context = void 0;
     this.historyValue = {};
-    this._internalQueue = void 0;
     this.configuration = void 0;
     this.children = void 0;
     this.context = config.context;
-    this._internalQueue = config._internalQueue ?? [];
     this.historyValue = config.historyValue || {};
     this.matches = this.matches.bind(this);
     this.toStrings = this.toStrings.bind(this);
@@ -1471,6 +1464,8 @@ function resolveRaise(_, state, args, {
   event: eventOrExpr,
   id,
   delay
+}, {
+  internalQueue
 }) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
@@ -1484,9 +1479,10 @@ function resolveRaise(_, state, args, {
   } else {
     resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
   }
-  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
-    _internalQueue: state._internalQueue.concat(resolvedEvent)
-  }) : state, {
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [state, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay

package/dist/{raise-cdcdf834.development.esm.js → raise-5b7ad3b7.development.esm.js}

@@ -859,6 +859,17 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
+function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
+  if (previousConfiguration.length !== nextConfigurationSet.size) {
+    return false;
+  }
+  for (const node of previousConfiguration) {
+    if (!nextConfigurationSet.has(node)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -868,50 +879,36 @@ function computeExitSet(transitions, configuration, historyValue) {
  * @param currentState
  * @param mutConfiguration
  */
-
-function microstep(transitions, currentState, actorCtx, event, isInitial) {
-  const mutConfiguration = new Set(currentState.configuration);
+function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
-  const microstate = microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial);
-  return cloneState(microstate, {
-    value: {} // TODO: make optional
-  });
-}
-
-function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const historyValue = {
-    ...currentState.historyValue
-  };
+  const mutConfiguration = new Set(currentState.configuration);
+  let historyValue = currentState.historyValue;
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
-  const internalQueue = [...currentState._internalQueue];
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let nextState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
+    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
   nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   if (nextState.status === 'done') {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    internalQueue.push(...nextState._internalQueue);
+    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+      return nextState;
+    }
     return cloneState(nextState, {
       configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue
+      historyValue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -950,7 +947,7 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       const initialActions = stateNodeToEnter.initial.actions;
       actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       if (completedNodes.has(parent)) {
@@ -1047,10 +1044,11 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
+  let changedHistory;
 
   // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
   for (const exitStateNode of statesToExit) {
@@ -1063,14 +1061,17 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
           return sn.parent === exitStateNode;
         };
       }
-      historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory ??= {
+        ...historyValue
+      };
+      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
-  return nextState;
+  return [nextState, changedHistory || historyValue];
 }
 function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
@@ -1135,9 +1136,10 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+    internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
@@ -1145,7 +1147,7 @@ function resolveActionsAndContext(currentState, event, actorCtx, actions, deferr
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx) {
+function macrostep(state, event, actorCtx, internalQueue = []) {
   if (event.type === WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${WILDCARD}')`);
   }
@@ -1154,7 +1156,7 @@ function macrostep(state, event, actorCtx) {
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopChildren(nextState, event, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -1167,44 +1169,37 @@ function macrostep(state, event, actorCtx) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
+    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
     states.push(nextState);
   }
+  let shouldSelectEventlessTransitions = true;
   while (nextState.status === 'active') {
-    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextState, nextEvent) : [];
+
+    // eventless transitions should always be selected after selecting *regular* transitions
+    // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
+    const previousState = enabledTransitions.length ? nextState : undefined;
     if (!enabledTransitions.length) {
-      if (!nextState._internalQueue.length) {
+      if (!internalQueue.length) {
         break;
-      } else {
-        nextEvent = nextState._internalQueue[0];
-        const transitions = selectTransitions(nextEvent, nextState);
-        nextState = microstep(transitions, nextState, actorCtx, nextEvent, false);
-        nextState._internalQueue.shift();
-        states.push(nextState);
       }
-    } else {
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false);
-      states.push(nextState);
+      nextEvent = internalQueue.shift();
+      enabledTransitions = selectTransitions(nextEvent, nextState);
     }
+    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    shouldSelectEventlessTransitions = nextState !== previousState;
+    states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextEvent, nextState, actorCtx);
+    stopChildren(nextState, nextEvent, actorCtx);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopStep(event, nextState, actorCtx) {
-  const actions = [];
-  for (const stateNode of nextState.configuration.sort((a, b) => b.order - a.order)) {
-    actions.push(...stateNode.exit);
-  }
-  for (const child of Object.values(nextState.children)) {
-    actions.push(stop(child));
-  }
-  return resolveActionsAndContext(nextState, event, actorCtx, actions);
+function stopChildren(nextState, event, actorCtx) {
+  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1310,11 +1305,9 @@ class State {
     this.error = void 0;
     this.context = void 0;
     this.historyValue = {};
-    this._internalQueue = void 0;
     this.configuration = void 0;
     this.children = void 0;
     this.context = config.context;
-    this._internalQueue = config._internalQueue ?? [];
     this.historyValue = config.historyValue || {};
     this.matches = this.matches.bind(this);
     this.toStrings = this.toStrings.bind(this);
@@ -1469,6 +1462,8 @@ function resolveRaise(_, state, args, {
   event: eventOrExpr,
   id,
   delay
+}, {
+  internalQueue
 }) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
@@ -1482,9 +1477,10 @@ function resolveRaise(_, state, args, {
   } else {
     resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
   }
-  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
-    _internalQueue: state._internalQueue.concat(resolvedEvent)
-  }) : state, {
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [state, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay