@nlozgachev/pipelined 0.65.0 → 0.66.0

package/dist/{Core-BDXRLmMa.cjs → Core-6SkC-fh5.cjs}

@@ -284,6 +284,189 @@ const Equality = {
 	}
 };
 //#endregion
+//#region src/Core/EventBus.ts
+const makeEventBus = (options) => ({
+	options,
+	_listeners: /* @__PURE__ */ new Set(),
+	_listenerArray: null,
+	_queue: [],
+	_isEmitting: false
+});
+const emitEventBus = (target, message) => {
+	const targets = Array.isArray(target) ? target : [target];
+	const msg = message;
+	for (const bus of targets) {
+		bus._queue.push(msg);
+		if (!bus._isEmitting) {
+			bus._isEmitting = true;
+			try {
+				while (bus._queue.length > 0) {
+					const nextMsg = bus._queue.shift();
+					if (bus._listenerArray === null) bus._listenerArray = Array.from(bus._listeners);
+					const listeners = bus._listenerArray;
+					for (const listener of listeners) try {
+						listener(nextMsg);
+					} catch (err) {
+						if (bus.options?.onError) bus.options.onError(err);
+						else throw err;
+					}
+				}
+			} finally {
+				bus._isEmitting = false;
+			}
+		}
+	}
+};
+const forwardEventBus = (options) => {
+	const targets = Array.isArray(options.to) ? options.to : [options.to];
+	const filterSet = options.only ? new Set(options.only) : null;
+	const handler = (msg) => {
+		if (filterSet !== null && !filterSet.has(msg.kind)) return;
+		for (const target of targets) emitEventBus(target, msg);
+	};
+	options.from._listeners.add(handler);
+	options.from._listenerArray = null;
+	return () => {
+		options.from._listeners.delete(handler);
+		options.from._listenerArray = null;
+	};
+};
+const listenEventBus = (bus, events, options) => {
+	const eventList = Array.isArray(events) ? events : [events];
+	const isOrdered = options?.ordered ?? false;
+	const isStrict = options?.strict ?? false;
+	const isOnce = options?.once ?? false;
+	const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+	const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+	const createMatcher = (onMatch) => {
+		let sequenceIndex = 0;
+		return (msg) => {
+			if (resetKinds !== null && resetKinds.has(msg.kind)) {
+				sequenceIndex = 0;
+				return;
+			}
+			if (!isOrdered) {
+				if (eventList.includes(msg.kind)) onMatch(msg);
+				return;
+			}
+			let expectedKind = eventList[sequenceIndex];
+			if (expectedKind !== msg.kind && optionalKinds !== null) {
+				let lookaheadIndex = sequenceIndex;
+				while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) lookaheadIndex++;
+				if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+					sequenceIndex = lookaheadIndex;
+					expectedKind = eventList[sequenceIndex];
+				}
+			}
+			if (msg.kind === expectedKind) {
+				sequenceIndex++;
+				if (sequenceIndex === eventList.length) {
+					sequenceIndex = 0;
+					onMatch(msg);
+				}
+			} else if (isStrict) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+			else if (eventList.includes(msg.kind)) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+		};
+	};
+	return {
+		reduce: (reducer, initialState) => {
+			let currentState = initialState;
+			const listenerFn = createMatcher((msg) => {
+				currentState = reducer(msg, currentState);
+				if (isOnce) {
+					bus._listeners.delete(listenerFn);
+					bus._listenerArray = null;
+				}
+			});
+			const unsubscribe = () => {
+				bus._listeners.delete(listenerFn);
+				bus._listenerArray = null;
+			};
+			bus._listeners.add(listenerFn);
+			bus._listenerArray = null;
+			return {
+				unsubscribe,
+				getState: () => currentState
+			};
+		},
+		tap: (effect) => {
+			const listenerFn = createMatcher((msg) => {
+				effect(msg);
+				if (isOnce) {
+					bus._listeners.delete(listenerFn);
+					bus._listenerArray = null;
+				}
+			});
+			const unsubscribe = () => {
+				bus._listeners.delete(listenerFn);
+				bus._listenerArray = null;
+			};
+			bus._listeners.add(listenerFn);
+			bus._listenerArray = null;
+			return unsubscribe;
+		}
+	};
+};
+const EventBus = {
+	/**
+	* Constructs a new `EventBus` instance.
+	*
+	* @example
+	* ```ts
+	* const bus = EventBus.make<AppMessages>({ name: "app" });
+	* ```
+	*/
+	make: makeEventBus,
+	/**
+	* Emits a message payload to one or more target event buses.
+	*
+	* Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
+	*
+	* @example
+	* ```ts
+	* EventBus.emit(busA, {
+	*   kind: "userLoggedIn",
+	*   value: { userId: "user-1" },
+	* });
+	*
+	* EventBus.emit([busA, busB], {
+	*   kind: "userLoggedIn",
+	*   value: { userId: "user-1" },
+	* });
+	* ```
+	*/
+	emit: emitEventBus,
+	/**
+	* Forwards messages from one event bus to another (or multiple).
+	*
+	* @example
+	* ```ts
+	* const stop = EventBus.forward({
+	*   from: authBus,
+	*   to: analyticsBus,
+	*   only: ["userLoggedIn"],
+	* });
+	* ```
+	*/
+	forward: forwardEventBus,
+	/**
+	* Initiates listener registration on an event bus for specific event kind(s) or sequence.
+	*
+	* @example
+	* ```ts
+	* const sub = EventBus.listen(
+	*   appBus,
+	*   ["userLoggedIn", "checkoutStarted"],
+	*   { ordered: true }
+	* ).reduce(
+	*   (msg, state) => ({ count: state.count + 1 }),
+	*   { count: 0 }
+	* );
+	* ```
+	*/
+	listen: listenEventBus
+};
+//#endregion
 //#region src/Core/Lazy.ts
 const fromFn = (f) => {
 	let done = false;
@@ -763,6 +946,24 @@ const Maybe = {
 		Result: (data) => Result.is.ok(data) ? makeSome$1(data.value) : makeNone$1()
 	},
 	/**
+	* Wraps a synchronous operation that may throw, returning a `Maybe<A>`.
+	* Returns `Some(value)` if successful, or `None` if an exception is thrown.
+	*
+	* @example
+	* ```ts
+	* const safeParse = (s: string) => Maybe.tryCatch(() => JSON.parse(s));
+	* safeParse('{"a": 1}'); // Some({ a: 1 })
+	* safeParse('invalid');   // None
+	* ```
+	*/
+	tryCatch: (f) => {
+		try {
+			return makeSome$1(f());
+		} catch {
+			return makeNone$1();
+		}
+	},
+	/**
 	* Transforms the value inside a Maybe if it exists.
 	*
 	* @example
@@ -849,16 +1050,32 @@ const Maybe = {
 		return data;
 	},
 	/**
-	* Filters a Maybe based on a predicate.
+	* Executes a side effect when the Maybe is None, without changing the Maybe.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Maybe.make.none(),
+	*   Maybe.tapNone(() => console.log("Value missing")),
+	* );
+	* ```
+	*/
+	tapNone: (f) => (data) => {
+		if (isNone(data)) f();
+		return data;
+	},
+	/**
+	* Filters a Maybe based on a predicate or type guard.
 	* Returns None if the predicate returns false or if the Maybe is already None.
 	*
 	* @example
 	* ```ts
 	* pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
 	* pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
+	* pipe(Maybe.make.some("hi"), Maybe.filter((x): x is string => typeof x === "string")); // Some("hi")
 	* ```
 	*/
-	filter: (predicate) => (data) => isSome(data) ? predicate(data.value) ? data : makeNone$1() : data,
+	filter: ((predicate) => (data) => isSome(data) ? predicate(data.value) ? data : makeNone$1() : data),
 	/**
 	* Recovers from a None by providing a fallback Maybe.
 	* The fallback can produce a different type, widening the result to `Maybe<A | B>`.
@@ -3837,189 +4054,6 @@ const State = {
 	}
 };
 //#endregion
-//#region src/Core/Stream.ts
-const makeStream = (options) => ({
-	options,
-	_listeners: /* @__PURE__ */ new Set(),
-	_listenerArray: null,
-	_queue: [],
-	_isEmitting: false
-});
-const emitStream = (target, message) => {
-	const targets = Array.isArray(target) ? target : [target];
-	const msg = message;
-	for (const stream of targets) {
-		stream._queue.push(msg);
-		if (!stream._isEmitting) {
-			stream._isEmitting = true;
-			try {
-				while (stream._queue.length > 0) {
-					const nextMsg = stream._queue.shift();
-					if (stream._listenerArray === null) stream._listenerArray = Array.from(stream._listeners);
-					const listeners = stream._listenerArray;
-					for (const listener of listeners) try {
-						listener(nextMsg);
-					} catch (err) {
-						if (stream.options?.onError) stream.options.onError(err);
-						else throw err;
-					}
-				}
-			} finally {
-				stream._isEmitting = false;
-			}
-		}
-	}
-};
-const forwardStream = (options) => {
-	const targets = Array.isArray(options.to) ? options.to : [options.to];
-	const filterSet = options.only ? new Set(options.only) : null;
-	const handler = (msg) => {
-		if (filterSet !== null && !filterSet.has(msg.kind)) return;
-		for (const target of targets) emitStream(target, msg);
-	};
-	options.from._listeners.add(handler);
-	options.from._listenerArray = null;
-	return () => {
-		options.from._listeners.delete(handler);
-		options.from._listenerArray = null;
-	};
-};
-const listenStream = (stream, events, options) => {
-	const eventList = Array.isArray(events) ? events : [events];
-	const isOrdered = options?.ordered ?? false;
-	const isStrict = options?.strict ?? false;
-	const isOnce = options?.once ?? false;
-	const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
-	const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
-	const createMatcher = (onMatch) => {
-		let sequenceIndex = 0;
-		return (msg) => {
-			if (resetKinds !== null && resetKinds.has(msg.kind)) {
-				sequenceIndex = 0;
-				return;
-			}
-			if (!isOrdered) {
-				if (eventList.includes(msg.kind)) onMatch(msg);
-				return;
-			}
-			let expectedKind = eventList[sequenceIndex];
-			if (expectedKind !== msg.kind && optionalKinds !== null) {
-				let lookaheadIndex = sequenceIndex;
-				while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) lookaheadIndex++;
-				if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
-					sequenceIndex = lookaheadIndex;
-					expectedKind = eventList[sequenceIndex];
-				}
-			}
-			if (msg.kind === expectedKind) {
-				sequenceIndex++;
-				if (sequenceIndex === eventList.length) {
-					sequenceIndex = 0;
-					onMatch(msg);
-				}
-			} else if (isStrict) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
-			else if (eventList.includes(msg.kind)) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
-		};
-	};
-	return {
-		reduce: (reducer, initialState) => {
-			let currentState = initialState;
-			const listenerFn = createMatcher((msg) => {
-				currentState = reducer(msg, currentState);
-				if (isOnce) {
-					stream._listeners.delete(listenerFn);
-					stream._listenerArray = null;
-				}
-			});
-			const unsubscribe = () => {
-				stream._listeners.delete(listenerFn);
-				stream._listenerArray = null;
-			};
-			stream._listeners.add(listenerFn);
-			stream._listenerArray = null;
-			return {
-				unsubscribe,
-				getState: () => currentState
-			};
-		},
-		tap: (effect) => {
-			const listenerFn = createMatcher((msg) => {
-				effect(msg);
-				if (isOnce) {
-					stream._listeners.delete(listenerFn);
-					stream._listenerArray = null;
-				}
-			});
-			const unsubscribe = () => {
-				stream._listeners.delete(listenerFn);
-				stream._listenerArray = null;
-			};
-			stream._listeners.add(listenerFn);
-			stream._listenerArray = null;
-			return unsubscribe;
-		}
-	};
-};
-const Stream = {
-	/**
-	* Constructs a new `Stream` instance.
-	*
-	* @example
-	* ```ts
-	* const stream = Stream.make<AppMessages>({ name: "app" });
-	* ```
-	*/
-	make: makeStream,
-	/**
-	* Emits a message payload to one or more target streams.
-	*
-	* Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
-	*
-	* @example
-	* ```ts
-	* Stream.emit(streamA, {
-	*   kind: "userLoggedIn",
-	*   value: { userId: "user-1" },
-	* });
-	*
-	* Stream.emit([streamA, streamB], {
-	*   kind: "userLoggedIn",
-	*   value: { userId: "user-1" },
-	* });
-	* ```
-	*/
-	emit: emitStream,
-	/**
-	* Forwards messages from one stream to another (or multiple).
-	*
-	* @example
-	* ```ts
-	* const stop = Stream.forward({
-	*   from: authStream,
-	*   to: analyticsStream,
-	*   only: ["userLoggedIn"],
-	* });
-	* ```
-	*/
-	forward: forwardStream,
-	/**
-	* Initiates listener registration on a stream for specific event kind(s) or sequence.
-	*
-	* @example
-	* ```ts
-	* const sub = Stream.listen(
-	*   appStream,
-	*   ["userLoggedIn", "checkoutStarted"],
-	*   { ordered: true }
-	* ).reduce(
-	*   (msg, state) => ({ count: state.count + 1 }),
-	*   { count: 0 }
-	* );
-	* ```
-	*/
-	listen: listenStream
-};
-//#endregion
 //#region src/Core/TaskMaybe.ts
 const makeSome = (value) => Task.resolve(Maybe.make.some(value));
 const makeNone = () => Task.resolve(Maybe.make.none());
@@ -4481,14 +4515,15 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* Retries a fallible Task.Result according to a RetryPolicy.
 	* If the task succeeds, returns Ok immediately.
 	* If the task fails, retries up to policy.attempts times with delays generated by policy.
+	* An optional `when` predicate selectively retries only specific errors (e.g. transient network errors).
 	*
 	* @example
 	* ```ts
 	* const policy = RetryPolicy.exponential({ attempts: 3, initial: Duration.milliseconds(100) });
-	* const retryableFetch = pipe(fetchData, Task.Result.retry(policy));
+	* const retryableFetch = pipe(fetchData, Task.Result.retry(policy, { when: (err) => isTransient(err) }));
 	* ```
 	*/
-	retry: (policy) => (task) => (signal) => Deferred.from.Promise((() => {
+	retry: (policy, options) => (task) => (signal) => Deferred.from.Promise((() => {
 		const { attempts } = policy;
 		const wait = (duration) => new Promise((res) => {
 			let timerId;
@@ -4496,10 +4531,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 				clearTimeout(timerId);
 				res();
 			};
-			if (signal) {
-				if (signal.aborted) return res();
-				signal.addEventListener("abort", onAbort, { once: true });
-			}
+			if (signal) signal.addEventListener("abort", onAbort, { once: true });
 			timerId = setTimeout(() => {
 				signal?.removeEventListener("abort", onAbort);
 				res();
@@ -4507,6 +4539,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 		});
 		const executeAttempt = (attempt) => Deferred.to.Promise(task(signal)).then((res) => {
 			if (Result.is.ok(res) || attempt >= attempts || signal?.aborted) return res;
+			if (options?.when && !options.when(res.error)) return res;
 			const delay = policy.getDelay(attempt);
 			return wait(delay).then(() => executeAttempt(attempt + 1));
 		});
@@ -4564,7 +4597,35 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* // [Ok(val1), Err(err2), Ok(val3)]
 	* ```
 	*/
-	allSettled: (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))))
+	allSettled: (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal))))),
+	/**
+	* Narrows the Ok value with a predicate. If the predicate returns false,
+	* converts the value to an Err using onFail.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Task.Result.make.ok(42),
+	*   Task.Result.ensure(n => n > 50, () => "too small")
+	* ); // Task.Result resolving to Err("too small")
+	* ```
+	*/
+	ensure: (predicate, onFail) => (task) => (signal) => Deferred.from.Promise(Deferred.to.Promise(task(signal)).then(Result.ensure(predicate, onFail))),
+	/**
+	* Maps both the Err and Ok channels simultaneously.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Task.Result.make.ok(42),
+	*   Task.Result.bimap(
+	*     (err: string) => new Error(err),
+	*     (n: number) => n * 2
+	*   )
+	* ); // Task.Result resolving to Ok(84)
+	* ```
+	*/
+	bimap: (onErr, onOk) => (task) => (signal) => Deferred.from.Promise(Deferred.to.Promise(task(signal)).then(Result.bimap(onErr, onOk)))
 };
 //#endregion
 //#region src/internal/InternalTypes.ts
@@ -5360,14 +5421,33 @@ sync: syncTask },
 	})),
 	/**
 	* Runs multiple Tasks in parallel and collects their results.
+	* An optional `concurrency` option limits the number of tasks executing at any given time.
 	*
 	* @example
 	* ```ts
 	* Task.all([loadConfig, detectLocale, loadTheme])();
 	* // Deferred<[Config, string, Theme]>
+	*
+	* Task.all([loadConfig, detectLocale, loadTheme], { concurrency: 2 })();
 	* ```
 	*/
-	all: (tasks) => fromPromise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))),
+	all: (tasks, options) => fromPromise((signal) => {
+		const concurrency = options?.concurrency;
+		if (concurrency === void 0 || concurrency <= 0 || tasks.length <= concurrency) return Promise.all(tasks.map((t) => toPromise(t, signal)));
+		const len = tasks.length;
+		const results = new Array(len);
+		let nextIndex = 0;
+		const worker = async () => {
+			while (nextIndex < len) {
+				const currentIndex = nextIndex++;
+				results[currentIndex] = await toPromise(tasks[currentIndex], signal);
+			}
+		};
+		const workerCount = Math.min(concurrency, len);
+		const workers = [];
+		for (let i = 0; i < workerCount; i++) workers.push(worker());
+		return Promise.all(workers).then(() => results);
+	}),
 	/**
 	* Delays the execution of a Task by the specified duration.
 	* Useful for debouncing or rate limiting.
@@ -5434,21 +5514,21 @@ sync: syncTask },
 		return run(times);
 	}),
 	/**
-	* Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-	* An optional delay duration can be inserted between runs.
-	* An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+	* Polls a Task repeatedly until the result satisfies a predicate, returning that result.
+	* An optional delay duration can be inserted between polling runs.
+	* An optional `attempts` cap stops the loop after N calls — the last value is returned
 	* regardless of whether the predicate was satisfied.
 	*
 	* @example
 	* ```ts
 	* pipe(
 	*   checkStatus,
-	*   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+	*   Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
 	* )(); // polls every 500ms until status is "ready"
 	* ```
 	*/
-	repeatUntil: (options) => (task) => fromPromise((signal) => {
-		const { when: predicate, delay: delayDuration, maxAttempts } = options;
+	poll: (options) => (task) => fromPromise((signal) => {
+		const { until: predicate, delay: delayDuration, attempts } = options;
 		const wait = () => new Promise((r) => {
 			let timerId;
 			const onAbort = () => {
@@ -5465,7 +5545,7 @@ sync: syncTask },
 			if (signal?.aborted && lastValue !== void 0) return Promise.resolve(lastValue);
 			return toPromise(task, signal).then((a) => {
 				if (predicate(a)) return a;
-				if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+				if (attempts !== void 0 && attempt >= attempts) return a;
 				if (signal?.aborted) return a;
 				return wait().then(() => run(attempt + 1, a));
 			});
@@ -6025,6 +6105,12 @@ Object.defineProperty(exports, "Equality", {
 		return Equality;
 	}
 });
+Object.defineProperty(exports, "EventBus", {
+	enumerable: true,
+	get: function() {
+		return EventBus;
+	}
+});
 Object.defineProperty(exports, "Lazy", {
 	enumerable: true,
 	get: function() {
@@ -6115,12 +6201,6 @@ Object.defineProperty(exports, "State", {
 		return State;
 	}
 });
-Object.defineProperty(exports, "Stream", {
-	enumerable: true,
-	get: function() {
-		return Stream;
-	}
-});
 Object.defineProperty(exports, "Task", {
 	enumerable: true,
 	get: function() {