reactor-core-ts 2.1.6 → 3.2.1

package/dist/publisher/operators/transform.js

@@ -0,0 +1,74 @@
+import { filterIterable, mapIterable } from "../../internal/iterable-transform.js";
+import { Flux } from "../flux.js";
+import { Signal } from "../../signal/signal.js";
+//#region src/publisher/operators/transform.ts
+Flux.prototype.map = function map(mapper) {
+	const source = this;
+	return new Flux((signal, context) => mapIterable(source.iterate(signal, context), mapper));
+};
+Flux.prototype.cast = function cast() {
+	return this;
+};
+Flux.prototype.filter = function filter(predicate) {
+	const source = this;
+	return new Flux((signal, context) => filterIterable(source.iterate(signal, context), predicate));
+};
+Flux.prototype.handle = function handle(handler) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		for await (const value of source.iterate(signal, context)) {
+			let done = false;
+			let output;
+			handler(value, {
+				/** Emits one mapped value for the current source value. */
+				next(nextValue) {
+					if (done) throw new Error("SynchronousSink allows only one signal per source value");
+					output = nextValue;
+					done = true;
+				},
+				/** Suppresses emission for the current source value. */
+				complete() {
+					done = true;
+				},
+				/** Fails the sequence with the provided error. */
+				error(error) {
+					throw error;
+				}
+			});
+			if (done && output !== void 0) yield output;
+		}
+	});
+};
+Flux.prototype.materialize = function materialize() {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		try {
+			for await (const value of source.iterate(signal, context)) yield Signal.next(value);
+			yield Signal.complete();
+		} catch (error) {
+			yield Signal.error(error);
+		}
+	});
+};
+Flux.prototype.dematerialize = function dematerialize() {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		for await (const signalValue of source.iterate(signal, context)) if (signalValue.isOnNext()) yield signalValue.get();
+		else if (signalValue.isOnError()) throw signalValue.getThrowable();
+		else if (signalValue.isOnComplete()) return;
+	});
+};
+Flux.prototype.transform = function transform(transformer) {
+	return Flux.from(transformer(this));
+};
+Flux.prototype.transformDeferred = function transformDeferred(transformer) {
+	const source = this;
+	return Flux.defer(() => transformer(source));
+};
+Flux.prototype.transformDeferredContextual = function transformDeferredContextual(transformer) {
+	const source = this;
+	return new Flux((signal, context) => Flux.from(transformer(source, context.readOnly())).iterate(signal, context));
+};
+//#endregion
+
+//# sourceMappingURL=transform.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","names":[],"sources":["../../../src/publisher/operators/transform.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Flux, Mono and operator implementation modules.\n */\nimport type {ContextView} from \"@/context/context-view.js\";\nimport {filterIterable, mapIterable} from \"@/internal/iterable-transform.js\";\nimport {Flux} from \"@/publisher/flux.js\";\nimport type {Mapper, PublisherInput, SynchronousSink} from \"@/publisher/types.js\";\nimport {Signal} from \"@/signal/signal.js\";\n\ndeclare module \"@/publisher/flux.js\" {\n    /** Transforming and materialization operators added to Flux. */\n    interface Flux<T> {\n        /** Maps each source value with the provided function. */\n        map<R>(mapper: Mapper<T, R>): Flux<R>;\n\n        /** Treats this Flux as a Flux of another TypeScript type. */\n        cast<R>(): Flux<R>;\n\n        /** Keeps only source values accepted by the predicate. */\n        filter(predicate: (value: T) => boolean): Flux<T>;\n\n        /** Handles each value with a synchronous sink that may emit, complete, or fail. */\n        handle<R>(handler: (value: T, sink: SynchronousSink<R>) => void): Flux<R>;\n\n        /** Converts values and terminal events into `Signal` values. */\n        materialize(): Flux<Signal<T>>;\n\n        /** Converts `Signal` values back into normal values and terminal events. */\n        dematerialize<R>(this: Flux<Signal<R>>): Flux<R>;\n\n        /** Applies a transformer to this Flux immediately and adapts its result. */\n        transform<R>(transformer: (source: Flux<T>) => PublisherInput<R>): Flux<R>;\n\n        /** Applies a transformer separately for each subscription. */\n        transformDeferred<R>(transformer: (source: Flux<T>) => PublisherInput<R>): Flux<R>;\n\n        /** Applies a transformer per subscription with access to the subscriber context. */\n        transformDeferredContextual<R>(transformer: (source: Flux<T>, context: ContextView) => PublisherInput<R>): Flux<R>;\n    }\n}\n\nFlux.prototype.map = function map<T, R>(this: Flux<T>, mapper: Mapper<T, R>): Flux<R> {\n    const source = this;\n    return new Flux((signal, context) => mapIterable(source.iterate(signal, context), mapper));\n};\n\nFlux.prototype.cast = function cast<T, R>(this: Flux<T>): Flux<R> {\n    return this as unknown as Flux<R>;\n};\n\nFlux.prototype.filter = function filter<T>(this: Flux<T>, predicate: (value: T) => boolean): Flux<T> {\n    const source = this;\n    return new Flux((signal, context) => filterIterable(source.iterate(signal, context), predicate));\n};\n\nFlux.prototype.handle = function handle<T, R>(\n    this: Flux<T>,\n    handler: (value: T, sink: SynchronousSink<R>) => void\n): Flux<R> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        for await (const value of source.iterate(signal, context)) {\n            let done = false;\n            let output: R | undefined;\n            const sink: SynchronousSink<R> = {\n                /** Emits one mapped value for the current source value. */\n                next(nextValue) {\n                    if (done) {\n                        throw new Error(\"SynchronousSink allows only one signal per source value\");\n                    }\n                    output = nextValue;\n                    done = true;\n                },\n                /** Suppresses emission for the current source value. */\n                complete() {\n                    done = true;\n                },\n                /** Fails the sequence with the provided error. */\n                error(error) {\n                    throw error;\n                }\n            };\n            handler(value, sink);\n            if (done && output !== undefined) {\n                yield output;\n            }\n        }\n    });\n};\n\nFlux.prototype.materialize = function materialize<T>(this: Flux<T>): Flux<Signal<T>> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        try {\n            for await (const value of source.iterate(signal, context)) {\n                yield Signal.next(value);\n            }\n            yield Signal.complete();\n        } catch (error) {\n            yield Signal.error(error);\n        }\n    });\n};\n\nFlux.prototype.dematerialize = function dematerialize<R>(this: Flux<Signal<R>>): Flux<R> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        for await (const signalValue of source.iterate(signal, context)) {\n            if (signalValue.isOnNext()) {\n                yield signalValue.get() as R;\n            } else if (signalValue.isOnError()) {\n                throw signalValue.getThrowable();\n            } else if (signalValue.isOnComplete()) {\n                return;\n            }\n        }\n    });\n};\n\nFlux.prototype.transform = function transform<T, R>(\n    this: Flux<T>,\n    transformer: (source: Flux<T>) => PublisherInput<R>\n): Flux<R> {\n    return Flux.from(transformer(this));\n};\n\nFlux.prototype.transformDeferred = function transformDeferred<T, R>(\n    this: Flux<T>,\n    transformer: (source: Flux<T>) => PublisherInput<R>\n): Flux<R> {\n    const source = this;\n    return Flux.defer(() => transformer(source));\n};\n\nFlux.prototype.transformDeferredContextual = function transformDeferredContextual<T, R>(\n    this: Flux<T>,\n    transformer: (source: Flux<T>, context: ContextView) => PublisherInput<R>\n): Flux<R> {\n    const source = this;\n    return new Flux((signal, context) => Flux.from(transformer(source, context.readOnly())).iterate(signal, context));\n};\n"],"mappings":";;;;AA0CA,KAAK,UAAU,MAAM,SAAS,IAAyB,QAA+B;CAClF,MAAM,SAAS;CACf,OAAO,IAAI,MAAM,QAAQ,YAAY,YAAY,OAAO,QAAQ,QAAQ,OAAO,GAAG,MAAM,CAAC;AAC7F;AAEA,KAAK,UAAU,OAAO,SAAS,OAAmC;CAC9D,OAAO;AACX;AAEA,KAAK,UAAU,SAAS,SAAS,OAAyB,WAA2C;CACjG,MAAM,SAAS;CACf,OAAO,IAAI,MAAM,QAAQ,YAAY,eAAe,OAAO,QAAQ,QAAQ,OAAO,GAAG,SAAS,CAAC;AACnG;AAEA,KAAK,UAAU,SAAS,SAAS,OAE7B,SACO;CACP,MAAM,SAAS;CACf,OAAO,IAAI,KAAK,iBAAiB,QAAQ,SAAS;EAC9C,WAAW,MAAM,SAAS,OAAO,QAAQ,QAAQ,OAAO,GAAG;GACvD,IAAI,OAAO;GACX,IAAI;GAmBJ,QAAQ,OAAO;;IAhBX,KAAK,WAAW;KACZ,IAAI,MACA,MAAM,IAAI,MAAM,yDAAyD;KAE7E,SAAS;KACT,OAAO;IACX;;IAEA,WAAW;KACP,OAAO;IACX;;IAEA,MAAM,OAAO;KACT,MAAM;IACV;GAEW,CAAI;GACnB,IAAI,QAAQ,WAAW,QACnB,MAAM;EAEd;CACJ,CAAC;AACL;AAEA,KAAK,UAAU,cAAc,SAAS,cAA+C;CACjF,MAAM,SAAS;CACf,OAAO,IAAI,KAAK,iBAAiB,QAAQ,SAAS;EAC9C,IAAI;GACA,WAAW,MAAM,SAAS,OAAO,QAAQ,QAAQ,OAAO,GACpD,MAAM,OAAO,KAAK,KAAK;GAE3B,MAAM,OAAO,SAAS;EAC1B,SAAS,OAAO;GACZ,MAAM,OAAO,MAAM,KAAK;EAC5B;CACJ,CAAC;AACL;AAEA,KAAK,UAAU,gBAAgB,SAAS,gBAAiD;CACrF,MAAM,SAAS;CACf,OAAO,IAAI,KAAK,iBAAiB,QAAQ,SAAS;EAC9C,WAAW,MAAM,eAAe,OAAO,QAAQ,QAAQ,OAAO,GAC1D,IAAI,YAAY,SAAS,GACrB,MAAM,YAAY,IAAI;OACnB,IAAI,YAAY,UAAU,GAC7B,MAAM,YAAY,aAAa;OAC5B,IAAI,YAAY,aAAa,GAChC;CAGZ,CAAC;AACL;AAEA,KAAK,UAAU,YAAY,SAAS,UAEhC,aACO;CACP,OAAO,KAAK,KAAK,YAAY,IAAI,CAAC;AACtC;AAEA,KAAK,UAAU,oBAAoB,SAAS,kBAExC,aACO;CACP,MAAM,SAAS;CACf,OAAO,KAAK,YAAY,YAAY,MAAM,CAAC;AAC/C;AAEA,KAAK,UAAU,8BAA8B,SAAS,4BAElD,aACO;CACP,MAAM,SAAS;CACf,OAAO,IAAI,MAAM,QAAQ,YAAY,KAAK,KAAK,YAAY,QAAQ,QAAQ,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,QAAQ,OAAO,CAAC;AACpH"}

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

@@ -0,0 +1,28 @@
+import type { PublisherInput } from "../types.js";
+import type { DurationInput, Scheduler } from "../../schedulers/types.js";
+declare module "../flux.js" {
+    /** Advanced buffer and window operators added to Flux. */
+    interface Flux<T> {
+        /** Buffers values until `maxSize` is reached or `maxTime` elapses after the first buffered value. */
+        bufferTimeout(maxSize: number, maxTime: DurationInput, scheduler?: Scheduler): Flux<T[]>;
+        /** Buffers values until the predicate matches, optionally cutting before the matching value. */
+        bufferUntil(predicate: (value: T) => boolean, cutBefore?: boolean): Flux<T[]>;
+        /** Buffers adjacent values while the selected key stays equal. */
+        bufferUntilChanged<K = T>(keySelector?: (value: T) => K, comparator?: (left: K, right: K) => boolean): Flux<T[]>;
+        /** Buffers values between an opening signal and the corresponding closing publisher. */
+        bufferWhen(openings: PublisherInput<unknown>, closeSelector: (opening: unknown) => PublisherInput<unknown>): Flux<T[]>;
+        /** Buffers consecutive values while the predicate matches. */
+        bufferWhile(predicate: (value: T) => boolean): Flux<T[]>;
+        /** Windows values until `maxSize` is reached or `maxTime` elapses after the first value. */
+        windowTimeout(maxSize: number, maxTime: DurationInput, scheduler?: Scheduler): Flux<Flux<T>>;
+        /** Windows values until the predicate matches, optionally cutting before the matching value. */
+        windowUntil(predicate: (value: T) => boolean, cutBefore?: boolean): Flux<Flux<T>>;
+        /** Windows adjacent values while the selected key stays equal. */
+        windowUntilChanged<K = T>(keySelector?: (value: T) => K, comparator?: (left: K, right: K) => boolean): Flux<Flux<T>>;
+        /** Windows values between an opening signal and the corresponding closing publisher. */
+        windowWhen(openings: PublisherInput<unknown>, closeSelector: (opening: unknown) => PublisherInput<unknown>): Flux<Flux<T>>;
+        /** Windows consecutive values while the predicate matches. */
+        windowWhile(predicate: (value: T) => boolean): Flux<Flux<T>>;
+    }
+}
+//# sourceMappingURL=windowing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"windowing.d.ts","sourceRoot":"","sources":["../../../src/publisher/operators/windowing.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAC,aAAa,EAAE,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAEpE,OAAO,QAAQ,qBAAqB,CAAC;IACjC,0DAA0D;IAC1D,UAAU,IAAI,CAAC,CAAC;QACZ,qGAAqG;QACrG,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEzF,gGAAgG;QAChG,WAAW,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAE9E,kEAAkE;QAClE,kBAAkB,CAAC,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEjH,wFAAwF;QACxF,UAAU,CAAC,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEvH,8DAA8D;QAC9D,WAAW,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEzD,4FAA4F;QAC5F,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAE7F,gGAAgG;QAChG,WAAW,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAElF,kEAAkE;QAClE,kBAAkB,CAAC,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAErH,wFAAwF;QACxF,UAAU,CAAC,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAE3H,8DAA8D;QAC9D,WAAW,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;KAChE;CACJ"}

package/dist/publisher/operators/windowing.js

@@ -0,0 +1,148 @@
+import { toAsyncIterator } from "../../internal/iterable.js";
+import { AsyncQueue } from "../../internal/async-queue.js";
+import { Schedulers } from "../../schedulers/schedulers.js";
+import { TIMEOUT, identity, raceIteratorWithTimeout } from "../helpers.js";
+import { Flux } from "../flux.js";
+//#region src/publisher/operators/windowing.ts
+Flux.prototype.bufferTimeout = function bufferTimeout(maxSize, maxTime, scheduler = Schedulers.timeout()) {
+	if (!Number.isInteger(maxSize) || maxSize <= 0) throw new RangeError("bufferTimeout expects a strictly positive integer maxSize");
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const iterator = toAsyncIterator(source.iterate(signal, context));
+		let bucket = [];
+		try {
+			while (!signal.aborted) {
+				const result = bucket.length === 0 ? await iterator.next() : await raceIteratorWithTimeout(iterator, maxTime, scheduler, signal);
+				if (result === TIMEOUT) {
+					if (bucket.length > 0) {
+						yield bucket;
+						bucket = [];
+					}
+					continue;
+				}
+				if (result.done) break;
+				bucket.push(result.value);
+				if (bucket.length >= maxSize) {
+					yield bucket;
+					bucket = [];
+				}
+			}
+			if (bucket.length > 0) yield bucket;
+		} finally {
+			await iterator.return?.();
+		}
+	});
+};
+Flux.prototype.bufferUntil = function bufferUntil(predicate, cutBefore = false) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let bucket = [];
+		for await (const value of source.iterate(signal, context)) {
+			if (cutBefore && predicate(value)) {
+				if (bucket.length > 0) yield bucket;
+				bucket = [value];
+				continue;
+			}
+			bucket.push(value);
+			if (!cutBefore && predicate(value)) {
+				yield bucket;
+				bucket = [];
+			}
+		}
+		if (bucket.length > 0) yield bucket;
+	});
+};
+Flux.prototype.bufferUntilChanged = function bufferUntilChanged(keySelector = identity, comparator = Object.is) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let bucket = [];
+		let previousKey;
+		let hasKey = false;
+		for await (const value of source.iterate(signal, context)) {
+			const key = keySelector(value);
+			if (hasKey && !comparator(previousKey, key)) {
+				yield bucket;
+				bucket = [];
+			}
+			bucket.push(value);
+			previousKey = key;
+			hasKey = true;
+		}
+		if (bucket.length > 0) yield bucket;
+	});
+};
+Flux.prototype.bufferWhen = function bufferWhen(openings, closeSelector) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		const opening = await firstOpening(openings, signal, context);
+		if (opening.done) return;
+		const closeSignal = Symbol("close");
+		const close = firstOpening(closeSelector(opening.value), signal, context).then(() => closeSignal);
+		const iterator = toAsyncIterator(source.iterate(signal, context));
+		const bucket = [];
+		try {
+			while (!signal.aborted) {
+				const result = await Promise.race([iterator.next(), close]);
+				if (result === closeSignal || result.done) break;
+				bucket.push(result.value);
+			}
+		} finally {
+			await iterator.return?.();
+		}
+		if (bucket.length > 0) yield bucket;
+	});
+};
+Flux.prototype.bufferWhile = function bufferWhile(predicate) {
+	const source = this;
+	return new Flux(async function* (signal, context) {
+		let bucket = [];
+		for await (const value of source.iterate(signal, context)) if (predicate(value)) bucket.push(value);
+		else if (bucket.length > 0) {
+			yield bucket;
+			bucket = [];
+		}
+		if (bucket.length > 0) yield bucket;
+	});
+};
+Flux.prototype.windowTimeout = function windowTimeout(maxSize, maxTime, scheduler) {
+	return windowsFromBuffers(this.bufferTimeout(maxSize, maxTime, scheduler));
+};
+Flux.prototype.windowUntil = function windowUntil(predicate, cutBefore) {
+	return windowsFromBuffers(this.bufferUntil(predicate, cutBefore));
+};
+Flux.prototype.windowUntilChanged = function windowUntilChanged(keySelector, comparator) {
+	return windowsFromBuffers(this.bufferUntilChanged(keySelector, comparator));
+};
+Flux.prototype.windowWhen = function windowWhen(openings, closeSelector) {
+	return windowsFromBuffers(this.bufferWhen(openings, closeSelector));
+};
+Flux.prototype.windowWhile = function windowWhile(predicate) {
+	return windowsFromBuffers(this.bufferWhile(predicate));
+};
+/** Resolves the first opening or closing signal from a publisher input. */
+async function firstOpening(source, signal, context) {
+	const iterator = toAsyncIterator(Flux.from(source).iterate(signal, context));
+	try {
+		return await iterator.next();
+	} finally {
+		await iterator.return?.();
+	}
+}
+/** Converts buffered arrays into window Flux values without yielding thenable publishers from an async generator. */
+function windowsFromBuffers(buffers) {
+	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;
+	});
+}
+//#endregion
+
+//# sourceMappingURL=windowing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"windowing.js","names":[],"sources":["../../../src/publisher/operators/windowing.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Advanced Reactor buffer and window compatibility operators for Flux.\n */\nimport {Context} from \"@/context/context.js\";\nimport {AsyncQueue} from \"@/internal/async-queue.js\";\nimport {toAsyncIterator} from \"@/internal/iterable.js\";\nimport {Flux} from \"@/publisher/flux.js\";\nimport {identity, raceIteratorWithTimeout, TIMEOUT} from \"@/publisher/helpers.js\";\nimport type {PublisherInput} from \"@/publisher/types.js\";\nimport {Schedulers} from \"@/schedulers/schedulers.js\";\nimport type {DurationInput, Scheduler} from \"@/schedulers/types.js\";\n\ndeclare module \"@/publisher/flux.js\" {\n    /** Advanced buffer and window operators added to Flux. */\n    interface Flux<T> {\n        /** Buffers values until `maxSize` is reached or `maxTime` elapses after the first buffered value. */\n        bufferTimeout(maxSize: number, maxTime: DurationInput, scheduler?: Scheduler): Flux<T[]>;\n\n        /** Buffers values until the predicate matches, optionally cutting before the matching value. */\n        bufferUntil(predicate: (value: T) => boolean, cutBefore?: boolean): Flux<T[]>;\n\n        /** Buffers adjacent values while the selected key stays equal. */\n        bufferUntilChanged<K = T>(keySelector?: (value: T) => K, comparator?: (left: K, right: K) => boolean): Flux<T[]>;\n\n        /** Buffers values between an opening signal and the corresponding closing publisher. */\n        bufferWhen(openings: PublisherInput<unknown>, closeSelector: (opening: unknown) => PublisherInput<unknown>): Flux<T[]>;\n\n        /** Buffers consecutive values while the predicate matches. */\n        bufferWhile(predicate: (value: T) => boolean): Flux<T[]>;\n\n        /** Windows values until `maxSize` is reached or `maxTime` elapses after the first value. */\n        windowTimeout(maxSize: number, maxTime: DurationInput, scheduler?: Scheduler): Flux<Flux<T>>;\n\n        /** Windows values until the predicate matches, optionally cutting before the matching value. */\n        windowUntil(predicate: (value: T) => boolean, cutBefore?: boolean): Flux<Flux<T>>;\n\n        /** Windows adjacent values while the selected key stays equal. */\n        windowUntilChanged<K = T>(keySelector?: (value: T) => K, comparator?: (left: K, right: K) => boolean): Flux<Flux<T>>;\n\n        /** Windows values between an opening signal and the corresponding closing publisher. */\n        windowWhen(openings: PublisherInput<unknown>, closeSelector: (opening: unknown) => PublisherInput<unknown>): Flux<Flux<T>>;\n\n        /** Windows consecutive values while the predicate matches. */\n        windowWhile(predicate: (value: T) => boolean): Flux<Flux<T>>;\n    }\n}\n\nFlux.prototype.bufferTimeout = function bufferTimeout<T>(\n    this: Flux<T>,\n    maxSize: number,\n    maxTime: DurationInput,\n    scheduler: Scheduler = Schedulers.timeout()\n): Flux<T[]> {\n    if (!Number.isInteger(maxSize) || maxSize <= 0) {\n        throw new RangeError(\"bufferTimeout expects a strictly positive integer maxSize\");\n    }\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        const iterator = toAsyncIterator(source.iterate(signal, context));\n        let bucket: T[] = [];\n        try {\n            while (!signal.aborted) {\n                const result =\n                    bucket.length === 0\n                        ? await iterator.next()\n                        : await raceIteratorWithTimeout(iterator, maxTime, scheduler, signal);\n                if (result === TIMEOUT) {\n                    if (bucket.length > 0) {\n                        yield bucket;\n                        bucket = [];\n                    }\n                    continue;\n                }\n                if (result.done) {\n                    break;\n                }\n                bucket.push(result.value);\n                if (bucket.length >= maxSize) {\n                    yield bucket;\n                    bucket = [];\n                }\n            }\n            if (bucket.length > 0) {\n                yield bucket;\n            }\n        } finally {\n            await iterator.return?.();\n        }\n    });\n};\n\nFlux.prototype.bufferUntil = function bufferUntil<T>(\n    this: Flux<T>,\n    predicate: (value: T) => boolean,\n    cutBefore = false\n): Flux<T[]> {\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            if (cutBefore && predicate(value)) {\n                if (bucket.length > 0) {\n                    yield bucket;\n                }\n                bucket = [value];\n                continue;\n            }\n            bucket.push(value);\n            if (!cutBefore && predicate(value)) {\n                yield bucket;\n                bucket = [];\n            }\n        }\n        if (bucket.length > 0) {\n            yield bucket;\n        }\n    });\n};\n\nFlux.prototype.bufferUntilChanged = function bufferUntilChanged<T, K = T>(\n    this: Flux<T>,\n    keySelector: (value: T) => K = identity as (value: T) => K,\n    comparator: (left: K, right: K) => boolean = Object.is\n): Flux<T[]> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        let bucket: T[] = [];\n        let previousKey: K | undefined;\n        let hasKey = false;\n        for await (const value of source.iterate(signal, context)) {\n            const key = keySelector(value);\n            if (hasKey && !comparator(previousKey as K, key)) {\n                yield bucket;\n                bucket = [];\n            }\n            bucket.push(value);\n            previousKey = key;\n            hasKey = true;\n        }\n        if (bucket.length > 0) {\n            yield bucket;\n        }\n    });\n};\n\nFlux.prototype.bufferWhen = function bufferWhen<T>(\n    this: Flux<T>,\n    openings: PublisherInput<unknown>,\n    closeSelector: (opening: unknown) => PublisherInput<unknown>\n): Flux<T[]> {\n    const source = this;\n    return new Flux(async function* (signal, context) {\n        const opening = await firstOpening(openings, signal, context);\n        if (opening.done) {\n            return;\n        }\n        const closeSignal = Symbol(\"close\");\n        const close: Promise<typeof closeSignal> = firstOpening(closeSelector(opening.value), signal, context).then(() => closeSignal);\n        const iterator = toAsyncIterator(source.iterate(signal, context));\n        const bucket: T[] = [];\n        try {\n            while (!signal.aborted) {\n                const result = await Promise.race<IteratorResult<T> | typeof closeSignal>([iterator.next(), close]);\n                if (result === closeSignal || result.done) {\n                    break;\n                }\n                bucket.push(result.value);\n            }\n        } finally {\n            await iterator.return?.();\n        }\n        if (bucket.length > 0) {\n            yield bucket;\n        }\n    });\n};\n\nFlux.prototype.bufferWhile = function bufferWhile<T>(this: Flux<T>, predicate: (value: T) => boolean): Flux<T[]> {\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            if (predicate(value)) {\n                bucket.push(value);\n            } else if (bucket.length > 0) {\n                yield bucket;\n                bucket = [];\n            }\n        }\n        if (bucket.length > 0) {\n            yield bucket;\n        }\n    });\n};\n\nFlux.prototype.windowTimeout = function windowTimeout<T>(\n    this: Flux<T>,\n    maxSize: number,\n    maxTime: DurationInput,\n    scheduler?: Scheduler\n): Flux<Flux<T>> {\n    return windowsFromBuffers(this.bufferTimeout(maxSize, maxTime, scheduler));\n};\n\nFlux.prototype.windowUntil = function windowUntil<T>(\n    this: Flux<T>,\n    predicate: (value: T) => boolean,\n    cutBefore?: boolean\n): Flux<Flux<T>> {\n    return windowsFromBuffers(this.bufferUntil(predicate, cutBefore));\n};\n\nFlux.prototype.windowUntilChanged = function windowUntilChanged<T, K = T>(\n    this: Flux<T>,\n    keySelector?: (value: T) => K,\n    comparator?: (left: K, right: K) => boolean\n): Flux<Flux<T>> {\n    return windowsFromBuffers(this.bufferUntilChanged(keySelector, comparator));\n};\n\nFlux.prototype.windowWhen = function windowWhen<T>(\n    this: Flux<T>,\n    openings: PublisherInput<unknown>,\n    closeSelector: (opening: unknown) => PublisherInput<unknown>\n): Flux<Flux<T>> {\n    return windowsFromBuffers(this.bufferWhen(openings, closeSelector));\n};\n\nFlux.prototype.windowWhile = function windowWhile<T>(this: Flux<T>, predicate: (value: T) => boolean): Flux<Flux<T>> {\n    return windowsFromBuffers(this.bufferWhile(predicate));\n};\n\n/** Resolves the first opening or closing signal from a publisher input. */\nasync function firstOpening(source: PublisherInput<unknown>, signal: AbortSignal, context: Context): Promise<IteratorResult<unknown>> {\n    const iterator = toAsyncIterator(Flux.from(source).iterate(signal, context));\n    try {\n        return await iterator.next();\n    } finally {\n        await iterator.return?.();\n    }\n}\n\n/** Converts buffered arrays into window Flux values without yielding thenable publishers from an async generator. */\nfunction windowsFromBuffers<T>(buffers: Flux<T[]>): Flux<Flux<T>> {\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"],"mappings":"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"}

package/dist/publisher/publisher.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * Publisher contract used by Flux, Mono and Reactive Streams adapters.
+ */
+import type { Subscriber } from "../subscription/subscriber.js";
+/** Reactive Streams publisher that can be subscribed to by a subscriber. */
+export interface Publisher<T> {
+    /** Subscribes the given subscriber to this publisher. */
+    subscribe(subscriber: Subscriber<T>): void;
+}
+//# sourceMappingURL=publisher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publisher.d.ts","sourceRoot":"","sources":["../../src/publisher/publisher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAE7D,4EAA4E;AAC5E,MAAM,WAAW,SAAS,CAAC,CAAC;IACxB,yDAAyD;IACzD,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CAC9C"}

package/dist/publisher/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @packageDocumentation
+ * Flux, Mono and operator implementation modules.
+ */
+import type { Publisher } from "./publisher.js";
+import type { Context } from "../context/context.js";
+import type { AnyIterable } from "../internal/iterable.js";
+/** Lazy factory backing Flux and Mono sources. */
+export type SourceFactory<T> = (signal: AbortSignal, context: Context) => AnyIterable<T>;
+/** Callback that consumes a value. */
+export type Consumer<T> = (value: T) => void;
+/** Predicate callback used by filtering operators. */
+export type Predicate<T> = (value: T) => boolean;
+/** Mapping callback used by transformation operators. */
+export type Mapper<T, R> = (value: T) => R;
+/** Input type accepted by publisher adaptation methods. */
+export type PublisherInput<T> = Publisher<T> | Iterable<T> | AsyncIterable<T> | PromiseLike<T>;
+/** Callback used by `Flux.create`. */
+export type FluxSinkCallback<T> = (sink: FluxSink<T>) => void;
+/** Callback used by `Mono.create`. */
+export type MonoSinkCallback<T> = (sink: MonoSink<T>) => void;
+/** Imperative sink exposed to `Flux.create` callbacks. */
+export interface FluxSink<T> {
+    /** Pushes one value to the created Flux. */
+    next(value: T): void;
+    /** Terminates the sequence with an error. */
+    error(error: unknown): void;
+    /** Completes the created Flux successfully. */
+    complete(): void;
+    /** Registers a callback invoked on cancellation. */
+    onCancel(callback: () => void): FluxSink<T>;
+    /** Returns true when the subscriber cancelled the sequence. */
+    isCancelled(): boolean;
+}
+/** Imperative sink exposed to `Mono.create` callbacks. */
+export interface MonoSink<T> extends FluxSink<T> {
+    /** Completes the Mono with an optional value. */
+    success(value?: T): void;
+    /** Registers a callback invoked on cancellation. */
+    onCancel(callback: () => void): MonoSink<T>;
+}
+/** Synchronous one-signal sink used by handle operators. */
+export interface SynchronousSink<T> {
+    /** Emits one value for the currently handled input. */
+    next(value: T): void;
+    /** Completes without emitting a value for the current input. */
+    complete(): void;
+    /** Fails the sequence with an error. */
+    error(error: unknown): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/publisher/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/publisher/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AACxD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,wBAAwB,CAAC;AAExD,kDAAkD;AAClD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC;AACzF,sCAAsC;AACtC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAC7C,sDAAsD;AACtD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AACjD,yDAAyD;AACzD,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AAC3C,2DAA2D;AAC3D,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;AAC/F,sCAAsC;AACtC,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAC9D,sCAAsC;AACtC,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAE9D,0DAA0D;AAC1D,MAAM,WAAW,QAAQ,CAAC,CAAC;IACvB,4CAA4C;IAC5C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAErB,6CAA6C;IAC7C,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAE5B,+CAA+C;IAC/C,QAAQ,IAAI,IAAI,CAAC;IAEjB,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE5C,+DAA+D;IAC/D,WAAW,IAAI,OAAO,CAAC;CAC1B;AAED,0DAA0D;AAC1D,MAAM,WAAW,QAAQ,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IAC5C,iDAAiD;IACjD,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IAEzB,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;CAC/C;AAED,4DAA4D;AAC5D,MAAM,WAAW,eAAe,CAAC,CAAC;IAC9B,uDAAuD;IACvD,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAErB,gEAAgE;IAChE,QAAQ,IAAI,IAAI,CAAC;IAEjB,wCAAwC;IACxC,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B"}

package/dist/schedulers/animation-frame-scheduler.d.ts

@@ -0,0 +1,11 @@
+import type { Disposable } from "../core/types.js";
+import { BaseScheduler } from "./base-scheduler.js";
+import type { DurationInput } from "./types.js";
+/** Scheduler that queues zero-delay tasks with `requestAnimationFrame` when available. */
+export declare class AnimationFrameScheduler extends BaseScheduler {
+    /** Creates an animation-frame scheduler. */
+    constructor(name?: string);
+    /** Schedules a task with `requestAnimationFrame`, falling back to timeout scheduling. */
+    schedule(task: () => void, delay?: DurationInput): Disposable;
+}
+//# sourceMappingURL=animation-frame-scheduler.d.ts.map

package/dist/schedulers/animation-frame-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-frame-scheduler.d.ts","sourceRoot":"","sources":["../../src/schedulers/animation-frame-scheduler.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAC7D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC;AAEzD,0FAA0F;AAC1F,qBAAa,uBAAwB,SAAQ,aAAa;IACtD,4CAA4C;IAC5C,YAAmB,IAAI,SAAmB,EAEzC;IAED,yFAAyF;IAClF,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,UAAU,CAenE;CACJ"}

package/dist/schedulers/animation-frame-scheduler.js

@@ -0,0 +1,30 @@
+import { BooleanDisposable } from "../core/boolean-disposable.js";
+import { toMillis } from "./duration.js";
+import { BaseScheduler } from "./base-scheduler.js";
+//#region src/schedulers/animation-frame-scheduler.ts
+/**
+* @packageDocumentation
+* Browser scheduler implementations and contracts.
+*/
+/** Scheduler that queues zero-delay tasks with `requestAnimationFrame` when available. */
+var AnimationFrameScheduler = class extends BaseScheduler {
+	/** Creates an animation-frame scheduler. */
+	constructor(name = "animationFrame") {
+		super(name);
+	}
+	/** Schedules a task with `requestAnimationFrame`, falling back to timeout scheduling. */
+	schedule(task, delay) {
+		const disposedDisposable = this.disposedIfNeeded();
+		if (disposedDisposable) return disposedDisposable;
+		const delayMs = toMillis(delay);
+		if (delayMs > 0 || typeof requestAnimationFrame !== "function") return this.scheduleTimeout(task, delayMs);
+		const id = requestAnimationFrame(() => {
+			if (!this.isDisposed()) task();
+		});
+		return new BooleanDisposable(() => cancelAnimationFrame(id));
+	}
+};
+//#endregion
+export { AnimationFrameScheduler };
+
+//# sourceMappingURL=animation-frame-scheduler.js.map

package/dist/schedulers/animation-frame-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-frame-scheduler.js","names":[],"sources":["../../src/schedulers/animation-frame-scheduler.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Browser scheduler implementations and contracts.\n */\nimport {BooleanDisposable} from \"@/core/boolean-disposable.js\";\nimport type {Disposable} from \"@/core/types.js\";\nimport {toMillis} from \"@/schedulers/duration.js\";\nimport {BaseScheduler} from \"@/schedulers/base-scheduler.js\";\nimport type {DurationInput} from \"@/schedulers/types.js\";\n\n/** Scheduler that queues zero-delay tasks with `requestAnimationFrame` when available. */\nexport class AnimationFrameScheduler extends BaseScheduler {\n    /** Creates an animation-frame scheduler. */\n    public constructor(name = \"animationFrame\") {\n        super(name);\n    }\n\n    /** Schedules a task with `requestAnimationFrame`, falling back to timeout scheduling. */\n    public schedule(task: () => void, delay?: DurationInput): Disposable {\n        const disposedDisposable = this.disposedIfNeeded();\n        if (disposedDisposable) {\n            return disposedDisposable;\n        }\n        const delayMs = toMillis(delay);\n        if (delayMs > 0 || typeof requestAnimationFrame !== \"function\") {\n            return this.scheduleTimeout(task, delayMs);\n        }\n        const id = requestAnimationFrame(() => {\n            if (!this.isDisposed()) {\n                task();\n            }\n        });\n        return new BooleanDisposable(() => cancelAnimationFrame(id));\n    }\n}\n"],"mappings":";;;;;;;;;AAWA,IAAa,0BAAb,cAA6C,cAAc;;CAEvD,YAAmB,OAAO,kBAAkB;EACxC,MAAM,IAAI;CACd;;CAGA,SAAgB,MAAkB,OAAmC;EACjE,MAAM,qBAAqB,KAAK,iBAAiB;EACjD,IAAI,oBACA,OAAO;EAEX,MAAM,UAAU,SAAS,KAAK;EAC9B,IAAI,UAAU,KAAK,OAAO,0BAA0B,YAChD,OAAO,KAAK,gBAAgB,MAAM,OAAO;EAE7C,MAAM,KAAK,4BAA4B;GACnC,IAAI,CAAC,KAAK,WAAW,GACjB,KAAK;EAEb,CAAC;EACD,OAAO,IAAI,wBAAwB,qBAAqB,EAAE,CAAC;CAC/D;AACJ"}

package/dist/schedulers/base-scheduler.d.ts

@@ -0,0 +1,28 @@
+import type { Disposable } from "../core/types.js";
+import type { DurationInput, Scheduler, SchedulerWorker } from "./types.js";
+/** Base implementation for browser schedulers that share lifecycle behavior. */
+export declare abstract class BaseScheduler implements Scheduler {
+    /** Human-readable scheduler name. */
+    readonly name: string;
+    /** Tracks whether this scheduler has been disposed. */
+    private disposed;
+    /** Creates a scheduler base with the provided name. */
+    constructor(name: string);
+    /** Returns the current wall-clock time in milliseconds. */
+    now(): number;
+    /** Schedules a single task, optionally after a delay. */
+    abstract schedule(task: () => void, delay?: DurationInput): Disposable;
+    /** Schedules a periodic task using this scheduler for the first execution. */
+    schedulePeriodically(task: () => void, initialDelay?: DurationInput, period?: DurationInput): Disposable;
+    /** Creates a worker that tracks tasks for grouped disposal. */
+    createWorker(): SchedulerWorker;
+    /** Marks this scheduler as disposed. */
+    dispose(): void;
+    /** Returns true when this scheduler is disposed. */
+    isDisposed(): boolean;
+    /** Returns an already-disposed disposable when this scheduler is disposed. */
+    protected disposedIfNeeded(): Disposable | undefined;
+    /** Schedules a timeout-backed task with disposal and disposed-state checks. */
+    protected scheduleTimeout(task: () => void, delayMs?: number): Disposable;
+}
+//# sourceMappingURL=base-scheduler.d.ts.map

package/dist/schedulers/base-scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-scheduler.d.ts","sourceRoot":"","sources":["../../src/schedulers/base-scheduler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAIhD,OAAO,KAAK,EAAC,aAAa,EAAE,SAAS,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAErF,gFAAgF;AAChF,8BAAsB,aAAc,YAAW,SAAS;IACpD,qCAAqC;IACrC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,uDAAuD;IACvD,OAAO,CAAC,QAAQ,CAAS;IAEzB,uDAAuD;IACvD,YAAmB,IAAI,EAAE,MAAM,EAE9B;IAED,2DAA2D;IACpD,GAAG,IAAI,MAAM,CAEnB;IAED,yDAAyD;IACzD,SAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,UAAU,CAAC;IAE9E,8EAA8E;IACvE,oBAAoB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,UAAU,CAmB9G;IAED,+DAA+D;IACxD,YAAY,IAAI,eAAe,CAErC;IAED,wCAAwC;IACjC,OAAO,IAAI,IAAI,CAErB;IAED,oDAAoD;IAC7C,UAAU,IAAI,OAAO,CAE3B;IAED,8EAA8E;IAC9E,SAAS,CAAC,gBAAgB,IAAI,UAAU,GAAG,SAAS,CAEnD;IAED,+EAA+E;IAC/E,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,OAAO,SAAI,GAAG,UAAU,CAUnE;CACJ"}

package/dist/schedulers/base-scheduler.js

@@ -0,0 +1,77 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/defineProperty.js";
+import { BooleanDisposable } from "../core/boolean-disposable.js";
+import { toMillis } from "./duration.js";
+import { CompositeDisposable } from "../core/composite-disposable.js";
+import { disposed } from "./disposed.js";
+import { BasicWorker } from "./basic-worker.js";
+//#region src/schedulers/base-scheduler.ts
+/**
+* @packageDocumentation
+* Browser scheduler implementations and contracts.
+*/
+/** Base implementation for browser schedulers that share lifecycle behavior. */
+var BaseScheduler = class {
+	/** Creates a scheduler base with the provided name. */
+	constructor(name) {
+		_defineProperty(
+			this,
+			/** Human-readable scheduler name. */
+			"name",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/** Tracks whether this scheduler has been disposed. */
+			"disposed",
+			false
+		);
+		this.name = name;
+	}
+	/** Returns the current wall-clock time in milliseconds. */
+	now() {
+		return Date.now();
+	}
+	/** Schedules a periodic task using this scheduler for the first execution. */
+	schedulePeriodically(task, initialDelay, period) {
+		if (this.disposed) return disposed();
+		const composite = new CompositeDisposable();
+		const start = this.schedule(() => {
+			if (composite.isDisposed()) return;
+			task();
+			const id = setInterval(() => {
+				if (!composite.isDisposed() && !this.disposed) task();
+			}, Math.max(1, toMillis(period)));
+			composite.add(new BooleanDisposable(() => clearInterval(id)));
+		}, initialDelay);
+		composite.add(start);
+		return composite;
+	}
+	/** Creates a worker that tracks tasks for grouped disposal. */
+	createWorker() {
+		return new BasicWorker(this);
+	}
+	/** Marks this scheduler as disposed. */
+	dispose() {
+		this.disposed = true;
+	}
+	/** Returns true when this scheduler is disposed. */
+	isDisposed() {
+		return this.disposed;
+	}
+	/** Returns an already-disposed disposable when this scheduler is disposed. */
+	disposedIfNeeded() {
+		return this.disposed ? disposed() : void 0;
+	}
+	/** Schedules a timeout-backed task with disposal and disposed-state checks. */
+	scheduleTimeout(task, delayMs = 0) {
+		if (this.disposed) return disposed();
+		const id = setTimeout(() => {
+			if (!this.disposed) task();
+		}, delayMs);
+		return new BooleanDisposable(() => clearTimeout(id));
+	}
+};
+//#endregion
+export { BaseScheduler };
+
+//# sourceMappingURL=base-scheduler.js.map

package/dist/schedulers/base-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-scheduler.js","names":[],"sources":["../../src/schedulers/base-scheduler.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Browser scheduler implementations and contracts.\n */\nimport {BooleanDisposable} from \"@/core/boolean-disposable.js\";\nimport {CompositeDisposable} from \"@/core/composite-disposable.js\";\nimport type {Disposable} from \"@/core/types.js\";\nimport {BasicWorker} from \"@/schedulers/basic-worker.js\";\nimport {disposed} from \"@/schedulers/disposed.js\";\nimport {toMillis} from \"@/schedulers/duration.js\";\nimport type {DurationInput, Scheduler, SchedulerWorker} from \"@/schedulers/types.js\";\n\n/** Base implementation for browser schedulers that share lifecycle behavior. */\nexport abstract class BaseScheduler implements Scheduler {\n    /** Human-readable scheduler name. */\n    public readonly name: string;\n    /** Tracks whether this scheduler has been disposed. */\n    private disposed = false;\n\n    /** Creates a scheduler base with the provided name. */\n    public constructor(name: string) {\n        this.name = name;\n    }\n\n    /** Returns the current wall-clock time in milliseconds. */\n    public now(): number {\n        return Date.now();\n    }\n\n    /** Schedules a single task, optionally after a delay. */\n    public abstract schedule(task: () => void, delay?: DurationInput): Disposable;\n\n    /** Schedules a periodic task using this scheduler for the first execution. */\n    public schedulePeriodically(task: () => void, initialDelay?: DurationInput, period?: DurationInput): Disposable {\n        if (this.disposed) {\n            return disposed();\n        }\n        const composite = new CompositeDisposable();\n        const start = this.schedule(() => {\n            if (composite.isDisposed()) {\n                return;\n            }\n            task();\n            const id = setInterval(() => {\n                if (!composite.isDisposed() && !this.disposed) {\n                    task();\n                }\n            }, Math.max(1, toMillis(period)));\n            composite.add(new BooleanDisposable(() => clearInterval(id)));\n        }, initialDelay);\n        composite.add(start);\n        return composite;\n    }\n\n    /** Creates a worker that tracks tasks for grouped disposal. */\n    public createWorker(): SchedulerWorker {\n        return new BasicWorker(this);\n    }\n\n    /** Marks this scheduler as disposed. */\n    public dispose(): void {\n        this.disposed = true;\n    }\n\n    /** Returns true when this scheduler is disposed. */\n    public isDisposed(): boolean {\n        return this.disposed;\n    }\n\n    /** Returns an already-disposed disposable when this scheduler is disposed. */\n    protected disposedIfNeeded(): Disposable | undefined {\n        return this.disposed ? disposed() : undefined;\n    }\n\n    /** Schedules a timeout-backed task with disposal and disposed-state checks. */\n    protected scheduleTimeout(task: () => void, delayMs = 0): Disposable {\n        if (this.disposed) {\n            return disposed();\n        }\n        const id = setTimeout(() => {\n            if (!this.disposed) {\n                task();\n            }\n        }, delayMs);\n        return new BooleanDisposable(() => clearTimeout(id));\n    }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,IAAsB,gBAAtB,MAAyD;;CAOrD,YAAmB,MAAc;;;;GALjC;;;;;;GAEA;GAAmB;;EAIf,KAAK,OAAO;CAChB;;CAGA,MAAqB;EACjB,OAAO,KAAK,IAAI;CACpB;;CAMA,qBAA4B,MAAkB,cAA8B,QAAoC;EAC5G,IAAI,KAAK,UACL,OAAO,SAAS;EAEpB,MAAM,YAAY,IAAI,oBAAoB;EAC1C,MAAM,QAAQ,KAAK,eAAe;GAC9B,IAAI,UAAU,WAAW,GACrB;GAEJ,KAAK;GACL,MAAM,KAAK,kBAAkB;IACzB,IAAI,CAAC,UAAU,WAAW,KAAK,CAAC,KAAK,UACjC,KAAK;GAEb,GAAG,KAAK,IAAI,GAAG,SAAS,MAAM,CAAC,CAAC;GAChC,UAAU,IAAI,IAAI,wBAAwB,cAAc,EAAE,CAAC,CAAC;EAChE,GAAG,YAAY;EACf,UAAU,IAAI,KAAK;EACnB,OAAO;CACX;;CAGA,eAAuC;EACnC,OAAO,IAAI,YAAY,IAAI;CAC/B;;CAGA,UAAuB;EACnB,KAAK,WAAW;CACpB;;CAGA,aAA6B;EACzB,OAAO,KAAK;CAChB;;CAGA,mBAAqD;EACjD,OAAO,KAAK,WAAW,SAAS,IAAI;CACxC;;CAGA,gBAA0B,MAAkB,UAAU,GAAe;EACjE,IAAI,KAAK,UACL,OAAO,SAAS;EAEpB,MAAM,KAAK,iBAAiB;GACxB,IAAI,CAAC,KAAK,UACN,KAAK;EAEb,GAAG,OAAO;EACV,OAAO,IAAI,wBAAwB,aAAa,EAAE,CAAC;CACvD;AACJ"}

package/dist/schedulers/basic-worker.d.ts

@@ -0,0 +1,22 @@
+import type { Disposable } from "../core/types.js";
+import type { DurationInput, Scheduler, SchedulerWorker } from "./types.js";
+/** Scheduler worker that tracks child tasks in a composite disposable. */
+export declare class BasicWorker implements SchedulerWorker {
+    /** Tasks currently owned by this worker, allocated only after a task needs tracking. */
+    private tasks;
+    /** Tracks whether this worker has been disposed. */
+    private disposed;
+    /** Scheduler used to create tracked tasks. */
+    private readonly scheduler;
+    /** Creates a worker backed by the provided scheduler. */
+    constructor(scheduler: Scheduler);
+    /** Schedules a task and tracks it for disposal. */
+    schedule(task: () => void, delay?: DurationInput): Disposable;
+    /** Schedules a periodic task and tracks it for disposal. */
+    schedulePeriodically(task: () => void, initialDelay?: DurationInput, period?: DurationInput): Disposable;
+    /** Disposes all tasks scheduled through this worker. */
+    dispose(): void;
+    /** Returns true after this worker has been disposed. */
+    isDisposed(): boolean;
+}
+//# sourceMappingURL=basic-worker.d.ts.map

package/dist/schedulers/basic-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-worker.d.ts","sourceRoot":"","sources":["../../src/schedulers/basic-worker.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAC,aAAa,EAAE,SAAS,EAAE,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAGrF,0EAA0E;AAC1E,qBAAa,WAAY,YAAW,eAAe;IAC/C,wFAAwF;IACxF,OAAO,CAAC,KAAK,CAAkC;IAC/C,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,8CAA8C;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IAEtC,yDAAyD;IACzD,YAAmB,SAAS,EAAE,SAAS,EAEtC;IAED,mDAAmD;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,UAAU,CAqBnE;IAED,4DAA4D;IACrD,oBAAoB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,UAAU,CAW9G;IAED,wDAAwD;IACjD,OAAO,IAAI,IAAI,CAOrB;IAED,wDAAwD;IACjD,UAAU,IAAI,OAAO,CAE3B;CACJ"}