ClassSubEvent<T>

Event constructor.

Current number of live subscriptions.

Last emitted event, if there was any, or undefined otherwise.

It is set after all subscribers have received the event, but just before optional IEmitOptions.onFinished callback is invoked.

Maximum number of subscribers that can receive events. Default is 0, meaning no limit applies.

Newer subscriptions outside the maximum quota will start receiving events when the older subscriptions get cancelled.

It can only be set with the constructor.

Cancels all existing subscriptions for the event.

This is a convenience method for some special cases, when you want to cancel all subscriptions for the event at once. Usually, subscribers just call cancel when they want to cancel their own subscription.

This method will always offer much better performance than cancelling each subscription individually, which may become increasingly important when working with a large number of subscribers.

Broadcasts data to all subscribers, according to the emit schedule, which is synchronous by default.

Retrieves subscriptions statistics, to help with diagnosing subscription leaks.

For this method to be useful, you need to set option name when calling SubEvent.subscribe.

See also: Diagnostics

Subscribes to receive just one event, and cancel the subscription immediately.

You may still want to call Subscription.cancel on the returned object, if you suddenly need to prevent the first event, or to avoid dead once-off subscriptions that never received their event, and thus were not cancelled.

Subscribes to the event.

When subscription is no longer needed, method Subscription.cancel should be called on the returned object, to avoid performance degradation caused by abandoned subscribers.

Method SubEvent.getStat can help with diagnosing leaked subscriptions.

Returns a new EventConsumer for the event, which physically hides methods SubEvent.emit and SubEvent.cancelAll.

This method simplifies creation of a receive-only event object representation.

const e = new SubEvent<number>(); // full-access, emit-receive event

const c = e.toConsumer(); // the same "e" event, but with receive-only access

// It is equivalent to the full syntax of:
// const c = new EventConsumer<number>(e);
Copy

Creates a new subscription as a promise, to resolve with the next received event value, and cancel the subscription.

Examples of where it can be useful include:

• verify that a fast-pace subscription keeps receiving data;
• peek at fast-pace subscription data for throttled updates;
• for simpler receive-once / signal async processing logic.

try {
    const nextValue = await myEvent.toPromise({timeout: 1000});
} catch(e) {
    // Either subscription didn't produce any event after 1 second,
    // or myEvent.cancelAll() was called somewhere.
}
Copy

The returned promise can reject in two cases:

• when the timeout has been reached (if set via option timeout), it rejects with Event timed out error;
• when cancelAll is called on the event object, it rejects with Event cancelled error.

Note that if you use this method consecutively, you can miss events in between, because the subscription is auto-cancelled after receiving the first event.