Ytukyg

I'm trying to make a typesafe EventEmitter, however I cannot enforce that the interface passed to the generic is of type EventMap without TypeScript complaining.

type EventHandler = () => void

type EventMap = Record<string, EventHandler>



interface EventListener {

  handler: EventHandler

  once: boolean

}



export class Emitter<Events extends EventMap> {

  private listeners = new Map<keyof Events, EventListener>()



  private addListener<E extends keyof EventMap>(type: E, listener: EventListener) {

    const listeners = this.listeners.get(type) || 

    this.listeners.set(type, [...listeners, listener])

  }



  @bind

  public on<E extends keyof EventMap>(type: E, handler: Events[E]) {

    this.addListener(type, { handler, once: false })

  }

}





interface TestEvents {

  test: (a: number) => void,

}



class Test extends Emitter<TestEvents> {}

Gives me

Type 'TestEvents' does not satisfy the constraint 'Record<string, EventHandler>'.

Index signature is missing in type 'TestEvents'.

You need to constrain it a bit differently, you want all keys of Events to be EventHandlers not necessarily for Events to have an index signature. You could use the following:

type EventHandler = (...a: any) => void



interface EventListener {

    handler: EventHandler

    once: boolean

}



export class Emitter<Events extends Record<keyof Events, EventHandler>> {

    private listeners = new Map<keyof Events, EventListener>()



    private addListener<E extends keyof Events>(type: E, listener: EventListener) {

        const listeners = this.listeners.get(type) || 

        this.listeners.set(type, [...listeners, listener])

    }



    public on<E extends keyof Events>(type: E, handler: Events[E]) {

        this.addListener(type, { handler, once: false })

    }

}





interface TestEvents {

    test: (a: number) => void,

}



class Test extends Emitter<TestEvents> { }

new Test().on("test", a => a.toExponential) // a is number.

There is a problem with this approach however, typescript will not be able to infer the argument type if you have multiple events in the map (which you probably will)

interface TestEvents {

    test: (a: number) => void,

    test2: (a: number) => void,

}



class Test extends Emitter<TestEvents> { }

new Test().on("test", a => a.toExponential) // a is any

This is fixable, but the types get more complicated, see here for a very similar idea.

Since Record is:

type Record<K extends string, T> = {

    [P in K]: T;

}

you are lacking index as defined:

interface TestEvents {

    test: () => void;

    [index: string] : EventHandler;

}

also your test method is invalid as it does not meet EventHandler requirements that forces no parameters on that method.

How about this:

export interface EventMap extends Record<string, EventHandler>{

    [index: string]: EventHandler;

    event1: () => void;

    event2: () => void;

}

now the required indexer exists but you force classes to have event1 and event2.