@thi.ng/rstream/merge.d.ts

Reactive streams & subscription primitives for constructing dataflow graphs / pipelines

import { type ISubscribable, type ISubscription, type TransformableOpts } from "./api.js";
import { Subscription } from "./subscription.js";
export interface StreamMergeOpts<A, B> extends TransformableOpts<A, B> {
    /**
     * Input sources.
     */
    src: ISubscribable<A>[];
}
/**
 * Returns a new {@link StreamMerge} subscription, consuming values from
 * multiple inputs and passing received values on to any subscribers.
 *
 * @remarks
 * Input streams can be added and removed dynamically. By default, `StreamMerge`
 * calls {@link ISubscriber.done} when the last active input is done, but this
 * behavior can be overridden via the provided
 * {@link StreamMergeOpts | options}.
 *
 * @example
 * ```ts tangle:../export/merge.ts
 * import { fromIterable, merge, trace } from "@thi.ng/rstream";
 *
 * merge({
 *     // input streams w/ different frequencies
 *     src: [
 *         fromIterable([1, 2, 3], { delay: 10 }),
 *         fromIterable([10, 20, 30], { delay: 21 }),
 *         fromIterable([100, 200, 300], { delay: 7 })
 *     ]
 * }).subscribe(trace());
 * // 100
 * // 1
 * // 200
 * // 10
 * // 2
 * // 300
 * // 3
 * // 20
 * // 30
 * // done
 * ```
 *
 * @example
 * Use the
 * [`labeled`](https://docs.thi.ng/umbrella/transducers/functions/labeled.html)
 * transducer for each input to create a stream of labeled values and
 * track their provenance:
 *
 * @example
 * ```ts tangle:../export/merge-2.ts
 * import { fromIterable, merge, trace } from "@thi.ng/rstream";
 * import { labeled } from "@thi.ng/transducers";
 *
 * merge({
 *     src: [
 *         fromIterable([1, 2, 3]).transform(labeled("a")),
 *         fromIterable([10, 20, 30]).transform(labeled("b")),
 *     ]
 * }).subscribe(trace());
 * // ["a", 1]
 * // ["b", 10]
 * // ["a", 2]
 * // ["b", 20]
 * // ["a", 3]
 * // ["b", 30]
 * // done
 * ```
 *
 * @param opts -
 */
export declare const merge: <A, B>(opts?: Partial<StreamMergeOpts<A, B>>) => StreamMerge<A, B>;
/**
 * See {@link merge} for reference & examples.
 */
export declare class StreamMerge<A, B> extends Subscription<A, B> {
    sources: Map<ISubscribable<A>, ISubscription<A, any>>;
    constructor(opts?: Partial<StreamMergeOpts<A, B>>);
    add(src: ISubscribable<A>): void;
    addAll(src: Iterable<ISubscribable<A>>): void;
    remove(src: ISubscribable<A>): boolean;
    removeID(id: string): boolean;
    removeAll(src: Iterable<ISubscribable<A>>): boolean;
    removeAllIDs(ids: Iterable<string>): boolean;
    unsubscribe(sub?: ISubscription<B, any>): boolean;
    protected markDone(src: ISubscribable<A>): void;
}
//# sourceMappingURL=merge.d.ts.map