reactor-core-ts 2.1.6 → 3.2.1

package/dist/publisher/mono.js

@@ -0,0 +1,373 @@
+import { EMPTY_ITERABLE, closeAsyncIterator, isAsyncIterable, neverIterable, toAsyncIterator } from "../internal/iterable.js";
+import { CompositeError } from "../errors/classes.js";
+import { throwIfNullish } from "../errors/helpers.js";
+import { firstValueFrom, raceWithAbort } from "../internal/abort.js";
+import { AsyncQueue } from "../internal/async-queue.js";
+import { Schedulers } from "../schedulers/schedulers.js";
+import { addCancelCallback, runCancelCallbacks, scheduleDelay } from "./helpers.js";
+import { Flux } from "./flux.js";
+//#region src/publisher/mono.ts
+/** Zero-or-one Reactive Streams publisher with Reactor-style Mono operators. */
+var Mono = class Mono extends Flux {
+	/** Creates a Mono from a lazy source factory. */
+	constructor(sourceFactory) {
+		super((signal, context) => {
+			const source = sourceFactory(signal, context);
+			if (!isAsyncIterable(source)) return (function* () {
+				if (signal.aborted) return;
+				const iterator = source[Symbol.iterator]();
+				try {
+					const first = iterator.next();
+					if (!first.done) yield first.value;
+				} finally {
+					iterator.return?.();
+				}
+			})();
+			return (async function* () {
+				const iterator = toAsyncIterator(source);
+				try {
+					const first = await raceWithAbort(iterator.next(), signal);
+					if (!first.done) yield first.value;
+				} finally {
+					await iterator.return?.();
+				}
+			})();
+		});
+	}
+	/** Creates a Mono that emits exactly one non-nullish value. */
+	static just(value) {
+		throwIfNullish(value, "value");
+		return new Mono(function* () {
+			yield value;
+		});
+	}
+	/** Creates a Mono that completes without a value. */
+	static empty() {
+		return EMPTY_MONO;
+	}
+	/** Creates a Mono that never emits or completes until cancelled. */
+	static never() {
+		return NEVER_MONO;
+	}
+	/** Creates a Mono that terminates with the provided error. */
+	static error(error) {
+		return new Mono(async function* () {
+			throw typeof error === "function" ? error() : error;
+		});
+	}
+	/** Defers Mono source creation until subscription time. */
+	static defer(supplier) {
+		return new Mono((signal, context) => Flux.from(supplier()).next().iterate(signal, context));
+	}
+	/** Defers Mono source creation and exposes the subscriber context. */
+	static deferContextual(supplier) {
+		return new Mono((signal, context) => Flux.from(supplier(context.readOnly())).next().iterate(signal, context));
+	}
+	/** Relays the first Mono that emits any signal. */
+	static first(...sources) {
+		return Mono.firstWithSignal(...sources);
+	}
+	/** Adapts a source and keeps at most its first value. */
+	static from(input) {
+		if (input instanceof Mono) return input;
+		return Flux.from(input).next();
+	}
+	/** Creates a Mono from a promise-like value. */
+	static fromPromise(promise) {
+		return new Mono(async function* (signal) {
+			const value = await raceWithAbort(Promise.resolve(promise), signal);
+			if (value !== void 0 && value !== null) yield value;
+		});
+	}
+	/** Creates a Mono from a CompletionStage-like promise. */
+	static fromCompletionStage(stage) {
+		return typeof stage === "function" ? Mono.defer(() => Mono.fromPromise(stage())) : Mono.fromPromise(stage);
+	}
+	/** Creates a Mono from a Future-like promise. */
+	static fromFuture(future, _suppressCancel) {
+		return typeof future === "function" ? Mono.defer(() => Mono.fromPromise(future())) : Mono.fromPromise(future);
+	}
+	/** Adapts a publisher directly, preserving only its first value for Mono semantics. */
+	static fromDirect(input) {
+		return new Mono((signal, context) => Flux.from(input).iterate(signal, context));
+	}
+	/** Creates a Mono from a synchronous supplier. */
+	static fromSupplier(supplier) {
+		return new Mono(function* () {
+			const value = supplier();
+			if (value !== void 0 && value !== null) yield value;
+		});
+	}
+	/** Creates a Mono from a synchronous callable. */
+	static fromCallable(callable) {
+		return Mono.fromSupplier(callable);
+	}
+	/** Runs a callback and completes after it returns. */
+	static fromRunnable(runnable) {
+		return new Mono(function* () {
+			runnable();
+		});
+	}
+	/** Creates a valued Mono for non-nullish input or an empty Mono otherwise. */
+	static justOrEmpty(value) {
+		return value === null || value === void 0 ? Mono.empty() : Mono.just(value);
+	}
+	/** Ignores every value from a source and completes when the source completes. */
+	static ignoreElements(source) {
+		return Flux.from(source).then();
+	}
+	/** Compares two sources element-by-element. */
+	static sequenceEqual(left, right, comparator = Object.is) {
+		return new Mono(async function* (signal, context) {
+			const leftIterator = toAsyncIterator(Flux.from(left).iterate(signal, context));
+			const rightIterator = toAsyncIterator(Flux.from(right).iterate(signal, context));
+			const nexts = new Array(2);
+			try {
+				for (;;) {
+					nexts[0] = raceWithAbort(leftIterator.next(), signal);
+					nexts[1] = raceWithAbort(rightIterator.next(), signal);
+					const [leftNext, rightNext] = await Promise.all(nexts);
+					if (leftNext.done || rightNext.done) {
+						yield Boolean(leftNext.done && rightNext.done);
+						return;
+					}
+					if (!comparator(leftNext.value, rightNext.value)) {
+						yield false;
+						return;
+					}
+				}
+			} finally {
+				await closeAsyncIterator(leftIterator);
+				await closeAsyncIterator(rightIterator);
+			}
+		});
+	}
+	/** Creates a Mono by bridging callback-style producers through a sink. */
+	static create(callback) {
+		throwIfNullish(callback, "callback");
+		return new Mono((signal) => {
+			const queue = new AsyncQueue(signal);
+			let cancelled = false;
+			let terminated = false;
+			let cancelCallbacks;
+			const sink = {
+				/** Emits one value and completes this Mono sink. */
+				next(value) {
+					this.success(value);
+				},
+				/** Completes this Mono sink without a value. */
+				complete() {
+					this.success();
+				},
+				/** Completes this Mono sink with an optional value. */
+				success(value) {
+					if (terminated) return;
+					terminated = true;
+					if (value !== void 0 && value !== null) queue.push(value);
+					queue.complete();
+				},
+				/** Terminates this Mono sink with an error. */
+				error(error) {
+					if (terminated) return;
+					terminated = true;
+					queue.error(error);
+				},
+				/** Registers a callback invoked when the subscription is cancelled. */
+				onCancel(cancelCallback) {
+					cancelCallbacks = addCancelCallback(cancelCallbacks, cancelCallback);
+					return sink;
+				},
+				/** Returns true after cancellation has been observed. */
+				isCancelled() {
+					return cancelled || signal.aborted;
+				}
+			};
+			signal.addEventListener("abort", () => {
+				cancelled = true;
+				runCancelCallbacks(cancelCallbacks);
+				cancelCallbacks = void 0;
+				queue.complete();
+			}, { once: true });
+			try {
+				callback(sink);
+			} catch (error) {
+				queue.error(error);
+			}
+			return queue;
+		});
+	}
+	/** Emits `0` after the provided delay. */
+	static delay(duration, scheduler = Schedulers.timeout()) {
+		return new Mono(async function* (signal) {
+			await scheduleDelay(scheduler, duration, signal);
+			yield 0;
+		});
+	}
+	/** Completes when all provided publishers complete. */
+	static when(...sources) {
+		if (sources.length === 0) return Mono.empty();
+		if (sources.length === 1) return new Mono(async function* (signal, context) {
+			await drainPublisherInput(sources[0], signal, context);
+		});
+		return new Mono(async function* (signal, context) {
+			await Promise.all(completionTasks(sources, signal, context));
+		});
+	}
+	/** Completes when all provided publishers complete and delays failures until all terminate. */
+	static whenDelayError(...sources) {
+		if (sources.length === 0) return Mono.empty();
+		if (sources.length === 1) return new Mono(async function* (signal, context) {
+			await drainPublisherInputAsCompositeError(sources[0], signal, context);
+		});
+		return new Mono(async function* (signal, context) {
+			const errors = [];
+			await Promise.all(completionDelayErrorTasks(sources, signal, context, errors));
+			if (errors.length > 0) throw new CompositeError(errors);
+		});
+	}
+	/** Relays the first source to signal value, completion or error. */
+	static firstWithSignal(...sources) {
+		if (sources.length === 0) return Mono.empty();
+		if (sources.length === 1) return Mono.from(sources[0]);
+		return new Mono((signal) => {
+			const queue = new AsyncQueue(signal);
+			let settled = false;
+			for (const source of sources) (async () => {
+				try {
+					const value = await firstValueFrom(Flux.from(source), signal);
+					if (!settled) {
+						settled = true;
+						if (value !== void 0) queue.push(value);
+						queue.complete();
+					}
+				} catch (error) {
+					if (!settled) {
+						settled = true;
+						queue.error(error);
+					}
+				}
+			})();
+			return queue;
+		});
+	}
+	/** Relays the first non-empty value from the provided sources. */
+	static firstWithValue(...sources) {
+		if (sources.length === 0) return Mono.empty();
+		if (sources.length === 1) return Mono.from(sources[0]);
+		return new Mono((signal) => {
+			const queue = new AsyncQueue(signal);
+			let remaining = sources.length;
+			const errors = [];
+			for (const source of sources) (async () => {
+				try {
+					const value = await firstValueFrom(Flux.from(source), signal);
+					if (value !== void 0) {
+						queue.push(value);
+						queue.complete();
+					} else {
+						remaining -= 1;
+						if (remaining === 0) errors.length > 0 ? queue.error(new CompositeError(errors)) : queue.complete();
+					}
+				} catch (error) {
+					errors.push(error);
+					remaining -= 1;
+					if (remaining === 0) queue.error(new CompositeError(errors));
+				}
+			})();
+			return queue;
+		});
+	}
+	/** Zips Monos by combining one value from each source. */
+	static zip(sources, combinator) {
+		return Flux.zip(sources, combinator).next();
+	}
+	/** Zips Monos by combining one value from each source while delaying source failures. */
+	static zipDelayError(sources, combinator) {
+		const sourceCount = sources.length;
+		if (sourceCount === 0) return Mono.empty();
+		if (sourceCount === 1) return singleZipDelayError(sources[0], combinator);
+		return new Mono(async function* (signal, context) {
+			const values = new Array(sourceCount);
+			const errors = [];
+			const tasks = new Array(sourceCount);
+			for (let index = 0; index < sourceCount; index += 1) tasks[index] = (async () => {
+				try {
+					values[index] = await firstValueFrom(Flux.from(sources[index]), signal);
+				} catch (error) {
+					errors.push(error);
+				}
+			})();
+			await Promise.all(tasks);
+			if (errors.length > 0) throw new CompositeError(errors);
+			for (let index = 0; index < sourceCount; index += 1) if (values[index] === void 0) return;
+			const tuple = values;
+			yield combinator ? combinator(tuple) : tuple;
+		});
+	}
+	/** Uses a resource for the duration of a derived Mono and cleans it up afterwards. */
+	static using(resourceSupplier, sourceFactory, resourceCleanup) {
+		return Flux.using(resourceSupplier, sourceFactory, resourceCleanup).next();
+	}
+	/** Uses an asynchronously supplied resource and runs asynchronous cleanup publishers. */
+	static usingWhen(resourceSupplier, sourceFactory, asyncComplete, asyncError, asyncCancel) {
+		return Flux.usingWhen(resourceSupplier, sourceFactory, asyncComplete, asyncError, asyncCancel).next();
+	}
+	/** Resolves to the Mono value, or undefined when empty. */
+	async block() {
+		return this.toPromise();
+	}
+};
+/** Shared stateless empty Mono instance. */
+var EMPTY_MONO = new Mono(() => EMPTY_ITERABLE);
+/** Shared stateless never Mono instance. */
+var NEVER_MONO = new Mono((signal) => neverIterable(signal));
+/** Zips one source without allocating multi-source coordination state. */
+function singleZipDelayError(source, combinator) {
+	return new Mono(async function* (signal) {
+		let value;
+		try {
+			value = await firstValueFrom(Flux.from(source), signal);
+		} catch (error) {
+			throw new CompositeError([error]);
+		}
+		if (value === void 0) return;
+		const tuple = [value];
+		yield combinator ? combinator(tuple) : tuple;
+	});
+}
+/** Creates completion tasks for publishers whose values are ignored. */
+function completionTasks(sources, signal, context) {
+	const tasks = new Array(sources.length);
+	for (let index = 0; index < sources.length; index += 1) tasks[index] = drainPublisherInput(sources[index], signal, context);
+	return tasks;
+}
+/** Creates completion tasks that collect failures until every publisher has terminated. */
+function completionDelayErrorTasks(sources, signal, context, errors) {
+	const tasks = new Array(sources.length);
+	for (let index = 0; index < sources.length; index += 1) tasks[index] = drainPublisherInputDelayError(sources[index], signal, context, errors);
+	return tasks;
+}
+/** Consumes a publisher and ignores every value. */
+async function drainPublisherInput(source, signal, context) {
+	for await (const _ of Flux.from(source).iterate(signal, context));
+}
+/** Consumes one publisher and wraps its failure like delayed-error composition. */
+async function drainPublisherInputAsCompositeError(source, signal, context) {
+	try {
+		await drainPublisherInput(source, signal, context);
+	} catch (error) {
+		throw new CompositeError([error]);
+	}
+}
+/** Consumes a publisher and records its failure instead of throwing immediately. */
+async function drainPublisherInputDelayError(source, signal, context, errors) {
+	try {
+		await drainPublisherInput(source, signal, context);
+	} catch (error) {
+		errors.push(error);
+	}
+}
+//#endregion
+export { Mono };
+
+//# sourceMappingURL=mono.js.map

package/dist/publisher/mono.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mono.js","names":[],"sources":["../../src/publisher/mono.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Flux, Mono and operator implementation modules.\n */\nimport type {Context} from \"@/context/context.js\";\nimport type {ContextView} from \"@/context/context-view.js\";\nimport {CompositeError} from \"@/errors/classes.js\";\nimport {throwIfNullish} from \"@/errors/helpers.js\";\nimport {firstValueFrom, raceWithAbort} from \"@/internal/abort.js\";\nimport {AsyncQueue} from \"@/internal/async-queue.js\";\nimport {closeAsyncIterator, EMPTY_ITERABLE, isAsyncIterable, neverIterable, toAsyncIterator} from \"@/internal/iterable.js\";\nimport {Flux} from \"@/publisher/flux.js\";\nimport {addCancelCallback, type CancelCallbacks, runCancelCallbacks, scheduleDelay} from \"@/publisher/helpers.js\";\nimport type {MonoSinkCallback, PublisherInput, SourceFactory} from \"@/publisher/types.js\";\nimport {Schedulers} from \"@/schedulers/schedulers.js\";\nimport type {DurationInput, Scheduler} from \"@/schedulers/types.js\";\n\n/** Zero-or-one Reactive Streams publisher with Reactor-style Mono operators. */\nexport class Mono<T> extends Flux<T> {\n    /** Creates a Mono from a lazy source factory. */\n    public constructor(sourceFactory: SourceFactory<T>) {\n        super((signal, context) => {\n            const source = sourceFactory(signal, context);\n            if (!isAsyncIterable<T>(source)) {\n                return (function* () {\n                    if (signal.aborted) {\n                        return;\n                    }\n                    const iterator = source[Symbol.iterator]();\n                    try {\n                        const first = iterator.next();\n                        if (!first.done) {\n                            yield first.value;\n                        }\n                    } finally {\n                        iterator.return?.();\n                    }\n                })();\n            }\n            return (async function* () {\n                const iterator = toAsyncIterator(source);\n                try {\n                    const first = await raceWithAbort(iterator.next(), signal);\n                    if (!first.done) {\n                        yield first.value;\n                    }\n                } finally {\n                    await iterator.return?.();\n                }\n            })();\n        });\n    }\n\n    /** Creates a Mono that emits exactly one non-nullish value. */\n    public static override just<T>(value: T): Mono<T> {\n        throwIfNullish(value, \"value\");\n        return new Mono(function* () {\n            yield value;\n        });\n    }\n\n    /** Creates a Mono that completes without a value. */\n    public static override empty<T = never>(): Mono<T> {\n        return EMPTY_MONO as Mono<T>;\n    }\n\n    /** Creates a Mono that never emits or completes until cancelled. */\n    public static override never<T = never>(): Mono<T> {\n        return NEVER_MONO as Mono<T>;\n    }\n\n    /** Creates a Mono that terminates with the provided error. */\n    public static override error<T = never>(error: unknown | (() => unknown)): Mono<T> {\n        return new Mono(async function* () {\n            throw typeof error === \"function\" ? (error as () => unknown)() : error;\n        });\n    }\n\n    /** Defers Mono source creation until subscription time. */\n    public static override defer<T>(supplier: () => PublisherInput<T>): Mono<T> {\n        return new Mono((signal, context) => Flux.from(supplier()).next().iterate(signal, context));\n    }\n\n    /** Defers Mono source creation and exposes the subscriber context. */\n    public static override deferContextual<T>(supplier: (context: ContextView) => PublisherInput<T>): Mono<T> {\n        return new Mono((signal, context) => Flux.from(supplier(context.readOnly())).next().iterate(signal, context));\n    }\n\n    /** Relays the first Mono that emits any signal. */\n    public static override first<T>(...sources: readonly PublisherInput<T>[]): Mono<T> {\n        return Mono.firstWithSignal(...sources);\n    }\n\n    /** Adapts a source and keeps at most its first value. */\n    public static override from<T>(input: PublisherInput<T>): Mono<T> {\n        if (input instanceof Mono) {\n            return input;\n        }\n        return Flux.from(input).next();\n    }\n\n    /** Creates a Mono from a promise-like value. */\n    public static fromPromise<T>(promise: PromiseLike<T>): Mono<T> {\n        return new Mono(async function* (signal) {\n            const value = await raceWithAbort(Promise.resolve(promise), signal);\n            if (value !== undefined && value !== null) {\n                yield value;\n            }\n        });\n    }\n\n    /** Creates a Mono from a CompletionStage-like promise. */\n    public static fromCompletionStage<T>(stage: PromiseLike<T> | (() => PromiseLike<T>)): Mono<T> {\n        return typeof stage === \"function\" ? Mono.defer(() => Mono.fromPromise((stage as () => PromiseLike<T>)())) : Mono.fromPromise(stage);\n    }\n\n    /** Creates a Mono from a Future-like promise. */\n    public static fromFuture<T>(future: PromiseLike<T> | (() => PromiseLike<T>), _suppressCancel?: boolean): Mono<T> {\n        return typeof future === \"function\" ? Mono.defer(() => Mono.fromPromise((future as () => PromiseLike<T>)())) : Mono.fromPromise(future);\n    }\n\n    /** Adapts a publisher directly, preserving only its first value for Mono semantics. */\n    public static fromDirect<T>(input: PublisherInput<T>): Mono<T> {\n        return new Mono((signal, context) => Flux.from(input).iterate(signal, context));\n    }\n\n    /** Creates a Mono from a synchronous supplier. */\n    public static fromSupplier<T>(supplier: () => T | null | undefined): Mono<T> {\n        return new Mono(function* () {\n            const value = supplier();\n            if (value !== undefined && value !== null) {\n                yield value;\n            }\n        });\n    }\n\n    /** Creates a Mono from a synchronous callable. */\n    public static fromCallable<T>(callable: () => T | null | undefined): Mono<T> {\n        return Mono.fromSupplier(callable);\n    }\n\n    /** Runs a callback and completes after it returns. */\n    public static fromRunnable(runnable: () => void): Mono<void> {\n        return new Mono(function* () {\n            runnable();\n        });\n    }\n\n    /** Creates a valued Mono for non-nullish input or an empty Mono otherwise. */\n    public static justOrEmpty<T>(value: T | null | undefined): Mono<T> {\n        return value === null || value === undefined ? Mono.empty<T>() : Mono.just(value);\n    }\n\n    /** Ignores every value from a source and completes when the source completes. */\n    public static ignoreElements<T>(source: PublisherInput<T>): Mono<T> {\n        return Flux.from(source).then() as unknown as Mono<T>;\n    }\n\n    /** Compares two sources element-by-element. */\n    public static sequenceEqual<T>(\n        left: PublisherInput<T>,\n        right: PublisherInput<T>,\n        comparator: (left: T, right: T) => boolean = Object.is\n    ): Mono<boolean> {\n        return new Mono(async function* (signal, context) {\n            const leftIterator = toAsyncIterator(Flux.from(left).iterate(signal, context));\n            const rightIterator = toAsyncIterator(Flux.from(right).iterate(signal, context));\n            const nexts: [\n                Promise<IteratorResult<T>>,\n                Promise<IteratorResult<T>>\n            ] = new Array<Promise<IteratorResult<T>>>(2) as [\n                Promise<IteratorResult<T>>,\n                Promise<IteratorResult<T>>\n            ];\n            try {\n                for (; ;) {\n                    nexts[0] = raceWithAbort(leftIterator.next(), signal);\n                    nexts[1] = raceWithAbort(rightIterator.next(), signal);\n                    const [leftNext, rightNext] = await Promise.all(nexts);\n                    if (leftNext.done || rightNext.done) {\n                        yield Boolean(leftNext.done && rightNext.done);\n                        return;\n                    }\n                    if (!comparator(leftNext.value, rightNext.value)) {\n                        yield false;\n                        return;\n                    }\n                }\n            } finally {\n                await closeAsyncIterator(leftIterator);\n                await closeAsyncIterator(rightIterator);\n            }\n        });\n    }\n\n    /** Creates a Mono by bridging callback-style producers through a sink. */\n    public static override create<T>(callback: MonoSinkCallback<T>): Mono<T> {\n        throwIfNullish(callback, \"callback\");\n        return new Mono(signal => {\n            const queue = new AsyncQueue<T>(signal);\n            let cancelled = false;\n            let terminated = false;\n            let cancelCallbacks: CancelCallbacks | undefined;\n            const sink = {\n                /** Emits one value and completes this Mono sink. */\n                next(value: T) {\n                    this.success(value);\n                },\n                /** Completes this Mono sink without a value. */\n                complete() {\n                    this.success();\n                },\n                /** Completes this Mono sink with an optional value. */\n                success(value?: T) {\n                    if (terminated) {\n                        return;\n                    }\n                    terminated = true;\n                    if (value !== undefined && value !== null) {\n                        queue.push(value);\n                    }\n                    queue.complete();\n                },\n                /** Terminates this Mono sink with an error. */\n                error(error: unknown) {\n                    if (terminated) {\n                        return;\n                    }\n                    terminated = true;\n                    queue.error(error);\n                },\n                /** Registers a callback invoked when the subscription is cancelled. */\n                onCancel(cancelCallback: () => void) {\n                    cancelCallbacks = addCancelCallback(cancelCallbacks, cancelCallback);\n                    return sink;\n                },\n                /** Returns true after cancellation has been observed. */\n                isCancelled() {\n                    return cancelled || signal.aborted;\n                }\n            };\n            signal.addEventListener(\n                \"abort\",\n                () => {\n                    cancelled = true;\n                    runCancelCallbacks(cancelCallbacks);\n                    cancelCallbacks = undefined;\n                    queue.complete();\n                },\n                {once: true}\n            );\n            try {\n                callback(sink);\n            } catch (error) {\n                queue.error(error);\n            }\n            return queue;\n        });\n    }\n\n    /** Emits `0` after the provided delay. */\n    public static delay(duration: DurationInput, scheduler: Scheduler = Schedulers.timeout()): Mono<number> {\n        return new Mono(async function* (signal) {\n            await scheduleDelay(scheduler, duration, signal);\n            yield 0;\n        });\n    }\n\n    /** Completes when all provided publishers complete. */\n    public static when(...sources: readonly PublisherInput<unknown>[]): Mono<void> {\n        if (sources.length === 0) {\n            return Mono.empty<void>();\n        }\n        if (sources.length === 1) {\n            return new Mono(async function* (signal, context) {\n                await drainPublisherInput(sources[0]!, signal, context);\n            });\n        }\n        return new Mono(async function* (signal, context) {\n            await Promise.all(completionTasks(sources, signal, context));\n        });\n    }\n\n    /** Completes when all provided publishers complete and delays failures until all terminate. */\n    public static whenDelayError(...sources: readonly PublisherInput<unknown>[]): Mono<void> {\n        if (sources.length === 0) {\n            return Mono.empty<void>();\n        }\n        if (sources.length === 1) {\n            return new Mono(async function* (signal, context) {\n                await drainPublisherInputAsCompositeError(sources[0]!, signal, context);\n            });\n        }\n        return new Mono(async function* (signal, context) {\n            const errors: unknown[] = [];\n            await Promise.all(completionDelayErrorTasks(sources, signal, context, errors));\n            if (errors.length > 0) {\n                throw new CompositeError(errors);\n            }\n        });\n    }\n\n    /** Relays the first source to signal value, completion or error. */\n    public static override firstWithSignal<T>(...sources: readonly PublisherInput<T>[]): Mono<T> {\n        if (sources.length === 0) {\n            return Mono.empty<T>();\n        }\n        if (sources.length === 1) {\n            return Mono.from(sources[0]!);\n        }\n        return new Mono(signal => {\n            const queue = new AsyncQueue<T>(signal);\n            let settled = false;\n            for (const source of sources) {\n                void (async () => {\n                    try {\n                        const value = await firstValueFrom(Flux.from(source), signal);\n                        if (!settled) {\n                            settled = true;\n                            if (value !== undefined) {\n                                queue.push(value);\n                            }\n                            queue.complete();\n                        }\n                    } catch (error) {\n                        if (!settled) {\n                            settled = true;\n                            queue.error(error);\n                        }\n                    }\n                })();\n            }\n            return queue;\n        });\n    }\n\n    /** Relays the first non-empty value from the provided sources. */\n    public static override firstWithValue<T>(...sources: readonly PublisherInput<T>[]): Mono<T> {\n        if (sources.length === 0) {\n            return Mono.empty<T>();\n        }\n        if (sources.length === 1) {\n            return Mono.from(sources[0]!);\n        }\n        return new Mono(signal => {\n            const queue = new AsyncQueue<T>(signal);\n            let remaining = sources.length;\n            const errors: unknown[] = [];\n            for (const source of sources) {\n                void (async () => {\n                    try {\n                        const value = await firstValueFrom(Flux.from(source), signal);\n                        if (value !== undefined) {\n                            queue.push(value);\n                            queue.complete();\n                        } else {\n                            remaining -= 1;\n                            if (remaining === 0) {\n                                errors.length > 0 ? queue.error(new CompositeError(errors)) : queue.complete();\n                            }\n                        }\n                    } catch (error) {\n                        errors.push(error);\n                        remaining -= 1;\n                        if (remaining === 0) {\n                            queue.error(new CompositeError(errors));\n                        }\n                    }\n                })();\n            }\n            return queue;\n        });\n    }\n\n    /** Zips Monos by combining one value from each source. */\n    public static override zip<T extends readonly unknown[], R = T>(\n        sources: { [K in keyof T]: PublisherInput<T[K]> },\n        combinator?: (values: T) => R\n    ): Mono<R> {\n        return Flux.zip(sources, combinator).next();\n    }\n\n    /** Zips Monos by combining one value from each source while delaying source failures. */\n    public static zipDelayError<T extends readonly unknown[], R = T>(\n        sources: { [K in keyof T]: PublisherInput<T[K]> },\n        combinator?: (values: T) => R\n    ): Mono<R> {\n        const sourceCount = sources.length;\n        if (sourceCount === 0) {\n            return Mono.empty<R>();\n        }\n        if (sourceCount === 1) {\n            return singleZipDelayError(sources[0]!, combinator);\n        }\n        return new Mono(async function* (signal, context) {\n            const values = new Array<unknown>(sourceCount);\n            const errors: unknown[] = [];\n            const tasks = new Array<Promise<void>>(sourceCount);\n            for (let index = 0; index < sourceCount; index += 1) {\n                tasks[index] = (async () => {\n                    try {\n                        values[index] = await firstValueFrom(Flux.from(sources[index]!), signal);\n                    } catch (error) {\n                        errors.push(error);\n                    }\n                })();\n            }\n            await Promise.all(tasks);\n            if (errors.length > 0) {\n                throw new CompositeError(errors);\n            }\n            for (let index = 0; index < sourceCount; index += 1) {\n                if (values[index] === undefined) {\n                    return;\n                }\n            }\n            const tuple = values as unknown as T;\n            yield combinator ? combinator(tuple) : (tuple as unknown as R);\n        });\n    }\n\n    /** Uses a resource for the duration of a derived Mono and cleans it up afterwards. */\n    public static override using<T, D>(\n        resourceSupplier: () => D,\n        sourceFactory: (resource: D) => PublisherInput<T>,\n        resourceCleanup?: (resource: D) => void\n    ): Mono<T> {\n        return Flux.using(resourceSupplier, sourceFactory, resourceCleanup).next();\n    }\n\n    /** Uses an asynchronously supplied resource and runs asynchronous cleanup publishers. */\n    public static override usingWhen<T, D>(\n        resourceSupplier: PublisherInput<D>,\n        sourceFactory: (resource: D) => PublisherInput<T>,\n        asyncComplete?: (resource: D) => PublisherInput<unknown>,\n        asyncError?: (resource: D, error: unknown) => PublisherInput<unknown>,\n        asyncCancel?: (resource: D) => PublisherInput<unknown>\n    ): Mono<T> {\n        return Flux.usingWhen(resourceSupplier, sourceFactory, asyncComplete, asyncError, asyncCancel).next();\n    }\n\n    /** Resolves to the Mono value, or undefined when empty. */\n    public async block(): Promise<T | undefined> {\n        return this.toPromise();\n    }\n}\n\n/** Shared stateless empty Mono instance. */\nconst EMPTY_MONO = new Mono<never>(() => EMPTY_ITERABLE);\n\n/** Shared stateless never Mono instance. */\nconst NEVER_MONO = new Mono<never>(signal => neverIterable(signal));\n\n/** Zips one source without allocating multi-source coordination state. */\nfunction singleZipDelayError<T extends readonly unknown[], R>(\n    source: PublisherInput<T[0]>,\n    combinator: ((values: T) => R) | undefined\n): Mono<R> {\n    return new Mono(async function* (signal) {\n        let value: T[0] | undefined;\n        try {\n            value = await firstValueFrom(Flux.from(source), signal);\n        } catch (error) {\n            throw new CompositeError([error]);\n        }\n        if (value === undefined) {\n            return;\n        }\n        const tuple = [value] as unknown as T;\n        yield combinator ? combinator(tuple) : (tuple as unknown as R);\n    });\n}\n\n/** Creates completion tasks for publishers whose values are ignored. */\nfunction completionTasks(\n    sources: readonly PublisherInput<unknown>[],\n    signal: AbortSignal,\n    context: Context\n): Promise<void>[] {\n    const tasks = new Array<Promise<void>>(sources.length);\n    for (let index = 0; index < sources.length; index += 1) {\n        tasks[index] = drainPublisherInput(sources[index]!, signal, context);\n    }\n    return tasks;\n}\n\n/** Creates completion tasks that collect failures until every publisher has terminated. */\nfunction completionDelayErrorTasks(\n    sources: readonly PublisherInput<unknown>[],\n    signal: AbortSignal,\n    context: Context,\n    errors: unknown[]\n): Promise<void>[] {\n    const tasks = new Array<Promise<void>>(sources.length);\n    for (let index = 0; index < sources.length; index += 1) {\n        tasks[index] = drainPublisherInputDelayError(sources[index]!, signal, context, errors);\n    }\n    return tasks;\n}\n\n/** Consumes a publisher and ignores every value. */\nasync function drainPublisherInput(source: PublisherInput<unknown>, signal: AbortSignal, context: Context): Promise<void> {\n    for await (const _ of Flux.from(source).iterate(signal, context)) {\n        // values are intentionally ignored\n    }\n}\n\n/** Consumes one publisher and wraps its failure like delayed-error composition. */\nasync function drainPublisherInputAsCompositeError(\n    source: PublisherInput<unknown>,\n    signal: AbortSignal,\n    context: Context\n): Promise<void> {\n    try {\n        await drainPublisherInput(source, signal, context);\n    } catch (error) {\n        throw new CompositeError([error]);\n    }\n}\n\n/** Consumes a publisher and records its failure instead of throwing immediately. */\nasync function drainPublisherInputDelayError(\n    source: PublisherInput<unknown>,\n    signal: AbortSignal,\n    context: Context,\n    errors: unknown[]\n): Promise<void> {\n    try {\n        await drainPublisherInput(source, signal, context);\n    } catch (error) {\n        errors.push(error);\n    }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,35 @@
+import { Mono } from "../mono.js";
+declare module "../flux.js" {
+    /** Aggregate and terminal count-style operators added to Flux. */
+    interface Flux<T> {
+        /** Groups source values into arrays of `size`, with a final partial buffer when needed. */
+        buffer(size: number): Flux<T[]>;
+        /** Splits source values into finite Flux windows containing up to `size` values each. */
+        window(size: number): Flux<Flux<T>>;
+        /** Emits the seed and each accumulated value produced from the source. */
+        scan<R>(seed: R, accumulator: (accumulated: R, value: T) => R): Flux<R>;
+        /** Emits running accumulated values, using the first source value as the initial state. */
+        scan(accumulator: (accumulated: T, value: T) => T): Flux<T>;
+        /** Reduces source values into one value, using the first value as the initial state. */
+        reduce(accumulator: (left: T, right: T) => T): Mono<T>;
+        /** Reduces source values into one value starting from the provided seed. */
+        reduce<R>(seed: R, accumulator: (left: R, right: T) => R): Mono<R>;
+        /** Collects all source values into an array emitted after completion. */
+        collectList(): Mono<T[]>;
+        /** Counts source values and emits the final count after completion. */
+        count(): Mono<number>;
+        /** Emits true when at least one source value matches the predicate. */
+        any(predicate: (value: T) => boolean): Mono<boolean>;
+        /** Emits true only when every source value matches the predicate. */
+        all(predicate: (value: T) => boolean): Mono<boolean>;
+        /** Emits true when a source value matches `value` by `Object.is`. */
+        hasElement(value: T): Mono<boolean>;
+        /** Emits the first source value, or completes empty when the source has none. */
+        next(): Mono<T>;
+        /** Emits the only source value, an optional default for empty sources, or fails on multiple values. */
+        single(defaultValue?: T): Mono<T>;
+        /** Emits the only source value, completes empty for empty sources, or fails on multiple values. */
+        singleOrEmpty(): Mono<T>;
+    }
+}
+//# sourceMappingURL=aggregate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../src/publisher/operators/aggregate.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AAQzC,OAAO,QAAQ,qBAAqB,CAAC;IACjC,kEAAkE;IAClE,UAAU,IAAI,CAAC,CAAC;QACZ,2FAA2F;QAC3F,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEhC,yFAAyF;QACzF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAEpC,0EAA0E;QAC1E,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAExE,2FAA2F;QAC3F,IAAI,CAAC,WAAW,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAE5D,wFAAwF;QACxF,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvD,4EAA4E;QAC5E,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEnE,yEAAyE;QACzE,WAAW,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEzB,uEAAuE;QACvE,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;QAEtB,uEAAuE;QACvE,GAAG,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAErD,qEAAqE;QACrE,GAAG,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAErD,qEAAqE;QACrE,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QAEpC,iFAAiF;QACjF,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;QAEhB,uGAAuG;QACvG,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAElC,mGAAmG;QACnG,aAAa,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;KAC5B;CACJ"}