atvik
    Preparing search index...

    Interface Subscribable<This, Args>

    Function that can be used to subscribe, filter and iterate over events. Subscribables are commonly fetched from an Event, adapted from another event emitters using createEventAdapter or manually created via createSubscribable.

    Subscribables are functions that allow them to be called directly to subscribe to the event:

    // Subscribe to the event
    const handle = subscribable(arg1 => console.log('event', arg1));

    // Unsubscribe via the returned handle
    handle.unsubscribe();

    It is also possible to subscribe/unsubscribe a listener using methods on the subscribable:

    const listener = arg1 => console.log('event', arg1);
    subscribable.subscribe(listener);
    subscribable.unsubscribe(listener);

    Subscribables may be filtered to create an instance that only emits certain events:

    const filteredSubscribable = subscribable.filter(arg1 => arg1 > 10);
    

    Listening for a single event may be done via once which returns a promise:

    const [ arg1 ] = await subscribable.once();
    

    Subscribables can also be used with an async iterator to allow for event loops:

    With default values:

    for await (const [ arg1 ] of subscribable) {
    console.log('event', arg1);
    }

    Sometimes events are emitted faster than they can be consumed, limiting and controlling overflow of events can be done via iterator().

    As an example this will limit to 10 queued events and then start dropping the earliest ones:

    for await (const [ arg1 ] of subscribable.iterator({ limit: 10 })) {
    console.log('event', arg1);
    }

    The behavior to use when the queue is full can be controlled by setting the overflow behavior to either OverflowBehavior.DropNewest or OverflowBehavior.DropOldest.

    const iteratorOptions = {
    limit: 10,
    overflowBehavior: OverflowBehavior.DropNewest
    };

    for await (const [ arg1 ] of subscribable.iterator(iteratorOptions)) {
    console.log('event', arg1);
    }
    interface Subscribable<This, Args extends unknown[] = []> {
        "[asyncIterator]"(): EventIterator<Args>;
        filter(
            filter: (this: This, ...args: Args) => boolean | Promise<boolean>,
        ): Subscribable<This, Args>;
        iterator(options?: EventIteratorOptions): EventIterator<Args>;
        map<NewArgs extends [] | [unknown, ...unknown[]]>(
            mapper: (this: This, ...args: Args) => NewArgs | Promise<NewArgs>,
        ): Subscribable<This, NewArgs>;
        once(options?: OnceOptions): Promise<Args>;
        subscribe(
            listener: Listener<This, Args>,
            options?: SubscribeOptions,
        ): SubscriptionHandle;
        unsubscribe(listener: Listener<This, Args>): void;
        withThis<NewThis>(newThis: NewThis): Subscribable<NewThis, Args>;
        (
            listener: Listener<This, Args>,
            options?: SubscribeOptions,
        ): SubscriptionHandle;
    }

    Type Parameters

    • This
    • Args extends unknown[] = []

    Hierarchy (View Summary)

    Index