@vielzeug/flux 26.11.11 → 26.11.13

package/dist/flux.js

@@ -44,7 +44,10 @@ function toIterator(e, t) {
 			value: void 0
 		});
 	}, complete = () => {
-		i.kind === "open" && (i.kind = "complete", detach(), resolveDone());
+		i.kind === "open" && (i = {
+			kind: "complete",
+			queue: i.queue
+		}, detach(), resolveDone());
 	}, fail = (e) => {
 		if (i.kind === "open") for (i = {
 			kind: "error",
@@ -220,7 +223,7 @@ function replayCapacity(e) {
 function createChannel(e = {}) {
 	let t = replayCapacity(e), n = new AbortController(), r = /* @__PURE__ */ new Set(), i = [];
 	"initial" in e && t > 0 && i.push(e.initial);
-	let a = stream((e) => {
+	let a = !1, o = [], s = stream((e) => {
 		if (n.signal.aborted) e.complete();
 		else {
 			for (let t of i) e.next(t);
@@ -230,18 +233,18 @@ function createChannel(e = {}) {
 		if (!n.signal.aborted) {
 			n.abort();
 			for (let e of [...r]) e.complete();
-			r.clear(), i.length = 0, s.length = 0;
+			r.clear(), i.length = 0, o.length = 0;
 		}
-	}, o = !1, s = [], flush = () => {
-		o = !0;
+	}, flush = () => {
+		a = !0;
 		try {
-			for (; s.length > 0;) {
-				let e = s.shift();
+			for (; o.length > 0;) {
+				let e = o.shift();
 				t > 0 && (i.length === t && i.shift(), i.push(e));
 				for (let t of [...r]) t.next(e);
 			}
 		} finally {
-			o = !1;
+			a = !1;
 		}
 	};
 	return {
@@ -253,9 +256,9 @@ function createChannel(e = {}) {
 			return n.signal.aborted;
 		},
 		send(e) {
-			n.signal.aborted || (s.push(e), o || flush());
+			n.signal.aborted || (o.push(e), a || flush());
 		},
-		stream: a,
+		stream: s,
 		[Symbol.dispose]: dispose
 	};
 }
@@ -344,17 +347,6 @@ function combineLatest(...e) {
 		});
 	});
 }
-// src/_scheduler.ts
-var e = {
-	delay(e, t) {
-		let n = setTimeout(e, t);
-		return () => clearTimeout(n);
-	},
-	repeat(e, t) {
-		let n = setInterval(e, t);
-		return () => clearInterval(n);
-	}
-};
 // src/operators/creation.ts
 function of(...e) {
 	return stream((t) => {
@@ -417,19 +409,19 @@ function fromEvent(e, t) {
 		return e.addEventListener(t, listener), () => e.removeEventListener(t, listener);
 	});
 }
-function interval(t) {
-	return assertDuration(t, "Interval duration"), stream((n) => {
-		let r = 0;
-		return e.repeat(() => n.next(r++), t);
+function interval(e) {
+	return assertDuration(e, "Interval duration"), stream((t) => {
+		let n = 0, r = setInterval(() => t.next(n++), e);
+		return () => clearInterval(r);
 	});
 }
-function timer(t) {
-	return assertDuration(t.delay, "Timer delay"), t.interval !== void 0 && assertDuration(t.interval, "Timer interval"), stream((n) => {
-		let r = 0, i, a = e.delay(() => {
-			n.next(r++), t.interval === void 0 ? n.complete() : i = e.repeat(() => n.next(r++), t.interval);
-		}, t.delay);
+function timer(e) {
+	return assertDuration(e.delay, "Timer delay"), e.interval !== void 0 && assertDuration(e.interval, "Timer interval"), stream((t) => {
+		let n = 0, r, i = setTimeout(() => {
+			t.next(n++), e.interval === void 0 ? t.complete() : r = setInterval(() => t.next(n++), e.interval);
+		}, e.delay);
 		return () => {
-			a(), i?.();
+			clearTimeout(i), r !== void 0 && clearInterval(r);
 		};
 	});
 }
@@ -477,43 +469,46 @@ function takeUntil(e) {
 		};
 	});
 }
-function debounce(t) {
-	return assertDuration(t, "Debounce duration"), (n) => stream((r, i) => {
-		let a, o, s = !1, flush = () => {
-			a = void 0, s && (s = !1, r.next(o));
-		}, c = link(n, {
+function debounce(e) {
+	return assertDuration(e, "Debounce duration"), (t) => stream((n, r) => {
+		let cancel, i, a = !1, flush = () => {
+			cancel = void 0, a && (a = !1, n.next(i));
+		}, o = link(t, {
 			complete() {
-				a?.(), flush(), r.complete();
+				cancel?.(), flush(), n.complete();
 			},
-			error: r.error,
-			next(n) {
-				o = n, s = !0, a?.(), a = e.delay(flush, t);
+			error: n.error,
+			next(t) {
+				i = t, a = !0, cancel?.();
+				let n = setTimeout(flush, e);
+				cancel = () => clearTimeout(n);
 			}
-		}, i);
+		}, r);
 		return () => {
-			a?.(), c.unsubscribe();
+			cancel?.(), o.unsubscribe();
 		};
 	});
 }
-function timeout(t) {
-	return assertDuration(t, "Timeout duration"), (n) => stream((r, i) => {
-		let a, start = () => {
-			a = e.delay(() => r.error(new FluxTimeoutError(t)), t);
+function timeout(e) {
+	return assertDuration(e, "Timeout duration"), (t) => stream((n, r) => {
+		let cancel, start = () => {
+			let t = setTimeout(() => n.error(new FluxTimeoutError(e)), e);
+			cancel = () => clearTimeout(t);
 		};
 		start();
-		let o = link(n, {
+		let i = link(t, {
 			complete() {
-				a(), r.complete();
+				cancel(), n.complete();
 			},
 			error(e) {
-				a(), r.error(e);
+				cancel(), n.error(e);
 			},
 			next(e) {
-				a(), start(), r.next(e);
+				cancel(), start(), n.next(e);
 			}
-		}, i);
+		}, r);
 		return () => {
-			a(), o.unsubscribe();
+			cancel(), i.unsubscribe();
 		};
 	});
 }
@@ -587,146 +582,149 @@ function switchMap(e) {
 		};
 	});
 }
-function flatten(e, t) {
-	let n = t.concurrency === Infinity;
-	return n || (assertPositiveInteger(t.concurrency, "mergeMap concurrency"), assertPositiveInteger(t.capacity, "mergeMap capacity")), (r) => stream((i, a) => {
-		let o = [], s = /* @__PURE__ */ new Set(), c = !1, l = {}, finish = () => {
-			c && s.size === 0 && o.length === 0 && i.complete();
+function flatten(e, t, n) {
+	let { capacity: r, concurrency: i } = t, a = i === "unbounded";
+	if (!a) {
+		if (assertPositiveInteger(i, `${n} concurrency`), r === void 0) throw RangeError(`${n} requires capacity when concurrency is finite; use { concurrency: "unbounded" } to start every value immediately`);
+		assertPositiveInteger(r, `${n} capacity`);
+	}
+	let o = a ? Infinity : i, s = a ? Infinity : r;
+	return (t) => stream((r, i) => {
+		let a = [], c = /* @__PURE__ */ new Set(), l = !1, u = {}, finish = () => {
+			l && c.size === 0 && a.length === 0 && r.complete();
 		}, startInner = (t) => {
 			tryCall(() => {
 				let n = {};
 				n.current = link(e(t), {
 					complete() {
-						n.current && s.delete(n.current), drain();
+						n.current && c.delete(n.current), drain();
 					},
-					error: i.error,
-					next: i.next
-				}, a), n.current.closed ? drain() : s.add(n.current);
-			}, i.error);
+					error: r.error,
+					next: r.next
+				}, i), n.current.closed ? drain() : c.add(n.current);
+			}, r.error);
 		}, drain = () => {
-			if (!a.aborted) {
-				for (; o.length > 0 && (n || s.size < t.concurrency);) {
-					let e = o.shift();
+			if (!i.aborted) {
+				for (; a.length > 0 && c.size < o;) {
+					let e = a.shift();
 					startInner(e);
 				}
 				finish();
 			}
 		};
-		return l.current = link(r, {
+		return u.current = link(t, {
 			complete() {
-				c = !0, finish();
+				l = !0, finish();
 			},
-			error: i.error,
+			error: r.error,
 			next(e) {
-				!n && o.length >= t.capacity ? (l.current?.unsubscribe(), i.error(new FluxCapacityError(t.capacity, "mergeMap buffer capacity exceeded"))) : (o.push(e), drain());
+				a.length >= s ? (u.current?.unsubscribe(), r.error(new FluxCapacityError(s, `${n} buffer capacity exceeded`))) : (a.push(e), drain());
 			}
-		}, a), () => {
-			l.current?.unsubscribe();
-			for (let e of s) e.unsubscribe();
-			o.length = 0;
+		}, i), () => {
+			u.current?.unsubscribe();
+			for (let e of c) e.unsubscribe();
+			a.length = 0;
 		};
 	});
 }
 function mergeMap(e, t) {
-	return flatten(e, t);
+	return flatten(e, t, "mergeMap");
 }
 function concatMap(e, t) {
 	return flatten(e, {
 		capacity: t.capacity,
 		concurrency: 1
-	});
+	}, "concatMap");
 }
 // src/operators/utility.ts
-function retry(t) {
-	return assertNonNegativeInteger(t.times, "retry times"), (n) => stream((r, i) => {
-		let a = 0, o, s, start = () => {
-			if (i.aborted) return;
-			let c = link(n, {
-				complete: r.complete,
-				error(n) {
-					if (a === t.times) {
-						r.error(n);
+function retry(e) {
+	return assertNonNegativeInteger(e.times, "retry times"), (t) => stream((n, r) => {
+		let i = 0, a, o, start = () => {
+			if (r.aborted) return;
+			let s = link(t, {
+				complete: n.complete,
+				error(t) {
+					if (i === e.times) {
+						n.error(t);
 						return;
 					}
-					let o = a++, c;
+					let a = i++, s;
 					if (tryCall(() => {
-						c = typeof t.delay == "function" ? t.delay(o) : t.delay;
-					}, r.error), !i.aborted) {
-						if (c !== void 0) try {
-							assertDuration(c, "Retry delay");
+						s = typeof e.delay == "function" ? e.delay(a) : e.delay;
+					}, n.error), !r.aborted) {
+						if (s !== void 0) try {
+							assertDuration(s, "Retry delay");
 						} catch (e) {
-							r.error(e);
+							n.error(e);
 							return;
 						}
-						c === void 0 || c === 0 ? queueMicrotask(start) : s = e.delay(start, c);
+						s === void 0 || s === 0 ? queueMicrotask(start) : o = setTimeout(start, s);
 					}
 				},
-				next: r.next
-			}, i);
-			c.closed || (o = c);
+				next: n.next
+			}, r);
+			s.closed || (a = s);
 		};
 		return start(), () => {
-			s?.(), o?.unsubscribe();
+			o !== void 0 && clearTimeout(o), a?.unsubscribe();
 		};
 	});
 }
+function watchSignal(e, t, n) {
+	if (!e) return () => {};
+	let abort = () => {
+		t.abort(), n(abortError(e, "Stream consumption aborted"));
+	};
+	return e.aborted ? (abort(), null) : (e.addEventListener("abort", abort, { once: !0 }), () => e.removeEventListener("abort", abort));
+}
 function first(e, t) {
 	return new Promise((n, r) => {
-		let i = new AbortController(), abort = () => {
-			i.abort(), r(abortError(t?.signal, "Stream consumption aborted"));
-		};
-		t?.signal?.aborted ? abort() : (t?.signal?.addEventListener("abort", abort, { once: !0 }), link(e, {
+		let i = new AbortController(), a = watchSignal(t?.signal, i, r);
+		a && link(e, {
 			complete() {
-				t?.signal?.removeEventListener("abort", abort), "defaultValue" in (t ?? {}) ? n(t.defaultValue) : r(new FluxEmptyError());
+				a(), "defaultValue" in (t ?? {}) ? n(t.defaultValue) : r(new FluxEmptyError());
 			},
 			error(e) {
-				t?.signal?.removeEventListener("abort", abort), r(e);
+				a(), r(e);
 			},
 			next(e) {
-				t?.signal?.removeEventListener("abort", abort), i.abort(), n(e);
+				a(), i.abort(), n(e);
 			}
-		}, i.signal));
+		}, i.signal);
 	});
 }
 function last(e, t) {
 	return new Promise((n, r) => {
-		let i = new AbortController(), abort = () => {
-			i.abort(), r(abortError(t?.signal, "Stream consumption aborted"));
-		};
-		if (t?.signal?.aborted) {
-			abort();
-			return;
-		}
-		let a = !1, o;
-		t?.signal?.addEventListener("abort", abort, { once: !0 }), link(e, {
+		let i = new AbortController(), a = watchSignal(t?.signal, i, r);
+		if (!a) return;
+		let o = !1, s;
+		link(e, {
 			complete() {
-				t?.signal?.removeEventListener("abort", abort), a ? n(o) : "defaultValue" in (t ?? {}) ? n(t.defaultValue) : r(new FluxEmptyError());
+				a(), o ? n(s) : "defaultValue" in (t ?? {}) ? n(t.defaultValue) : r(new FluxEmptyError());
 			},
 			error(e) {
-				t?.signal?.removeEventListener("abort", abort), r(e);
+				a(), r(e);
 			},
 			next(e) {
-				a = !0, o = e;
+				o = !0, s = e;
 			}
 		}, i.signal);
 	});
 }
 function toArray(e, t) {
 	return assertNonNegativeInteger(t.maxItems, "toArray maxItems"), new Promise((n, r) => {
-		let i = new AbortController(), a = [], abort = () => {
-			i.abort(), r(abortError(t?.signal, "Stream consumption aborted"));
-		};
-		t.signal?.aborted ? abort() : (t.signal?.addEventListener("abort", abort, { once: !0 }), link(e, {
+		let i = new AbortController(), a = [], o = watchSignal(t.signal, i, r);
+		o && link(e, {
 			complete() {
-				t.signal?.removeEventListener("abort", abort), n(a);
+				o(), n(a);
 			},
 			error(e) {
-				t.signal?.removeEventListener("abort", abort), r(e);
+				o(), r(e);
 			},
 			next(e) {
-				a.length === t.maxItems ? (t.signal?.removeEventListener("abort", abort), i.abort(), r(new FluxCapacityError(t.maxItems, "toArray maxItems exceeded"))) : a.push(e);
+				a.length === t.maxItems ? (o(), i.abort(), r(new FluxCapacityError(t.maxItems, "toArray maxItems exceeded"))) : a.push(e);
 			}
-		}, i.signal));
+		}, i.signal);
 	});
 }
 // src/pipe.ts