reactor-core-ts 2.1.6 → 3.2.2

package/dist/publisher/operators/lift.js

@@ -0,0 +1,343 @@
+import _defineProperty from "../../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/defineProperty.js";
+import { Context } from "../../context/context.js";
+import { addCap } from "../../core/demand.js";
+import { Flux } from "../flux.js";
+//#region src/publisher/operators/lift.ts
+/**
+* @packageDocumentation
+* Internal subscriber-lifting primitives for demand-preserving Flux operators.
+*/
+/**
+* Lifts a Flux at the Reactive Streams subscriber boundary while keeping an
+* iterable implementation for explicit async-iterator consumption.
+*/
+function liftFlux(source, sourceFactory, lifter) {
+	return new LiftedFlux(source, sourceFactory, lifter);
+}
+/** Creates a one-to-one operator that forwards downstream demand unchanged. */
+function liftOneToOne(source, sourceFactory, hooksFactory) {
+	return liftFlux(source, sourceFactory, (subscriber) => new OneToOneOperatorSubscriber(subscriber, hooksFactory(subscriber)));
+}
+/** Creates a filtering operator that replenishes only values dropped from finite demand. */
+function liftFilter(source, sourceFactory, predicate) {
+	return liftFlux(source, sourceFactory, (subscriber) => new FilterOperatorSubscriber(subscriber, predicate));
+}
+/** Returns the context exposed by a subscriber, or the shared empty context. */
+function subscriberContext(subscriber) {
+	return subscriber.currentContext?.() ?? Context.empty();
+}
+/** Flux whose normal subscribe path is assembled through a subscriber lifter. */
+var LiftedFlux = class extends Flux {
+	/** Creates a lifted Flux around an upstream source. */
+	constructor(source, sourceFactory, lifter) {
+		super(sourceFactory);
+		_defineProperty(this, "source", void 0);
+		_defineProperty(this, "lifter", void 0);
+		this.source = source;
+		this.lifter = lifter;
+	}
+	/** Subscribes without crossing the async-iterator bridge. */
+	subscribeActual(subscriber) {
+		let upstreamSubscriber;
+		try {
+			upstreamSubscriber = this.lifter(subscriber);
+		} catch (error) {
+			signalAssemblyError(subscriber, error);
+			return;
+		}
+		this.source.subscribe(upstreamSubscriber);
+	}
+};
+/** Subscription/subscriber pair shared by synchronous one-to-one operators. */
+var OneToOneOperatorSubscriber = class {
+	/** Creates a one-to-one operator subscriber. */
+	constructor(actual, hooks) {
+		_defineProperty(this, "actual", void 0);
+		_defineProperty(this, "hooks", void 0);
+		_defineProperty(
+			this,
+			/** Upstream subscription received during the Reactive Streams handshake. */
+			"upstream",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Prevents duplicate subscriptions from replacing the active upstream. */
+			"subscribed",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Suppresses signals and demand after cancellation or termination. */
+			"terminated",
+			false
+		);
+		this.actual = actual;
+		this.hooks = hooks;
+	}
+	/** Installs the upstream subscription and exposes this forwarding subscription downstream. */
+	onSubscribe(subscription) {
+		if (this.subscribed || this.terminated) {
+			subscription.cancel();
+			return;
+		}
+		this.subscribed = true;
+		this.upstream = subscription;
+		try {
+			this.hooks.onSubscribe?.(subscription);
+		} catch (error) {
+			this.terminated = true;
+			cancelSilently(subscription);
+			this.actual.onSubscribe(this);
+			this.signalError(error);
+			return;
+		}
+		try {
+			this.actual.onSubscribe(this);
+		} catch (error) {
+			this.terminated = true;
+			try {
+				subscription.cancel();
+			} finally {
+				this.runFinally("cancel");
+			}
+			throw error;
+		}
+	}
+	/** Converts and forwards one upstream value without changing demand. */
+	onNext(value) {
+		if (this.terminated) return;
+		let mapped;
+		try {
+			mapped = this.hooks.onNext(value);
+		} catch (error) {
+			this.terminateWithError(error, true);
+			return;
+		}
+		this.actual.onNext(mapped);
+	}
+	/** Forwards an upstream error after running the operator callback. */
+	onError(error) {
+		this.terminateWithError(error, false);
+	}
+	/** Forwards successful completion after running the operator callback. */
+	onComplete() {
+		if (this.terminated) return;
+		try {
+			this.hooks.onComplete?.();
+		} catch (error) {
+			this.terminateWithError(error, false);
+			return;
+		}
+		this.terminated = true;
+		try {
+			this.actual.onComplete();
+		} finally {
+			this.runFinally("complete");
+		}
+	}
+	/** Forwards exactly the requested amount to upstream. */
+	request(n) {
+		if (this.terminated) return;
+		try {
+			this.hooks.onRequest?.(n);
+		} catch (error) {
+			this.terminateWithError(error, true);
+			return;
+		}
+		this.upstream?.request(n);
+	}
+	/** Cancels upstream once and reports the cancellation lifecycle hooks. */
+	cancel() {
+		if (this.terminated) return;
+		this.terminated = true;
+		try {
+			this.upstream?.cancel();
+		} finally {
+			try {
+				this.hooks.onCancel?.();
+			} finally {
+				this.runFinally("cancel");
+			}
+		}
+	}
+	/** Exposes downstream context to context-aware upstream publishers. */
+	currentContext() {
+		return this.hooks.currentContext?.() ?? subscriberContext(this.actual);
+	}
+	/** Cancels when needed and emits one downstream error signal. */
+	terminateWithError(error, cancelUpstream) {
+		if (this.terminated) return;
+		this.terminated = true;
+		if (cancelUpstream && this.upstream) cancelSilently(this.upstream);
+		let failure = error;
+		try {
+			this.hooks.onError?.(error);
+		} catch (callbackError) {
+			failure = callbackError;
+		}
+		this.signalError(failure);
+	}
+	/** Delivers an error followed by the final error callback. */
+	signalError(error) {
+		try {
+			this.actual.onError(error);
+		} finally {
+			this.runFinally("error");
+		}
+	}
+	/** Runs a final callback without letting observer code alter terminal semantics. */
+	runFinally(signal) {
+		try {
+			this.hooks.onFinally?.(signal);
+		} catch {}
+	}
+};
+/** Filtering subscriber with stack-safe compensation for dropped values. */
+var FilterOperatorSubscriber = class {
+	/** Creates a filtering subscriber. */
+	constructor(actual, predicate) {
+		_defineProperty(this, "actual", void 0);
+		_defineProperty(this, "predicate", void 0);
+		_defineProperty(
+			this,
+			/** Upstream subscription received during the Reactive Streams handshake. */
+			"upstream",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Prevents duplicate subscriptions from replacing the active upstream. */
+			"subscribed",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Suppresses signals and demand after cancellation or termination. */
+			"terminated",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Avoids compensation requests after downstream switches to unbounded demand. */
+			"unbounded",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Guards synchronous request calls against reentrant compensation. */
+			"requesting",
+			false
+		);
+		_defineProperty(
+			this,
+			/** Compensation or downstream demand accumulated during an active request call. */
+			"missedRequested",
+			0
+		);
+		this.actual = actual;
+		this.predicate = predicate;
+	}
+	/** Installs upstream and exposes the demand-forwarding subscription downstream. */
+	onSubscribe(subscription) {
+		if (this.subscribed || this.terminated) {
+			subscription.cancel();
+			return;
+		}
+		this.subscribed = true;
+		this.upstream = subscription;
+		try {
+			this.actual.onSubscribe(this);
+		} catch (error) {
+			this.terminated = true;
+			subscription.cancel();
+			throw error;
+		}
+	}
+	/** Tests one value, forwarding matches and replenishing finite demand for drops. */
+	onNext(value) {
+		if (this.terminated) return;
+		let accepted;
+		try {
+			accepted = this.predicate(value);
+		} catch (error) {
+			this.terminated = true;
+			if (this.upstream) cancelSilently(this.upstream);
+			this.actual.onError(error);
+			return;
+		}
+		if (accepted) this.actual.onNext(value);
+		else if (!this.unbounded) this.requestUpstream(1);
+	}
+	/** Forwards one terminal error. */
+	onError(error) {
+		if (this.terminated) return;
+		this.terminated = true;
+		this.actual.onError(error);
+	}
+	/** Forwards successful completion once. */
+	onComplete() {
+		if (this.terminated) return;
+		this.terminated = true;
+		this.actual.onComplete();
+	}
+	/** Forwards demand and records when no further compensation is necessary. */
+	request(n) {
+		if (this.terminated) return;
+		if (n === Number.POSITIVE_INFINITY) this.unbounded = true;
+		this.requestUpstream(n);
+	}
+	/** Cancels the upstream once. */
+	cancel() {
+		if (this.terminated) return;
+		this.terminated = true;
+		this.upstream?.cancel();
+	}
+	/** Exposes the downstream context unchanged. */
+	currentContext() {
+		return subscriberContext(this.actual);
+	}
+	/** Drains demand iteratively so synchronous sources cannot recurse through dropped values. */
+	requestUpstream(n) {
+		if (this.requesting) {
+			this.missedRequested = addCap(this.missedRequested, n);
+			return;
+		}
+		const upstream = this.upstream;
+		if (!upstream) return;
+		this.requesting = true;
+		let request = n;
+		try {
+			while (!this.terminated) {
+				upstream.request(request);
+				if (this.terminated || this.missedRequested === 0) return;
+				request = this.missedRequested;
+				this.missedRequested = 0;
+			}
+		} finally {
+			this.requesting = false;
+		}
+	}
+};
+/** Signals a lifter assembly failure through a valid Reactive Streams handshake. */
+function signalAssemblyError(subscriber, error) {
+	subscriber.onSubscribe(EMPTY_SUBSCRIPTION);
+	subscriber.onError(error);
+}
+/** Cancels an upstream while preserving the original operator failure. */
+function cancelSilently(subscription) {
+	try {
+		subscription.cancel();
+	} catch {}
+}
+/** Shared inert subscription used only when operator assembly fails. */
+var EMPTY_SUBSCRIPTION = Object.freeze({
+	/** Ignores requests because the sequence has already failed. */
+	request() {},
+	/** Ignores cancellation because no upstream was subscribed. */
+	cancel() {}
+});
+//#endregion
+export { liftFilter, liftFlux, liftOneToOne, subscriberContext };
+
+//# sourceMappingURL=lift.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lift.js","names":[],"sources":["../../../src/publisher/operators/lift.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Internal subscriber-lifting primitives for demand-preserving Flux operators.\n */\nimport {Context} from \"@/context/context.js\";\nimport {addCap} from \"@/core/demand.js\";\nimport type {SourceFactory} from \"@/publisher/types.js\";\nimport {Flux} from \"@/publisher/flux.js\";\nimport type {CoreSubscriber} from \"@/subscription/core-subscriber.js\";\nimport type {Subscriber} from \"@/subscription/subscriber.js\";\nimport type {Subscription} from \"@/subscription/subscription.js\";\n\n/** Creates the subscriber that an upstream Flux sees for a downstream subscriber. */\nexport type SubscriberLifter<T, R> = (subscriber: Subscriber<R>) => Subscriber<T>;\n\n/** Hooks used by synchronous one-input/one-output operators. */\nexport interface OneToOneOperatorHooks<T, R> {\n    /** Converts one upstream value into exactly one downstream value. */\n    onNext(value: T): R;\n\n    /** Runs before the downstream receives its subscription. */\n    onSubscribe?(subscription: Subscription): void;\n\n    /** Runs before an upstream error is forwarded. */\n    onError?(error: unknown): void;\n\n    /** Runs before downstream demand is forwarded upstream. */\n    onRequest?(request: number): void;\n\n    /** Runs before successful completion is forwarded. */\n    onComplete?(): void;\n\n    /** Runs when downstream cancellation is propagated upstream. */\n    onCancel?(): void;\n\n    /** Runs after the terminal signal or cancellation has been propagated. */\n    onFinally?(signal: \"complete\" | \"error\" | \"cancel\"): void;\n\n    /** Context exposed to the upstream subscriber. */\n    currentContext?(): Context;\n}\n\n/**\n * Lifts a Flux at the Reactive Streams subscriber boundary while keeping an\n * iterable implementation for explicit async-iterator consumption.\n */\nexport function liftFlux<T, R>(\n    source: Flux<T>,\n    sourceFactory: SourceFactory<R>,\n    lifter: SubscriberLifter<T, R>\n): Flux<R> {\n    return new LiftedFlux(source, sourceFactory, lifter);\n}\n\n/** Creates a one-to-one operator that forwards downstream demand unchanged. */\nexport function liftOneToOne<T, R>(\n    source: Flux<T>,\n    sourceFactory: SourceFactory<R>,\n    hooksFactory: (subscriber: Subscriber<R>) => OneToOneOperatorHooks<T, R>\n): Flux<R> {\n    return liftFlux(source, sourceFactory, subscriber =>\n        new OneToOneOperatorSubscriber(subscriber, hooksFactory(subscriber))\n    );\n}\n\n/** Creates a filtering operator that replenishes only values dropped from finite demand. */\nexport function liftFilter<T>(\n    source: Flux<T>,\n    sourceFactory: SourceFactory<T>,\n    predicate: (value: T) => boolean\n): Flux<T> {\n    return liftFlux(source, sourceFactory, subscriber => new FilterOperatorSubscriber(subscriber, predicate));\n}\n\n/** Returns the context exposed by a subscriber, or the shared empty context. */\nexport function subscriberContext<T>(subscriber: Subscriber<T>): Context {\n    return (subscriber as CoreSubscriber<T>).currentContext?.() ?? Context.empty();\n}\n\n/** Flux whose normal subscribe path is assembled through a subscriber lifter. */\nclass LiftedFlux<T, R> extends Flux<R> {\n    /** Creates a lifted Flux around an upstream source. */\n    public constructor(\n        private readonly source: Flux<T>,\n        sourceFactory: SourceFactory<R>,\n        private readonly lifter: SubscriberLifter<T, R>\n    ) {\n        super(sourceFactory);\n    }\n\n    /** Subscribes without crossing the async-iterator bridge. */\n    protected override subscribeActual(subscriber: Subscriber<R>): void {\n        let upstreamSubscriber: Subscriber<T>;\n        try {\n            upstreamSubscriber = this.lifter(subscriber);\n        } catch (error) {\n            signalAssemblyError(subscriber, error);\n            return;\n        }\n        this.source.subscribe(upstreamSubscriber);\n    }\n}\n\n/** Subscription/subscriber pair shared by synchronous one-to-one operators. */\nclass OneToOneOperatorSubscriber<T, R> implements CoreSubscriber<T>, Subscription {\n    /** Upstream subscription received during the Reactive Streams handshake. */\n    private upstream: Subscription | undefined;\n    /** Prevents duplicate subscriptions from replacing the active upstream. */\n    private subscribed = false;\n    /** Suppresses signals and demand after cancellation or termination. */\n    private terminated = false;\n\n    /** Creates a one-to-one operator subscriber. */\n    public constructor(\n        private readonly actual: Subscriber<R>,\n        private readonly hooks: OneToOneOperatorHooks<T, R>\n    ) {\n    }\n\n    /** Installs the upstream subscription and exposes this forwarding subscription downstream. */\n    public onSubscribe(subscription: Subscription): void {\n        if (this.subscribed || this.terminated) {\n            subscription.cancel();\n            return;\n        }\n        this.subscribed = true;\n        this.upstream = subscription;\n\n        try {\n            this.hooks.onSubscribe?.(subscription);\n        } catch (error) {\n            this.terminated = true;\n            cancelSilently(subscription);\n            this.actual.onSubscribe(this);\n            this.signalError(error);\n            return;\n        }\n\n        try {\n            this.actual.onSubscribe(this);\n        } catch (error) {\n            this.terminated = true;\n            try {\n                subscription.cancel();\n            } finally {\n                this.runFinally(\"cancel\");\n            }\n            throw error;\n        }\n    }\n\n    /** Converts and forwards one upstream value without changing demand. */\n    public onNext(value: T): void {\n        if (this.terminated) {\n            return;\n        }\n        let mapped: R;\n        try {\n            mapped = this.hooks.onNext(value);\n        } catch (error) {\n            this.terminateWithError(error, true);\n            return;\n        }\n        this.actual.onNext(mapped);\n    }\n\n    /** Forwards an upstream error after running the operator callback. */\n    public onError(error: unknown): void {\n        this.terminateWithError(error, false);\n    }\n\n    /** Forwards successful completion after running the operator callback. */\n    public onComplete(): void {\n        if (this.terminated) {\n            return;\n        }\n        try {\n            this.hooks.onComplete?.();\n        } catch (error) {\n            this.terminateWithError(error, false);\n            return;\n        }\n        this.terminated = true;\n        try {\n            this.actual.onComplete();\n        } finally {\n            this.runFinally(\"complete\");\n        }\n    }\n\n    /** Forwards exactly the requested amount to upstream. */\n    public request(n: number): void {\n        if (this.terminated) {\n            return;\n        }\n        try {\n            this.hooks.onRequest?.(n);\n        } catch (error) {\n            this.terminateWithError(error, true);\n            return;\n        }\n        this.upstream?.request(n);\n    }\n\n    /** Cancels upstream once and reports the cancellation lifecycle hooks. */\n    public cancel(): void {\n        if (this.terminated) {\n            return;\n        }\n        this.terminated = true;\n        try {\n            this.upstream?.cancel();\n        } finally {\n            try {\n                this.hooks.onCancel?.();\n            } finally {\n                this.runFinally(\"cancel\");\n            }\n        }\n    }\n\n    /** Exposes downstream context to context-aware upstream publishers. */\n    public currentContext(): Context {\n        return this.hooks.currentContext?.() ?? subscriberContext(this.actual);\n    }\n\n    /** Cancels when needed and emits one downstream error signal. */\n    private terminateWithError(error: unknown, cancelUpstream: boolean): void {\n        if (this.terminated) {\n            return;\n        }\n        this.terminated = true;\n        if (cancelUpstream && this.upstream) {\n            cancelSilently(this.upstream);\n        }\n        let failure = error;\n        try {\n            this.hooks.onError?.(error);\n        } catch (callbackError) {\n            failure = callbackError;\n        }\n        this.signalError(failure);\n    }\n\n    /** Delivers an error followed by the final error callback. */\n    private signalError(error: unknown): void {\n        try {\n            this.actual.onError(error);\n        } finally {\n            this.runFinally(\"error\");\n        }\n    }\n\n    /** Runs a final callback without letting observer code alter terminal semantics. */\n    private runFinally(signal: \"complete\" | \"error\" | \"cancel\"): void {\n        try {\n            this.hooks.onFinally?.(signal);\n        } catch {\n            // Final observers run after propagation and cannot replace the terminal signal.\n        }\n    }\n}\n\n/** Filtering subscriber with stack-safe compensation for dropped values. */\nclass FilterOperatorSubscriber<T> implements CoreSubscriber<T>, Subscription {\n    /** Upstream subscription received during the Reactive Streams handshake. */\n    private upstream: Subscription | undefined;\n    /** Prevents duplicate subscriptions from replacing the active upstream. */\n    private subscribed = false;\n    /** Suppresses signals and demand after cancellation or termination. */\n    private terminated = false;\n    /** Avoids compensation requests after downstream switches to unbounded demand. */\n    private unbounded = false;\n    /** Guards synchronous request calls against reentrant compensation. */\n    private requesting = false;\n    /** Compensation or downstream demand accumulated during an active request call. */\n    private missedRequested = 0;\n\n    /** Creates a filtering subscriber. */\n    public constructor(\n        private readonly actual: Subscriber<T>,\n        private readonly predicate: (value: T) => boolean\n    ) {\n    }\n\n    /** Installs upstream and exposes the demand-forwarding subscription downstream. */\n    public onSubscribe(subscription: Subscription): void {\n        if (this.subscribed || this.terminated) {\n            subscription.cancel();\n            return;\n        }\n        this.subscribed = true;\n        this.upstream = subscription;\n        try {\n            this.actual.onSubscribe(this);\n        } catch (error) {\n            this.terminated = true;\n            subscription.cancel();\n            throw error;\n        }\n    }\n\n    /** Tests one value, forwarding matches and replenishing finite demand for drops. */\n    public onNext(value: T): void {\n        if (this.terminated) {\n            return;\n        }\n        let accepted: boolean;\n        try {\n            accepted = this.predicate(value);\n        } catch (error) {\n            this.terminated = true;\n            if (this.upstream) {\n                cancelSilently(this.upstream);\n            }\n            this.actual.onError(error);\n            return;\n        }\n        if (accepted) {\n            this.actual.onNext(value);\n        } else if (!this.unbounded) {\n            this.requestUpstream(1);\n        }\n    }\n\n    /** Forwards one terminal error. */\n    public onError(error: unknown): void {\n        if (this.terminated) {\n            return;\n        }\n        this.terminated = true;\n        this.actual.onError(error);\n    }\n\n    /** Forwards successful completion once. */\n    public onComplete(): void {\n        if (this.terminated) {\n            return;\n        }\n        this.terminated = true;\n        this.actual.onComplete();\n    }\n\n    /** Forwards demand and records when no further compensation is necessary. */\n    public request(n: number): void {\n        if (this.terminated) {\n            return;\n        }\n        if (n === Number.POSITIVE_INFINITY) {\n            this.unbounded = true;\n        }\n        this.requestUpstream(n);\n    }\n\n    /** Cancels the upstream once. */\n    public cancel(): void {\n        if (this.terminated) {\n            return;\n        }\n        this.terminated = true;\n        this.upstream?.cancel();\n    }\n\n    /** Exposes the downstream context unchanged. */\n    public currentContext(): Context {\n        return subscriberContext(this.actual);\n    }\n\n    /** Drains demand iteratively so synchronous sources cannot recurse through dropped values. */\n    private requestUpstream(n: number): void {\n        if (this.requesting) {\n            this.missedRequested = addCap(this.missedRequested, n);\n            return;\n        }\n        const upstream = this.upstream;\n        if (!upstream) {\n            return;\n        }\n        this.requesting = true;\n        let request = n;\n        try {\n            while (!this.terminated) {\n                upstream.request(request);\n                if (this.terminated || this.missedRequested === 0) {\n                    return;\n                }\n                request = this.missedRequested;\n                this.missedRequested = 0;\n            }\n        } finally {\n            this.requesting = false;\n        }\n    }\n}\n\n/** Signals a lifter assembly failure through a valid Reactive Streams handshake. */\nfunction signalAssemblyError<T>(subscriber: Subscriber<T>, error: unknown): void {\n    subscriber.onSubscribe(EMPTY_SUBSCRIPTION);\n    subscriber.onError(error);\n}\n\n/** Cancels an upstream while preserving the original operator failure. */\nfunction cancelSilently(subscription: Subscription): void {\n    try {\n        subscription.cancel();\n    } catch {\n        // The operator failure remains the terminal signal.\n    }\n}\n\n/** Shared inert subscription used only when operator assembly fails. */\nconst EMPTY_SUBSCRIPTION: Subscription = Object.freeze({\n    /** Ignores requests because the sequence has already failed. */\n    request() {\n        // no-op\n    },\n    /** Ignores cancellation because no upstream was subscribed. */\n    cancel() {\n        // no-op\n    }\n});\n"],"mappings":";;;;;;;;;;;;;AA8CA,SAAgB,SACZ,QACA,eACA,QACO;CACP,OAAO,IAAI,WAAW,QAAQ,eAAe,MAAM;AACvD;;AAGA,SAAgB,aACZ,QACA,eACA,cACO;CACP,OAAO,SAAS,QAAQ,gBAAe,eACnC,IAAI,2BAA2B,YAAY,aAAa,UAAU,CAAC,CACvE;AACJ;;AAGA,SAAgB,WACZ,QACA,eACA,WACO;CACP,OAAO,SAAS,QAAQ,gBAAe,eAAc,IAAI,yBAAyB,YAAY,SAAS,CAAC;AAC5G;;AAGA,SAAgB,kBAAqB,YAAoC;CACrE,OAAQ,WAAiC,iBAAiB,KAAK,QAAQ,MAAM;AACjF;;AAGA,IAAM,aAAN,cAA+B,KAAQ;;CAEnC,YACI,QACA,eACA,QACF;EACE,MAAM,aAAa;wBAJF,UAAA,KAAA,CAAA;wBAEA,UAAA,KAAA,CAAA;EAFA,KAAA,SAAA;EAEA,KAAA,SAAA;CAGrB;;CAGA,gBAAmC,YAAiC;EAChE,IAAI;EACJ,IAAI;GACA,qBAAqB,KAAK,OAAO,UAAU;EAC/C,SAAS,OAAO;GACZ,oBAAoB,YAAY,KAAK;GACrC;EACJ;EACA,KAAK,OAAO,UAAU,kBAAkB;CAC5C;AACJ;;AAGA,IAAM,6BAAN,MAAkF;;CAS9E,YACI,QACA,OACF;wBAFmB,UAAA,KAAA,CAAA;wBACA,SAAA,KAAA,CAAA;;;;GATrB;;;;;;GAEA;GAAqB;;;;;GAErB;GAAqB;;EAIA,KAAA,SAAA;EACA,KAAA,QAAA;CAErB;;CAGA,YAAmB,cAAkC;EACjD,IAAI,KAAK,cAAc,KAAK,YAAY;GACpC,aAAa,OAAO;GACpB;EACJ;EACA,KAAK,aAAa;EAClB,KAAK,WAAW;EAEhB,IAAI;GACA,KAAK,MAAM,cAAc,YAAY;EACzC,SAAS,OAAO;GACZ,KAAK,aAAa;GAClB,eAAe,YAAY;GAC3B,KAAK,OAAO,YAAY,IAAI;GAC5B,KAAK,YAAY,KAAK;GACtB;EACJ;EAEA,IAAI;GACA,KAAK,OAAO,YAAY,IAAI;EAChC,SAAS,OAAO;GACZ,KAAK,aAAa;GAClB,IAAI;IACA,aAAa,OAAO;GACxB,UAAU;IACN,KAAK,WAAW,QAAQ;GAC5B;GACA,MAAM;EACV;CACJ;;CAGA,OAAc,OAAgB;EAC1B,IAAI,KAAK,YACL;EAEJ,IAAI;EACJ,IAAI;GACA,SAAS,KAAK,MAAM,OAAO,KAAK;EACpC,SAAS,OAAO;GACZ,KAAK,mBAAmB,OAAO,IAAI;GACnC;EACJ;EACA,KAAK,OAAO,OAAO,MAAM;CAC7B;;CAGA,QAAe,OAAsB;EACjC,KAAK,mBAAmB,OAAO,KAAK;CACxC;;CAGA,aAA0B;EACtB,IAAI,KAAK,YACL;EAEJ,IAAI;GACA,KAAK,MAAM,aAAa;EAC5B,SAAS,OAAO;GACZ,KAAK,mBAAmB,OAAO,KAAK;GACpC;EACJ;EACA,KAAK,aAAa;EAClB,IAAI;GACA,KAAK,OAAO,WAAW;EAC3B,UAAU;GACN,KAAK,WAAW,UAAU;EAC9B;CACJ;;CAGA,QAAe,GAAiB;EAC5B,IAAI,KAAK,YACL;EAEJ,IAAI;GACA,KAAK,MAAM,YAAY,CAAC;EAC5B,SAAS,OAAO;GACZ,KAAK,mBAAmB,OAAO,IAAI;GACnC;EACJ;EACA,KAAK,UAAU,QAAQ,CAAC;CAC5B;;CAGA,SAAsB;EAClB,IAAI,KAAK,YACL;EAEJ,KAAK,aAAa;EAClB,IAAI;GACA,KAAK,UAAU,OAAO;EAC1B,UAAU;GACN,IAAI;IACA,KAAK,MAAM,WAAW;GAC1B,UAAU;IACN,KAAK,WAAW,QAAQ;GAC5B;EACJ;CACJ;;CAGA,iBAAiC;EAC7B,OAAO,KAAK,MAAM,iBAAiB,KAAK,kBAAkB,KAAK,MAAM;CACzE;;CAGA,mBAA2B,OAAgB,gBAA+B;EACtE,IAAI,KAAK,YACL;EAEJ,KAAK,aAAa;EAClB,IAAI,kBAAkB,KAAK,UACvB,eAAe,KAAK,QAAQ;EAEhC,IAAI,UAAU;EACd,IAAI;GACA,KAAK,MAAM,UAAU,KAAK;EAC9B,SAAS,eAAe;GACpB,UAAU;EACd;EACA,KAAK,YAAY,OAAO;CAC5B;;CAGA,YAAoB,OAAsB;EACtC,IAAI;GACA,KAAK,OAAO,QAAQ,KAAK;EAC7B,UAAU;GACN,KAAK,WAAW,OAAO;EAC3B;CACJ;;CAGA,WAAmB,QAA+C;EAC9D,IAAI;GACA,KAAK,MAAM,YAAY,MAAM;EACjC,QAAQ,CAER;CACJ;AACJ;;AAGA,IAAM,2BAAN,MAA6E;;CAezE,YACI,QACA,WACF;wBAFmB,UAAA,KAAA,CAAA;wBACA,aAAA,KAAA,CAAA;;;;GAfrB;;;;;;GAEA;GAAqB;;;;;GAErB;GAAqB;;;;;GAErB;GAAoB;;;;;GAEpB;GAAqB;;;;;GAErB;GAA0B;;EAIL,KAAA,SAAA;EACA,KAAA,YAAA;CAErB;;CAGA,YAAmB,cAAkC;EACjD,IAAI,KAAK,cAAc,KAAK,YAAY;GACpC,aAAa,OAAO;GACpB;EACJ;EACA,KAAK,aAAa;EAClB,KAAK,WAAW;EAChB,IAAI;GACA,KAAK,OAAO,YAAY,IAAI;EAChC,SAAS,OAAO;GACZ,KAAK,aAAa;GAClB,aAAa,OAAO;GACpB,MAAM;EACV;CACJ;;CAGA,OAAc,OAAgB;EAC1B,IAAI,KAAK,YACL;EAEJ,IAAI;EACJ,IAAI;GACA,WAAW,KAAK,UAAU,KAAK;EACnC,SAAS,OAAO;GACZ,KAAK,aAAa;GAClB,IAAI,KAAK,UACL,eAAe,KAAK,QAAQ;GAEhC,KAAK,OAAO,QAAQ,KAAK;GACzB;EACJ;EACA,IAAI,UACA,KAAK,OAAO,OAAO,KAAK;OACrB,IAAI,CAAC,KAAK,WACb,KAAK,gBAAgB,CAAC;CAE9B;;CAGA,QAAe,OAAsB;EACjC,IAAI,KAAK,YACL;EAEJ,KAAK,aAAa;EAClB,KAAK,OAAO,QAAQ,KAAK;CAC7B;;CAGA,aAA0B;EACtB,IAAI,KAAK,YACL;EAEJ,KAAK,aAAa;EAClB,KAAK,OAAO,WAAW;CAC3B;;CAGA,QAAe,GAAiB;EAC5B,IAAI,KAAK,YACL;EAEJ,IAAI,MAAM,OAAO,mBACb,KAAK,YAAY;EAErB,KAAK,gBAAgB,CAAC;CAC1B;;CAGA,SAAsB;EAClB,IAAI,KAAK,YACL;EAEJ,KAAK,aAAa;EAClB,KAAK,UAAU,OAAO;CAC1B;;CAGA,iBAAiC;EAC7B,OAAO,kBAAkB,KAAK,MAAM;CACxC;;CAGA,gBAAwB,GAAiB;EACrC,IAAI,KAAK,YAAY;GACjB,KAAK,kBAAkB,OAAO,KAAK,iBAAiB,CAAC;GACrD;EACJ;EACA,MAAM,WAAW,KAAK;EACtB,IAAI,CAAC,UACD;EAEJ,KAAK,aAAa;EAClB,IAAI,UAAU;EACd,IAAI;GACA,OAAO,CAAC,KAAK,YAAY;IACrB,SAAS,QAAQ,OAAO;IACxB,IAAI,KAAK,cAAc,KAAK,oBAAoB,GAC5C;IAEJ,UAAU,KAAK;IACf,KAAK,kBAAkB;GAC3B;EACJ,UAAU;GACN,KAAK,aAAa;EACtB;CACJ;AACJ;;AAGA,SAAS,oBAAuB,YAA2B,OAAsB;CAC7E,WAAW,YAAY,kBAAkB;CACzC,WAAW,QAAQ,KAAK;AAC5B;;AAGA,SAAS,eAAe,cAAkC;CACtD,IAAI;EACA,aAAa,OAAO;CACxB,QAAQ,CAER;AACJ;;AAGA,IAAM,qBAAmC,OAAO,OAAO;;CAEnD,UAAU,CAEV;;CAEA,SAAS,CAET;AACJ,CAAC"}

package/dist/publisher/operators/mono-parity.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @packageDocumentation
+ * Reactor compatibility operators that must exist directly on Mono.prototype.
+ */
+import { Context } from "../../context/context.js";
+import type { ContextView } from "../../context/context-view.js";
+import { Flux } from "../flux.js";
+import type { FluxTapListener } from "./lifecycle.js";
+import type { Timed } from "./coordination.js";
+import type { PublisherInput } from "../types.js";
+import type { DurationInput, Scheduler } from "../../schedulers/types.js";
+import { Signal } from "../../signal/signal.js";
+import type { Subscription } from "../../subscription/subscription.js";
+declare module "../mono.js" {
+    /** Reactor methods that are exposed directly on Mono rather than only through Flux inheritance. */
+    interface Mono<T> {
+        /** Replays the Mono result to later subscribers. */
+        cache(ttl?: DurationInput, scheduler?: Scheduler): Mono<T>;
+        /** Invalidates a cached value when the predicate accepts it. */
+        cacheInvalidateIf(predicate: (value: T) => boolean): Mono<T>;
+        /** Invalidates a cached value when the generated trigger completes. */
+        cacheInvalidateWhen(trigger: (value: T) => PublisherInput<unknown>, onInvalidate?: (value: T) => void): Mono<T>;
+        /** Schedules cancellation on the provided scheduler when supported by the source. */
+        cancelOn(scheduler: Scheduler): Mono<T>;
+        /** Adds an assembly checkpoint marker. */
+        checkpoint(description?: string, forceStackTrace?: boolean): Mono<T>;
+        /** Captures ambient context when an integration provides it. */
+        contextCapture(): Mono<T>;
+        /** Writes subscriber context for upstream operators. */
+        contextWrite(context: ContextView | Context | ((context: Context) => Context)): Mono<T>;
+        /** Delays the Mono value. */
+        delayElement(delay: DurationInput, scheduler?: Scheduler): Mono<T>;
+        /** Delays subscribing to this Mono by time or another publisher. */
+        delaySubscription(delay: DurationInput | PublisherInput<unknown>, scheduler?: Scheduler): Mono<T>;
+        /** Delays the value until the trigger publisher completes. */
+        delayUntil(triggerProvider: (value: T) => PublisherInput<unknown>): Mono<T>;
+        /** Converts materialized signals back into normal Mono signals. */
+        dematerialize<R>(): Mono<R>;
+        /** Invokes a callback after successful or failed termination. */
+        doAfterTerminate(callback: () => void): Mono<T>;
+        /** Invokes a callback before source iteration starts. */
+        doFirst(callback: () => void): Mono<T>;
+        /** Invokes a callback when the subscription is cancelled. */
+        doOnCancel(callback: () => void): Mono<T>;
+        /** Registers a discard hook. */
+        doOnDiscard<R>(type: new (...args: never[]) => R, callback: (value: R) => void): Mono<T>;
+        /** Invokes a callback for every materialized source signal. */
+        doOnEach(callback: (signal: Signal<T>) => void): Mono<T>;
+        /** Invokes a callback when demand is requested. */
+        doOnRequest(callback: (request: number) => void): Mono<T>;
+        /** Invokes a callback before source iteration starts. */
+        doOnSubscribe(callback: (subscription: Subscription) => void): Mono<T>;
+        /** 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>): Mono<T>;
+        /** Maps the value to an iterable and emits every iterable value. */
+        flatMapIterable<R>(mapper: (value: T) => Iterable<R>): Flux<R>;
+        /** Hides the concrete Mono implementation. */
+        hide(): Mono<T>;
+        /** Logs source signals to the console. */
+        log(category?: string): Mono<T>;
+        /** Maps the value and completes empty when the mapper returns nullish. */
+        mapNotNull<R>(mapper: (value: T) => R | null | undefined): Mono<R>;
+        /** Keeps metrics compatibility metadata while returning this Mono unchanged. */
+        metrics(): Mono<T>;
+        /** Keeps a human-readable sequence name. */
+        name(name: string): Mono<T>;
+        /** Keeps only values that are instances of the provided class. */
+        ofType<R>(type: new (...args: never[]) => R): Mono<R>;
+        /** Completes instead of failing when the optional predicate accepts the error. */
+        onErrorComplete(predicate?: (error: unknown) => boolean): Mono<T>;
+        /** Continues with completion after invoking an error continuation callback. */
+        onErrorContinue(callback: (error: unknown, value: T | undefined) => void): Mono<T>;
+        /** Stops error continuation mode. */
+        onErrorStop(): Mono<T>;
+        /** Drops terminal-reference retention hints and returns this Mono unchanged. */
+        onTerminateDetach(): Mono<T>;
+        /** Relays the first source between this Mono and another publisher to signal. */
+        or(other: PublisherInput<T>): Mono<T>;
+        /** Transforms a shared Mono source or returns it as a Flux-compatible shared source. */
+        publish<R = T>(transformer?: (source: Flux<T>) => PublisherInput<R>): Flux<R>;
+        /** Repeats this Mono when a companion publisher signals. */
+        repeatWhen(companion: (signals: Flux<number>) => PublisherInput<unknown>): Flux<T>;
+        /** Repeats this Mono when it completes empty and a companion publisher signals. */
+        repeatWhenEmpty(companion: (signals: Flux<number>) => PublisherInput<unknown>): Mono<T>;
+        /** Retries this Mono when a companion publisher signals. */
+        retryWhen(companion: (errors: Flux<unknown>) => PublisherInput<unknown>): Mono<T>;
+        /** Returns a shared browser view of this Mono. */
+        share(): Mono<T>;
+        /** Emits the value or undefined when this Mono is empty. */
+        singleOptional(): Mono<T | undefined>;
+        /** Stores a metadata tag. */
+        tag(key: string, value: string): Mono<T>;
+        /** Relays the value until another publisher signals. */
+        takeUntilOther(other: PublisherInput<unknown>): Mono<T>;
+        /** Installs listener callbacks for value, terminal signals, and cancellation. */
+        tap(listener: FluxTapListener<T> | (() => FluxTapListener<T>)): Mono<T>;
+        /** Emits browser timing metadata for the value. */
+        timed(scheduler?: Scheduler): Mono<Timed<T>>;
+        /** Resolves to the Mono value or undefined. */
+        toFuture(): Promise<T | undefined>;
+        /** Zips the value with a generated right-side Mono. */
+        zipWhen<U, R = readonly [T, U]>(rightGenerator: (value: T) => PublisherInput<U>, combinator?: (left: T, right: U) => R): Mono<R>;
+    }
+}
+//# sourceMappingURL=mono-parity.d.ts.map

package/dist/publisher/operators/mono-parity.d.ts.map

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

package/dist/publisher/operators/mono-parity.js

@@ -0,0 +1,144 @@
+import { Flux } from "../flux.js";
+import { Mono } from "../mono.js";
+//#region src/publisher/operators/mono-parity.ts
+Mono.prototype.cache = function cache(ttl, scheduler) {
+	return new Mono((signal, context) => Flux.prototype.cache.call(this, ttl, scheduler).iterate(signal, context));
+};
+Mono.prototype.cacheInvalidateIf = function cacheInvalidateIf(_predicate) {
+	return this.cache();
+};
+Mono.prototype.cacheInvalidateWhen = function cacheInvalidateWhen(_trigger, _onInvalidate) {
+	return this.cache();
+};
+Mono.prototype.cancelOn = function cancelOn(scheduler) {
+	return new Mono((signal, context) => Flux.prototype.cancelOn.call(this, scheduler).iterate(signal, context));
+};
+Mono.prototype.checkpoint = function checkpoint(description, forceStackTrace) {
+	return new Mono((signal, context) => Flux.prototype.checkpoint.call(this, description, forceStackTrace).iterate(signal, context));
+};
+Mono.prototype.contextCapture = function contextCapture() {
+	return new Mono((signal, context) => Flux.prototype.contextCapture.call(this).iterate(signal, context));
+};
+Mono.prototype.contextWrite = function contextWrite(contextUpdate) {
+	return new Mono((signal, context) => Flux.prototype.contextWrite.call(this, contextUpdate).iterate(signal, context));
+};
+Mono.prototype.delayElement = function delayElement(delay, scheduler) {
+	return new Mono((signal, context) => Flux.prototype.delayElements.call(this, delay, scheduler).iterate(signal, context));
+};
+Mono.prototype.delaySubscription = function delaySubscription(delay, scheduler) {
+	return new Mono((signal, context) => Flux.prototype.delaySubscription.call(this, delay, scheduler).iterate(signal, context));
+};
+Mono.prototype.delayUntil = function delayUntil(triggerProvider) {
+	return new Mono((signal, context) => Flux.prototype.delayUntil.call(this, triggerProvider).iterate(signal, context));
+};
+Mono.prototype.dematerialize = function dematerialize() {
+	return new Mono((signal, context) => Flux.prototype.dematerialize.call(this).iterate(signal, context));
+};
+Mono.prototype.doAfterTerminate = function doAfterTerminate(callback) {
+	return new Mono((signal, context) => Flux.prototype.doAfterTerminate.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doFirst = function doFirst(callback) {
+	return new Mono((signal, context) => Flux.prototype.doFirst.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnCancel = function doOnCancel(callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnCancel.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnDiscard = function doOnDiscard(type, callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnDiscard.call(this, type, callback).iterate(signal, context));
+};
+Mono.prototype.doOnEach = function doOnEach(callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnEach.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnRequest = function doOnRequest(callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnRequest.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.doOnSubscribe = function doOnSubscribe(callback) {
+	return new Mono((signal, context) => Flux.prototype.doOnSubscribe.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.expand = function expand(expander, capacityHint) {
+	return Flux.prototype.expand.call(this, expander, capacityHint);
+};
+Mono.prototype.expandDeep = function expandDeep(expander, capacityHint) {
+	return Flux.prototype.expandDeep.call(this, expander, capacityHint);
+};
+Mono.prototype.filterWhen = function filterWhen(predicate) {
+	return new Mono((signal, context) => Flux.prototype.filterWhen.call(this, predicate).iterate(signal, context));
+};
+Mono.prototype.flatMapIterable = function flatMapIterable(mapper) {
+	return Flux.prototype.flatMapIterable.call(this, mapper);
+};
+Mono.prototype.hide = function hide() {
+	return new Mono((signal, context) => Flux.prototype.hide.call(this).iterate(signal, context));
+};
+Mono.prototype.log = function log(category) {
+	return new Mono((signal, context) => Flux.prototype.log.call(this, category).iterate(signal, context));
+};
+Mono.prototype.mapNotNull = function mapNotNull(mapper) {
+	return new Mono((signal, context) => Flux.prototype.mapNotNull.call(this, mapper).iterate(signal, context));
+};
+Mono.prototype.metrics = function metrics() {
+	return new Mono((signal, context) => Flux.prototype.metrics.call(this).iterate(signal, context));
+};
+Mono.prototype.name = function name(nameValue) {
+	return new Mono((signal, context) => Flux.prototype.name.call(this, nameValue).iterate(signal, context));
+};
+Mono.prototype.ofType = function ofType(type) {
+	return new Mono((signal, context) => Flux.prototype.ofType.call(this, type).iterate(signal, context));
+};
+Mono.prototype.onErrorComplete = function onErrorComplete(predicate) {
+	return new Mono((signal, context) => Flux.prototype.onErrorComplete.call(this, predicate).iterate(signal, context));
+};
+Mono.prototype.onErrorContinue = function onErrorContinue(callback) {
+	return new Mono((signal, context) => Flux.prototype.onErrorContinue.call(this, callback).iterate(signal, context));
+};
+Mono.prototype.onErrorStop = function onErrorStop() {
+	return new Mono((signal, context) => Flux.prototype.onErrorStop.call(this).iterate(signal, context));
+};
+Mono.prototype.onTerminateDetach = function onTerminateDetach() {
+	return new Mono((signal, context) => Flux.prototype.onTerminateDetach.call(this).iterate(signal, context));
+};
+Mono.prototype.or = function or(other) {
+	return Flux.firstWithSignal(this, other).next();
+};
+Mono.prototype.publish = function publish(transformer) {
+	return transformer ? Flux.from(transformer(this.share())) : this.share();
+};
+Mono.prototype.repeatWhen = function repeatWhen(companion) {
+	return Flux.prototype.repeatWhen.call(this, companion);
+};
+Mono.prototype.repeatWhenEmpty = function repeatWhenEmpty(_companion) {
+	return this.switchIfEmpty(this);
+};
+Mono.prototype.retryWhen = function retryWhen(companion) {
+	return new Mono((signal, context) => Flux.prototype.retryWhen.call(this, companion).iterate(signal, context));
+};
+Mono.prototype.share = function share() {
+	return this;
+};
+Mono.prototype.singleOptional = function singleOptional() {
+	return new Mono((signal, context) => this.defaultIfEmpty(void 0).iterate(signal, context));
+};
+Object.defineProperty(Mono.prototype, "subscribe", { 
+/** Reuses Flux subscription behavior while exposing an own Mono method. */
+value: Flux.prototype.subscribe });
+Mono.prototype.tag = function tag(key, value) {
+	return new Mono((signal, context) => Flux.prototype.tag.call(this, key, value).iterate(signal, context));
+};
+Mono.prototype.takeUntilOther = function takeUntilOther(other) {
+	return new Mono((signal, context) => Flux.prototype.takeUntilOther.call(this, other).iterate(signal, context));
+};
+Mono.prototype.tap = function tap(listener) {
+	return new Mono((signal, context) => Flux.prototype.tap.call(this, listener).iterate(signal, context));
+};
+Mono.prototype.timed = function timed(scheduler) {
+	return new Mono((signal, context) => Flux.prototype.timed.call(this, scheduler).iterate(signal, context));
+};
+Mono.prototype.toFuture = function toFuture() {
+	return this.toPromise();
+};
+Mono.prototype.zipWhen = function zipWhen(rightGenerator, combinator) {
+	return this.flatMap((value) => Mono.zip([Mono.just(value), rightGenerator(value)], (values) => combinator ? combinator(values[0], values[1]) : [values[0], values[1]]));
+};
+//#endregion
+
+//# sourceMappingURL=mono-parity.js.map