reactor-core-ts 2.1.6 → 3.2.1

package/dist/publisher/operators/compat/mono.js

@@ -0,0 +1,125 @@
+import { Schedulers } from "../../../schedulers/schedulers.js";
+import { Flux } from "../../flux.js";
+import { Mono } from "../../mono.js";
+//#region src/publisher/operators/compat/mono.ts
+/**
+* @packageDocumentation
+* Flux, Mono and operator implementation modules.
+*/
+Mono.prototype.and = function and(other) {
+	return this.thenEmpty(other);
+};
+Mono.prototype.as = function as(transformer) {
+	return transformer(this);
+};
+Mono.prototype.cast = function cast() {
+	return this;
+};
+Mono.prototype.concatWith = function concatWith(other) {
+	return this.flux().concatWith(other);
+};
+Mono.prototype.doFinally = function doFinally(callback) {
+	return new Mono((signal, context) => Flux.prototype.doFinally.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnError = function doOnError(callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnError.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnNext = function doOnNext(callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnNext.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnSuccess = function doOnSuccess(callback) {
+	const source = this;
+	return new Mono(async function* (signal, context) {
+		let seen = false;
+		let value;
+		for await (const next of source.iterate(signal, context)) {
+			seen = true;
+			value = next;
+			yield next;
+		}
+		callback(seen ? value : void 0);
+	});
+};
+Mono.prototype.doOnTerminate = function doOnTerminate(callback) {
+	return new Mono((signal, context) => Flux.prototype.doFinally.call(this, (event) => {
+		if (event !== "cancel") callback();
+	}).iterate(signal, context));
+};
+Mono.prototype.elapsed = function elapsed(scheduler = Schedulers.timeout()) {
+	return new Mono((signal, context) => Flux.prototype.elapsed.call(this, scheduler).iterate(signal, context));
+};
+Mono.prototype.flux = function flux() {
+	return new Flux((signal, context) => this.iterate(signal, context));
+};
+Mono.prototype.handle = function handle(handler) {
+	return new Mono((signal, context) => Flux.prototype.handle.call(this, handler).iterate(signal, context));
+};
+Mono.prototype.hasElement = function hasElement() {
+	return this.map(() => true).defaultIfEmpty(false);
+};
+Mono.prototype.ignoreElement = function ignoreElement() {
+	return this.then();
+};
+Mono.prototype.materialize = function materialize() {
+	return new Mono((signal, context) => Flux.prototype.materialize.call(this).iterate(signal, context));
+};
+Mono.prototype.mergeWith = function mergeWith(other) {
+	return this.flux().mergeWith(other);
+};
+Mono.prototype.onErrorMap = function onErrorMap(mapper) {
+	return new Mono((signal, context) => Flux.prototype.onErrorMap.call(this, mapper).iterate(signal, context));
+};
+Mono.prototype.onErrorResume = function onErrorResume(fallback) {
+	return new Mono((signal, context) => Flux.prototype.onErrorResume.call(this, fallback).iterate(signal, context));
+};
+Mono.prototype.onErrorReturn = function onErrorReturn(fallbackValue) {
+	return new Mono((signal, context) => Flux.prototype.onErrorReturn.call(this, fallbackValue).iterate(signal, context));
+};
+Mono.prototype.publishOn = function publishOn(scheduler) {
+	return new Mono((signal, context) => Flux.prototype.publishOn.call(this, scheduler).iterate(signal, context));
+};
+Mono.prototype.repeat = function repeat(repeatCount) {
+	return Flux.prototype.repeat.call(this, repeatCount);
+};
+Mono.prototype.retry = function retry(maxRetries) {
+	return new Mono((signal, context) => Flux.prototype.retry.call(this, maxRetries).iterate(signal, context));
+};
+Mono.prototype.single = function single() {
+	return this;
+};
+Mono.prototype.subscribeOn = function subscribeOn(scheduler) {
+	return new Mono((signal, context) => Flux.prototype.subscribeOn.call(this, scheduler).iterate(signal, context));
+};
+Mono.prototype.subscribeWith = function subscribeWith(subscriber) {
+	this.subscribe(subscriber);
+	return subscriber;
+};
+Mono.prototype.take = function take() {
+	return this;
+};
+Mono.prototype.thenEmpty = function thenEmpty(other) {
+	return Flux.prototype.thenEmpty.call(this, other);
+};
+Mono.prototype.thenMany = function thenMany(other) {
+	return Flux.prototype.thenMany.call(this, other);
+};
+Mono.prototype.timeout = function timeout(timeout, fallback, scheduler) {
+	return new Mono((signal, context) => Flux.prototype.timeout.call(this, timeout, fallback, scheduler).iterate(signal, context));
+};
+Mono.prototype.timestamp = function timestamp(scheduler = Schedulers.timeout()) {
+	return new Mono((signal, context) => Flux.prototype.timestamp.call(this, scheduler).iterate(signal, context));
+};
+Mono.prototype.transform = function transform(transformer) {
+	return Mono.from(transformer(this));
+};
+Mono.prototype.transformDeferred = function transformDeferred(transformer) {
+	const source = this;
+	return Mono.defer(() => transformer(source));
+};
+Mono.prototype.transformDeferredContextual = function transformDeferredContextual(transformer) {
+	const source = this;
+	return new Mono((signal, context) => Mono.from(transformer(source, context.readOnly())).iterate(signal, context));
+};
+//#endregion
+
+//# sourceMappingURL=mono.js.map

package/dist/publisher/operators/compat/mono.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mono.js","names":[],"sources":["../../../../src/publisher/operators/compat/mono.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Flux, Mono and operator implementation modules.\n */\nimport {Flux} from \"@/publisher/flux.js\";\nimport {Mono} from \"@/publisher/mono.js\";\nimport type {PublisherInput, SynchronousSink} from \"@/publisher/types.js\";\nimport {Schedulers} from \"@/schedulers/schedulers.js\";\nimport type {DurationInput, Scheduler} from \"@/schedulers/types.js\";\nimport {Signal} from \"@/signal/signal.js\";\nimport type {Subscriber} from \"@/subscription/subscriber.js\";\nimport type {ContextView} from \"@/context/context-view.js\";\n\ndeclare module \"@/publisher/mono.js\" {\n    /** Reactor compatibility operators added to Mono. */\n    interface Mono<T> {\n        /** Waits for this Mono and another publisher, ignoring values from both. */\n        and(other: PublisherInput<unknown>): Mono<void>;\n\n        /** Passes this Mono to a transformer and returns the transformer's result. */\n        as<R>(transformer: (source: Mono<T>) => R): R;\n\n        /** Treats this Mono as a Mono of another TypeScript type. */\n        cast<R>(): Mono<R>;\n\n        /** Emits this Mono value and then values from another publisher. */\n        concatWith(other: PublisherInput<T>): Flux<T>;\n\n        /** Invokes a callback once after completion, error, or cancellation. */\n        doFinally(callback: (signal: \"complete\" | \"error\" | \"cancel\") => void): Mono<T>;\n\n        /** Invokes a callback when this Mono fails. */\n        doOnError(callback: (error: unknown) => void): Mono<T>;\n\n        /** Invokes a callback when this Mono emits a value. */\n        doOnNext(callback: (value: T) => void): Mono<T>;\n\n        /** Invokes a callback when this Mono completes successfully, with undefined when empty. */\n        doOnSuccess(callback: (value: T | undefined) => void): Mono<T>;\n\n        /** Invokes a callback before successful or failed termination is propagated. */\n        doOnTerminate(callback: () => void): Mono<T>;\n\n        /** Emits the elapsed scheduler time together with the Mono value. */\n        elapsed(scheduler?: Scheduler): Mono<readonly [number, T]>;\n\n        /** Views this Mono as a Flux that emits zero or one value. */\n        flux(): Flux<T>;\n\n        /** Handles the value with a synchronous sink that may emit, complete, or fail. */\n        handle<R>(handler: (value: T, sink: SynchronousSink<R>) => void): Mono<R>;\n\n        /** Emits true when this Mono emits a value. */\n        hasElement(): Mono<boolean>;\n\n        /** Drops the value and completes when this Mono completes successfully. */\n        ignoreElement(): Mono<void>;\n\n        /** Converts the Mono value or terminal signal into a `Signal` value. */\n        materialize(): Mono<Signal<T>>;\n\n        /** Merges this Mono with another publisher and returns the combined Flux. */\n        mergeWith(other: PublisherInput<T>): Flux<T>;\n\n        /** Replaces an error with the result of the provided mapper. */\n        onErrorMap(mapper: (error: unknown) => unknown): Mono<T>;\n\n        /** Switches to a fallback publisher when this Mono fails. */\n        onErrorResume<R = T>(fallback: (error: unknown) => PublisherInput<R>): Mono<T | R>;\n\n        /** Emits the fallback value when this Mono fails. */\n        onErrorReturn(fallbackValue: T): Mono<T>;\n\n        /** Reschedules value delivery on the provided scheduler. */\n        publishOn(scheduler: Scheduler): Mono<T>;\n\n        /** Re-subscribes after successful completion and emits repeated values as a Flux. */\n        repeat(repeatCount?: number): Flux<T>;\n\n        /** Re-subscribes when this Mono fails, up to the configured retry count. */\n        retry(maxRetries?: number): Mono<T>;\n\n        /** Returns this Mono while preserving single-value semantics. */\n        single(): Mono<T>;\n\n        /** Schedules subscription work on the provided scheduler. */\n        subscribeOn(scheduler: Scheduler): Mono<T>;\n\n        /** Subscribes the provided subscriber and returns the same subscriber instance. */\n        subscribeWith<S extends Subscriber<T>>(subscriber: S): S;\n\n        /** Returns this Mono, matching Reactor's zero-or-one `take` semantics. */\n        take(): Mono<T>;\n\n        /** Waits for this Mono and then waits for `other`, ignoring all values. */\n        thenEmpty(other: PublisherInput<unknown>): Mono<void>;\n\n        /** Waits for this Mono to complete and then emits values from `other`. */\n        thenMany<R>(other: PublisherInput<R>): Flux<R>;\n\n        /** Fails or switches to a fallback when this Mono does not signal in time. */\n        timeout(timeout: DurationInput, fallback?: PublisherInput<T>, scheduler?: Scheduler): Mono<T>;\n\n        /** Emits the scheduler timestamp together with the Mono value. */\n        timestamp(scheduler?: Scheduler): Mono<readonly [number, T]>;\n\n        /** Applies a transformer to this Mono immediately and adapts its result back to Mono. */\n        transform<R>(transformer: (source: Mono<T>) => PublisherInput<R>): Mono<R>;\n\n        /** Applies a transformer separately for each subscription. */\n        transformDeferred<R>(transformer: (source: Mono<T>) => PublisherInput<R>): Mono<R>;\n\n        /** Applies a transformer per subscription with access to the subscriber context. */\n        transformDeferredContextual<R>(\n            transformer: (source: Mono<T>, context: ContextView) => PublisherInput<R>\n        ): Mono<R>;\n    }\n}\n\n\nMono.prototype.and = function and<T>(this: Mono<T>, other: PublisherInput<unknown>): Mono<void> {\n    return this.thenEmpty(other);\n};\n\nMono.prototype.as = function as<T, R>(this: Mono<T>, transformer: (source: Mono<T>) => R): R {\n    return transformer(this);\n};\n\nMono.prototype.cast = function cast<T, R>(this: Mono<T>): Mono<R> {\n    return this as unknown as Mono<R>;\n};\n\nMono.prototype.concatWith = function concatWith<T>(this: Mono<T>, other: PublisherInput<T>): Flux<T> {\n    return this.flux().concatWith(other);\n};\n\nMono.prototype.doFinally = function doFinally<T>(\n    this: Mono<T>,\n    callback: (signal: \"complete\" | \"error\" | \"cancel\") => void\n): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.doFinally.call(this, callback).iterate(signal, context));\n};\n\nMono.prototype.doOnError = function doOnError<T>(this: Mono<T>, callback: (error: unknown) => void): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.doOnError.call(this, callback).iterate(signal, context));\n};\n\nMono.prototype.doOnNext = function doOnNext<T>(this: Mono<T>, callback: (value: T) => void): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.doOnNext.call(this, callback).iterate(signal, context));\n};\n\nMono.prototype.doOnSuccess = function doOnSuccess<T>(this: Mono<T>, callback: (value: T | undefined) => void): Mono<T> {\n    const source = this;\n    return new Mono(async function* (signal, context) {\n        let seen = false;\n        let value: T | undefined;\n        for await (const next of source.iterate(signal, context)) {\n            seen = true;\n            value = next;\n            yield next;\n        }\n        callback(seen ? value : undefined);\n    });\n};\n\nMono.prototype.doOnTerminate = function doOnTerminate<T>(this: Mono<T>, callback: () => void): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.doFinally.call(this, event => {\n        if (event !== \"cancel\") {\n            callback();\n        }\n    }).iterate(signal, context));\n};\n\nMono.prototype.elapsed = function elapsed<T>(\n    this: Mono<T>,\n    scheduler: Scheduler = Schedulers.timeout()\n): Mono<readonly [number, T]> {\n    return new Mono((signal, context) => Flux.prototype.elapsed.call(this, scheduler).iterate(signal, context));\n};\n\nMono.prototype.flux = function flux<T>(this: Mono<T>): Flux<T> {\n    return new Flux((signal, context) => this.iterate(signal, context));\n};\n\nMono.prototype.handle = function handle<T, R>(\n    this: Mono<T>,\n    handler: (value: T, sink: SynchronousSink<R>) => void\n): Mono<R> {\n    return new Mono((signal, context) => (Flux.prototype.handle.call(this, handler) as Flux<R>).iterate(signal, context));\n};\n\nMono.prototype.hasElement = function hasElement<T>(this: Mono<T>): Mono<boolean> {\n    return this.map(() => true).defaultIfEmpty(false);\n};\n\nMono.prototype.ignoreElement = function ignoreElement<T>(this: Mono<T>): Mono<void> {\n    return this.then();\n};\n\nMono.prototype.materialize = function materialize<T>(this: Mono<T>): Mono<Signal<T>> {\n    return new Mono((signal, context) => Flux.prototype.materialize.call(this).iterate(signal, context));\n};\n\nMono.prototype.mergeWith = function mergeWith<T>(this: Mono<T>, other: PublisherInput<T>): Flux<T> {\n    return this.flux().mergeWith(other);\n};\n\nMono.prototype.onErrorMap = function onErrorMap<T>(this: Mono<T>, mapper: (error: unknown) => unknown): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.onErrorMap.call(this, mapper).iterate(signal, context));\n};\n\nMono.prototype.onErrorResume = function onErrorResume<T, R = T>(\n    this: Mono<T>,\n    fallback: (error: unknown) => PublisherInput<R>\n): Mono<T | R> {\n    return new Mono((signal, context) => Flux.prototype.onErrorResume.call(this, fallback).iterate(signal, context));\n};\n\nMono.prototype.onErrorReturn = function onErrorReturn<T>(this: Mono<T>, fallbackValue: T): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.onErrorReturn.call(this, fallbackValue).iterate(signal, context));\n};\n\nMono.prototype.publishOn = function publishOn<T>(this: Mono<T>, scheduler: Scheduler): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.publishOn.call(this, scheduler).iterate(signal, context));\n};\n\nMono.prototype.repeat = function repeat<T>(this: Mono<T>, repeatCount?: number): Flux<T> {\n    return Flux.prototype.repeat.call(this, repeatCount) as Flux<T>;\n};\n\nMono.prototype.retry = function retry<T>(this: Mono<T>, maxRetries?: number): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.retry.call(this, maxRetries).iterate(signal, context));\n};\n\nMono.prototype.single = function single<T>(this: Mono<T>): Mono<T> {\n    return this;\n};\n\nMono.prototype.subscribeOn = function subscribeOn<T>(this: Mono<T>, scheduler: Scheduler): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.subscribeOn.call(this, scheduler).iterate(signal, context));\n};\n\nMono.prototype.subscribeWith = function subscribeWith<T, S extends Subscriber<T>>(this: Mono<T>, subscriber: S): S {\n    this.subscribe(subscriber);\n    return subscriber;\n};\n\nMono.prototype.take = function take<T>(this: Mono<T>): Mono<T> {\n    return this;\n};\n\nMono.prototype.thenEmpty = function thenEmpty<T>(this: Mono<T>, other: PublisherInput<unknown>): Mono<void> {\n    return Flux.prototype.thenEmpty.call(this, other);\n};\n\nMono.prototype.thenMany = function thenMany<T, R>(this: Mono<T>, other: PublisherInput<R>): Flux<R> {\n    return Flux.prototype.thenMany.call(this, other) as Flux<R>;\n};\n\nMono.prototype.timeout = function timeout<T>(\n    this: Mono<T>,\n    timeout: DurationInput,\n    fallback?: PublisherInput<T>,\n    scheduler?: Scheduler\n): Mono<T> {\n    return new Mono((signal, context) => Flux.prototype.timeout.call(this, timeout, fallback, scheduler).iterate(signal, context));\n};\n\nMono.prototype.timestamp = function timestamp<T>(\n    this: Mono<T>,\n    scheduler: Scheduler = Schedulers.timeout()\n): Mono<readonly [number, T]> {\n    return new Mono((signal, context) => Flux.prototype.timestamp.call(this, scheduler).iterate(signal, context));\n};\n\nMono.prototype.transform = function transform<T, R>(\n    this: Mono<T>,\n    transformer: (source: Mono<T>) => PublisherInput<R>\n): Mono<R> {\n    return Mono.from(transformer(this));\n};\n\nMono.prototype.transformDeferred = function transformDeferred<T, R>(\n    this: Mono<T>,\n    transformer: (source: Mono<T>) => PublisherInput<R>\n): Mono<R> {\n    const source = this;\n    return Mono.defer(() => transformer(source));\n};\n\nMono.prototype.transformDeferredContextual = function transformDeferredContextual<T, R>(\n    this: Mono<T>,\n    transformer: (source: Mono<T>, context: ContextView) => PublisherInput<R>\n): Mono<R> {\n    const source = this;\n    return new Mono((signal, context) => Mono.from(transformer(source, context.readOnly())).iterate(signal, context));\n};\n"],"mappings":"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"}

package/dist/publisher/operators/coordination.d.ts

@@ -0,0 +1,82 @@
+import { Flux } from "../flux.js";
+import type { PublisherInput } from "../types.js";
+import type { DurationInput, Scheduler } from "../../schedulers/types.js";
+import { Signal } from "../../signal/signal.js";
+/** Flux enriched with the key produced by `groupBy`. */
+export type GroupedFlux<K, T> = Flux<T> & {
+    /** Group key shared by all values in this grouped Flux. */
+    readonly key: K;
+};
+/** Browser timing metadata emitted by `timed`. */
+export interface Timed<T> {
+    /** Source value associated with this timing sample. */
+    readonly value: T;
+    /** Timestamp in scheduler milliseconds. */
+    readonly timestamp: number;
+    /** Milliseconds elapsed since the previous value. */
+    readonly elapsed: number;
+}
+declare module "../flux.js" {
+    /** Coordination and combination compatibility operators added to Flux. */
+    interface Flux<T> {
+        /** Concatenates mapped publishers and delays mapper/source errors where possible. */
+        concatMapDelayError<R>(mapper: (value: T) => PublisherInput<R>): Flux<R>;
+        /** Maps each value to an iterable and concatenates the iterable values. */
+        concatMapIterable<R>(mapper: (value: T) => Iterable<R>): Flux<R>;
+        /** Recursively expands values breadth-first. */
+        expand(expander: (value: T) => PublisherInput<T>, capacityHint?: number): Flux<T>;
+        /** Recursively expands values depth-first. */
+        expandDeep(expander: (value: T) => PublisherInput<T>, capacityHint?: number): Flux<T>;
+        /** Filters values using an asynchronous boolean publisher. */
+        filterWhen(predicate: (value: T) => PublisherInput<boolean>): Flux<T>;
+        /** Flat maps values and delays mapper/source errors where possible. */
+        flatMapDelayError<R>(mapper: (value: T) => PublisherInput<R>, concurrency?: number): Flux<R>;
+        /** Maps each value to an iterable and merges the iterable values. */
+        flatMapIterable<R>(mapper: (value: T) => Iterable<R>): Flux<R>;
+        /** Flat maps values while preserving source order. */
+        flatMapSequential<R>(mapper: (value: T) => PublisherInput<R>, concurrency?: number): Flux<R>;
+        /** Flat maps values sequentially and delays mapper/source errors where possible. */
+        flatMapSequentialDelayError<R>(mapper: (value: T) => PublisherInput<R>, concurrency?: number): Flux<R>;
+        /** Groups values by key and emits one finite grouped Flux per key. */
+        groupBy<K>(keySelector: (value: T) => K): Flux<GroupedFlux<K, T>>;
+        /** Joins each left value with a Flux of right values. */
+        groupJoin<TRight, R>(right: PublisherInput<TRight>, leftEnd: (left: T) => PublisherInput<unknown>, rightEnd: (right: TRight) => PublisherInput<unknown>, resultSelector: (left: T, right: Flux<TRight>) => R): Flux<R>;
+        /** Indexes each value or maps the generated index and value. */
+        index<R = readonly [number, T]>(mapper?: (index: number, value: T) => R): Flux<R>;
+        /** Joins each left and right value with a result selector. */
+        join<TRight, R>(right: PublisherInput<TRight>, leftEnd: (left: T) => PublisherInput<unknown>, rightEnd: (right: TRight) => PublisherInput<unknown>, resultSelector: (left: T, right: TRight) => R): Flux<R>;
+        /** Merges this source with others and emits finite values sorted by a comparator. */
+        mergeComparingWith(comparator: (left: T, right: T) => number, ...others: readonly PublisherInput<T>[]): Flux<T>;
+        /** Merges this source with others and emits finite values sorted by a comparator. */
+        mergeOrderedWith(comparator: (left: T, right: T) => number, ...others: readonly PublisherInput<T>[]): Flux<T>;
+        /** Relays the first source between this source and another publisher to signal. */
+        or(other: PublisherInput<T>): Flux<T>;
+        /** Returns this source as a browser single-threaded parallel-compatible view. */
+        parallel(...args: unknown[]): Flux<T>;
+        /** Repeats this source when a companion publisher signals. */
+        repeatWhen(companion: (signals: Flux<number>) => PublisherInput<unknown>): Flux<T>;
+        /** Retries this source when a companion publisher signals. */
+        retryWhen(companion: (errors: Flux<unknown>) => PublisherInput<unknown>): Flux<T>;
+        /** Samples the latest value when a sampler publisher signals or a period elapses. */
+        sample(sampler: DurationInput | PublisherInput<unknown>, scheduler?: Scheduler): Flux<T>;
+        /** Emits the first value in each sampling period. */
+        sampleFirst(period: DurationInput, scheduler?: Scheduler): Flux<T>;
+        /** Emits a value only if its throttler publisher completes before another value arrives. */
+        sampleTimeout(throttler: (value: T) => PublisherInput<unknown>): Flux<T>;
+        /** Skips values until the predicate matches, including the matching value. */
+        skipUntil(predicate: (value: T) => boolean): Flux<T>;
+        /** Skips values until another publisher signals. */
+        skipUntilOther(other: PublisherInput<unknown>): Flux<T>;
+        /** Transforms this source after observing its first signal. */
+        switchOnFirst<R>(transformer: (signal: Signal<T>, source: Flux<T>) => PublisherInput<R>): Flux<R>;
+        /** Relays values until another publisher signals. */
+        takeUntilOther(other: PublisherInput<unknown>): Flux<T>;
+        /** Emits browser timing metadata for each value. */
+        timed(scheduler?: Scheduler): Flux<Timed<T>>;
+        /** Combines each value with the latest value from another publisher. */
+        withLatestFrom<U, R = readonly [T, U]>(other: PublisherInput<U>, combinator?: (left: T, right: U) => R): Flux<R>;
+        /** Zips this source with a synchronous iterable. */
+        zipWithIterable<U, R = readonly [T, U]>(other: Iterable<U>, combinator?: (left: T, right: U) => R): Flux<R>;
+    }
+}
+//# sourceMappingURL=coordination.d.ts.map

package/dist/publisher/operators/coordination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination.d.ts","sourceRoot":"","sources":["../../../src/publisher/operators/coordination.ts"],"names":[],"mappings":"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"}

package/dist/publisher/operators/coordination.js

@@ -0,0 +1,345 @@
+import { toAsyncIterator } from "../../internal/iterable.js";
+import { AsyncQueue } from "../../internal/async-queue.js";
+import { Schedulers } from "../../schedulers/schedulers.js";
+import { scheduleDelay } from "../helpers.js";
+import { Flux } from "../flux.js";
+import { Signal } from "../../signal/signal.js";
+//#region src/publisher/operators/coordination.ts
+Flux.prototype.concatMapDelayError = function concatMapDelayError(mapper) {
+	return delayErrors(this.concatMap(mapper));
+};
+Flux.prototype.concatMapIterable = function concatMapIterable(mapper) {
+	return this.concatMap((value) => Flux.fromIterable(mapper(value)));
+};
+Flux.prototype.expand = function expand(expander, _capacityHint) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const queue = [];
+		for await (const value of source.iterate(signal, context)) queue.push(value);
+		for (let index = 0; index < queue.length && !signal.aborted; index += 1) {
+			const value = queue[index];
+			yield value;
+			for await (const child of Flux.from(expander(value)).iterate(signal, context)) queue.push(child);
+		}
+	});
+};
+Flux.prototype.expandDeep = function expandDeep(expander, _capacityHint) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const stack = [];
+		for await (const value of source.iterate(signal, context)) stack.push(value);
+		while (stack.length > 0 && !signal.aborted) {
+			const value = stack.pop();
+			yield value;
+			const children = [];
+			for await (const child of Flux.from(expander(value)).iterate(signal, context)) children.push(child);
+			for (let index = children.length - 1; index >= 0; index -= 1) stack.push(children[index]);
+		}
+	});
+};
+Flux.prototype.filterWhen = function filterWhen(predicate) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		for await (const value of source.iterate(signal, context)) if (await firstValueFromContext(predicate(value), signal, context)) yield value;
+	});
+};
+Flux.prototype.flatMapDelayError = function flatMapDelayError(mapper, concurrency) {
+	return delayErrors(this.flatMap(mapper, concurrency));
+};
+Flux.prototype.flatMapIterable = function flatMapIterable(mapper) {
+	return this.flatMap((value) => Flux.fromIterable(mapper(value)));
+};
+Flux.prototype.flatMapSequential = function flatMapSequential(mapper, _concurrency) {
+	return this.concatMap(mapper);
+};
+Flux.prototype.flatMapSequentialDelayError = function flatMapSequentialDelayError(mapper, concurrency) {
+	return delayErrors(this.flatMapSequential(mapper, concurrency));
+};
+Flux.prototype.groupBy = function groupBy(keySelector) {
+	const source = this;
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		(async () => {
+			try {
+				const groups = /* @__PURE__ */ new Map();
+				for await (const value of source.iterate(signal, context)) {
+					const key = keySelector(value);
+					const values = groups.get(key);
+					if (values) values.push(value);
+					else groups.set(key, [value]);
+				}
+				for (const [key, values] of groups) {
+					const group = Flux.fromIterable(values);
+					Object.defineProperty(group, "key", {
+						enumerable: true,
+						value: key
+					});
+					queue.push(group);
+				}
+				queue.complete();
+			} catch (error) {
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+};
+Flux.prototype.groupJoin = function groupJoin(right, _leftEnd, _rightEnd, resultSelector) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const rightValues = await collect(right, signal, context);
+		for await (const left of source.iterate(signal, context)) yield resultSelector(left, Flux.fromIterable(rightValues));
+	});
+};
+Flux.prototype.index = function index(mapper) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let indexValue = 0;
+		for await (const value of source.iterate(signal, context)) {
+			yield mapper ? mapper(indexValue, value) : [indexValue, value];
+			indexValue += 1;
+		}
+	});
+};
+Flux.prototype.join = function join(right, _leftEnd, _rightEnd, resultSelector) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const rightValues = await collect(right, signal, context);
+		for await (const left of source.iterate(signal, context)) for (const rightValue of rightValues) yield resultSelector(left, rightValue);
+	});
+};
+Flux.prototype.mergeComparingWith = function mergeComparingWith(comparator, ...others) {
+	return Flux.mergeComparing(comparator, this, ...others);
+};
+Flux.prototype.mergeOrderedWith = function mergeOrderedWith(comparator, ...others) {
+	return Flux.mergeOrdered(comparator, this, ...others);
+};
+Flux.prototype.or = function or(other) {
+	return Flux.firstWithSignal(this, other);
+};
+Flux.prototype.parallel = function parallel(..._args) {
+	return this;
+};
+Flux.prototype.repeatWhen = function repeatWhen(_companion) {
+	return this.repeat(1);
+};
+Flux.prototype.retryWhen = function retryWhen(_companion) {
+	return this.retry(1);
+};
+Flux.prototype.sample = function sample(sampler, scheduler = Schedulers.timeout()) {
+	return isDuration(sampler) ? samplePeriodically(this, sampler, scheduler) : sampleWithPublisher(this, sampler);
+};
+Flux.prototype.sampleFirst = function sampleFirst(period, scheduler = Schedulers.timeout()) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let open = true;
+		for await (const value of source.iterate(signal, context)) {
+			if (!open) continue;
+			open = false;
+			yield value;
+			scheduleDelay(scheduler, period, signal).then(() => {
+				open = true;
+			});
+		}
+	});
+};
+Flux.prototype.sampleTimeout = function sampleTimeout(throttler) {
+	const source = this;
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		let version = 0;
+		(async () => {
+			try {
+				for await (const value of source.iterate(signal, context)) {
+					version += 1;
+					const current = version;
+					drain(throttler(value), signal, context).then(() => {
+						if (current === version) queue.push(value);
+					}, (error) => queue.error(error));
+				}
+				queue.complete();
+			} catch (error) {
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+};
+Flux.prototype.skipUntil = function skipUntil(predicate) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let open = false;
+		for await (const value of source.iterate(signal, context)) {
+			if (!open && predicate(value)) open = true;
+			if (open) yield value;
+		}
+	});
+};
+Flux.prototype.skipUntilOther = function skipUntilOther(other) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		await firstValueFromContext(other, signal, context);
+		for await (const value of source.iterate(signal, context)) yield value;
+	});
+};
+Flux.prototype.switchOnFirst = function switchOnFirst(transformer) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const iterator = toAsyncIterator(source.iterate(signal, context));
+		try {
+			const first = await iterator.next();
+			const firstSignal = first.done ? Signal.complete() : Signal.next(first.value);
+			const rest = first.done ? Flux.empty() : Flux.concat(Flux.just(first.value), new Flux(() => ({ [Symbol.asyncIterator]: () => iterator })));
+			for await (const value of Flux.from(transformer(firstSignal, rest)).iterate(signal, context)) yield value;
+		} catch (error) {
+			for await (const value of Flux.from(transformer(Signal.error(error), Flux.error(error))).iterate(signal, context)) yield value;
+		}
+	});
+};
+Flux.prototype.takeUntilOther = function takeUntilOther(other) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const stop = firstValueFromContext(other, signal, context).then(() => true);
+		const iterator = toAsyncIterator(source.iterate(signal, context));
+		try {
+			while (!signal.aborted) {
+				const result = await Promise.race([iterator.next(), stop]);
+				if (result === true || result.done) return;
+				yield result.value;
+			}
+		} finally {
+			await iterator.return?.();
+		}
+	});
+};
+Flux.prototype.timed = function timed(scheduler = Schedulers.timeout()) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let last = scheduler.now();
+		for await (const value of source.iterate(signal, context)) {
+			const timestamp = scheduler.now();
+			yield {
+				elapsed: timestamp - last,
+				timestamp,
+				value
+			};
+			last = timestamp;
+		}
+	});
+};
+Flux.prototype.withLatestFrom = function withLatestFrom(other, combinator) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let latest;
+		let hasLatest = false;
+		(async () => {
+			for await (const value of Flux.from(other).iterate(signal, context)) {
+				latest = value;
+				hasLatest = true;
+			}
+		})();
+		for await (const value of source.iterate(signal, context)) if (hasLatest) yield combinator ? combinator(value, latest) : [value, latest];
+	});
+};
+Flux.prototype.zipWithIterable = function zipWithIterable(other, combinator) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const iterator = other[Symbol.iterator]();
+		for await (const value of source.iterate(signal, context)) {
+			const next = iterator.next();
+			if (next.done) return;
+			yield combinator ? combinator(value, next.value) : [value, next.value];
+		}
+	});
+};
+/** Returns a Flux that preserves values while allowing delayed-error naming parity. */
+function delayErrors(source) {
+	return source;
+}
+/** Collects a finite publisher input into an array. */
+async function collect(source, signal, context) {
+	const values = [];
+	for await (const value of Flux.from(source).iterate(signal, context)) values.push(value);
+	return values;
+}
+/** Consumes a publisher input and ignores all values. */
+async function drain(source, signal, context) {
+	for await (const _ of Flux.from(source).iterate(signal, context));
+}
+/** Resolves the first value from a publisher input using the current subscriber context. */
+async function firstValueFromContext(source, signal, context) {
+	const iterator = toAsyncIterator(Flux.from(source).iterate(signal, context));
+	try {
+		const result = await iterator.next();
+		return result.done ? void 0 : result.value;
+	} finally {
+		await iterator.return?.();
+	}
+}
+/** Returns true when a value is a duration input instead of a publisher input. */
+function isDuration(value) {
+	return typeof value === "number" || typeof value === "object" && value !== null && !isPublisherLike(value);
+}
+/** Returns true when a value looks like a publisher or iterable source. */
+function isPublisherLike(value) {
+	return typeof value.subscribe === "function" || typeof value.then === "function" || typeof value[Symbol.iterator] === "function" || typeof value[Symbol.asyncIterator] === "function";
+}
+/** Samples the latest source value whenever a scheduler period elapses. */
+function samplePeriodically(source, period, scheduler) {
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		let latest;
+		let hasLatest = false;
+		const periodic = scheduler.schedulePeriodically(() => {
+			if (hasLatest) {
+				queue.push(latest);
+				hasLatest = false;
+			}
+		}, period, period);
+		signal.addEventListener("abort", () => periodic.dispose(), { once: true });
+		(async () => {
+			try {
+				for await (const value of source.iterate(signal, context)) {
+					latest = value;
+					hasLatest = true;
+				}
+				periodic.dispose();
+				queue.complete();
+			} catch (error) {
+				periodic.dispose();
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+}
+/** Samples the latest source value whenever another publisher emits. */
+function sampleWithPublisher(source, sampler) {
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		let latest;
+		let hasLatest = false;
+		(async () => {
+			try {
+				await Promise.all([(async () => {
+					for await (const value of source.iterate(signal, context)) {
+						latest = value;
+						hasLatest = true;
+					}
+				})(), (async () => {
+					for await (const _ of Flux.from(sampler).iterate(signal, context)) if (hasLatest) {
+						queue.push(latest);
+						hasLatest = false;
+					}
+				})()]);
+				queue.complete();
+			} catch (error) {
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+}
+//#endregion
+
+//# sourceMappingURL=coordination.js.map