vigla 0.2.0 → 0.2.2

package/src/runtime/reactivity/effects.ts

@@ -54,6 +54,7 @@ import { handlerOf } from './handlers.ts';
 import { orphan, teardownOrphan } from './errors.ts';
 import { ownLeaving } from './outgoing.ts';
 import { presently, retire } from './past.ts';
+import { link, unlink } from './siblings.ts';
 import {
 	deriving,
 	evaluation,
@@ -265,12 +266,7 @@ function create(kind: Kind, fn: (() => void | (() => void)) | null, parent: Effe
 		slots: null,
 		captured: null
 	};
-	if (parent !== null) {
-		effect.prev = parent.last;
-		if (parent.last === null) parent.first = effect;
-		else parent.last.next = effect;
-		parent.last = effect;
-	}
+	if (parent !== null) link(effect, parent);
 	const claimer = ownEffect(effect);
 	if (drafting !== 0 && parent !== null) capture(parent, effect, claimer);
 	return effect;
@@ -544,16 +540,6 @@ function immediately(stop: () => void): void {
 	stop();
 }
 
-function unlink(effect: Effect): void {
-	const parent = effect.parent;
-	if (parent === null) return;
-	if (effect.prev === null) parent.first = effect.next;
-	else effect.prev.next = effect.next;
-	if (effect.next === null) parent.last = effect.prev;
-	else effect.next.prev = effect.prev;
-	effect.prev = effect.next = null;
-}
-
 type Among = ((child: Effect) => boolean) | null;
 
 function doomed(child: Effect, keepBranches: boolean, among: Among): boolean {

package/src/runtime/reactivity/held.ts

@@ -104,6 +104,7 @@ function fold(from: Batch, into: Batch): void {
 	from.work = 0;
 	from.done = true;
 	from.into = into;
+	(into.folded ??= []).push(from.order, ...(from.folded ?? []));
 	if (from.merges !== null) {
 		for (const transfer of from.merges) transfer(from, into);
 		(into.merges ??= []).push(...from.merges);

package/src/runtime/reactivity/reads.ts

@@ -1,5 +1,5 @@
 import { DEV } from 'esm-env';
-import { processed } from './batch.ts';
+import { foreign, processed } from './batch.ts';
 import {
 	destroyEffects,
 	discardAside,
@@ -317,16 +317,18 @@ export function changed(reads: ReadonlyMap<Source, unknown>, target: Reaction):
 }
 
 export function stale(target: Reaction, recheck = false): boolean {
-	if (recheck) {
-		if (target.deps === null) return true;
+	if (recheck && target.deps === null) return true;
+	if (recheck && ((target.deps as Source[]).length > 0 || (target as Effect).async)) {
 		const effect = target as Effect;
-		const own = (view?.batch ?? processed())?.reads?.get(effect);
+		const batch = view?.batch ?? processed();
+		const own = batch?.reads?.get(effect);
 		if (
 			own === undefined &&
 			effect.kind === BLOCK &&
 			(!effect.async || effect.forked) &&
 			effect.batch !== 0 &&
-			effect.batch !== (view?.batch.order ?? processed()?.order)
+			effect.batch !== batch?.order &&
+			(batch === null || effect.forked || foreign(effect.batch, batch))
 		)
 			return true;
 		const reads = own ?? observedReads(target);

package/src/runtime/reactivity/siblings.ts

@@ -0,0 +1,25 @@
+import type { Effect } from './graph.ts';
+
+export function link(effect: Effect, parent: Effect): void {
+	effect.prev = parent.last;
+	if (parent.last === null) parent.first = effect;
+	else parent.last.next = effect;
+	parent.last = effect;
+}
+
+export function unlink(effect: Effect): void {
+	const parent = effect.parent;
+	if (parent === null) return;
+	if (effect.prev === null) parent.first = effect.next;
+	else effect.prev.next = effect.next;
+	if (effect.next === null) parent.last = effect.prev;
+	else effect.next.prev = effect.prev;
+	effect.prev = effect.next = null;
+}
+
+export function sendLast(effect: Effect): void {
+	const parent = effect.parent;
+	if (effect.destroyed || parent === null || parent.last === effect) return;
+	unlink(effect);
+	link(effect, parent);
+}