Add Mailbox

packages/core/src/Mailbox.ts

@@ -0,0 +1,36 @@
+export class Mailbox<T> {
+  private events: T[] = [];
+  private index: number = 0;
+
+  public status: 'deferred' | 'idle' | 'processing' = 'deferred';
+
+  public get size(): number {
+    return this.events.length - this.index;
+  }
+
+  public clear(): void {
+    this.events.length = 0;
+    this.index = 0;
+  }
+
+  public enqueue(event: T): void {
+    this.events.push(event);
+  }
+
+  public dequeue(): T | undefined {
+    const event = this.events[this.index];
+
+    if (!event) {
+      return undefined;
+    }
+
+    this.index++;
+
+    if (this.index > this.events.length - 1) {
+      this.events.length = 0;
+      this.index = 0;
+    }
+
+    return event;
+  }
+}

packages/core/src/StateMachine.ts

@@ -240,32 +240,42 @@ export class StateMachine<
     return transitionNode(this.root, state.value, state, _event) || [];
   }
 
-  public get first(): State<TContext, TEvent, TTypestate> {
-    const pseudoinitial = this.resolveState(
+  private get preInitialState(): State<TContext, TEvent, TTypestate> {
+    const preInitial = this.resolveState(
       State.from(
         getStateValue(this.root, getConfiguration([this.root])),
         this.context
       )
     );
-    pseudoinitial._initial = true;
+    preInitial._initial = true;
 
-    return pseudoinitial;
+    return preInitial;
   }
 
   /**
    * The initial State instance, which includes all actions to be executed from
    * entering the initial state.
    */
   public get initialState(): State<TContext, TEvent, TTypestate> {
-    const nextState = resolveMicroTransition(this, [], this.first, undefined);
+    const nextState = resolveMicroTransition(
+      this,
+      [],
+      this.preInitialState,
+      undefined
+    );
     return macrostep(nextState, null as any, this);
   }
 
   /**
    * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
    */
   public getInitialState(): State<TContext, TEvent, TTypestate> {
-    const nextState = resolveMicroTransition(this, [], this.first, undefined);
+    const nextState = resolveMicroTransition(
+      this,
+      [],
+      this.preInitialState,
+      undefined
+    );
     return macrostep(nextState, null as any, this) as State<
       TContext,
       TEvent,

packages/core/src/interpreter.ts

@@ -48,6 +48,7 @@ import type {
   Subscribable
 } from './types';
 import { isExecutableAction } from '../actions/ExecutableAction';
+import { Mailbox } from './Mailbox';
 
 export type StateListener<
   TContext extends MachineContext,
@@ -110,8 +111,7 @@ export class Interpreter<
   public options: Readonly<InterpreterOptions>;
 
   public id: string;
-  private mailbox: Array<SCXML.Event<TEvent>> = [];
-  private mailboxStatus: 'deferred' | 'idle' | 'processing' = 'deferred';
+  private mailbox: Mailbox<SCXML.Event<TEvent>> = new Mailbox();
   private delayedEventsMap: Record<string, number> = {};
   private listeners: Set<
     StateListener<TContext, TEvent, TTypestate>
@@ -418,18 +418,19 @@ export class Interpreter<
   }
 
   private flush() {
-    this.mailboxStatus = 'processing';
-    while (this.mailbox.length) {
-      const event = this.mailbox.shift()!;
-
+    this.mailbox.status = 'processing';
+    let event = this.mailbox.dequeue();
+    while (event) {
       // TODO: handle errors
       this.forward(event);
 
       const nextState = this.nextState(event);
 
       this.update(nextState);
+
+      event = this.mailbox.dequeue();
     }
-    this.mailboxStatus = 'idle';
+    this.mailbox.status = 'idle';
   }
 
   /**
@@ -469,7 +470,7 @@ export class Interpreter<
       this.clock.clearTimeout(this.delayedEventsMap[key]);
     }
 
-    this.mailbox.length = 0;
+    this.mailbox.clear();
     this.status = InterpreterStatus.Stopped;
     registry.free(this.sessionId);
 
@@ -518,9 +519,9 @@ export class Interpreter<
       );
     }
 
-    this.mailbox.push(_event);
+    this.mailbox.enqueue(_event);
 
-    if (this.mailboxStatus === 'idle') {
+    if (this.mailbox.status === 'idle') {
       this.flush();
     }
   };