@d-fischer/typed-event-emitter

This module provides an alternative API to the well known event emitting interfaces used in the browser (DOM) or node.js. Instead of accepting arbitrary strings as the event name, this module forces you to register your events in your class. Consequently, the style of binding and emitting events differs a little, ensuring already at binding time that the events actually exist.

Install

1yarn add @d-fischer/typed-event-emitter
2# or
3npm install @d-fischer/typed-event-emitter

Usage

1import { EventEmitter } from '@d-fischer/typed-event-emitter';
2
3class MyClass extends EventEmitter {
4	// register an event
5	onValueChanged = this.registerEvent<[newValue: number]>();
6
7	private _value: number;
8
9	constructor(value: number) {
10		// initialize EventEmitter
11		super();
12
13		this._value = value;
14	}
15
16	get value() {
17		return this._value;
18	}
19
20	set value(value: number) {
21		this._value = value;
22		// emit the event to all listeners
23		this.emit(this.onValueChanged, this._value);
24	}
25}
26
27const instance = new MyClass();
28
29// listen to event
30instance.onValueChanged(newValue => {
31	console.log('Value changed', newValue);
32});
33
34// invoke setter
35instance.value = 27;

First, the EventEmitter is loaded from the module. Any class that shall emit events, must extend that EventEmitter. If your class has its own constructor, make sure to call super().

Any events your class shall be able to emit must be registered in the form:

1onFooBar = this.registerEvent<[...argTypes]>();

Where onFooBar can be any name (it doesn't need to begin with on) and argTypes must be a tuple representing the arguments of the function the listeners must have. With this, you can see the signature your function must have when you're about to bind a listener to that event.

To emit an event (only possible from within your event emitter), you have to call this.emit(this.onFooBar, ...), where this.onFooBar is the event to emit and ... any number of parameters, that will be passed to the listeners.

Internal events

You can also declare internal events as well as internal listeners. The main advantage over just using regular listeners appears when you write a library for other people to use. If an end user decides to clear all events using instance.removeListener() without any parameter or with only the event binder to clear out a specific event, internal listeners will survive that.

1import { EventEmitter } from '@d-fischer/typed-event-emitter';
2
3class MyClass extends EventEmitter {
4	// register an event
5	onValueChanged = this.registerEvent<[newValue: number]>();
6
7	private _value: number;
8
9	constructor(value: number) {
10		// initialize EventEmitter
11		super();
12
13		this._value = value;
14		
15		this.addInternalListener(this.onValueChanged, newValue => {
16			console.log('Value changed (internal)', newValue);
17		});
18	}
19
20	get value() {
21		return this._value;
22	}
23
24	set value(value: number) {
25		this._value = value;
26		// emit the event to all listeners
27		this.emit(this.onValueChanged, this._value);
28	}
29}
30
31const instance = new MyClass();
32
33// listen to event
34instance.onValueChanged(newValue => {
35	console.log('Value changed (external)', newValue);
36});
37
38// invoke setter, shows internal & external logs
39instance.value = 27;
40
41// clear listeners for event
42instance.removeListener(instance.onValueChanged);
43
44// invoke setter, still shows internal log
45instance.value = 42;

JavaScript

Your JavaScript host (i.e., your browser, node.js, etc.) should support classes and inheritance in order to work correctly. The code shown above can also be written in JavaScript (node.js):

1const { EventEmitter } = require('@d-fischer/typed-event-emitter');
2
3class MyClass extends EventEmitter {
4	constructor(value) {
5		// initialize EventEmitter
6		super();
7
8		/* newValue: number */
9		this.onValueChanged = this.registerEvent();
10
11		this._value = value;
12	}
13
14	get value() {
15		return this._value;
16	}
17
18	set value(value) {
19		this._value = value;
20		this.emit(this.onValueChanged, this._value);
21	}
22}
23
24let instance = new MyClass();
25instance.onValueChanged(newValue => {
26	console.log(`Value changed: ${newValue}`);
27});
28
29instance.value = 27;

Node that the events are registered explicitly within the constructor. Make sure to initialize them after calling super().