@yume-chan/event
TypeScript icon, indicating that this package has built-in type declarations

0.0.23 • Public • Published

@yume-chan/event

Provides a strongly-typed EventEmitter/Event implementation.

Inspired by TypeScript, Visual Studio Code, and more.

Disposable

interface Disposable {
    dispose(): void;
}

Represents anything that need cleanup before the garbage collector recycle it.

AutoDisposable

class AutoDisposable implements Disposable {
    private disposables;
    constructor();
    protected addDisposable<T extends Disposable>(disposable: T): T;
    dispose(): void;
}

A base class for objects that need to manage multiple Disposables.

Calling dispose on it will automatically dispose all Disposables added via addDisposable.

Usually works like:

class MyObject extends AutoDisposable {
    private event1 = this.addDisposable(new EventEmitter<void>());

    private event2 = this.addDisposable(new EventEmitter<void>());

    public dispose() {
        // If the derived class has its own dispose logic
        // Don't forget to call super's `dispose`
        super.dispose();

        // Clean up itself.
    }
}

DisposableList

class DisposableList extends AutoDisposable {
    add<T extends Disposable>(disposable: T): T;
}

An AutoDisposable that can be used alone (i.e. not as a base class).

EventEmitter/Event

interface EventListener<TEvent, TThis, TArgs extends unknown[], TResult> {
    (this: TThis, e: TEvent, ...args: TArgs): TResult;
}

interface RemoveEventListener extends Disposable {
    (): void;
}

interface Event<TEvent, TResult = unknown> {
    (listener: EventListener<TEvent, unknown, [], TResult>): RemoveEventListener;
    <TThis, TArgs extends unknown[]>(listener: EventListener<TEvent, TThis, TArgs, TResult>, thisArg: TThis, ...args: TArgs): RemoveEventListener;
}

class EventEmitter<TEvent, TResult = unknown> implements Disposable {
    protected readonly listeners: EventListenerInfo<TEvent, TResult>[];
    constructor();
    protected addEventListener(info: EventListenerInfo<TEvent, TResult>): RemoveEventListener;
    event: Event<TEvent, TResult>;
    fire(e: TEvent): void;
    dispose(): void;
}
Node.js EventEmitter This EventEmitter
Can emit multiple event types Yes No
Only trusted source can emit events No Yes
Strongly-typed No Yes

One EventEmitter for one event type. So for classes that have multiple event types, multiple EventEmitter can be created and assigned to multiple fields.

Usually classes keep EventEmitters private (using TypeScript's private modifier, or ECMAScript private field), only expose the Event interface (via EventEmitter.event).

Everyone can subscribe to the event using the Event interface, but the event can only be emitted from the EventEmitter class.

const emitter = new EventEmitter<void>();
const subscribe = emitter.event;
const unsubscribe = subscribe(() => {});
emitter.fire();
unsubscribe();

The returned unsubscribe is both a function and a Disposable, so it can be used with AutoDisposable or DisposableList.

Package Sidebar

Install

npm i @yume-chan/event

Weekly Downloads

695

Version

0.0.23

License

MIT

Unpacked Size

41.4 kB

Total Files

32

Last publish

Collaborators

  • yume-chan