@stratus51/emitter NPM

Implementation of some Typescript classes representing objects capable of pushing packets to a list of callbacks. It was primarily designed to handle internal events.

examples

Summary

Emitters methods
Available emitters
- ImmediateEmitter
- AsynchronousEmitter

Emitters methods

Each concrete emitter class implements the abstract methods defined by the abstract class Emitter<T>. The Emitter<T> class methods are the ones listed below.

In the typescript version of the library, an emitter can emit only one type of packet (represented by a generic type T) to allow type checking the packets.

`.sub(callback: (packet: T) => void): this`

Subscribes a callback to this emitter. The callback will then be called whenever this emitter emits any packet.

`.unsub(callback: (packet: T) => void): boolean`

Unsubscribes the callback from the emitter. It will no longer be called upon this emitter's packet emissions. Returns whether the callback was subscribed or not.

`.pub(packet: T): this`

Makes the emitter emit a packet. It will trigger all the callbacks currently subscribed to the emitter.

`.filter(accept: (packet: T) => boolean): Emitter<T>`

Creates a new Emitter<T> that will forward the packets of the parent emitter which match the accept condition (true means the packets is forwarded).

`.map(convert: (packet: T) => U): Emitter`

Creates a new Emitter that will convert any packet from the parent emitter into a new type U of packet and forward those to its subscribed callbacks.

`.relay(source: Emitter<T>): this`

Subscribes to another emitter and relay its packets to our subscribed callbacks.

`.sub_until(condition: (packet: T) => U | undefined, timeout?: number): Promise`

Subscribes the condition callback to this emitter until it returns any value that is not undefined.

The timeout optional parameter allows the condition to be unsubscribed after timeout milliseconds even if it never returned a non undefined result.
The return value is a promise that will resolve when the condition is unsubscribed. If it was due to the condition succeeding, the promise resolves to the result returned by condition. Else, on timeout it resolves to undefined.

`.raw_sub_until(condition: (packet: T) => U | undefined, end_callback?: (U | undefined) => void, timeout?: number): this`

Same as [sub_until](#sub_until) but using an optional callback to catch the end of subscription instead of a promise. This can save memory, would it be required.