Class EventQueue

src/back/util/EventQueue.ts:9–68

/** Executes a queue of asynchronous functions, one at a time. */
export class EventQueue implements IEventQueue {
  /** Max size of queue (Unlimited if undefined) */
  private readonly maxSize?: number;
  /** Queue of functions. */
  private queue: EventFunction[] = [];
  /** If this is currently executing an event (flag). */
  private isExecuting = false;
  /** Called whenever an error occurs. */
  public onError: (error: any) => void = noop;

  constructor(maxSize?: number) {
    this.maxSize = maxSize;
  }

  /**
   * Add en event to the end of the queue.
   *
   * @param event Event function to add.
   * @param returnPromise If a promise should be returned.
   * @returns Nothing or a promise that resolves after the event is executed,
   *          or rejects if it rejects or throws an error.
   */
  push(event: EventFunction, returnPromise?: boolean): Promise<void> | void {
    // Wrap the event, and create a promise, if a promise should be returned
    const [wrappedEvent, promise] = returnPromise ? wrapEvent(event) : [undefined, undefined];
    // Push end off early if max size is reached
    if (this.queue.length === this.maxSize) {
      this.queue.shift();
    }
    // Add event to the end of the queue
    this.queue.push(wrappedEvent || event);
    this.update();
    // Return promise (if any)
    return promise;
  }

  private update() {
    if (!this.isExecuting && this.queue.length > 0) {
      // Update flag
      this.isExecuting = true;
      // Start executing
      this.executeNext()
      .finally(() => { this.isExecuting = false; });
    }
  }

  /**
   * Execute the next event in the queue (and continue doing so until the queue is empty).
   *
   * @returns A promise that resolves when it reaches the end of the queue.
   */
  private async executeNext(): Promise<void> {
    const event = this.queue.shift();
    if (event) {
      try { await executeEventFunction(event); }
      catch (error) { this.onError(error); }
      await this.executeNext();
    }