@elurjs/core 3.6.2 → 3.7.0-beta.0

package/dist/lib/elur/next-2/reactivity.js

@@ -0,0 +1,614 @@
+import { inputPending as e, yieldControl as t } from "./scheduler.js";
+//#region src/elur/next-2/reactivity.ts
+var n = 0, r = 1, i = 2, a = 4, o = 8, s = 16, c = 32, l = 0, u = 0, d = null, f = null, p = 1, ee = 2, m = 4, h = 8, g = [], _ = [], te = class {
+	childrenHead = null;
+	childCount = 0;
+	cleanups = null;
+	parent = null;
+	nextOwned = null;
+	prevOwned = null;
+	onOwnerError;
+	_disposed = !1;
+	dispose() {
+		this._disposed || (this._disposed = !0, v(this), b(this));
+	}
+};
+function v(e) {
+	if (e.cleanups) {
+		for (let t of e.cleanups) t();
+		e.cleanups = null;
+	}
+	let t = e.childrenHead;
+	for (e.childrenHead = null, e.childCount = 0; t;) {
+		let e = t.nextOwned;
+		t.nextOwned = null, t.prevOwned = null, t.parent = null, t.dispose(), t = e;
+	}
+}
+function y(e) {
+	if (!f) return;
+	e.parent = f;
+	let t = f.childrenHead;
+	e.nextOwned = t, e.prevOwned = null, t && (t.prevOwned = e), f.childrenHead = e, f.childCount++;
+}
+function b(e) {
+	let t = e.parent;
+	e.parent = null, e.prevOwned ? e.prevOwned.nextOwned = e.nextOwned : t && (t.childrenHead = e.nextOwned), e.nextOwned && (e.nextOwned.prevOwned = e.prevOwned), e.nextOwned = null, e.prevOwned = null, t && t.childCount--;
+}
+function ne() {
+	return f;
+}
+function re(e, t) {
+	let n = f, r = d;
+	f = e, d = null;
+	try {
+		return t();
+	} finally {
+		f = n, d = r;
+	}
+}
+function ie(e) {
+	let t = new te();
+	return t.parent = f, re(t, () => e(() => t.dispose()));
+}
+function ae(e) {
+	f && (f.cleanups ??= []).push(e);
+}
+var oe = 1e4, se = 100, ce = class extends Error {
+	constructor(e, t) {
+		let n = [];
+		for (let t = e.sourcesHead; t; t = t.nextSource) {
+			let e = t.source;
+			if (n.push(e instanceof Q ? `computed(v${e.version})` : `signal(v${e.version})`), n.length >= 8) {
+				n.push("…");
+				break;
+			}
+		}
+		super(`[elur] Maximum effect re-execution depth exceeded (possible infinite loop). Ciclo de efectos: un effect corrió ${t} veces en un solo flush (límite por nodo ${se}). Fuentes del effect: [${n.join(", ")}]. Probable write-inside-effect que se re-encola a sí mismo.`), this.name = "ReactiveCycleError";
+	}
+}, le = [], x = null;
+function ue(e) {
+	le.push(x), x = e;
+}
+function de() {
+	x = le.pop() ?? null;
+}
+var S = null, C = null;
+function w() {
+	let e = C;
+	if (!e || e.size === 0) {
+		S = null;
+		return;
+	}
+	if (e.size === 1) {
+		S = e.values().next().value ?? null;
+		return;
+	}
+	S = {
+		onCreate(t, n) {
+			for (let r of e) r.onCreate?.(t, n);
+		},
+		onWrite(t, n) {
+			for (let r of e) r.onWrite?.(t, n);
+		}
+	};
+}
+function fe(e) {
+	let t = /* @__PURE__ */ new Set();
+	e && t.add(e), C = t, w();
+}
+function pe(e) {
+	let t = C;
+	return t || (t = /* @__PURE__ */ new Set(), S && t.add(S), C = t), t.add(e), w(), () => {
+		t.delete(e), w();
+	};
+}
+function me() {
+	return 0;
+}
+var T = [], E = [], D = null, O = 0, he = 8192;
+function k(e, t, n, r) {
+	let i = D;
+	return i ? (D = i.nextSource, O--, i.source = e, i.target = t, i.seenVersion = n, i.mark = r, i.linked = !1, i.prevSource = null, i.nextTarget = null, i.prevTarget = null, i) : {
+		source: e,
+		target: t,
+		seenVersion: n,
+		mark: r,
+		linked: !1,
+		nextSource: null,
+		prevSource: null,
+		nextTarget: null,
+		prevTarget: null
+	};
+}
+function A(e) {
+	O >= he || (e.source = null, e.target = null, e.nextTarget = null, e.prevTarget = null, e.prevSource = null, e.nextSource = D, D = e, O++);
+}
+function j(e, t) {
+	t.nextTarget = e.consumersHead, t.prevTarget = null, e.consumersHead && (e.consumersHead.prevTarget = t), e.consumersHead = t, t.linked = !0, e.liveCount++, e.liveCount === 1 && e instanceof Q && T.push(e);
+}
+function M(e, t) {
+	t.linked && (t.prevTarget ? t.prevTarget.nextTarget = t.nextTarget : e.consumersHead = t.nextTarget, t.nextTarget && (t.nextTarget.prevTarget = t.prevTarget), t.linked = !1, e.liveCount--, e.liveCount === 0 && e instanceof Q && E.push(e));
+}
+function N() {
+	for (; T.length;) {
+		let e = T.pop();
+		for (let t = e.sourcesHead; t; t = t.nextSource) t.linked || j(t.source, t);
+	}
+}
+function P() {
+	for (; E.length;) {
+		let e = E.pop();
+		for (let t = e.sourcesHead; t; t = t.nextSource) M(t.source, t);
+	}
+}
+function ge(e, t) {
+	if (e.durable) return;
+	for (let n = t.sourcesHead; n; n = n.nextSource) if (n.source === e) {
+		n.seenVersion = e.version, n.mark = t.evalMark;
+		return;
+	}
+	let n = k(e, t, e.version, t.evalMark);
+	n.nextSource = t.sourcesHead, t.sourcesHead && (t.sourcesHead.prevSource = n), t.sourcesHead = n, t.live() && (j(e, n), T.length && N());
+}
+function F(e) {
+	let t = e.sourcesHead;
+	for (; t;) {
+		let n = t.nextSource;
+		t.mark !== e.evalMark && (t.prevSource ? t.prevSource.nextSource = t.nextSource : e.sourcesHead = t.nextSource, t.nextSource && (t.nextSource.prevSource = t.prevSource), M(t.source, t), A(t)), t = n;
+	}
+	E.length && P();
+}
+var I = [];
+function _e(e) {
+	if (!(e.state & (i | s)) && !(e instanceof Q && e.state & a)) if (e.state = i, e instanceof Q) {
+		for (let t = e.consumersHead; t; t = t.nextTarget) {
+			let e = t.target;
+			e.state === n && (e.state = r, e instanceof Q ? I.push(t) : H(e));
+		}
+		for (; I.length;) {
+			let e = I.pop();
+			for (let t = e.target.consumersHead; t; t = t.nextTarget) {
+				let e = t.target;
+				e.state === n && (e.state = r, e instanceof Q ? I.push(t) : H(e));
+			}
+		}
+	} else H(e);
+}
+function ve(e) {
+	for (let t = e.consumersHead; t; t = t.nextTarget) _e(t.target);
+	u === 0 && ke();
+}
+function L(e) {
+	(e.childrenHead !== null || e.cleanups !== null) && v(e), e.evalMark++;
+	let t = d, r = f;
+	d = e, f = e, e.state = a;
+	let o, s = !0;
+	try {
+		o = e.fn(), s = !1;
+	} finally {
+		d = t, f = r, s && e.state & a && (e.state = i);
+	}
+	F(e), e.state = n, e.lastCleanEpoch = l, (!(e.flags & p) || !e.equals(o, e._value)) && (e._value = o, e.flags |= p, e.version++);
+}
+var R = 64, z = 128, B = 256, V = z | 320, ye = [], be = 0;
+function xe(e) {
+	let t = e.state & (i | 5);
+	if (e.state & s) return;
+	if (t === a) throw Error("[elur-next] Ciclo reactivo detectado en computed().");
+	if (t === 0 && e.flags & p && (e.live() || e.lastCleanEpoch === l)) return;
+	let r = t === i || !(e.flags & p), o = !1;
+	for (let t = e.sourcesHead; t; t = t.nextSource) {
+		let e = t.source;
+		if (e instanceof Q && (!(e.flags & p) || e.state !== n || !e.live() && e.lastCleanEpoch !== l)) {
+			o = !0;
+			break;
+		}
+		!r && e.version !== t.seenVersion && (r = !0);
+	}
+	if (!o) {
+		if (r) L(e);
+		else {
+			e.state = n, e.lastCleanEpoch = l;
+			for (let t = e.sourcesHead; t; t = t.nextSource) t.seenVersion = t.source.version;
+		}
+		return;
+	}
+	let u = be++ === 0 ? ye : [];
+	try {
+		let t = e;
+		for (; t;) {
+			if (!(t.state & R)) {
+				t.state |= R, t._pCursor = null, t._pLink = null;
+				let e = t.state & (i | 5);
+				if (t.state & s) {
+					t.state &= ~c, t.state &= ~V, t = u.pop();
+					continue;
+				}
+				if (e === a && Se(u, t), e === 0 && t.flags & p && (t.live() || t.lastCleanEpoch === l)) {
+					t.state &= ~V, t = u.pop();
+					continue;
+				}
+				t.state |= c, e === i && (t.state |= z), t._pCursor = t.sourcesHead;
+			}
+			if (t._pLink) {
+				let e = t._pLink;
+				t._pLink = null, e.source.version !== e.seenVersion && (t.state |= B);
+			}
+			let e = !1;
+			for (; t._pCursor;) {
+				let r = t._pCursor;
+				t._pCursor = r.nextSource;
+				let i = r.source;
+				if (i instanceof Q && (!(i.flags & p) || i.state !== n || !i.live() && i.lastCleanEpoch !== l)) {
+					i.state & c && Se(u, t), t._pLink = r, u.push(t), i.state |= c, t = i, e = !0;
+					break;
+				}
+				i.version !== r.seenVersion && (t.state |= B);
+			}
+			if (!e) {
+				if (t.state &= ~c, t.state & (z | B) || !(t.flags & p)) L(t);
+				else {
+					t.state = n, t.lastCleanEpoch = l;
+					for (let e = t.sourcesHead; e; e = e.nextSource) e.seenVersion = e.source.version;
+				}
+				t.state &= ~V, t._pCursor = null, t._pLink = null, t = u.pop();
+			}
+		}
+	} finally {
+		be--;
+	}
+}
+function Se(e, t) {
+	for (let t of e) t.state &= ~(c | V), t._pCursor = null, t._pLink = null;
+	throw t.state &= ~(c | V), e.length = 0, Error("[elur-next] Ciclo reactivo detectado en computed().");
+}
+function Ce(e) {
+	(e.state !== n || !e.live() && e.lastCleanEpoch !== l) && xe(e);
+}
+function we(e) {
+	let t = !1;
+	for (let n = e.sourcesHead; n; n = n.nextSource) n.source instanceof Q && Ce(n.source), n.source.version !== n.seenVersion && (t = !0);
+	return t;
+}
+function H(e) {
+	e.state & (o | s) || (e.state |= o, (e.flags & m ? g : _).push(e));
+}
+var U = !1, W = 0, G = 0, K = 0, Te = 0, q = 0, J = !1, Ee = 256, Y = () => {
+	g.length = 0, _.length = 0, G = 0, K = 0;
+};
+function X() {
+	W++, U = !1;
+}
+function De() {
+	for (; G < g.length || K < _.length;) {
+		if (++Te > oe) throw Y(), Error("[elur] Maximum effect re-execution depth exceeded (possible infinite loop).");
+		if (q++, G >= g.length && K < _.length && q > Ee && e()) {
+			Oe();
+			return;
+		}
+		let t = G < g.length ? g[G++] : _[K++];
+		if (t.state &= ~o, t.state & s) continue;
+		if (t.state !== i && !we(t)) {
+			t.state = n;
+			continue;
+		}
+		let r = Math.floor(t._flush / 1024), a = (r === W ? t._flush - r * 1024 : 0) + 1;
+		if (t._flush = W * 1024 + a, a > se) throw Y(), new ce(t, a);
+		t.run();
+	}
+	Y();
+}
+function Oe() {
+	J || (J = !0, t().then(() => {
+		J = !1, q = 0;
+		try {
+			De();
+		} catch (e) {
+			X(), queueMicrotask(() => {
+				throw e;
+			});
+			return;
+		}
+		J || X();
+	}));
+}
+function ke() {
+	if (!U) {
+		U = !0, Te = 0, q = 0;
+		try {
+			De();
+		} catch (e) {
+			throw X(), e;
+		}
+		J || X();
+	}
+}
+var Z = class {
+	version = 0;
+	liveCount = 0;
+	durable = !1;
+	consumersHead = null;
+	_v;
+	constructor(e) {
+		this._v = e, S?.onCreate?.(this, e);
+	}
+	get value() {
+		return d && ge(this, d), this._v;
+	}
+	set value(e) {
+		if (this.durable) {
+			console.warn("[elur-next2] constSignal: write ignorada — el producer es estático (B.12.4).");
+			return;
+		}
+		Object.is(this._v, e) || (this._v = e, S?.onWrite?.(this, e), this.version++, l++, ve(this));
+	}
+	update(e) {
+		this.value = e(this._v);
+	}
+	peek() {
+		return this._v;
+	}
+	dispose() {
+		for (; this.consumersHead;) {
+			let e = this.consumersHead;
+			M(this, e), e.prevSource ? e.prevSource.nextSource = e.nextSource : e.target.sourcesHead = e.nextSource, e.nextSource && (e.nextSource.prevSource = e.prevSource), A(e);
+		}
+		P();
+	}
+}, Q = class extends Z {
+	state = n;
+	sourcesHead = null;
+	evalMark = 0;
+	lastCleanEpoch = -1;
+	childrenHead = null;
+	childCount = 0;
+	nextOwned = null;
+	prevOwned = null;
+	cleanups = null;
+	parent = null;
+	_value;
+	fn;
+	equals;
+	flags = 0;
+	_pCursor = null;
+	_pLink = null;
+	constructor(e, t = Object.is) {
+		super(void 0), this.fn = e, this.equals = t, y(this);
+	}
+	live() {
+		return this.consumersHead !== null;
+	}
+	get value() {
+		return this.flags & ee || (this.flags |= ee, this.state = i), Ce(this), d && ge(this, d), this._value;
+	}
+	peek() {
+		return this._value;
+	}
+	dispose() {
+		this.state = s, v(this), this.evalMark++, F(this);
+		let e = this.consumersHead;
+		for (; e;) {
+			let t = e.nextTarget;
+			M(this, e), e.prevSource ? e.prevSource.nextSource = e.nextSource : e.target.sourcesHead = e.nextSource, e.nextSource && (e.nextSource.prevSource = e.prevSource), A(e), e = t;
+		}
+		this.sourcesHead = null, P(), b(this);
+	}
+}, Ae = class {
+	state = n;
+	sourcesHead = null;
+	evalMark = 0;
+	childrenHead = null;
+	childCount = 0;
+	nextOwned = null;
+	prevOwned = null;
+	cleanups = null;
+	parent = null;
+	flags = 0;
+	_flush = 0;
+	_fn;
+	_cleanup = void 0;
+	_errorHandler;
+	constructor(e, t = !1) {
+		this._fn = e, t && (this.flags |= m), this._errorHandler = x, y(this);
+	}
+	live() {
+		return !0;
+	}
+	run() {
+		if (this.flags & h) return;
+		if (this.state & a) throw Error("[elur-next] Effect re-entrante detectado.");
+		typeof this._cleanup == "function" && this._cleanup(), (this.childrenHead !== null || this.cleanups !== null) && v(this), this.evalMark++;
+		let e = d, t = f;
+		d = this, f = this, this.state = a;
+		let r = !0;
+		try {
+			this._cleanup = this._fn(), r = !1;
+		} catch (e) {
+			if (this._errorHandler) this._errorHandler(e), r = !1;
+			else {
+				let t = !1;
+				for (let n = this.parent; n; n = n.parent) if (n.onOwnerError?.(e)) {
+					t = !0;
+					break;
+				}
+				if (t) r = !1;
+				else throw e;
+			}
+		} finally {
+			d = e, f = t, r && this.state & a && (this.state = i);
+		}
+		F(this), this.state = n;
+	}
+	dispose() {
+		this.flags & h || (this.flags |= h, this.state = s, typeof this._cleanup == "function" && this._cleanup(), v(this), this.evalMark++, F(this), b(this));
+	}
+};
+function je(e) {
+	return new Z(e);
+}
+function Me(e) {
+	let t = new Z(e);
+	return t.durable = !0, t;
+}
+function Ne(e, t = Object.is) {
+	return new Q(e, t);
+}
+function Pe(e) {
+	let t = new Ae(e);
+	return t.run(), () => t.dispose();
+}
+function Fe(e) {
+	let t = new Ae(e, !0);
+	return t.run(), () => t.dispose();
+}
+function Ie(e) {
+	u++;
+	try {
+		return e();
+	} finally {
+		u--, u === 0 && ke();
+	}
+}
+function $(e) {
+	let t = d;
+	d = null;
+	try {
+		return e();
+	} finally {
+		d = t;
+	}
+}
+function Le(e, t, n = {}) {
+	let { immediate: r = !1, once: i = !1 } = n, a = e instanceof Z ? () => e.value : e, o = !0, s, c = () => {};
+	return c = Pe(() => {
+		let e = a();
+		if (o && (o = !1, !r)) {
+			s = e;
+			return;
+		}
+		t(e, s), s = e, i && c();
+	}), c;
+}
+function Re(e) {
+	return Promise.resolve().then(e);
+}
+var ze = class {
+	state = n;
+	flags = m;
+	_flush = 0;
+	sourcesHead = null;
+	evalMark = 0;
+	childrenHead = null;
+	childCount = 0;
+	nextOwned = null;
+	prevOwned = null;
+	cleanups = null;
+	parent = null;
+	_fn;
+	_node;
+	constructor(e, t) {
+		this._fn = e, this._node = t, y(this);
+	}
+	live() {
+		return !0;
+	}
+	run() {
+		if (this.flags & h || this.state & a) return;
+		(this.childrenHead !== null || this.cleanups !== null) && v(this), this.evalMark++;
+		let e = d, t = f;
+		d = this, f = this, this.state = a;
+		try {
+			let e = this._fn();
+			this._node.nodeValue = e == null || e === !1 ? "" : String(e);
+		} finally {
+			d = e, f = t;
+		}
+		F(this), this.state = n;
+	}
+	dispose() {
+		this.flags & h || (this.flags |= h, this.state = s, v(this), this.evalMark++, F(this), b(this));
+	}
+};
+function Be(e, t) {
+	let n = new ze(t, e);
+	return n.run(), () => n.dispose();
+}
+var Ve = class {
+	state = n;
+	flags = m;
+	_flush = 0;
+	sourcesHead = null;
+	evalMark = 0;
+	childrenHead = null;
+	childCount = 0;
+	nextOwned = null;
+	prevOwned = null;
+	cleanups = null;
+	parent = null;
+	_source;
+	_link = null;
+	_write;
+	_prev;
+	constructor(e, t) {
+		if (this._source = e, this._write = t, this._prev = e instanceof Q ? $(() => e.value) : e.peek(), t(this._prev), y(this), !e.durable) {
+			let t = k(e, this, e.version, 0);
+			t.nextSource = null, this._link = t, this.sourcesHead = t, j(e, t), T.length && N();
+		}
+	}
+	live() {
+		return !0;
+	}
+	run() {
+		let e = this._source.peek();
+		this._link && (this._link.seenVersion = this._source.version), e !== this._prev && (this._prev = e, this._write(e)), this.state = n;
+	}
+	dispose() {
+		this.flags & h || (this.flags |= h, this.state = s, this._link && (M(this._source, this._link), A(this._link), this._link = null, this.sourcesHead = null), b(this));
+	}
+};
+function He(e, t) {
+	let n = new Ve(e, t);
+	return () => n.dispose();
+}
+var Ue = class {
+	state = n;
+	flags = m;
+	_flush = 0;
+	sourcesHead = null;
+	evalMark = 0;
+	childrenHead = null;
+	childCount = 0;
+	nextOwned = null;
+	prevOwned = null;
+	cleanups = null;
+	parent = null;
+	_source;
+	_link = null;
+	_get;
+	_write;
+	_prev;
+	constructor(e, t, n) {
+		if (this._source = e, this._get = t, this._write = n, this._prev = $(t), n(this._prev), y(this), !e.durable) {
+			let t = k(e, this, e.version, 0);
+			t.nextSource = null, this._link = t, this.sourcesHead = t, j(e, t), T.length && N();
+		}
+	}
+	live() {
+		return !0;
+	}
+	run() {
+		let e = $(this._get);
+		this._link && (this._link.seenVersion = this._source.version), e !== this._prev && (this._prev = e, this._write(e)), this.state = n;
+	}
+	dispose() {
+		this.flags & h || (this.flags |= h, this.state = s, this._link && (M(this._source, this._link), A(this._link), this._link = null, this.sourcesHead = null), b(this));
+	}
+};
+function We(e, t, n) {
+	let r = new Ue(e, t, n);
+	return () => r.dispose();
+}
+//#endregion
+export { Q as Computed, te as Owner, ce as ReactiveCycleError, Z as Signal, pe as _addSignalDebugHooks, We as _bindDerived, He as _bindSignal, Be as _bindText, me as _getNotifyBufSize, de as _popErrorHandler, ue as _pushErrorHandler, Fe as _renderEffect, fe as _setSignalDebugHooks, Ie as batch, Ne as computed, Me as constSignal, ie as createRoot, Pe as effect, ne as getOwner, Re as nextTick, ae as onCleanup, re as runWithOwner, je as signal, $ as untrack, Le as watch };
+
+//# sourceMappingURL=reactivity.js.map