Typed Event Emitter

NOTE: REQUIRES TYPESCRIPT 3.0

A TypeScript library for strongly typed event emitters in 0 kB. Declare events using a simple interface mapping event names to their payloads to get stricter versions of emit, on, and other common EventEmitter APIs. Works with any kind of EventEmitter.

Installation

npm i strict-event-emitter-types

Example

1import StrictEventEmitter from 'strict-event-emitter-types';
2
3// define your events
4interface Events {
5  request: (request: Request, response: Response) => void;
6  done: void;
7}
8
9// grab an event emitter
10import { EventEmitter } from 'events';
11
12// Create strict event emitter types
13let ee: StrictEventEmitter<EventEmitter, Events> = new EventEmitter;
14
15// now enjoy your strongly typed EventEmitter API!🎉
16
17ee.on('request', (r, resp) => ... );
18// r and resp are contextually typed to Request and Response
19
20ee.on('somethingElse');
21// Error: unknown event
22
23ee.on('done', x => x);
24// Error: The 'done' event does not have a payload
25
26ee.emit('request', new Request());
27// Error: missing event payload (the response)
28
29ee.emit('request', new Request(), false);
30// Error: incorrect payload type

Usage

Event Records

Event records are interfaces or object types that map event names to the event's payload types. In the following example, three events are declared:

1interface Events {
2  req: (request: Request, response: Response) => void;
3  done: void;
4  conn: Connection;
5}

Each event shows one of three ways to type the event payloads:

1. Function type: Parameters are the event payload. The return type is ignored.
2. void: A shortcut for an event with no payload, i.e. () => void
3. Anything else: A shortcut for an event with one payload, for example (p: number) => void can be written as just number.

StrictEventEmitter<TEmitterType, TEventRecord, TEmitRecord>

The default export. A generic type that takes three type parameters:

1. TEmitterType: Your EventEmitter type (e.g. node's EventEmitter or socket.io socket)
2. TEventRecord: A type mapping event names to event payloads
3. TEmitRecord: Optionally, a similar type mapping things you can emit.

The third parameter is handy when typing web sockets where client and server can listen to and emit different events. For example, if you are using socket.io:

1// create types representing the server side and client
2// side sockets
3export type ServerSocket =
4  StrictEventEmitter<SocketIO.Socket, EventsFromServer, EventsFromClient>;
5export type ClientSocket =
6  StrictEventEmitter<SocketIOClient.Socket, EventsFromClient, EventsFromServer>;
7
8// elsewhere on server
9let serverSocket: ServerSocket = new SocketIO.Socket();
10serverSocket.on(/* only events that are sent from the client are allowed */, ...)
11serverSocket.emit(/* only events that are emitted from the server are allowed */, ...)
12
13// elsewhere on client
14let clientSocket: ClientSocket = new SocketIOClient.Socket();
15clientSocket.on(/* only events that are sent from the server are allowed */, ...)
16clientSocket.emit(/* only events that are emitted from the client are allowed */, ...)

Usage with Subclasses

To subclass an EventEmitter you need to cast the base EventEmitter to the strict EventEmitter before extending:

1type MyEmitter = StrictEventEmitter<EventEmitter, Events>;
2
3class MyEventEmitter extends (EventEmitter as { new(): MyEmitter }) {
4  doEmit() {
5    this.emit(...); // strict
6  }
7}

StrictBroadcast<TStrictEventEmitter>

A type for a function which takes (and strictly checks) an emit event and a payload. TStrictEventEmitter is the event emitter type instantiated from StrictEventEmitter.

Useful for broadcast abstractions. It is not possible to contextually type assigments to this type, so your declarations will look something like this:

1import { StrictBroadcast } from 'strict-event-emitter-types';
2
3const broadcast: StrictBroadcast<ServerSocket> = function(
4  event: string,
5  payload?: any
6) {
7  // ...
8};

Note that the loose types for event and payload only apply inside the broadcast function (consumers will see a much stricter signature). Declaring more precise parameter types or narrowing using type guards would allow strongly-typed dispatching to emitters.