Typescript Event Bus

Emitter.ts

import IEvent from "IEvent";
import IEventListener from "IEventListener";

export class EventEmitter
{
    private listeners: { [key: string]: IEventListener[] } = {};

    public on(event: Function, listener: IEventListener): void
    {
        if (!this.listeners[event.name]) this.listeners[event.name] = [];

        this.listeners[event.name].push(listener);
    }

    public async emit(event: IEvent): Promise<void[]>
    {
        const listeners: IEventListener[] = this.listeners[event.constructor.name] || [];

        return Promise.all(listeners.map(listener => listener.handle(event)));
    }

    public async fire(event: IEvent): Promise<void>
    {
        const listeners: IEventListener[] = this.listeners[event.constructor.name] || [];

        for (let listener of listeners)
        {
            await listener.handle(event);
        }
    }
}

export const Emitter = new EventEmitter();

IEvent.ts

export default interface IEvent
{
  //...
}

IEventListener.ts

import IEvent from "IEvent";

export default interface IEventListener
{
    handle(event: IEvent): Promise<void>;
}

index.ts

import Emitter from 'Emitter';
import MyEvent from 'MyEvent';
import MyEventListener from 'MyEventListener';

Emitter.on(MyEvent, (new MyEventListener()));
Emitter.emit(new MyEvent());

MyEvent.ts

import IEvent from "IEvent";

export default class MyEvent implements IEvent
{
  //...
}

MyEventListener.ts

import MyEvent from "events/MyEvent";
import IEventListener from "events/IEventListener";

export default class MyEventListener implements IEventListener
{
    constructor()
    {
      //...
    }

    async handle(event: MyEvent): Promise<void>
    {
      //...
    }
}