@mearie/core 0.1.0 → 0.2.0

package/dist/make-C7I1YIXm.mjs

@@ -0,0 +1,712 @@
+//#region src/stream/pipe.ts
+/**
+* @param source - The source stream.
+* @param operators - The operators to apply.
+* @returns The result of the last operator.
+*/
+function pipe(source, ...operators) {
+	return operators.reduce((src, operator) => operator(src), source);
+}
+
+//#endregion
+//#region src/stream/operators/merge-map.ts
+/**
+* Maps each value to a source and flattens all sources into a single output source.
+* Similar to flatMap. Values from all inner sources are merged concurrently.
+* @param fn - Function that returns a source for each value.
+* @returns An operator that flattens mapped sources.
+*/
+const mergeMap = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let outerCompleted = false;
+			let activeInner = 0;
+			let ended = false;
+			const innerSubscriptions = [];
+			const checkComplete = () => {
+				if (outerCompleted && activeInner === 0 && !ended) {
+					ended = true;
+					sink.complete();
+				}
+			};
+			const outerSubscription = source({
+				next(value) {
+					if (ended) return;
+					activeInner++;
+					const innerSubscription = fn(value)({
+						next(innerValue) {
+							if (!ended) sink.next(innerValue);
+						},
+						complete() {
+							activeInner--;
+							checkComplete();
+						}
+					});
+					innerSubscriptions.push(innerSubscription);
+				},
+				complete() {
+					outerCompleted = true;
+					checkComplete();
+				}
+			});
+			return { unsubscribe() {
+				ended = true;
+				outerSubscription.unsubscribe();
+				for (const sub of innerSubscriptions) sub.unsubscribe();
+				innerSubscriptions.length = 0;
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/filter.ts
+function filter(predicate) {
+	return (source) => {
+		return (sink) => {
+			return source({
+				next(value) {
+					if (predicate(value)) sink.next(value);
+				},
+				complete() {
+					sink.complete();
+				}
+			});
+		};
+	};
+}
+
+//#endregion
+//#region src/stream/sources/from-promise.ts
+const fromPromise = (promise) => {
+	return (sink) => {
+		let cancelled = false;
+		promise.then((value) => {
+			if (!cancelled) {
+				sink.next(value);
+				sink.complete();
+			}
+		}, () => {
+			if (!cancelled) sink.complete();
+		});
+		return { unsubscribe() {
+			cancelled = true;
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/operators/merge.ts
+/**
+* Merges multiple sources into a single source.
+* Values are emitted as soon as they arrive from any source.
+* Completes when all sources complete.
+* @param sources - The sources to merge.
+* @returns A merged source.
+*/
+const merge = (...sources) => {
+	return (sink) => {
+		if (sources.length === 0) {
+			sink.complete();
+			return { unsubscribe() {} };
+		}
+		let activeCount = sources.length;
+		const subscriptions = [];
+		let ended = false;
+		let ready = false;
+		const buffer = [];
+		const checkComplete = () => {
+			if (activeCount === 0 && !ended) {
+				ended = true;
+				sink.complete();
+			}
+		};
+		for (const source of sources) {
+			const subscription = source({
+				next(value) {
+					if (!ended) if (ready) sink.next(value);
+					else buffer.push(value);
+				},
+				complete() {
+					activeCount--;
+					if (ready) checkComplete();
+				}
+			});
+			subscriptions.push(subscription);
+		}
+		ready = true;
+		for (const value of buffer) if (!ended) sink.next(value);
+		buffer.length = 0;
+		checkComplete();
+		return { unsubscribe() {
+			ended = true;
+			for (const sub of subscriptions) sub.unsubscribe();
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/operators/tap.ts
+/**
+* Executes a side effect for each value without modifying the stream.
+* Useful for debugging, logging, or triggering side effects.
+* @param fn - The side effect function.
+* @returns An operator that taps into the stream.
+*/
+const tap = (fn) => {
+	return (source) => {
+		return (sink) => {
+			return source({
+				next(value) {
+					fn(value);
+					sink.next(value);
+				},
+				complete() {
+					sink.complete();
+				}
+			});
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/sources/from-array.ts
+/**
+* Creates a source that emits values from an array and completes.
+* @param values - The array of values to emit.
+* @returns A source containing the array values.
+*/
+const fromArray = (values) => {
+	return (sink) => {
+		let cancelled = false;
+		for (const value of values) {
+			if (cancelled) break;
+			sink.next(value);
+		}
+		if (!cancelled) sink.complete();
+		return { unsubscribe() {
+			cancelled = true;
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/compose.ts
+/**
+* @param operators - The operators to compose.
+* @returns A composed operator.
+*/
+function compose(...operators) {
+	return (source) => {
+		return operators.reduce((src, operator) => operator(src), source);
+	};
+}
+
+//#endregion
+//#region src/stream/sinks/subscribe.ts
+/**
+* Subscribe to a Source with an Observer.
+* This is a terminal operator that starts the source execution.
+* @param observer - The observer to receive values.
+* @returns A function that takes a source and returns a subscription.
+*/
+const subscribe = (observer) => {
+	return (source) => {
+		let closed = false;
+		const subscription = source({
+			next(value) {
+				if (!closed) observer.next?.(value);
+			},
+			complete() {
+				if (!closed) {
+					closed = true;
+					observer.complete?.();
+				}
+			}
+		});
+		return () => {
+			closed = true;
+			subscription.unsubscribe();
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/sinks/publish.ts
+const publish = (source) => {
+	source({
+		next() {},
+		complete() {}
+	});
+};
+
+//#endregion
+//#region src/stream/sinks/collect.ts
+/**
+* Collects the last value emitted by a source.
+* This is a terminal operator that returns the last emitted value.
+* Rejects if the source completes without emitting any values.
+* @param source - The source to collect from.
+* @returns A promise that resolves with the last emitted value.
+*/
+const collect = (source) => {
+	return new Promise((resolve, reject) => {
+		let lastValue;
+		let hasValue = false;
+		source({
+			next(value) {
+				lastValue = value;
+				hasValue = true;
+			},
+			complete() {
+				if (hasValue) resolve(lastValue);
+				else reject(/* @__PURE__ */ new Error("Source completed without emitting any values"));
+			}
+		});
+	});
+};
+
+//#endregion
+//#region src/stream/sinks/collect-all.ts
+/**
+* Collects all values from a source into an array.
+* This is a terminal operator that accumulates all emitted values.
+* @param source - The source to collect values from.
+* @returns A promise that resolves with an array of all emitted values.
+*/
+const collectAll = (source) => {
+	return new Promise((resolve) => {
+		const results = [];
+		source({
+			next(value) {
+				results.push(value);
+			},
+			complete() {
+				resolve(results);
+			}
+		});
+	});
+};
+
+//#endregion
+//#region src/stream/sinks/peek.ts
+/**
+* Synchronously reads the first value from a source and immediately unsubscribes.
+* This is useful for reading the current state without maintaining a long-lived subscription.
+* Throws if the source does not emit a value synchronously.
+* @param source - The source to peek from.
+* @returns The first value emitted by the source.
+*/
+const peek = (source) => {
+	let value;
+	let hasValue = false;
+	source({
+		next(v) {
+			if (!hasValue) {
+				value = v;
+				hasValue = true;
+			}
+		},
+		complete() {}
+	}).unsubscribe();
+	if (hasValue) return value;
+	else throw new Error("Source did not emit a value synchronously");
+};
+
+//#endregion
+//#region src/stream/operators/map.ts
+/**
+* Maps each value from the source through a transformation function.
+* @param fn - The transformation function.
+* @returns An operator that maps values.
+*/
+const map = (fn) => {
+	return (source) => {
+		return (sink) => {
+			return source({
+				next(value) {
+					sink.next(fn(value));
+				},
+				complete() {
+					sink.complete();
+				}
+			});
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/take.ts
+/**
+* Takes only the first N values from the source and completes.
+* @param count - The number of values to take.
+* @returns An operator that takes values.
+*/
+const take = (count) => {
+	return (source) => {
+		return (sink) => {
+			let subscription = null;
+			const limit = Math.floor(count);
+			if (limit <= 0) {
+				sink.complete();
+				return { unsubscribe() {} };
+			}
+			let taken = 0;
+			let completed = false;
+			subscription = source({
+				next(value) {
+					if (!completed && taken < limit) {
+						sink.next(value);
+						taken++;
+						if (taken >= limit) {
+							completed = true;
+							sink.complete();
+							subscription?.unsubscribe();
+						}
+					}
+				},
+				complete() {
+					if (!completed) {
+						completed = true;
+						sink.complete();
+					}
+				}
+			});
+			if (completed) subscription?.unsubscribe();
+			return { unsubscribe() {
+				if (!completed) {
+					completed = true;
+					subscription.unsubscribe();
+				}
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/take-until.ts
+/**
+* Emits values from the source until the notifier source emits a value.
+* When the notifier emits, the source is cancelled and completes immediately.
+* @param notifier - Source that signals when to complete.
+* @returns Operator that completes when notifier emits.
+*/
+const takeUntil = (notifier) => {
+	return (source) => {
+		return (sink) => {
+			let sourceSubscription = null;
+			let notifierSubscription = null;
+			let completed = false;
+			const complete = () => {
+				if (completed) return;
+				completed = true;
+				if (sourceSubscription) sourceSubscription.unsubscribe();
+				if (notifierSubscription) notifierSubscription.unsubscribe();
+				sink.complete();
+			};
+			notifierSubscription = notifier({
+				next() {
+					complete();
+				},
+				complete() {}
+			});
+			sourceSubscription = source({
+				next(value) {
+					if (!completed) sink.next(value);
+				},
+				complete() {
+					complete();
+				}
+			});
+			return { unsubscribe() {
+				complete();
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/share.ts
+/**
+* Shares a single source across multiple subscribers (multicast).
+* The source is only executed once, and all subscribers receive the same values.
+* This is essential for deduplication and caching scenarios.
+* @returns An operator that shares the source.
+*/
+const share = () => {
+	return (source) => {
+		const sinks = [];
+		let subscription = null;
+		let started = false;
+		let completed = false;
+		return (sink) => {
+			if (completed) {
+				sink.complete();
+				return { unsubscribe() {} };
+			}
+			sinks.push(sink);
+			if (!started) {
+				started = true;
+				subscription = source({
+					next(value) {
+						for (const s of [...sinks]) {
+							if (completed) break;
+							s.next(value);
+						}
+					},
+					complete() {
+						if (!completed) {
+							completed = true;
+							for (const s of [...sinks]) s.complete();
+							sinks.length = 0;
+						}
+					}
+				});
+			}
+			return { unsubscribe() {
+				const idx = sinks.indexOf(sink);
+				if (idx !== -1) sinks.splice(idx, 1);
+				if (sinks.length === 0 && subscription) {
+					subscription.unsubscribe();
+					subscription = null;
+					started = false;
+				}
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/switch-map.ts
+const switchMap = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let outerCompleted = false;
+			let ended = false;
+			let innerSubscription = null;
+			let hasInner = false;
+			const checkComplete = () => {
+				if (outerCompleted && !hasInner && !ended) {
+					ended = true;
+					sink.complete();
+				}
+			};
+			const outerSubscription = source({
+				next(value) {
+					if (ended) return;
+					if (innerSubscription) {
+						innerSubscription.unsubscribe();
+						innerSubscription = null;
+					}
+					hasInner = true;
+					innerSubscription = fn(value)({
+						next(innerValue) {
+							if (!ended) sink.next(innerValue);
+						},
+						complete() {
+							hasInner = false;
+							innerSubscription = null;
+							checkComplete();
+						}
+					});
+				},
+				complete() {
+					outerCompleted = true;
+					checkComplete();
+				}
+			});
+			return { unsubscribe() {
+				ended = true;
+				outerSubscription.unsubscribe();
+				if (innerSubscription) {
+					innerSubscription.unsubscribe();
+					innerSubscription = null;
+				}
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/initialize.ts
+/**
+* Executes a side effect when the source is initialized (being subscribed to).
+* @param fn - The side effect function.
+* @returns An operator that executes the side effect when the source is initialized.
+*/
+const initialize = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let completed = false;
+			const subscription = source({
+				next(value) {
+					if (!completed) sink.next(value);
+				},
+				complete() {
+					if (!completed) {
+						completed = true;
+						sink.complete();
+					}
+				}
+			});
+			fn();
+			return { unsubscribe() {
+				completed = true;
+				subscription.unsubscribe();
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/finalize.ts
+/**
+* Executes a side effect when the source terminates (completes or unsubscribes).
+* @param fn - The side effect function.
+* @returns An operator that executes the side effect when the source terminates.
+*/
+const finalize = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let completed = false;
+			const subscription = source({
+				next(value) {
+					if (!completed) sink.next(value);
+				},
+				complete() {
+					if (!completed) {
+						completed = true;
+						fn();
+						sink.complete();
+					}
+				}
+			});
+			return { unsubscribe() {
+				if (!completed) {
+					completed = true;
+					fn();
+				}
+				subscription.unsubscribe();
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/sources/from-value.ts
+/**
+* Creates a source that emits a single value and completes.
+* @param value - The value to emit.
+* @returns A source containing the single value.
+*/
+const fromValue = (value) => {
+	return (sink) => {
+		let cancelled = false;
+		if (!cancelled) {
+			sink.next(value);
+			sink.complete();
+		}
+		return { unsubscribe() {
+			cancelled = true;
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/sources/make-subject.ts
+/**
+* Creates a new Subject which can be used as an IO event hub.
+* @returns A new Subject.
+*/
+const makeSubject = () => {
+	const sinks = [];
+	const source = (sink) => {
+		sinks.push(sink);
+		return { unsubscribe() {
+			const idx = sinks.indexOf(sink);
+			if (idx !== -1) sinks.splice(idx, 1);
+		} };
+	};
+	const next = (value) => {
+		for (const sink of [...sinks]) sink.next(value);
+	};
+	const complete = () => {
+		for (const sink of [...sinks]) sink.complete();
+		sinks.length = 0;
+	};
+	return {
+		source,
+		next,
+		complete
+	};
+};
+
+//#endregion
+//#region src/stream/sources/from-subscription.ts
+const fromSubscription = (pull, poke) => {
+	return (sink) => {
+		let teardown = null;
+		let cancelled = false;
+		const initialValue = pull();
+		sink.next(initialValue);
+		if (cancelled) return { unsubscribe() {
+			cancelled = true;
+		} };
+		teardown = poke(() => {
+			if (!cancelled) {
+				const value = pull();
+				sink.next(value);
+			}
+		});
+		return { unsubscribe() {
+			cancelled = true;
+			if (teardown) {
+				teardown();
+				teardown = null;
+			}
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/sources/make.ts
+/**
+* Creates a new Source from scratch from a passed subscriber function.
+*
+* The subscriber function receives an observer with next and complete callbacks.
+* It must return a teardown function which is called when the source is cancelled.
+* @internal
+* @param subscriber - A callback that is called when the Source is subscribed to.
+* @returns A Source created from the subscriber parameter.
+*/
+const make = (subscriber) => {
+	return (sink) => {
+		let cancelled = false;
+		let teardown = null;
+		teardown = subscriber({
+			next: (value) => {
+				if (!cancelled) sink.next(value);
+			},
+			complete: () => {
+				if (!cancelled) {
+					cancelled = true;
+					if (teardown) {
+						teardown();
+						teardown = null;
+					}
+					sink.complete();
+				}
+			}
+		});
+		return { unsubscribe() {
+			cancelled = true;
+			if (teardown) {
+				teardown();
+				teardown = null;
+			}
+		} };
+	};
+};
+
+//#endregion
+export { mergeMap as C, filter as S, compose as _, finalize as a, merge as b, share as c, map as d, peek as f, subscribe as g, publish as h, fromValue as i, takeUntil as l, collect as m, fromSubscription as n, initialize as o, collectAll as p, makeSubject as r, switchMap as s, make as t, take as u, fromArray as v, pipe as w, fromPromise as x, tap as y };