strongbus - v3.0.0
    Preparing search index...

    Interface SubscriptionSurface<TEventMap>

    Subscribe, await, scan, and pipe events on a Bus.

    Event-map typing is bivariant (via method/bivarianceHack members, without an in out variance marker) so a surface over a wider map is assignable to a narrower view — the same Wide→Narrow shape as Bus itself.

    interface SubscriptionSurface<TEventMap extends EventMap = EventMap> {
        on<T extends string | number | symbol>(
            event: T,
            handler: EventHandler<TEventMap, T>,
            options?: SubscribeOptions,
        ): Subscription;
        off<T extends string | number | symbol>(
            event: T,
            handler: EventHandler<TEventMap, T>,
        ): void;
        once<T extends string | number | symbol>(
            event: T,
            handler: EventHandler<TEventMap, T>,
            options?: SubscribeOptions,
        ): Subscription;
        any: <
            TMap extends AnyEventMap<TEventMap>,
            TEvents extends
                Exclude<keyof TMap, "*">[] & Exclude<keyof TEventMap, "*">[],
        >(
            events: TEvents,
            handler: EventSink<TMap>,
            options?: SubscribeOptions,
        ) => Subscription;
        next: {
            <T extends string | number | symbol | (keyof TEventMap)[]>(
                resolutionTrigger: T,
                options?: SubscribeOptions,
            ): CancelablePromise<NextResult<TEventMap, T>>;
            <T extends string | number | symbol | (keyof TEventMap)[]>(
                resolutionTrigger: T,
                rejectionTrigger: T extends (keyof TEventMap)[]
                    ? SubscribableListenable<Exclude<keyof TEventMap, T[number]>>
                    : T extends keyof TEventMap
                        ? SubscribableListenable<Exclude<keyof TEventMap, T>>
                        : never,
                options?: SubscribeOptions,
            ): CancelablePromise<NextResult<TEventMap, T>>;
        };
        scan: {
            <T = any, TMap extends ScanEventMap<TEventMap> = TEventMap>(
                trigger: Listenable<keyof TMap> & Listenable<keyof TEventMap>,
                evaluator: (
                    resolve: Resolver<T, TMap>,
                    reject: Rejecter,
                ) => void | Promise<void>,
                options?: ScanOptions,
            ): CancelablePromise<T>;
            <T = any, TMap extends ScanEventMap<TEventMap> = TEventMap>(
                params: {
                    evaluator: (
                        resolve: Resolver<T, TMap>,
                        reject: Rejecter,
                    ) => void | Promise<void>;
                    trigger: Listenable<keyof TMap> & Listenable<keyof TEventMap>;
                } & ScanOptions,
            ): CancelablePromise<T>;
        };
        tap: <TMap extends PipeEventMap<TEventMap>>(
            handler: TapHandler<TMap>,
            options?: SubscribeOptions,
        ) => Subscription;
        pipe: {
            <TMap extends PipeEventMap<TEventMap>>(
                predicate: PipePredicate<TMap>,
            ): FilteredPipeHandle<TMap>;
            <TDownstream extends Bus<any>>(
                downstream: TDownstream & PipePayloadOverlap<
                    TEventMap,
                    InferPipeDownstreamMap<TDownstream>,
                >,
                options?: SubscribeOptions,
            ): TDownstream;
        };
        unpipe: <TDownstream extends Bus<any>>(downstream: TDownstream) => void;
    }

    Type Parameters

    Hierarchy (View Summary)

    • SubscriptionSurface

    Implemented by

    Index

    Properties

    any next scan tap pipe unpipe

    Methods

    on off once

    Properties

    any: <
        TMap extends AnyEventMap<TEventMap>,
        TEvents extends
            Exclude<keyof TMap, "*">[] & Exclude<keyof TEventMap, "*">[],
    >(
        events: TEvents,
        handler: EventSink<TMap>,
        options?: SubscribeOptions,
    ) => Subscription
    next: {
        <T extends string | number | symbol | (keyof TEventMap)[]>(
            resolutionTrigger: T,
            options?: SubscribeOptions,
        ): CancelablePromise<NextResult<TEventMap, T>>;
        <T extends string | number | symbol | (keyof TEventMap)[]>(
            resolutionTrigger: T,
            rejectionTrigger: T extends (keyof TEventMap)[]
                ? SubscribableListenable<Exclude<keyof TEventMap, T[number]>>
                : T extends keyof TEventMap
                    ? SubscribableListenable<Exclude<keyof TEventMap, T>>
                    : never,
            options?: SubscribeOptions,
        ): CancelablePromise<NextResult<TEventMap, T>>;
    }

    Await the first matching event as a CancelablePromise of {event, payload}.

    Triggers must be SubscribableListenable values (a single event key or array of keys). The '*' wildcard is not supported — it cannot keep event and payload types correlated.

    To resolve on the first of several known events, pass every key: next(['foo', 'bar', 'baz']). The result discriminates on event.

    When you need to inspect payload shape, filter events, or resolve only under a condition, use Bus.scan — including trigger: '*' with an evaluator that discriminates on resolve.trigger (see Scanner.Evaluator).

    scan: {
        <T = any, TMap extends ScanEventMap<TEventMap> = TEventMap>(
            trigger: Listenable<keyof TMap> & Listenable<keyof TEventMap>,
            evaluator: (
                resolve: Resolver<T, TMap>,
                reject: Rejecter,
            ) => void | Promise<void>,
            options?: ScanOptions,
        ): CancelablePromise<T>;
        <T = any, TMap extends ScanEventMap<TEventMap> = TEventMap>(
            params: {
                evaluator: (
                    resolve: Resolver<T, TMap>,
                    reject: Rejecter,
                ) => void | Promise<void>;
                trigger: Listenable<keyof TMap> & Listenable<keyof TEventMap>;
            } & ScanOptions,
        ): CancelablePromise<T>;
    }

    Type Declaration

    tap: <TMap extends PipeEventMap<TEventMap>>(
        handler: TapHandler<TMap>,
        options?: SubscribeOptions,
    ) => Subscription

    Observe every raised event as a correlated PipedMessage. Does not create a graph edge. Unsubscribe via the returned Subscription.

    pipe: {
        <TMap extends PipeEventMap<TEventMap>>(
            predicate: PipePredicate<TMap>,
        ): FilteredPipeHandle<TMap>;
        <TDownstream extends Bus<any>>(
            downstream: TDownstream & PipePayloadOverlap<
                TEventMap,
                InferPipeDownstreamMap<TDownstream>,
            >,
            options?: SubscribeOptions,
        ): TDownstream;
    }
    unpipe: <TDownstream extends Bus<any>>(downstream: TDownstream) => void

    Methods

    Settings

    Member Visibility

    On This Page

    Properties
    Methods