@vielzeug/stateit 2.0.0 → 3.0.1

package/dist/stateit.js

@@ -1,270 +1,336 @@
-//#region src/runtime.ts
-var e = Symbol("stateit.uninitialized"), t = {
-	cleanups: null,
-	deps: null,
-	effect: null
-}, n = {
-	depth: 0,
-	pending: /* @__PURE__ */ new Set()
-}, r = 100, i = (e) => {
-	e.maxEffectIterations !== void 0 && (r = e.maxEffectIterations);
-}, a = () => {
-	n.depth = 0, t.deps = null, t.effect = null, t.cleanups = null, n.pending.clear();
-}, o = class {
-	#e = /* @__PURE__ */ new Set();
-	_track() {
-		if (t.deps !== null && t.effect !== null) {
-			let e = t.effect;
-			this.#e.add(e), t.deps.add(() => this.#e.delete(e));
-		}
-	}
-	_notify() {
-		if (this.#e.size === 0) return;
-		if (n.depth > 0) {
-			for (let e of this.#e) n.pending.add(e);
-			return;
-		}
-		let e = [];
-		for (let t of [...this.#e]) try {
-			t();
-		} catch (t) {
-			e.push(t);
-		}
-		if (e.length) throw e.length === 1 ? e[0] : AggregateError(e, "[stateit] multiple subscriber errors");
-	}
-}, s = (e, n, r, i) => {
-	let a = t.effect, o = t.deps, s = t.cleanups;
-	t.effect = e, t.deps = n, t.cleanups = r;
-	try {
-		return i();
-	} finally {
-		t.effect = a, t.deps = o, t.cleanups = s;
-	}
-}, c = () => {
-	let e = [...n.pending];
-	n.pending.clear();
-	let t = [];
-	for (let n of e) try {
-		n();
+//#region src/stateit.ts
+var e = 100, t = Symbol("stateit.is-signal"), n = Symbol.observable ?? Symbol.for("observable"), r = n, i = (e) => Object.assign(e, {
+	dispose: e,
+	[Symbol.dispose]: e
+}), a = /* @__PURE__ */ new WeakMap(), o = (e) => e instanceof Error ? e : Error(String(e)), s = (e, t) => {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError(t);
+}, c = (e, t) => {
+	let n = [];
+	for (let t of e) try {
+		t();
 	} catch (e) {
-		t.push(e);
+		n.push(e);
 	}
-	if (t.length) throw t.length === 1 ? t[0] : AggregateError(t, "[stateit] batch errors");
-}, l = (e) => {
-	n.depth++;
+	if (n.length === 1) throw n[0];
+	if (n.length > 1) throw AggregateError(n, `[stateit] ${t}`);
+}, l = (e, t, n) => {
+	let r = o(e);
+	throw t.length === 0 ? r : AggregateError([r, ...t.map(o)], `[stateit] ${n}`, { cause: r });
+}, u = (e) => {
 	try {
-		let t = e();
-		return --n.depth === 0 && c(), t;
+		return c(e, "cleanup errors"), [];
 	} catch (e) {
-		if (--n.depth === 0) try {
-			c();
-		} catch {}
-		throw e;
+		return e instanceof AggregateError ? e.errors : [e];
 	}
-}, u = Symbol("stateit.signal"), d = Symbol("stateit.store"), f = class extends o {
-	[u] = !0;
-	#e;
-	#t = e;
-	#n = !0;
-	#r = !1;
-	#i;
-	#a = /* @__PURE__ */ new Set();
-	#o = () => {
-		this.#n || (this.#n = !0, this._notify());
-	};
-	constructor(e, t) {
-		super(), this.#e = e, this.#i = t?.equals ?? Object.is, t?.lazy || this.#s();
+}, d = null, f = null, p = null, m = null, h = (e, t, n, r, i) => {
+	let a = d, o = f, s = p, c = m;
+	d = e, f = t, p = n, m = r;
+	try {
+		return i();
+	} finally {
+		d = a, f = o, p = s, m = c;
 	}
-	#s() {
-		for (let e of this.#a) e();
-		this.#a.clear();
-		let t = s(this.#o, this.#a, null, this.#e);
-		this.#n = !1, (this.#t === e || !this.#i(this.#t, t)) && (this.#t = t);
+}, g = 0, _ = /* @__PURE__ */ new Set(), v = /* @__PURE__ */ new Set(), y = (e) => {
+	let t = new Set(e), n = /* @__PURE__ */ new Map();
+	for (let t of e) n.set(t, 0);
+	for (let r of e) for (let e of r.computedSubscribers()) t.has(e) && n.set(e, (n.get(e) ?? 0) + 1);
+	let r = [];
+	for (let t of e) (n.get(t) ?? 0) === 0 && r.push(t);
+	let i = [];
+	for (; r.length > 0;) {
+		let e = r.shift();
+		i.push(e);
+		for (let i of e.computedSubscribers()) {
+			if (!t.has(i)) continue;
+			let e = (n.get(i) ?? 0) - 1;
+			n.set(i, e), e === 0 && r.push(i);
+		}
 	}
-	get value() {
-		return this.#r ? this.#t : (this.#n && this.#s(), this._track(), this.#t);
+	if (i.length < e.length) for (let t of e) i.includes(t) || i.push(t);
+	return i;
+}, b = (e) => {
+	let t = [...e.computedSubscribers()], n = /* @__PURE__ */ new Set();
+	for (let t of e.subscribers()) _.add(t);
+	for (; t.length > 0;) {
+		let e = t.pop();
+		if (!n.has(e) && (n.add(e), e.markDirty())) {
+			v.add(e);
+			for (let n of e.computedSubscribers()) t.push(n);
+		}
 	}
-	peek() {
-		if (this.#t === e) {
-			if (this.#r) return;
-			this.#s();
+}, x = () => {
+	for (; v.size > 0;) {
+		let e = y([...v]);
+		v.clear();
+		for (let t of e) if (t.hasAnySubscribers() && t.refreshIfDirty()) {
+			for (let e of t.subscribers()) _.add(e);
+			for (let e of t.computedSubscribers()) e.markDirty() && v.add(e);
 		}
-		return this.#t;
 	}
-	get stale() {
-		return this.#n || this.#r;
+}, S = () => {
+	let t = 0;
+	for (; _.size > 0 || v.size > 0;) {
+		if (++t > e) throw Error(`[stateit] infinite flush loop (> ${e} iterations)`);
+		if (v.size > 0 && x(), _.size === 0) continue;
+		let n = [..._];
+		_.clear(), c(n, "subscriber errors");
 	}
-	dispose() {
-		if (!this.#r) {
-			this.#r = !0;
-			for (let e of this.#a) e();
-			this.#a.clear();
+}, C = (e) => {
+	e.hasAnySubscribers() && (b(e), g === 0 && S());
+}, w = class {
+	computedSubs_ = /* @__PURE__ */ new Set();
+	subscribers_ = /* @__PURE__ */ new Set();
+	track() {
+		if (p) {
+			if (f !== null) {
+				let e = f;
+				this.computedSubs_.add(e), p.add(() => this.computedSubs_.delete(e));
+				return;
+			}
+			if (d !== null) {
+				let e = d;
+				this.subscribers_.add(e), p.add(() => this.subscribers_.delete(e));
+			}
 		}
 	}
-	[Symbol.dispose]() {
-		this.dispose();
+	notify() {
+		C(this);
 	}
-}, p = (e, t) => new f(e, t), m = class extends f {
-	#e;
-	constructor(e, t, n) {
-		super(e, n), this.#e = t;
+	hasAnySubscribers() {
+		return this.computedSubs_.size > 0 || this.subscribers_.size > 0;
 	}
-	get value() {
-		return super.value;
+	computedSubscribers() {
+		return this.computedSubs_;
 	}
-	set value(e) {
-		this.#e(e);
+	subscribers() {
+		return this.subscribers_;
 	}
-	update(e) {
-		this.#e(e(this.peek()));
+	subscribe(e) {
+		return this.subscribers_.add(e), i(() => {
+			this.subscribers_.delete(e);
+		});
 	}
-}, h = (e, t, n) => new m(e, t, n), g = (e, t, n) => p(() => t(...e.map((e) => e.value)), n), _ = (e, t) => {
-	let n, i = /* @__PURE__ */ new Set(), a = !1, o = !1, c = !1, l = t?.maxIterations ?? r, u = () => {
-		n?.(), n = void 0;
-		for (let e of i) e();
-		i.clear();
-	}, d = () => {
-		o = !1, u();
-		let r = [], a, l = !1;
-		try {
-			s(f, i, r, () => {
-				let t = e();
-				typeof t == "function" && r.push(t);
-			});
-		} catch (e) {
-			if (t?.onError) l = !0, a = e;
-			else throw e;
-		}
-		return n = r.length > 0 ? () => {
-			for (let e of r) e();
-		} : void 0, l && (u(), t.onError(a), c = !0), l;
-	}, f = () => {
-		if (c || a) {
-			a && (o = !0);
-			return;
-		}
-		a = !0;
-		try {
-			let e = 0;
-			do {
-				if (++e > l) throw Error(`[stateit] effect: possible infinite reactive loop (> ${l} iterations)`);
-				if (d()) break;
-			} while (o);
-		} finally {
-			a = !1;
-		}
-	};
-	f();
-	let p = () => {
-		c || (c = !0, u());
-	};
-	return Object.assign(p, {
-		dispose: p,
-		[Symbol.dispose]: p
-	});
-}, v = (e) => s(null, null, null, e), y = (e) => {
-	t.cleanups?.push(e);
-}, b = class extends o {
-	[u] = !0;
-	#e;
-	#t;
+}, T = class extends w {
+	value_;
+	equals_;
+	[t] = !0;
 	constructor(e, t) {
-		super(), this.#e = e, this.#t = t?.equals ?? Object.is;
+		super(), this.value_ = e, this.equals_ = t ?? Object.is;
 	}
 	get value() {
-		return this._track(), this.#e;
+		return this.track(), this.value_;
 	}
-	set value(e) {
-		this.#t(this.#e, e) || (this.#e = e, this._notify());
+	peek() {
+		return this.value_;
 	}
+	subscribe = (e) => super.subscribe(e);
 	update(e) {
-		this.value = e(this.#e);
+		this.value = e(this.value_);
 	}
-	peek() {
-		return this.#e;
+	set value(e) {
+		this.equals_(this.value_, e) || (this.value_ = e, this.notify());
 	}
-}, x = (e, t) => new b(e, t), S = /* @__PURE__ */ new WeakMap(), C = (e) => {
-	let t = S.get(e);
-	if (t) return t;
-	let n = {
-		get [u]() {
-			return !0;
-		},
-		peek: () => e.peek(),
-		get value() {
-			return e.value;
-		}
-	};
-	return S.set(e, n), n;
-}, w = (e) => typeof e == "object" && !!e && u in e, T = (e) => w(e) ? e.value : e, E = (e) => w(e) ? e.peek() : e, D = (e, t) => {
-	if (e === t) return !0;
-	if (e == null || t == null) return e === t;
-	if (typeof e != "object" || typeof t != "object") return !1;
-	let n = Object.keys(e), r = Object.keys(t);
-	if (n.length !== r.length) return !1;
-	for (let r of n) if (!Object.is(e[r], t[r])) return !1;
-	return !0;
-}, O = class extends b {
-	[d] = !0;
-	#e;
-	#t = !1;
+}, E = class extends w {
+	hasValue_ = !1;
+	value_;
+	dirty_ = !0;
+	computing_ = !1;
+	disposed_ = !1;
+	deps_ = /* @__PURE__ */ new Set();
+	compute_;
+	equals_;
+	[t] = !0;
 	constructor(e, t) {
-		super(e, { equals: t?.equals ?? D }), this.#e = { ...e };
-	}
-	get frozen() {
-		return this.#t;
+		super(), this.compute_ = e, this.equals_ = t ?? Object.is;
 	}
-	get value() {
-		return super.value;
+	markDirty() {
+		return this.disposed_ || this.dirty_ ? !1 : (this.dirty_ = !0, !0);
 	}
-	set value(e) {
-		this.#t || (super.value = e);
+	refreshIfDirty() {
+		return this.dirty_ ? this.recompute() : !1;
 	}
-	patch(e) {
-		this.value = {
-			...this.peek(),
-			...e
-		};
+	recompute() {
+		if (this.computing_) throw Error("[stateit] computed cycle detected");
+		for (let e of this.deps_) e();
+		this.deps_.clear(), this.computing_ = !0;
+		try {
+			let e = h(null, this, this.deps_, null, this.compute_);
+			return this.dirty_ = !1, !this.hasValue_ || !this.equals_(this.value_, e) ? (this.hasValue_ = !0, this.value_ = e, !0) : !1;
+		} catch (e) {
+			let t = u(this.deps_);
+			return this.deps_.clear(), l(e, t, "computed failed dependency cleanup errors");
+		} finally {
+			this.computing_ = !1;
+		}
 	}
-	update(e) {
-		this.value = e({ ...this.peek() });
+	get value() {
+		if (this.disposed_) throw Error("[stateit] Cannot read disposed computed signal");
+		return this.refreshIfDirty(), this.track(), this.value_;
 	}
-	reset() {
-		this.value = { ...this.#e };
+	peek() {
+		if (this.disposed_) throw Error("[stateit] Cannot read disposed computed signal");
+		return this.refreshIfDirty(), this.value_;
 	}
-	select(e, t) {
-		return p(() => e(this.value), t);
+	subscribe = (e) => {
+		if (this.disposed_) throw Error("[stateit] Cannot subscribe to a disposed computed signal");
+		return this.refreshIfDirty(), super.subscribe(e);
+	};
+	dispose() {
+		if (!this.disposed_) {
+			this.disposed_ = !0;
+			for (let e of this.deps_) e();
+			this.deps_.clear();
+		}
 	}
-	freeze() {
-		this.#t = !0;
+	[Symbol.dispose]() {
+		this.dispose();
 	}
-}, k = (e, t) => new O(e, t), A = (e) => typeof e == "object" && !!e && d in e, j = (e, t, n) => {
-	let r = n?.equals ?? Object.is, i = e.peek();
-	n?.immediate && t(i, i);
-	let a;
-	return a = _(() => {
-		let o = e.value;
-		if (!r(i, o)) {
-			let e = i;
-			i = o, t(o, e), n?.once && a();
-		}
-	}), a;
-}, M = (e, t, n) => new Promise((r, i) => {
-	let a = n?.signal;
+}, D = (e, t) => new T(e, t?.equals), O = (e, t) => {
+	let n = new E(e, t?.equals);
+	return m !== null && F(() => n.dispose()), n;
+}, k = (e) => {
+	g++;
+	let t, n;
 	try {
-		a?.throwIfAborted();
+		t = e();
+	} catch (e) {
+		n = e;
+	}
+	if (g--, g === 0) try {
+		S();
 	} catch (e) {
-		i(e);
-		return;
+		throw n === void 0 ? o(e) : AggregateError([n, e], "[stateit] batch error with flush errors", { cause: e });
 	}
-	let o = j(e, (e) => {
-		(!t || t(e)) && (o(), a?.removeEventListener("abort", s), r(e));
-	}), s = () => {
-		o(), i(a.reason);
+	if (n !== void 0) throw o(n);
+	return t;
+}, A = (t) => {
+	let n, r = /* @__PURE__ */ new Set(), a = !1, o = !1, s = !1, d = () => {
+		if (!n && r.size === 0) return;
+		let e = n ? [n, ...r] : [...r];
+		n = void 0, r.clear(), c(e, "effect teardown errors");
+	}, f = () => {
+		if (!s) {
+			if (a) {
+				o = !0;
+				return;
+			}
+			a = !0;
+			try {
+				let i = 0;
+				do {
+					if (++i > e) throw Error(`[stateit] infinite effect loop (> ${e} iterations)`);
+					o = !1, d();
+					let a = [], s;
+					try {
+						s = h(f, null, r, a, t);
+					} catch (e) {
+						let t = [...u(r), ...u(a)];
+						r.clear(), l(e, t, "effect failure with cleanup errors");
+					}
+					typeof s == "function" && a.push(s), n = a.length > 0 ? () => {
+						c(a, "effect cleanup errors");
+					} : void 0;
+				} while (o && !s);
+			} finally {
+				a = !1;
+			}
+		}
+	};
+	return f(), i(() => {
+		s || (s = !0, d());
+	});
+}, j = (e) => h(null, null, null, null, e), M = (e) => {
+	let t = e, n = a.get(t);
+	if (n) return n;
+	let r = {
+		peek() {
+			return e.peek();
+		},
+		subscribe(t) {
+			return e.subscribe(t);
+		},
+		get value() {
+			return e.value;
+		}
+	};
+	return a.set(t, r), r;
+}, N = (e) => ({ subscribe(t) {
+	return t(e.value), e.subscribe(() => t(e.value));
+} }), P = (e) => {
+	let t = (t) => {
+		let n = typeof t == "function" ? { next: t } : t;
+		n.next?.(e.value);
+		let r = e.subscribe(() => n.next?.(e.value));
+		return { unsubscribe() {
+			r();
+		} };
+	}, r = {
+		[n]() {
+			return r;
+		},
+		subscribe: t
+	};
+	return r;
+}, F = (e) => {
+	if (m === null) throw Error("[stateit] onCleanup() must be called from within an active effect or scope.");
+	m.push(e);
+}, I = (e) => {
+	let t = [], n = !1, r = (e) => {
+		if (n) throw Error("[stateit] Cannot run inside a disposed scope.");
+		return h(null, null, null, t, e);
+	}, i = () => {
+		n || (n = !0, c([...t].reverse(), "scope cleanup errors"), t.length = 0);
+	}, a = {
+		dispose: i,
+		run: r,
+		[Symbol.dispose]: i
+	};
+	return e && r(e), a;
+};
+function L(e, t, n) {
+	let r = typeof e == "function" ? e : () => e.value, i = n?.equals ?? Object.is, a = !1, o;
+	return n?.immediate && (o = j(r), a = !0, t(o, o)), A(() => {
+		let e = r();
+		if (!a) {
+			a = !0, o = e;
+			return;
+		}
+		if (i(o, e)) return;
+		let n = o;
+		o = e, t(e, n);
+	});
+}
+var R = (e) => {
+	s(e, "[stateit] store() requires a plain object initial state.");
+	let n = structuredClone(e), r = D(structuredClone(e));
+	return {
+		[t]: !0,
+		patch(e) {
+			s(e, "[stateit] store.patch() requires a plain object partial.");
+			let t = j(() => r.value);
+			Object.keys(e).some((n) => !Object.is(t[n], e[n])) && (r.value = {
+				...t,
+				...e
+			});
+		},
+		peek() {
+			return r.peek();
+		},
+		reset() {
+			r.value = structuredClone(n);
+		},
+		subscribe(e) {
+			return r.subscribe(e);
+		},
+		update(e) {
+			r.update(e);
+		},
+		get value() {
+			return r.value;
+		}
 	};
-	a?.addEventListener("abort", s, { once: !0 });
-});
+}, z = (e) => typeof e == "object" && !!e && !!e[t];
 //#endregion
-export { f as ComputedNode, b as SignalImpl, m as WritableNode, u as _SIGNAL_BRAND, d as _STORE_BRAND, c as _flushPending, a as _resetContextForTesting, l as batch, p as computed, i as configureStateit, g as derived, _ as effect, w as isSignal, A as isStore, M as nextValue, y as onCleanup, E as peekValue, C as readonly, D as shallowEqual, x as signal, k as store, T as toValue, v as untrack, j as watch, h as writable };
+export { k as batch, O as computed, A as effect, z as isSignal, r as observableSymbol, F as onCleanup, M as readonly, I as scope, D as signal, R as store, P as toObservable, N as toStore, i as toSubscription, j as untrack, L as watch };
 
 //# sourceMappingURL=stateit.js.map