@pravosleva/reactive-engine 2.7.2 → 3.0.0-alpha.1

package/dist/core.mjs

@@ -1,90 +1,262 @@
-import { createComputed as e } from "./core.method.computed.mjs";
-import { createSignal as t } from "./core.method.signal.mjs";
-import { executeUntrack as n } from "./core.method.untrack.mjs";
-import { createReactive as r } from "./core.method.reactive.mjs";
-import { createEffect as i } from "./core.method.effect.mjs";
-import { ReactiveDebounceLogger as a } from "./core.logger.mjs";
-import { createResource as o } from "./core.method.resource.mjs";
+import { ReactiveDebounceLogger as e, queueLog as t } from "./core.logger.mjs";
+import { createReactive as n } from "./core.method.reactive.mjs";
+import { createResource as r } from "./core.method.resource.mjs";
 //#region src/core/core.ts
-var s = {
-	signal: "background: #007acc; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;",
-	computed: "background: #42b883; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;",
-	effect: "background: #e01e5a; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;",
-	batch: "background: #7952b3; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;",
-	resource: "background: #d97706; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;",
-	reactive: "background: #007acc; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;"
-}, c = null;
-function l(e) {
-	if (e === null) return "null";
-	if (e === void 0) return "undefined";
-	if (typeof e == "object") try {
-		return JSON.stringify(e);
-	} catch {
-		return "[Cyclic Object or Layer]";
-	}
-	return String(e);
-}
-function u(e, t, n) {
-	c || (c = {
-		id: Math.random().toString(36).substring(2, 9),
-		pendingLogQueue: [],
-		isFlushing: !1
-	}, queueMicrotask(() => d())), c.pendingLogQueue.push({
-		type: e,
-		label: t,
-		from: n?.from,
-		to: n?.to,
-		payload: n?.payload,
-		timestamp: Date.now()
-	});
-}
-function d() {
-	if (!c || c.isFlushing) return;
-	c.isFlushing = !0;
-	let e = c.pendingLogQueue;
-	if (e.length === 0) {
-		c = null;
-		return;
-	}
-	console.groupCollapsed(`%cREACTIVE TRANSACTION%c [id: ${c.id}] (${e.length} operations)`, "background: #7952b3; color: #fff; padding: 2px 6px; border-radius: 4px; font-weight: bold;", "color: #888; font-weight: normal;");
-	for (let t of e) {
-		let e = s[t.type], n = t.from !== void 0 || t.to !== void 0, r = `%c${t.type.toUpperCase()}%c ${t.label}`;
-		n && (t.from ? r += ` ${l(t.from)} → ${l(t.to)}` : r += ` (${l(t.to)})`), t.payload === void 0 ? console.log(r, e, "color: inherit;") : (console.groupCollapsed(r, e, "color: inherit;"), console.log("Payload:", t.payload), console.groupEnd());
-	}
-	console.groupEnd(), c = null;
-}
-var f = class {
-	frameworkPrefix = "core";
-	logger;
-	epoch = 0;
+var i = class {
+	source = null;
+	target = null;
+	nextSubscriber = null;
+	prevSubscriber = null;
+	nextDependency = null;
+	prevDependency = null;
+	version = 0;
+	clear() {
+		this.source = null, this.target = null, this.nextSubscriber = null, this.prevSubscriber = null, this.nextDependency = null, this.prevDependency = null, this.version = 0;
+	}
+}, a = class {
+	static pool = [];
+	static size = 0;
+	static maxPoolSize = 1e5;
+	static acquire(e, t) {
+		if (this.size > 0) {
+			this.size--;
+			let n = this.pool[this.size];
+			return this.pool[this.size] = null, n.source = e, n.target = t, n;
+		}
+		let n = new i();
+		return n.source = e, n.target = t, n;
+	}
+	static release(e) {
+		this.size < this.maxPoolSize && (e.clear(), this.pool[this.size] = e, this.size++);
+	}
+}, o = class {
+	id;
+	type;
+	version = 0;
+	state = 0;
+	depth = 0;
+	subscribersHead = null;
+	subscribersTail = null;
+	dependenciesHead = null;
+	dependenciesTail = null;
+	depsCursor = null;
+	_value;
+	_prevValue;
+	fn = null;
+	cleanups = /* @__PURE__ */ new Set();
+	isDisposed = !1;
+	ownedEffects = /* @__PURE__ */ new Set();
+	wrapper = null;
+	engine = null;
+	constructor(e, t, n) {
+		this.type = e, this.id = t, this._value = n, this._prevValue = n;
+	}
+	get subscribers() {
+		let e = /* @__PURE__ */ new Set(), t = this.subscribersHead;
+		for (; t !== null;) t.target && e.add(t.target), t = t.nextSubscriber;
+		return e;
+	}
+	get dependencies() {
+		let e = /* @__PURE__ */ new Set(), t = this.dependenciesHead;
+		for (; t !== null;) t.source && e.add(t.source), t = t.nextDependency;
+		return e;
+	}
+}, s = class {
+	buckets = [];
+	maxDepth = -1;
+	schedule(e) {
+		let t = e.depth;
+		this.buckets[t] || (this.buckets[t] = []), this.buckets[t].includes(e) || (this.buckets[t].push(e), t > this.maxDepth && (this.maxDepth = t));
+	}
+	clearAll() {
+		for (let e = 0; e <= this.maxDepth; e++) {
+			let t = this.buckets[e];
+			if (t) {
+				for (let e of t) e.state = 0;
+				this.buckets[e] = [];
+			}
+		}
+		this.maxDepth = -1;
+	}
+	flush(e) {
+		let t = e.activeConsumer;
+		try {
+			let t = 0;
+			for (; t <= this.maxDepth;) {
+				let n = this.buckets[t];
+				if (!n || n.length === 0) {
+					t++;
+					continue;
+				}
+				this.buckets[t] = [], n.sort((e, t) => t.depth - e.depth);
+				for (let t of n) if (!(t.isDisposed || t.state === 0) && (t.state === 1 && (e.checkNeedsUpdate(t) ? t.state = 2 : t.state = 0), t.state === 2)) try {
+					e.runEffectNode(t);
+				} catch (e) {
+					throw this.clearAll(), e;
+				}
+				let r = !1;
+				for (let e = 0; e <= this.maxDepth; e++) if (this.buckets[e] && this.buckets[e].length > 0) {
+					t = e, r = !0;
+					break;
+				}
+				r || t++;
+			}
+		} finally {
+			e.activeConsumer = t, this.maxDepth = -1;
+		}
+	}
+}, c = class {
 	activeConsumer = null;
 	batchDepth = 0;
-	subscriberId = 0;
-	pendingEffects = [];
-	maxPendingDepth = 0;
+	batchedSignals = [];
+	batchInitialValues = /* @__PURE__ */ new Map();
 	computedCache = /* @__PURE__ */ new WeakMap();
-	diRegistry = /* @__PURE__ */ new Map();
-	diCache = /* @__PURE__ */ new Map();
+	logger;
 	proxyCache = /* @__PURE__ */ new WeakMap();
 	proxyTargets = /* @__PURE__ */ new WeakSet();
 	reactiveSignals = /* @__PURE__ */ new WeakMap();
+	scheduler = new s();
+	currentOwner = null;
+	effectIdCounter = 0;
+	diRegistry = /* @__PURE__ */ new Map();
+	diCache = /* @__PURE__ */ new Map();
 	cycleDetectionStack = /* @__PURE__ */ new Set();
-	batchedSignals = /* @__PURE__ */ new Set();
-	activeOwner = null;
-	activeCleanupNode = null;
-	pendingCleanups = /* @__PURE__ */ new Set();
-	queueCleanup(e) {
-		this.pendingCleanups.add(e);
-	}
 	constructor(e) {
 		this.logger = e?.logger || { isEnabled: !1 };
 	}
-	scheduleEffect(e) {
-		let t = e.depth || 0;
-		this.pendingEffects[t] || (this.pendingEffects[t] = /* @__PURE__ */ new Set()), this.pendingEffects[t].add(e), t > this.maxPendingDepth && (this.maxPendingDepth = t);
+	log(n) {
+		!this.logger || !this.logger.isEnabled || e.processLog(this.logger, t, n);
+	}
+	signal(e, t) {
+		let n = typeof t == "string" ? t : t?.name || "signal", r = typeof t == "object" ? t?.validate : void 0, i = typeof t == "object" ? t?.isInternalCoreSignal : !1, a = new o("signal", n, e);
+		a.engine = this;
+		let s = this;
+		this.log({
+			type: "signal",
+			label: n,
+			details: { to: e },
+			isInternalCoreSignal: i
+		});
+		let c = {
+			_node: a,
+			_engine: this,
+			get value() {
+				return s.activeConsumer && s.trackNode(a, s.activeConsumer), a._value;
+			},
+			set value(e) {
+				if (r) {
+					let t = r(e);
+					if (t === !1 || typeof t == "string") {
+						console.error(`[Validation Error] Invalid value supplied to signal "${n}": ${t}`);
+						return;
+					}
+				}
+				let t = typeof e == "object" && !!e;
+				if (Object.is(a._value, e) && !t) return;
+				let o = a._value;
+				a._prevValue = o, s.batchDepth > 0 && !s.batchInitialValues.has(a) && s.batchInitialValues.set(a, {
+					value: o,
+					version: a.version
+				}), a._value = e, a.version++, s.log({
+					type: "signal",
+					label: n,
+					details: {
+						from: o,
+						to: e
+					},
+					isInternalCoreSignal: i
+				}), s.notifySubscribers(a, 2), s.batchDepth > 0 ? s.batchedSignals.includes(a) || s.batchedSignals.push(a) : s.flushEffects();
+			},
+			get valueWithoutTracking() {
+				return a._value;
+			},
+			subscribe(e) {
+				return s.effect(() => {
+					e(c.value);
+				});
+			},
+			destroy() {
+				s.disposeNode(a);
+			}
+		};
+		return a.wrapper = c, c;
+	}
+	notifySubscribers(e, t) {
+		let n = e.subscribersHead;
+		for (; n !== null;) {
+			let e = n.target;
+			if (e === this.activeConsumer) {
+				n = n.nextSubscriber;
+				continue;
+			}
+			e.state < t && (e.state = t, e.type === "effect" ? this.scheduler.schedule(e) : this.notifySubscribers(e, 1)), n = n.nextSubscriber;
+		}
+	}
+	computed(e, t) {
+		let n = new o("computed", t || "computed");
+		n.engine = this, n.fn = e, n.state = 2;
+		let r = this, i = {
+			_node: n,
+			_engine: this,
+			get value() {
+				return n.state === 1 && (r.checkNeedsUpdate(n) ? n.state = 2 : n.state = 0), n.state === 2 && (n._value, r.evaluateComputed(n)), r.activeConsumer && r.trackNode(n, r.activeConsumer), n._value;
+			},
+			get valueWithoutTracking() {
+				return n._value;
+			},
+			subscribe(e) {
+				return r.effect(() => {
+					e(i.value);
+				});
+			},
+			destroy() {
+				r.disposeNode(n);
+			},
+			_isDirty() {
+				return n.state === 2;
+			},
+			get dependencies() {
+				let e = /* @__PURE__ */ new Set(), t = n.dependenciesHead;
+				for (; t !== null;) t.source && t.source.wrapper && e.add(t.source.wrapper), t = t.nextDependency;
+				return e;
+			}
+		};
+		return n.wrapper = i, this.batchDepth === 0 && this.computedCache.set(e, i), i;
 	}
-	queueLog(e, t, n) {
-		u(e, t, n);
+	effect(e, t) {
+		let n = t || "effect", r = new o("effect", n);
+		r.state = 2, r.depth = this.currentOwner ? this.currentOwner.depth + 1 : 0, r.wrapper = {
+			id: ++this.effectIdCounter,
+			run: () => {
+				this.runEffectNode(r);
+			},
+			markDirty: () => {
+				r.state = 2, this.scheduler.schedule(r);
+			},
+			cleanups: r.cleanups,
+			label: n,
+			get isDirty() {
+				return r.state === 2;
+			},
+			get isDisposed() {
+				return r.isDisposed;
+			},
+			_node: r
+		}, r.fn = () => {
+			this.log({
+				type: "effect",
+				label: n
+			});
+			let t = e();
+			typeof t == "function" && r.cleanups.add(t);
+		}, this.currentOwner && this.currentOwner.ownedEffects.add(r), this.runEffectNode(r);
+		let i = () => {
+			this.disposeNode(r);
+		};
+		return i._node = r, i;
+	}
+	resource(e, t, n) {
+		return r(this, e, t, n);
 	}
 	batch(e) {
 		this.batchDepth++;
@@ -92,79 +264,174 @@ var f = class {
 			return e();
 		} finally {
 			if (this.batchDepth--, this.batchDepth === 0) {
-				if (this.batchedSignals.size > 0) {
-					for (let e of this.batchedSignals) e._flushBatch && e._flushBatch();
-					this.batchedSignals.clear();
+				for (let e of this.batchedSignals) {
+					let t = this.batchInitialValues.get(e), n = e._value !== null && typeof e._value == "object";
+					t && !n && Object.is(e._value, t.value) && (e.version = t.version, this.resetCleanState(e));
 				}
-				this.flushEffects();
+				this.batchedSignals = [], this.batchInitialValues.clear(), this.flushEffects();
 			}
 		}
 	}
-	flushEffects() {
-		if (this.batchDepth > 0) return;
-		let e = this.activeConsumer;
+	resetCleanState(e) {
+		let t = e.subscribersHead;
+		for (; t !== null;) {
+			let e = t.target;
+			e.state > 0 && !this.checkNeedsUpdate(e) && (e.state = 0, this.resetCleanState(e)), t = t.nextSubscriber;
+		}
+	}
+	untrack(e) {
+		let t = this.activeConsumer;
+		this.activeConsumer = null;
 		try {
-			for (let e = 0; e <= this.maxPendingDepth; e++) {
-				let t = this.pendingEffects[e];
-				if (!t || t.size === 0) continue;
-				let n = Array.from(t);
-				t.clear();
-				for (let t of n) if (!t.isDisposed && t.isDirty) {
-					if (t.dependencies && t.dependencies.size > 0) {
-						let e = !1;
-						for (let n of t.dependencies) {
-							let r = n._node || n;
-							r.type === "computed" && r.state > 0 && r.update && r.update(), t.depVersions && t.depVersions.get(n) !== r.version && (e = !0);
-						}
-						if (!e && t.dependencies.size > 0) {
-							t.isDirty = !1;
-							continue;
-						}
-					}
-					try {
-						t.run();
-					} catch (t) {
-						for (let t = e; t <= this.maxPendingDepth; t++) {
-							let e = this.pendingEffects[t];
-							if (e) {
-								for (let t of e) t.isDirty = !1;
-								e.clear();
-							}
-						}
-						throw this.maxPendingDepth = 0, t;
-					}
-				}
-				if (e > 0) {
-					let t = !1;
-					for (let n = 0; n < e; n++) if (this.pendingEffects[n] && this.pendingEffects[n].size > 0) {
-						t = !0;
-						break;
-					}
-					t && (e = -1);
-				}
-			}
-			this.maxPendingDepth = 0;
+			return e();
 		} finally {
-			this.activeConsumer = e;
+			this.activeConsumer = t;
 		}
 	}
-	log(e) {
-		!this.logger || !this.logger.isEnabled || a.processLog(this.logger, u, e);
+	flushEffects() {
+		this.batchDepth === 0 && this.scheduler.flush(this);
 	}
-	signal(e, n) {
-		return t(this, e, n);
+	trackNode(e, t) {
+		let n = t.depsCursor;
+		if (n !== null && n.source === e) {
+			n.version = e.version, t.depsCursor = n.nextDependency;
+			return;
+		}
+		let r = t.dependenciesHead;
+		for (; r !== n;) {
+			if (r.source === e) {
+				r.version = e.version;
+				return;
+			}
+			r = r.nextDependency;
+		}
+		let i = n === null ? null : n.nextDependency;
+		for (; i !== null;) {
+			if (i.source === e) {
+				i.prevDependency !== null && (i.prevDependency.nextDependency = i.nextDependency), i.nextDependency === null ? t.dependenciesTail = i.prevDependency : i.nextDependency.prevDependency = i.prevDependency, i.version = e.version, this.insertLinkBeforeCursor(t, i, n);
+				return;
+			}
+			i = i.nextDependency;
+		}
+		let o = a.acquire(e, t);
+		o.version = e.version, t.depth <= e.depth && (t.depth = e.depth + 1), e.subscribersTail === null ? (e.subscribersHead = o, e.subscribersTail = o) : (e.subscribersTail.nextSubscriber = o, o.prevSubscriber = e.subscribersTail, e.subscribersTail = o), n === null ? t.dependenciesTail === null ? (t.dependenciesHead = o, t.dependenciesTail = o) : (t.dependenciesTail.nextDependency = o, o.prevDependency = t.dependenciesTail, t.dependenciesTail = o) : this.insertLinkBeforeCursor(t, o, n);
 	}
-	computed(t, n) {
-		return e(this, t, n);
+	insertLinkBeforeCursor(e, t, n) {
+		let r = n.prevDependency;
+		t.prevDependency = r, t.nextDependency = n, n.prevDependency = t, r === null ? e.dependenciesHead = t : r.nextDependency = t;
 	}
-	effect(e, t) {
-		return i(this, e, t);
+	endTracking(e) {
+		let t = e.depsCursor;
+		if (e.depsCursor = null, t === null) return;
+		let n = t.prevDependency;
+		for (n === null ? (e.dependenciesHead = null, e.dependenciesTail = null) : (n.nextDependency = null, e.dependenciesTail = n); t !== null;) {
+			let e = t.nextDependency, n = t.source;
+			t.prevSubscriber === null ? n.subscribersHead = t.nextSubscriber : t.prevSubscriber.nextSubscriber = t.nextSubscriber, t.nextSubscriber === null ? n.subscribersTail = t.prevSubscriber : t.nextSubscriber.prevSubscriber = t.prevSubscriber, a.release(t), t = e;
+		}
 	}
-	untrack(e) {
-		return n(this, e);
+	unlinkDependencies(e, t = !1) {
+		let n = e.dependenciesHead;
+		for (e.dependenciesHead = null, e.dependenciesTail = null; n !== null;) {
+			let r = n.nextDependency, i = n.source;
+			n.prevSubscriber === null ? i.subscribersHead = n.nextSubscriber : n.prevSubscriber.nextSubscriber = n.nextSubscriber, n.nextSubscriber === null ? i.subscribersTail = n.prevSubscriber : n.nextSubscriber.prevSubscriber = n.prevSubscriber, a.release(n), t && e.isDisposed && e.type === "computed" && i.type === "computed" && i.subscribersHead === null && this.disposeNode(i), n = r;
+		}
+	}
+	checkNeedsUpdate(e) {
+		let t = e.dependenciesHead;
+		for (; t !== null;) {
+			let e = t.source;
+			if (e.state === 1 && (this.checkNeedsUpdate(e) ? e.state = 2 : e.state = 0), e.state === 2 && this.evaluateComputed(e), t.version !== e.version) return t.version = e.version, !0;
+			t = t.nextDependency;
+		}
+		return !1;
+	}
+	evaluateComputed(e) {
+		if (e.ownedEffects.size > 0) {
+			let t = Array.from(e.ownedEffects);
+			e.ownedEffects.clear();
+			for (let e of t) this.disposeNode(e);
+		}
+		e.depsCursor = e.dependenciesHead;
+		let t = this.activeConsumer, n = this.currentOwner;
+		this.activeConsumer = e, this.currentOwner = e;
+		let r = e._value;
+		try {
+			let t = e.fn();
+			Object.is(e._value, t) || (e._value = t, e.version++), e.state = 0, this.log({
+				type: "computed",
+				label: e.id,
+				details: {
+					from: r,
+					to: e._value
+				}
+			});
+		} finally {
+			this.endTracking(e), this.activeConsumer = t, this.currentOwner = n;
+		}
+	}
+	executeCleanups(e) {
+		if (e.cleanups.size === 0) return;
+		let t = Array.from(e.cleanups);
+		e.cleanups.clear();
+		let n = null;
+		for (let e of t) try {
+			this.untrack(() => e());
+		} catch (e) {
+			n === null && (n = e);
+		}
+		if (n !== null) throw n;
+	}
+	runEffectNode(e) {
+		if (e.isDisposed) return;
+		if (e.ownedEffects.size > 0) {
+			let t = Array.from(e.ownedEffects);
+			e.ownedEffects.clear();
+			for (let e of t) this.disposeNode(e);
+		}
+		try {
+			this.executeCleanups(e);
+		} catch (t) {
+			throw e.state = 0, t;
+		}
+		e.depsCursor = e.dependenciesHead;
+		let t = this.activeConsumer, n = this.currentOwner;
+		this.activeConsumer = e, this.currentOwner = e;
+		try {
+			e.fn(), e.state = 0;
+		} finally {
+			this.endTracking(e), this.activeConsumer = t, this.currentOwner = n, e.isDisposed && this.unlinkDependencies(e, !0);
+		}
+	}
+	disposeNode(e) {
+		if (e.isDisposed) return;
+		if (e.isDisposed = !0, e.state = 0, e.ownedEffects.size > 0) {
+			let t = Array.from(e.ownedEffects);
+			e.ownedEffects.clear();
+			for (let e of t) this.disposeNode(e);
+		}
+		try {
+			this.executeCleanups(e);
+		} catch {}
+		this.unlinkDependencies(e, !0);
+		let t = e.subscribersHead;
+		for (e.subscribersHead = null, e.subscribersTail = null; t !== null;) {
+			let e = t.nextSubscriber, n = t.target;
+			n && (t.prevDependency === null ? n.dependenciesHead = t.nextDependency : t.prevDependency.nextDependency = t.nextDependency, t.nextDependency === null ? n.dependenciesTail = t.prevDependency : t.nextDependency.prevDependency = t.prevDependency), a.release(t), t = e;
+		}
 	}
 	reactive(e, t) {
-		return r(this, e, t);
+		return n(this, e, t);
+	}
+	delay(e, t) {
+		return new Promise((n, r) => {
+			if (t.aborted) return r(new DOMException("Aborted", "AbortError"));
+			let i = setTimeout(() => {
+				t.removeEventListener("abort", a), n();
+			}, e), a = () => {
+				clearTimeout(i), r(new DOMException("Aborted", "AbortError"));
+			};
+			t.addEventListener("abort", a, { once: !0 });
+		});
 	}
 	provide(e, t) {
 		this.diRegistry.set(e, t), this.diCache.delete(e);
@@ -200,22 +467,11 @@ var f = class {
 			this.cycleDetectionStack.delete(e);
 		}
 	}
-	delay(e, t) {
-		return new Promise((n, r) => {
-			if (t.aborted) return r(new DOMException("Aborted", "AbortError"));
-			let i = setTimeout(() => {
-				t.removeEventListener("abort", a), n();
-			}, e), a = () => {
-				clearTimeout(i), r(new DOMException("Aborted", "AbortError"));
-			};
-			t.addEventListener("abort", a, { once: !0 });
-		});
-	}
-	resource(e, t, n) {
-		return o(this, e, t, n);
-	}
-};
+}, l = new c();
+function u() {
+	l = new c();
+}
 //#endregion
-export { f as ReactiveEngine, f as ReactiveEngineAutomatic, f as ReactiveEngineCore, d as flushLogs, u as queueLog };
+export { s as EffectScheduler, a as LinkPool, i as NodeLink, c as ReactiveEngine, c as ReactiveEngineAutomatic, c as ReactiveEngineCore, o as ReactiveNode, l as currentEngineInstance, u as resetGlobalReactiveEngine };
 
 //# sourceMappingURL=core.mjs.map