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
  • .sub(callback: (packet: T) => void): this
  • .unsub(callback: (packet: T) => void): boolean
  • .pub(packet: T): this
  • .filter(accept: (packet: T) => boolean): Emitter<T>
  • .map<U>(convert: (packet: T) => U): Emitter<U>
  • .relay(source: Emitter<T>): this
  • .sub_until<U>(condition: (packet: T) => U | undefined, timeout?: number): Promise<U | undefined>
  • .raw_sub_until<U>(condition: (packet: T) => U | undefined, end_callback?: (result: U | undefined) => void, timeout?: number): this
  • .as_callback(): (packet: T) => void
• 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<U>(convert: (packet: T) => U): Emitter<U>

Creates a new Emitter<U> 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<U>(condition: (packet: T) => U | undefined, timeout?: number): Promise<U | undefined>

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<U>(condition: (packet: T) => U | undefined, end_callback?: (U | undefined) => void, timeout?: number): this

Same as 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.

.as_callback(): (packet: T) => void

Builds a callback feeding this emitter. The callback is built on the first call and then passed to any subsequent calls.

Available emitters

ImmediateEmitter

Emitter implementation that triggers all the subscribed callbacks during the .pub method call.

AsynchronousEmitter

Emitter implementation that triggers all the subscribed callbacks one tick after the .pub method call (using process.nextTick()).