56 lines
2.3 KiB
Markdown
56 lines
2.3 KiB
Markdown
# Eventlet
|
|
|
|
Eventlet is a minimal typed event library.
|
|
|
|
It is designed to be used as either a standalone object which emits events, or as a member property of a class that emits events. You can create an Eventlet and specify the listener signature like this:
|
|
|
|
```ts
|
|
const greeter = new Eventlet<(greeting: string, subject: string) => void>();
|
|
const onGreet = (greeting: string, subject: string) => console.log(`${ greeting }, ${ subject }!`);
|
|
greeter.add(onGreet);
|
|
greeter.emit("Hello", "world"); // "Hello, world!"
|
|
```
|
|
|
|
The ability to emit is typed separately from the ability to register listeners (`EmitControl` vs. `Emitter`, respectively), making it easy to hide emit capabilities from your public interfaces:
|
|
|
|
```ts
|
|
class ClassWithChangingProperty {
|
|
private _prop = 3;
|
|
public get prop() {
|
|
return this._prop;
|
|
}
|
|
public set prop(newValue: number) {
|
|
this._prop = newValue;
|
|
this._propChanged.emit();
|
|
}
|
|
|
|
// The default listener signature has no parameters if event typing is not provided.
|
|
private readonly _propChanged = new Eventlet();
|
|
// The public interface can just expose the Emitter capability of the Eventlet.
|
|
// This keeps its EmitControl capability private.
|
|
public get propChanged(): Emitter {
|
|
return this._propChanged;
|
|
}
|
|
}
|
|
```
|
|
|
|
If you don't specify a listener signature, it defaults to `() => void`.
|
|
|
|
Listeners can be removed when they are no longer needed. Pass the same function reference that was originally added.
|
|
|
|
```ts
|
|
type MessageReceivedListener = (message: string) => void;
|
|
const messageReceived = new Eventlet<MessageReceivedListener>();
|
|
const onMessageReceived = (message: string) => console.log(message);
|
|
messageReceived.add(onMessageReceived);
|
|
messageReceived.emit("Hello!"); // "Hello!"
|
|
// ...time passes...
|
|
messageReceived.remove(onMessageReceived);
|
|
```
|
|
|
|
## Usage recommendations
|
|
|
|
* Each Eventlet is designed to be used for a single event type. For a scenario with multiple event types, use multiple Eventlets.
|
|
* Eventlet should not be used as a superclass. Instead add an Eventlet as a member property of the class that will use it.
|
|
* References to the registered listeners are held by the Eventlet. Be sure to remove them when they're no longer needed so they can be garbage collected appropriately.
|