events.ts

type Listener<E extends Event> = [EventListener<E>, EventOptions | undefined];

/**
 * Class to manage the event listeners
 * and dispatch events
 */
export default class Events<E extends Event> {
  listeners = new Map<string, Set<Listener<E>>>();

  /** Assign a listener to an event */
  addEventListener(
    type: string,
    listenerFn: EventListener<E>,
    options?: EventOptions,
  ) {
    const listeners = this.listeners.get(type) || new Set();
    const listener: Listener<E> = [listenerFn, options];

    listeners.add(listener);
    this.listeners.set(type, listeners);

    // Remove on abort
    if (options?.signal) {
      options.signal.addEventListener("abort", () => {
        listeners.delete(listener);
      });
    }

    return this;
  }

  /** Dispatch an event */
  async dispatchEvent(event: E) {
    const { type } = event;
    const listeners = this.listeners.get(type);

    if (!listeners) {
      return true;
    }

    for (const listener of listeners) {
      const [listenerFn, listenerOptions] = listener;

      // Remove the listener if it's a once listener
      if (listenerOptions?.once) {
        listeners.delete(listener);
      }

      if (await listenerFn(event) === false) {
        return false;
      }
    }

    return true;
  }
}

/** An event object */
export interface Event {
  /** The event type */
  type: string;
}

/** Event listener */
export type EventListener<E extends Event> = (event: E) => unknown;

/** The available options for events */
export interface EventOptions {
  /**
   * To indicate that the listener should be invoked at most once
   * after being added
   */
  once?: boolean;

  /**
   * The listener will be removed
   * when the given AbortSignal object's abort() method is called
   */
  signal?: AbortSignal;
}