reactor-core-ts 2.1.5 → 3.2.1

package/dist/publisher/operators/aggregate.js

@@ -0,0 +1,217 @@
+import { isAsyncIterable } from "../../internal/iterable.js";
+import { NoSuchElementError } from "../../errors/classes.js";
+import { AsyncQueue } from "../../internal/async-queue.js";
+import { collectIterable, countIterable } from "../../internal/iterable-terminal.js";
+import { Flux } from "../flux.js";
+import { Mono } from "../mono.js";
+//#region src/publisher/operators/aggregate.ts
+/**
+* @packageDocumentation
+* Flux, Mono and operator implementation modules.
+*/
+/** Sentinel used when a terminal operation completes without emitting. */
+var NO_VALUE = Symbol("no-value");
+Flux.prototype.buffer = function buffer(size) {
+	if (!Number.isInteger(size) || size <= 0) throw new RangeError("buffer size must be a strictly positive integer");
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let bucket = [];
+		for await (const value of source.iterate(signal, context)) {
+			bucket.push(value);
+			if (bucket.length === size) {
+				yield bucket;
+				bucket = [];
+			}
+		}
+		if (bucket.length > 0) yield bucket;
+	});
+};
+Flux.prototype.window = function window(size) {
+	const buffers = this.buffer(size);
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		(async () => {
+			try {
+				for await (const values of buffers.iterate(signal, context)) queue.push(Flux.fromIterable(values));
+				queue.complete();
+			} catch (error) {
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+};
+Flux.prototype.scan = function scan(seedOrAccumulator, accumulator) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		if (accumulator) {
+			let current = seedOrAccumulator;
+			yield current;
+			for await (const value of source.iterate(signal, context)) {
+				current = accumulator(current, value);
+				yield current;
+			}
+		} else {
+			let initialized = false;
+			let current;
+			const acc = seedOrAccumulator;
+			for await (const value of source.iterate(signal, context)) if (!initialized) {
+				current = value;
+				initialized = true;
+				yield current;
+			} else {
+				current = acc(current, value);
+				yield current;
+			}
+		}
+	});
+};
+Flux.prototype.reduce = function reduce(seedOrAccumulator, accumulator) {
+	return terminalMono(this, (values) => accumulator ? reduceSeed(values, seedOrAccumulator, accumulator) : reduceNoSeed(values, seedOrAccumulator));
+};
+Flux.prototype.collectList = function collectList() {
+	return terminalMono(this, collectIterable);
+};
+Flux.prototype.count = function count() {
+	return terminalMono(this, countIterable);
+};
+Flux.prototype.any = function any(predicate) {
+	return terminalMono(this, (values) => anyValue(values, predicate));
+};
+Flux.prototype.all = function all(predicate) {
+	return terminalMono(this, (values) => allValue(values, predicate));
+};
+Flux.prototype.hasElement = function hasElement(value) {
+	return this.any((next) => Object.is(next, value));
+};
+Flux.prototype.next = function next() {
+	return terminalMono(this, firstValue);
+};
+Flux.prototype.single = function single(defaultValue) {
+	const hasDefault = arguments.length > 0;
+	return terminalMono(this, (values) => singleValue(values, false, hasDefault, defaultValue));
+};
+Flux.prototype.singleOrEmpty = function singleOrEmpty() {
+	return terminalMono(this, (values) => singleValue(values, true));
+};
+/** Creates a Mono from a terminal iterable computation while preserving sync sources. */
+function terminalMono(source, evaluate) {
+	return new Mono((signal, context) => {
+		const values = source.iterate(signal, context);
+		return isAsyncIterable(values) ? emitAsync(() => evaluate(values)) : emitSync(() => evaluate(values));
+	});
+}
+/** Emits a terminal sync value unless it represents an empty Mono. */
+function emitSync(producer) {
+	return (function* () {
+		const value = producer();
+		if (value !== NO_VALUE) yield value;
+	})();
+}
+/** Emits a terminal async value unless it represents an empty Mono. */
+function emitAsync(producer) {
+	return (async function* () {
+		const value = await producer();
+		if (value !== NO_VALUE) yield value;
+	})();
+}
+/** Reduces values with an explicit seed. */
+function reduceSeed(values, seed, accumulator) {
+	if (isAsyncIterable(values)) return (async () => {
+		let current = seed;
+		for await (const value of values) current = accumulator(current, value);
+		return current;
+	})();
+	let current = seed;
+	for (const value of values) current = accumulator(current, value);
+	return current;
+}
+/** Reduces values using the first value as the seed. */
+function reduceNoSeed(values, accumulator) {
+	if (isAsyncIterable(values)) return (async () => {
+		let initialized = false;
+		let current;
+		for await (const value of values) {
+			current = initialized ? accumulator(current, value) : value;
+			initialized = true;
+		}
+		return initialized ? current : NO_VALUE;
+	})();
+	let initialized = false;
+	let current;
+	for (const value of values) {
+		current = initialized ? accumulator(current, value) : value;
+		initialized = true;
+	}
+	return initialized ? current : NO_VALUE;
+}
+/** Returns true when any value matches the predicate. */
+function anyValue(values, predicate) {
+	if (isAsyncIterable(values)) return (async () => {
+		for await (const value of values) if (predicate(value)) return true;
+		return false;
+	})();
+	for (const value of values) if (predicate(value)) return true;
+	return false;
+}
+/** Returns true when every value matches the predicate. */
+function allValue(values, predicate) {
+	if (isAsyncIterable(values)) return (async () => {
+		for await (const value of values) if (!predicate(value)) return false;
+		return true;
+	})();
+	for (const value of values) if (!predicate(value)) return false;
+	return true;
+}
+/** Returns the first value and closes the source iterator early. */
+function firstValue(values) {
+	if (isAsyncIterable(values)) return (async () => {
+		const iterator = values[Symbol.asyncIterator]();
+		try {
+			const next = await iterator.next();
+			return next.done ? NO_VALUE : next.value;
+		} finally {
+			await iterator.return?.();
+		}
+	})();
+	const iterator = values[Symbol.iterator]();
+	try {
+		const next = iterator.next();
+		return next.done ? NO_VALUE : next.value;
+	} finally {
+		iterator.return?.();
+	}
+}
+/** Returns the only value, a default value or the empty sentinel. */
+function singleValue(values, emptyIsAllowed, hasDefault = false, defaultValue) {
+	if (isAsyncIterable(values)) return (async () => singleResult(await collectSingle(values), emptyIsAllowed, hasDefault, defaultValue))();
+	let seen = false;
+	let result;
+	for (const value of values) {
+		if (seen) throw new Error("Source emitted more than one item");
+		seen = true;
+		result = value;
+	}
+	return singleResult(seen ? result : NO_VALUE, emptyIsAllowed, hasDefault, defaultValue);
+}
+/** Collects exactly one async value or returns the empty sentinel. */
+async function collectSingle(values) {
+	let seen = false;
+	let result;
+	for await (const value of values) {
+		if (seen) throw new Error("Source emitted more than one item");
+		seen = true;
+		result = value;
+	}
+	return seen ? result : NO_VALUE;
+}
+/** Resolves single-value empty/default behavior. */
+function singleResult(value, emptyIsAllowed, hasDefault, defaultValue) {
+	if (value !== NO_VALUE) return value;
+	if (hasDefault) return defaultValue;
+	if (emptyIsAllowed) return NO_VALUE;
+	throw new NoSuchElementError();
+}
+//#endregion
+
+//# sourceMappingURL=aggregate.js.map

package/dist/publisher/operators/aggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.js","names":[],"sources":["../../../src/publisher/operators/aggregate.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Flux, Mono and operator implementation modules.\n */\nimport {NoSuchElementError} from \"@/errors/classes.js\";\nimport {AsyncQueue} from \"@/internal/async-queue.js\";\nimport {type AnyIterable, isAsyncIterable} from \"@/internal/iterable.js\";\nimport {collectIterable, countIterable} from \"@/internal/iterable-terminal.js\";\nimport {Flux} from \"@/publisher/flux.js\";\nimport {Mono} from \"@/publisher/mono.js\";\n\n/** Sentinel used when a terminal operation completes without emitting. */\nconst NO_VALUE = Symbol(\"no-value\");\n\n/** Terminal operation result that may represent an empty Mono. */\ntype MaybeValue<T> = T | typeof NO_VALUE;\n\ndeclare module \"@/publisher/flux.js\" {\n    /** Aggregate and terminal count-style operators added to Flux. */\n    interface Flux<T> {\n        /** Groups source values into arrays of `size`, with a final partial buffer when needed. */\n        buffer(size: number): Flux<T[]>;\n\n        /** Splits source values into finite Flux windows containing up to `size` values each. */\n        window(size: number): Flux<Flux<T>>;\n\n        /** Emits the seed and each accumulated value produced from the source. */\n        scan<R>(seed: R, accumulator: (accumulated: R, value: T) => R): Flux<R>;\n\n        /** Emits running accumulated values, using the first source value as the initial state. */\n        scan(accumulator: (accumulated: T, value: T) => T): Flux<T>;\n\n        /** Reduces source values into one value, using the first value as the initial state. */\n        reduce(accumulator: (left: T, right: T) => T): Mono<T>;\n\n        /** Reduces source values into one value starting from the provided seed. */\n        reduce<R>(seed: R, accumulator: (left: R, right: T) => R): Mono<R>;\n\n        /** Collects all source values into an array emitted after completion. */\n        collectList(): Mono<T[]>;\n\n        /** Counts source values and emits the final count after completion. */\n        count(): Mono<number>;\n\n        /** Emits true when at least one source value matches the predicate. */\n        any(predicate: (value: T) => boolean): Mono<boolean>;\n\n        /** Emits true only when every source value matches the predicate. */\n        all(predicate: (value: T) => boolean): Mono<boolean>;\n\n        /** Emits true when a source value matches `value` by `Object.is`. */\n        hasElement(value: T): Mono<boolean>;\n\n        /** Emits the first source value, or completes empty when the source has none. */\n        next(): Mono<T>;\n\n        /** Emits the only source value, an optional default for empty sources, or fails on multiple values. */\n        single(defaultValue?: T): Mono<T>;\n\n        /** Emits the only source value, completes empty for empty sources, or fails on multiple values. */\n        singleOrEmpty(): Mono<T>;\n    }\n}\n\nFlux.prototype.buffer = function buffer<T>(this: Flux<T>, size: number): Flux<T[]> {\n    if (!Number.isInteger(size) || size <= 0) {\n        throw new RangeError(\"buffer size must be a strictly positive integer\");\n    }\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        let bucket: T[] = [];\n        for await (const value of source.iterate(signal, context)) {\n            bucket.push(value);\n            if (bucket.length === size) {\n                yield bucket;\n                bucket = [];\n            }\n        }\n        if (bucket.length > 0) {\n            yield bucket;\n        }\n    });\n};\n\nFlux.prototype.window = function window<T>(this: Flux<T>, size: number): Flux<Flux<T>> {\n    const buffers = this.buffer(size);\n    return new Flux((signal, context) => {\n        const queue = new AsyncQueue<Flux<T>>(signal);\n        void (async () => {\n            try {\n                for await (const values of buffers.iterate(signal, context)) {\n                    queue.push(Flux.fromIterable(values));\n                }\n                queue.complete();\n            } catch (error) {\n                queue.error(error);\n            }\n        })();\n        return queue;\n    });\n};\n\nFlux.prototype.scan = function scan<T, R>(\n    this: Flux<T>,\n    seedOrAccumulator: R | ((accumulated: T, value: T) => T),\n    accumulator?: (accumulated: R, value: T) => R\n): Flux<R | T> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        if (accumulator) {\n            let current = seedOrAccumulator as R;\n            yield current;\n            for await (const value of source.iterate(signal, context)) {\n                current = accumulator(current, value);\n                yield current;\n            }\n        } else {\n            let initialized = false;\n            let current: T | undefined;\n            const acc = seedOrAccumulator as (accumulated: T, value: T) => T;\n            for await (const value of source.iterate(signal, context)) {\n                if (!initialized) {\n                    current = value;\n                    initialized = true;\n                    yield current;\n                } else {\n                    current = acc(current as T, value);\n                    yield current;\n                }\n            }\n        }\n    });\n};\n\nFlux.prototype.reduce = function reduce<T, R>(\n    this: Flux<T>,\n    seedOrAccumulator: R | ((left: T, right: T) => T),\n    accumulator?: (left: R, right: T) => R\n): Mono<R | T> {\n    return terminalMono(this, values => accumulator\n        ? reduceSeed(values, seedOrAccumulator as R, accumulator)\n        : reduceNoSeed(values, seedOrAccumulator as (left: T, right: T) => T));\n};\n\nFlux.prototype.collectList = function collectList<T>(this: Flux<T>): Mono<T[]> {\n    return terminalMono(this, collectIterable);\n};\n\nFlux.prototype.count = function count<T>(this: Flux<T>): Mono<number> {\n    return terminalMono(this, countIterable);\n};\n\nFlux.prototype.any = function any<T>(this: Flux<T>, predicate: (value: T) => boolean): Mono<boolean> {\n    return terminalMono(this, values => anyValue(values, predicate));\n};\n\nFlux.prototype.all = function all<T>(this: Flux<T>, predicate: (value: T) => boolean): Mono<boolean> {\n    return terminalMono(this, values => allValue(values, predicate));\n};\n\nFlux.prototype.hasElement = function hasElement<T>(this: Flux<T>, value: T): Mono<boolean> {\n    return this.any(next => Object.is(next, value));\n};\n\nFlux.prototype.next = function next<T>(this: Flux<T>): Mono<T> {\n    return terminalMono(this, firstValue);\n};\n\nFlux.prototype.single = function single<T>(this: Flux<T>, defaultValue?: T): Mono<T> {\n    const hasDefault = arguments.length > 0;\n    return terminalMono(this, values => singleValue(values, false, hasDefault, defaultValue));\n};\n\nFlux.prototype.singleOrEmpty = function singleOrEmpty<T>(this: Flux<T>): Mono<T> {\n    return terminalMono(this, values => singleValue<T>(values, true));\n};\n\n/** Creates a Mono from a terminal iterable computation while preserving sync sources. */\nfunction terminalMono<T, R>(\n    source: Flux<T>,\n    evaluate: (values: AnyIterable<T>) => MaybeValue<R> | Promise<MaybeValue<R>>\n): Mono<R> {\n    return new Mono((signal, context) => {\n        const values = source.iterate(signal, context);\n        return isAsyncIterable<T>(values) ? emitAsync(() => evaluate(values)) : emitSync(() => evaluate(values) as MaybeValue<R>);\n    });\n}\n\n/** Emits a terminal sync value unless it represents an empty Mono. */\nfunction emitSync<T>(producer: () => MaybeValue<T>): Iterable<T> {\n    return (function* () {\n        const value = producer();\n        if (value !== NO_VALUE) {\n            yield value as T;\n        }\n    })();\n}\n\n/** Emits a terminal async value unless it represents an empty Mono. */\nfunction emitAsync<T>(producer: () => MaybeValue<T> | Promise<MaybeValue<T>>): AsyncIterable<T> {\n    return (async function* () {\n        const value = await producer();\n        if (value !== NO_VALUE) {\n            yield value as T;\n        }\n    })();\n}\n\n/** Reduces values with an explicit seed. */\nfunction reduceSeed<T, R>(\n    values: AnyIterable<T>,\n    seed: R,\n    accumulator: (left: R, right: T) => R\n): R | Promise<R> {\n    if (isAsyncIterable<T>(values)) {\n        return (async () => {\n            let current = seed;\n            for await (const value of values) {\n                current = accumulator(current, value);\n            }\n            return current;\n        })();\n    }\n    let current = seed;\n    for (const value of values) {\n        current = accumulator(current, value);\n    }\n    return current;\n}\n\n/** Reduces values using the first value as the seed. */\nfunction reduceNoSeed<T>(\n    values: AnyIterable<T>,\n    accumulator: (left: T, right: T) => T\n): MaybeValue<T> | Promise<MaybeValue<T>> {\n    if (isAsyncIterable<T>(values)) {\n        return (async () => {\n            let initialized = false;\n            let current: T | undefined;\n            for await (const value of values) {\n                current = initialized ? accumulator(current as T, value) : value;\n                initialized = true;\n            }\n            return initialized ? current as T : NO_VALUE;\n        })();\n    }\n    let initialized = false;\n    let current: T | undefined;\n    for (const value of values) {\n        current = initialized ? accumulator(current as T, value) : value;\n        initialized = true;\n    }\n    return initialized ? current as T : NO_VALUE;\n}\n\n/** Returns true when any value matches the predicate. */\nfunction anyValue<T>(values: AnyIterable<T>, predicate: (value: T) => boolean): boolean | Promise<boolean> {\n    if (isAsyncIterable<T>(values)) {\n        return (async () => {\n            for await (const value of values) {\n                if (predicate(value)) {\n                    return true;\n                }\n            }\n            return false;\n        })();\n    }\n    for (const value of values) {\n        if (predicate(value)) {\n            return true;\n        }\n    }\n    return false;\n}\n\n/** Returns true when every value matches the predicate. */\nfunction allValue<T>(values: AnyIterable<T>, predicate: (value: T) => boolean): boolean | Promise<boolean> {\n    if (isAsyncIterable<T>(values)) {\n        return (async () => {\n            for await (const value of values) {\n                if (!predicate(value)) {\n                    return false;\n                }\n            }\n            return true;\n        })();\n    }\n    for (const value of values) {\n        if (!predicate(value)) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/** Returns the first value and closes the source iterator early. */\nfunction firstValue<T>(values: AnyIterable<T>): MaybeValue<T> | Promise<MaybeValue<T>> {\n    if (isAsyncIterable<T>(values)) {\n        return (async () => {\n            const iterator = values[Symbol.asyncIterator]();\n            try {\n                const next = await iterator.next();\n                return next.done ? NO_VALUE : next.value;\n            } finally {\n                await iterator.return?.();\n            }\n        })();\n    }\n    const iterator = values[Symbol.iterator]();\n    try {\n        const next = iterator.next();\n        return next.done ? NO_VALUE : next.value;\n    } finally {\n        iterator.return?.();\n    }\n}\n\n/** Returns the only value, a default value or the empty sentinel. */\nfunction singleValue<T>(\n    values: AnyIterable<T>,\n    emptyIsAllowed: boolean,\n    hasDefault = false,\n    defaultValue?: T\n): MaybeValue<T> | Promise<MaybeValue<T>> {\n    if (isAsyncIterable<T>(values)) {\n        return (async () => singleResult(await collectSingle(values), emptyIsAllowed, hasDefault, defaultValue))();\n    }\n    let seen = false;\n    let result: T | undefined;\n    for (const value of values) {\n        if (seen) {\n            throw new Error(\"Source emitted more than one item\");\n        }\n        seen = true;\n        result = value;\n    }\n    return singleResult(seen ? result as T : NO_VALUE, emptyIsAllowed, hasDefault, defaultValue);\n}\n\n/** Collects exactly one async value or returns the empty sentinel. */\nasync function collectSingle<T>(values: AsyncIterable<T>): Promise<MaybeValue<T>> {\n    let seen = false;\n    let result: T | undefined;\n    for await (const value of values) {\n        if (seen) {\n            throw new Error(\"Source emitted more than one item\");\n        }\n        seen = true;\n        result = value;\n    }\n    return seen ? result as T : NO_VALUE;\n}\n\n/** Resolves single-value empty/default behavior. */\nfunction singleResult<T>(\n    value: MaybeValue<T>,\n    emptyIsAllowed: boolean,\n    hasDefault: boolean,\n    defaultValue: T | undefined\n): MaybeValue<T> {\n    if (value !== NO_VALUE) {\n        return value;\n    }\n    if (hasDefault) {\n        return defaultValue as T;\n    }\n    if (emptyIsAllowed) {\n        return NO_VALUE;\n    }\n    throw new NoSuchElementError();\n}\n"],"mappings":"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"}

package/dist/publisher/operators/compat/flux.d.ts

@@ -0,0 +1,56 @@
+import { Mono } from "../../mono.js";
+import type { PublisherInput } from "../../types.js";
+import type { Subscriber } from "../../../subscription/subscriber.js";
+/** Constructor-like runtime value used by `ofType`. */
+type ClassLike<R> = abstract new (...args: never[]) => R;
+declare module "../../flux.js" {
+    /** Reactor compatibility operators added to Flux. */
+    interface Flux<T> {
+        /** Passes this Flux to a transformer and returns the transformer's result. */
+        as<R>(transformer: (source: Flux<T>) => R): R;
+        /** Resolves with the first value, or undefined when the source completes empty. */
+        blockFirst(): Promise<T | undefined>;
+        /** Resolves with the last value, or undefined when the source completes empty. */
+        blockLast(): Promise<T | undefined>;
+        /** Creates a container per subscription and accumulates every source value into it. */
+        collect<R>(supplier: () => R, accumulator: (container: R, value: T) => void): Mono<R>;
+        /** Collects source values into a Map using extracted keys and optional mapped values. */
+        collectMap<K, V = T>(keyExtractor: (value: T) => K, valueExtractor?: (value: T) => V): Mono<Map<K, V>>;
+        /** Collects source values into a Map whose keys point to arrays of matching values. */
+        collectMultimap<K, V = T>(keyExtractor: (value: T) => K, valueExtractor?: (value: T) => V): Mono<Map<K, V[]>>;
+        /** Collects all source values into an array and sorts it before emitting. */
+        collectSortedList(comparator?: (left: T, right: T) => number): Mono<T[]>;
+        /** Appends literal values after this Flux completes. */
+        concatWithValues(...values: readonly T[]): Flux<T>;
+        /** Emits the value at a zero-based index, a default, or an error when missing. */
+        elementAt(index: number, defaultValue?: T): Mono<T>;
+        /** Emits true when the source emits at least one value. */
+        hasElements(): Mono<boolean>;
+        /** Wraps this source in a new Flux to hide its concrete identity. */
+        hide(): Flux<T>;
+        /** Drops all values and completes when the source completes successfully. */
+        ignoreElements(): Mono<void>;
+        /** Emits the final source value, an optional default, or an error when empty. */
+        last(defaultValue?: T): Mono<T>;
+        /** Maps each value and drops null or undefined mapping results. */
+        mapNotNull<R>(mapper: (value: T) => R | null | undefined): Flux<R>;
+        /** Keeps only values that are instances of the provided runtime class. */
+        ofType<R>(type: ClassLike<R>): Flux<R>;
+        /** Creates an initial state per subscription and reduces source values into it. */
+        reduceWith<R>(supplier: () => R, accumulator: (accumulated: R, value: T) => R): Mono<R>;
+        /** Creates an initial state per subscription and emits each running accumulation. */
+        scanWith<R>(supplier: () => R, accumulator: (accumulated: R, value: T) => R): Flux<R>;
+        /** Drops the final `n` values from the source. */
+        skipLast(n: number): Flux<T>;
+        /** Collects all source values, sorts them, and replays the sorted values. */
+        sort(comparator?: (left: T, right: T) => number): Flux<T>;
+        /** Subscribes the provided subscriber and returns the same subscriber instance. */
+        subscribeWith<S extends Subscriber<T>>(subscriber: S): S;
+        /** Emits only the final `n` values after the source completes. */
+        takeLast(n: number): Flux<T>;
+        /** Waits for this source and then waits for `other`, ignoring all values. */
+        thenEmpty(other: PublisherInput<unknown>): Mono<void>;
+    }
+}
+export {};
+//# sourceMappingURL=flux.d.ts.map

package/dist/publisher/operators/compat/flux.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flux.d.ts","sourceRoot":"","sources":["../../../../src/publisher/operators/compat/flux.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AACzC,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAE7D,uDAAuD;AACvD,KAAK,SAAS,CAAC,CAAC,IAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEzD,OAAO,QAAQ,qBAAqB,CAAC;IACjC,qDAAqD;IACrD,UAAU,IAAI,CAAC,CAAC;QACZ,8EAA8E;QAC9E,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE9C,mFAAmF;QACnF,UAAU,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;QAErC,kFAAkF;QAClF,SAAS,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;QAEpC,uFAAuF;QACvF,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEtF,yFAAyF;QACzF,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEvG,uFAAuF;QACvF,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE9G,6EAA6E;QAC7E,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEzE,wDAAwD;QACxD,gBAAgB,CAAC,GAAG,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEnD,kFAAkF;QAClF,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEpD,2DAA2D;QAC3D,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;QAE7B,qEAAqE;QACrE,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;QAEhB,6EAA6E;QAC7E,cAAc,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;QAE7B,iFAAiF;QACjF,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEhC,mEAAmE;QACnE,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEnE,0EAA0E;QAC1E,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvC,mFAAmF;QACnF,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAExF,qFAAqF;QACrF,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEtF,kDAAkD;QAClD,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAE7B,6EAA6E;QAC7E,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAE1D,mFAAmF;QACnF,aAAa,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;QAEzD,kEAAkE;QAClE,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAE7B,6EAA6E;QAC7E,SAAS,CAAC,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;KACzD;CACJ"}

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

@@ -0,0 +1,156 @@
+import { isAsyncIterable } from "../../../internal/iterable.js";
+import { NoSuchElementError } from "../../../errors/classes.js";
+import { identity } from "../../helpers.js";
+import { Flux } from "../../flux.js";
+import { Mono } from "../../mono.js";
+//#region src/publisher/operators/compat/flux.ts
+/**
+* @packageDocumentation
+* Flux, Mono and operator implementation modules.
+*/
+Flux.prototype.as = function as(transformer) {
+	return transformer(this);
+};
+Flux.prototype.blockFirst = function blockFirst() {
+	return this.next().block();
+};
+Flux.prototype.blockLast = function blockLast() {
+	return this.toPromise();
+};
+Flux.prototype.collect = function collect(supplier, accumulator) {
+	const source = this;
+	return new Mono((signal, context) => {
+		const values = source.iterate(signal, context);
+		if (isAsyncIterable(values)) return (async function* () {
+			const container = supplier();
+			for await (const value of values) accumulator(container, value);
+			yield container;
+		})();
+		return (function* () {
+			const container = supplier();
+			for (const value of values) accumulator(container, value);
+			yield container;
+		})();
+	});
+};
+Flux.prototype.collectMap = function collectMap(keyExtractor, valueExtractor = identity) {
+	return this.collect(() => /* @__PURE__ */ new Map(), (map, value) => map.set(keyExtractor(value), valueExtractor(value)));
+};
+Flux.prototype.collectMultimap = function collectMultimap(keyExtractor, valueExtractor = identity) {
+	return this.collect(() => /* @__PURE__ */ new Map(), (map, value) => {
+		const key = keyExtractor(value);
+		const bucket = map.get(key);
+		if (bucket) bucket.push(valueExtractor(value));
+		else map.set(key, [valueExtractor(value)]);
+	});
+};
+Flux.prototype.collectSortedList = function collectSortedList(comparator) {
+	return this.collectList().map((values) => values.sort(comparator));
+};
+Flux.prototype.concatWithValues = function concatWithValues(...values) {
+	return this.concatWith(Flux.just(...values));
+};
+Flux.prototype.elementAt = function elementAt(index, defaultValue) {
+	if (!Number.isInteger(index) || index < 0) throw new RangeError("index must be a non-negative integer");
+	const hasDefault = arguments.length > 1;
+	return this.skip(index).next().switchIfEmpty(hasDefault ? Mono.just(defaultValue) : Mono.error(new NoSuchElementError()));
+};
+Flux.prototype.hasElements = function hasElements() {
+	return this.any(() => true);
+};
+Flux.prototype.hide = function hide() {
+	const source = this;
+	return new Flux((signal, context) => source.iterate(signal, context));
+};
+Flux.prototype.ignoreElements = function ignoreElements() {
+	return this.then();
+};
+Flux.prototype.last = function last(defaultValue) {
+	const source = this;
+	const hasDefault = arguments.length > 0;
+	return new Mono(async function* (signal, context) {
+		let seen = false;
+		let lastValue;
+		for await (const value of source.iterate(signal, context)) {
+			seen = true;
+			lastValue = value;
+		}
+		if (seen) yield lastValue;
+		else if (hasDefault) yield defaultValue;
+		else throw new NoSuchElementError();
+	});
+};
+Flux.prototype.mapNotNull = function mapNotNull(mapper) {
+	return this.handle((value, sink) => {
+		const mapped = mapper(value);
+		if (mapped !== null && mapped !== void 0) sink.next(mapped);
+	});
+};
+Flux.prototype.ofType = function ofType(type) {
+	return this.filter((value) => value instanceof type).cast();
+};
+Flux.prototype.reduceWith = function reduceWith(supplier, accumulator) {
+	const source = this;
+	return new Mono(async function* (signal, context) {
+		for await (const value of source.reduce(supplier(), accumulator).iterate(signal, context)) yield value;
+	});
+};
+Flux.prototype.scanWith = function scanWith(supplier, accumulator) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		for await (const value of source.scan(supplier(), accumulator).iterate(signal, context)) yield value;
+	});
+};
+Flux.prototype.skipLast = function skipLast(n) {
+	if (!Number.isInteger(n) || n < 0) throw new RangeError("skipLast expects a non-negative integer");
+	if (n === 0) return this;
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const queue = [];
+		let head = 0;
+		for await (const value of source.iterate(signal, context)) {
+			queue.push(value);
+			if (queue.length - head > n) {
+				const next = queue[head];
+				head += 1;
+				if (head > 1024 && head * 2 > queue.length) {
+					queue.copyWithin(0, head);
+					queue.length -= head;
+					head = 0;
+				}
+				yield next;
+			}
+		}
+	});
+};
+Flux.prototype.sort = function sort(comparator) {
+	return new Flux((signal, context) => this.collectSortedList(comparator).flatMapMany(Flux.fromIterable).iterate(signal, context));
+};
+Flux.prototype.subscribeWith = function subscribeWith(subscriber) {
+	this.subscribe(subscriber);
+	return subscriber;
+};
+Flux.prototype.takeLast = function takeLast(n) {
+	if (!Number.isInteger(n) || n < 0) throw new RangeError("takeLast expects a non-negative integer");
+	if (n === 0) return Flux.empty();
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const values = [];
+		let head = 0;
+		for await (const value of source.iterate(signal, context)) if (values.length < n) values.push(value);
+		else {
+			values[head] = value;
+			head = (head + 1) % n;
+		}
+		for (let index = 0; index < values.length; index += 1) {
+			if (signal.aborted) return;
+			yield values[(head + index) % values.length];
+		}
+	});
+};
+Flux.prototype.thenEmpty = function thenEmpty(other) {
+	return this.thenMany(other).then();
+};
+//#endregion
+
+//# sourceMappingURL=flux.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flux.js","names":[],"sources":["../../../../src/publisher/operators/compat/flux.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Flux, Mono and operator implementation modules.\n */\nimport {NoSuchElementError} from \"@/errors/classes.js\";\nimport {isAsyncIterable} from \"@/internal/iterable.js\";\nimport {Flux} from \"@/publisher/flux.js\";\nimport {identity} from \"@/publisher/helpers.js\";\nimport {Mono} from \"@/publisher/mono.js\";\nimport type {PublisherInput} from \"@/publisher/types.js\";\nimport type {Subscriber} from \"@/subscription/subscriber.js\";\n\n/** Constructor-like runtime value used by `ofType`. */\ntype ClassLike<R> = abstract new (...args: never[]) => R;\n\ndeclare module \"@/publisher/flux.js\" {\n    /** Reactor compatibility operators added to Flux. */\n    interface Flux<T> {\n        /** Passes this Flux to a transformer and returns the transformer's result. */\n        as<R>(transformer: (source: Flux<T>) => R): R;\n\n        /** Resolves with the first value, or undefined when the source completes empty. */\n        blockFirst(): Promise<T | undefined>;\n\n        /** Resolves with the last value, or undefined when the source completes empty. */\n        blockLast(): Promise<T | undefined>;\n\n        /** Creates a container per subscription and accumulates every source value into it. */\n        collect<R>(supplier: () => R, accumulator: (container: R, value: T) => void): Mono<R>;\n\n        /** Collects source values into a Map using extracted keys and optional mapped values. */\n        collectMap<K, V = T>(keyExtractor: (value: T) => K, valueExtractor?: (value: T) => V): Mono<Map<K, V>>;\n\n        /** Collects source values into a Map whose keys point to arrays of matching values. */\n        collectMultimap<K, V = T>(keyExtractor: (value: T) => K, valueExtractor?: (value: T) => V): Mono<Map<K, V[]>>;\n\n        /** Collects all source values into an array and sorts it before emitting. */\n        collectSortedList(comparator?: (left: T, right: T) => number): Mono<T[]>;\n\n        /** Appends literal values after this Flux completes. */\n        concatWithValues(...values: readonly T[]): Flux<T>;\n\n        /** Emits the value at a zero-based index, a default, or an error when missing. */\n        elementAt(index: number, defaultValue?: T): Mono<T>;\n\n        /** Emits true when the source emits at least one value. */\n        hasElements(): Mono<boolean>;\n\n        /** Wraps this source in a new Flux to hide its concrete identity. */\n        hide(): Flux<T>;\n\n        /** Drops all values and completes when the source completes successfully. */\n        ignoreElements(): Mono<void>;\n\n        /** Emits the final source value, an optional default, or an error when empty. */\n        last(defaultValue?: T): Mono<T>;\n\n        /** Maps each value and drops null or undefined mapping results. */\n        mapNotNull<R>(mapper: (value: T) => R | null | undefined): Flux<R>;\n\n        /** Keeps only values that are instances of the provided runtime class. */\n        ofType<R>(type: ClassLike<R>): Flux<R>;\n\n        /** Creates an initial state per subscription and reduces source values into it. */\n        reduceWith<R>(supplier: () => R, accumulator: (accumulated: R, value: T) => R): Mono<R>;\n\n        /** Creates an initial state per subscription and emits each running accumulation. */\n        scanWith<R>(supplier: () => R, accumulator: (accumulated: R, value: T) => R): Flux<R>;\n\n        /** Drops the final `n` values from the source. */\n        skipLast(n: number): Flux<T>;\n\n        /** Collects all source values, sorts them, and replays the sorted values. */\n        sort(comparator?: (left: T, right: T) => number): Flux<T>;\n\n        /** Subscribes the provided subscriber and returns the same subscriber instance. */\n        subscribeWith<S extends Subscriber<T>>(subscriber: S): S;\n\n        /** Emits only the final `n` values after the source completes. */\n        takeLast(n: number): Flux<T>;\n\n        /** Waits for this source and then waits for `other`, ignoring all values. */\n        thenEmpty(other: PublisherInput<unknown>): Mono<void>;\n    }\n}\n\n\nFlux.prototype.as = function as<T, R>(this: Flux<T>, transformer: (source: Flux<T>) => R): R {\n    return transformer(this);\n};\n\nFlux.prototype.blockFirst = function blockFirst<T>(this: Flux<T>): Promise<T | undefined> {\n    return this.next().block();\n};\n\nFlux.prototype.blockLast = function blockLast<T>(this: Flux<T>): Promise<T | undefined> {\n    return this.toPromise();\n};\n\nFlux.prototype.collect = function collect<T, R>(\n    this: Flux<T>,\n    supplier: () => R,\n    accumulator: (container: R, value: T) => void\n): Mono<R> {\n    const source = this;\n    return new Mono((signal, context) => {\n        const values = source.iterate(signal, context);\n        if (isAsyncIterable<T>(values)) {\n            return (async function* () {\n                const container = supplier();\n                for await (const value of values) {\n                    accumulator(container, value);\n                }\n                yield container;\n            })();\n        }\n        return (function* () {\n            const container = supplier();\n            for (const value of values) {\n                accumulator(container, value);\n            }\n            yield container;\n        })();\n    });\n};\n\nFlux.prototype.collectMap = function collectMap<T, K, V = T>(\n    this: Flux<T>,\n    keyExtractor: (value: T) => K,\n    valueExtractor: (value: T) => V = identity as (value: T) => V\n): Mono<Map<K, V>> {\n    return this.collect(\n        () => new Map<K, V>(),\n        (map, value) => map.set(keyExtractor(value), valueExtractor(value))\n    );\n};\n\nFlux.prototype.collectMultimap = function collectMultimap<T, K, V = T>(\n    this: Flux<T>,\n    keyExtractor: (value: T) => K,\n    valueExtractor: (value: T) => V = identity as (value: T) => V\n): Mono<Map<K, V[]>> {\n    return this.collect(\n        () => new Map<K, V[]>(),\n        (map, value) => {\n            const key = keyExtractor(value);\n            const bucket = map.get(key);\n            if (bucket) {\n                bucket.push(valueExtractor(value));\n            } else {\n                map.set(key, [valueExtractor(value)]);\n            }\n        }\n    );\n};\n\nFlux.prototype.collectSortedList = function collectSortedList<T>(\n    this: Flux<T>,\n    comparator?: (left: T, right: T) => number\n): Mono<T[]> {\n    return this.collectList().map(values => values.sort(comparator));\n};\n\nFlux.prototype.concatWithValues = function concatWithValues<T>(this: Flux<T>, ...values: readonly T[]): Flux<T> {\n    return this.concatWith(Flux.just(...values));\n};\n\nFlux.prototype.elementAt = function elementAt<T>(this: Flux<T>, index: number, defaultValue?: T): Mono<T> {\n    if (!Number.isInteger(index) || index < 0) {\n        throw new RangeError(\"index must be a non-negative integer\");\n    }\n    const hasDefault = arguments.length > 1;\n    return this.skip(index).next().switchIfEmpty(hasDefault ? Mono.just(defaultValue as T) : Mono.error(new NoSuchElementError()));\n};\n\nFlux.prototype.hasElements = function hasElements<T>(this: Flux<T>): Mono<boolean> {\n    return this.any(() => true);\n};\n\nFlux.prototype.hide = function hide<T>(this: Flux<T>): Flux<T> {\n    const source = this;\n    return new Flux((signal, context) => source.iterate(signal, context));\n};\n\nFlux.prototype.ignoreElements = function ignoreElements<T>(this: Flux<T>): Mono<void> {\n    return this.then();\n};\n\nFlux.prototype.last = function last<T>(this: Flux<T>, defaultValue?: T): Mono<T> {\n    const source = this;\n    const hasDefault = arguments.length > 0;\n    return new Mono(async function* (signal, context) {\n        let seen = false;\n        let lastValue: T | undefined;\n        for await (const value of source.iterate(signal, context)) {\n            seen = true;\n            lastValue = value;\n        }\n        if (seen) {\n            yield lastValue as T;\n        } else if (hasDefault) {\n            yield defaultValue as T;\n        } else {\n            throw new NoSuchElementError();\n        }\n    });\n};\n\nFlux.prototype.mapNotNull = function mapNotNull<T, R>(\n    this: Flux<T>,\n    mapper: (value: T) => R | null | undefined\n): Flux<R> {\n    return this.handle((value, sink) => {\n        const mapped = mapper(value);\n        if (mapped !== null && mapped !== undefined) {\n            sink.next(mapped);\n        }\n    });\n};\n\nFlux.prototype.ofType = function ofType<T, R>(this: Flux<T>, type: ClassLike<R>): Flux<R> {\n    return this.filter(value => value instanceof type).cast<R>();\n};\n\nFlux.prototype.reduceWith = function reduceWith<T, R>(\n    this: Flux<T>,\n    supplier: () => R,\n    accumulator: (accumulated: R, value: T) => R\n): Mono<R> {\n    const source = this;\n    return new Mono(async function* (signal, context) {\n        for await (const value of source.reduce(supplier(), accumulator).iterate(signal, context)) {\n            yield value;\n        }\n    });\n};\n\nFlux.prototype.scanWith = function scanWith<T, R>(\n    this: Flux<T>,\n    supplier: () => R,\n    accumulator: (accumulated: R, value: T) => R\n): Flux<R> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        for await (const value of source.scan(supplier(), accumulator).iterate(signal, context)) {\n            yield value;\n        }\n    });\n};\n\nFlux.prototype.skipLast = function skipLast<T>(this: Flux<T>, n: number): Flux<T> {\n    if (!Number.isInteger(n) || n < 0) {\n        throw new RangeError(\"skipLast expects a non-negative integer\");\n    }\n    if (n === 0) {\n        return this;\n    }\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        const queue: T[] = [];\n        let head = 0;\n        for await (const value of source.iterate(signal, context)) {\n            queue.push(value);\n            if (queue.length - head > n) {\n                const next = queue[head] as T;\n                head += 1;\n                if (head > 1024 && head * 2 > queue.length) {\n                    queue.copyWithin(0, head);\n                    queue.length -= head;\n                    head = 0;\n                }\n                yield next;\n            }\n        }\n    });\n};\n\nFlux.prototype.sort = function sort<T>(this: Flux<T>, comparator?: (left: T, right: T) => number): Flux<T> {\n    return new Flux((signal, context) => this.collectSortedList(comparator).flatMapMany(Flux.fromIterable).iterate(signal, context));\n};\n\nFlux.prototype.subscribeWith = function subscribeWith<T, S extends Subscriber<T>>(this: Flux<T>, subscriber: S): S {\n    this.subscribe(subscriber);\n    return subscriber;\n};\n\nFlux.prototype.takeLast = function takeLast<T>(this: Flux<T>, n: number): Flux<T> {\n    if (!Number.isInteger(n) || n < 0) {\n        throw new RangeError(\"takeLast expects a non-negative integer\");\n    }\n    if (n === 0) {\n        return Flux.empty<T>();\n    }\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        const values: T[] = [];\n        let head = 0;\n        for await (const value of source.iterate(signal, context)) {\n            if (values.length < n) {\n                values.push(value);\n            } else {\n                values[head] = value;\n                head = (head + 1) % n;\n            }\n        }\n        for (let index = 0; index < values.length; index += 1) {\n            if (signal.aborted) {\n                return;\n            }\n            yield values[(head + index) % values.length] as T;\n        }\n    });\n};\n\nFlux.prototype.thenEmpty = function thenEmpty<T>(this: Flux<T>, other: PublisherInput<unknown>): Mono<void> {\n    return this.thenMany(other).then();\n};\n"],"mappings":"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"}

package/dist/publisher/operators/compat/mono.d.ts

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

package/dist/publisher/operators/compat/mono.d.ts.map

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