@esportsplus/reactivity 0.39.0 → 0.39.1

package/README.md

@@ -236,7 +236,7 @@ These operate directly on signal/computed nodes — the transformer emits them,
 | `read(node)` | Reads a signal or computed value, subscribing the current scope |
 | `write(signal, value)` | Sets a signal value |
 | `peek(node)` | Reads a signal/computed's current value **without** subscribing (returns an up-to-date value even for a dirty computed) |
-| `untrack(fn)` | Runs `fn` without tracking dependencies; returns `fn`'s result |
+| `untrack(fn)` | Runs `fn` without tracking dependencies; returns `fn`'s result. Ownership is unchanged: effects, computeds, child roots and `onCleanup` created inside are owned by the running effect/computed (or the enclosing `root((dispose) => …)`) and torn down on its next re-run or dispose. Use a zero-arg `root(() => …)` for deliberately detached work |
 | `batch(fn)` | Groups writes so dependent effects defer until `fn` returns; pair with `flush()` for a synchronous transaction |
 | `flush()` | Synchronously settles all pending computed/effect updates |
 | `dispose(computed)` | Disposes a computed and its dependencies |

package/build/system.js

@@ -813,12 +813,18 @@ signal.selector = (node, key) => {
 };
 const untrack = (fn) => {
     let o = observer;
+    if (o === null) {
+        return fn();
+    }
+    let s = scope;
     observer = null;
+    scope = o;
     try {
         return fn();
     }
     finally {
         observer = o;
+        scope = s;
     }
 };
 const write = (signal, value) => {

package/package.json

@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.39.0",
+  "version": "0.39.1",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/src/system.ts

@@ -1032,7 +1032,8 @@ const flush = (): void => {
     }
 };
 
-// Whether an onCleanup() made now would land on an owner (a running computed/effect or a root's scope)
+// Whether an onCleanup() made now would land on an owner (a running computed/effect, also inside
+// untrack, or a root's scope)
 const hasOwner = (): boolean => observer !== null || scope !== null;
 
 const isComputed = (value: unknown): value is Computed<unknown> => {
@@ -1195,16 +1196,26 @@ signal.selector = <T>(node: Signal<T>, key: T): boolean => {
     return read(entry);
 };
 
+// Pauses tracking without changing ownership: work created inside fn is owned by the running
+// computation (as scope), so its next re-run or dispose tears it down. Outside one this is a plain call.
 const untrack = <T>(fn: () => T): T => {
     let o = observer;
 
+    if (o === null) {
+        return fn();
+    }
+
+    let s = scope;
+
     observer = null;
+    scope = o;
 
     try {
         return fn();
     }
     finally {
         observer = o;
+        scope = s;
     }
 };
 

package/test/ownership.test.ts

@@ -551,19 +551,36 @@ describe('ownership throwing cleanup', () => {
 
 
 describe('hasOwner', () => {
-    it('is true inside a tracking root or a run, false outside and in a detached root', () => {
+    it('is true inside a tracking root or a run (also untracked), false outside and in a detached root', () => {
         let seen: boolean[] = [],
             stop = effect(() => {
                 seen.push(hasOwner());
                 seen.push(untrack(() => hasOwner()));
+                seen.push(untrack(() => root(() => hasOwner())));
             });
 
         seen.push(hasOwner());
+        seen.push(untrack(() => hasOwner()));
         root((d) => { seen.push(hasOwner()); d(); });
         root(() => { seen.push(hasOwner()); });
         stop();
 
-        expect(seen).toEqual([true, false, false, true, false]);
+        expect(seen).toEqual([true, true, false, false, false, true, false]);
+    });
+
+    it('is true inside untrack during a re-run', async () => {
+        let s = signal(0),
+            seen: boolean[] = [],
+            stop = effect(() => {
+                read(s);
+                seen.push(untrack(() => hasOwner()));
+            });
+
+        write(s, 1);
+        await Promise.resolve();
+        stop();
+
+        expect(seen).toEqual([true, true]);
     });
 });
 

package/test/untrack.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { computed, effect, peek, read, signal, untrack, write } from '~/system';
+import { computed, effect, hasOwner, onCleanup, peek, read, root, signal, untrack, write } from '~/system';
+import type { Computed } from '~/system';
 
 
 describe('untrack', () => {
@@ -72,6 +73,229 @@ describe('untrack', () => {
 });
 
 
+describe('untrack ownership', () => {
+    it('an effect created inside untrack during a re-run is disposed by the next re-run and by dispose', async () => {
+        let inner = signal(0),
+            innerRuns: string[] = [],
+            outer = signal(0),
+            stop = effect(() => {
+                let gen = read(outer);
+
+                untrack(() => {
+                    effect(() => {
+                        innerRuns.push(`${gen}:${read(inner)}`);
+                    });
+                });
+            });
+
+        write(outer, 1);
+        await Promise.resolve();
+
+        expect(innerRuns).toEqual(['0:0', '1:0']);
+
+        write(inner, 1);
+        await Promise.resolve();
+
+        // Only generation 1's inner effect is alive; generation 0's was disposed by the re-run
+        expect(innerRuns).toEqual(['0:0', '1:0', '1:1']);
+
+        stop();
+        write(inner, 2);
+        await Promise.resolve();
+
+        expect(innerRuns).toEqual(['0:0', '1:0', '1:1']);
+    });
+
+    it('onCleanup inside untrack runs on the next re-run and on dispose', async () => {
+        let log: number[] = [],
+            s = signal(0),
+            stop = effect(() => {
+                let v = read(s);
+
+                untrack(() => onCleanup(() => { log.push(v); }));
+            });
+
+        write(s, 1);
+        await Promise.resolve();
+
+        expect(log).toEqual([0]);
+
+        stop();
+
+        expect(log).toEqual([0, 1]);
+    });
+
+    it('tears down untracked children and cleanups in registration order', async () => {
+        let log: string[] = [],
+            s = signal(0),
+            stop = effect(() => {
+                read(s);
+                onCleanup(() => { log.push('a'); });
+                untrack(() => {
+                    effect(() => {
+                        onCleanup(() => { log.push('b'); });
+                    });
+                    onCleanup(() => { log.push('c'); });
+                });
+                root((d) => {
+                    onCleanup(() => { log.push('d'); });
+                });
+            });
+
+        write(s, 1);
+        await Promise.resolve();
+
+        expect(log).toEqual(['a', 'b', 'c', 'd']);
+
+        stop();
+
+        // dispose() drains owned children after the owner's own cleanups, exactly as for tracked children
+        expect(log.slice(4).sort()).toEqual(['a', 'b', 'c', 'd']);
+    });
+
+    it('reads inside untrack still do not subscribe, nor do reads of untracked children', async () => {
+        let a = signal(0),
+            b = signal(0),
+            runs = 0;
+
+        effect(() => {
+            runs++;
+            untrack(() => {
+                read(a);
+                computed(() => read(b));
+            });
+        });
+
+        write(a, 1);
+        write(b, 1);
+        await Promise.resolve();
+
+        expect(runs).toBe(1);
+    });
+
+    it('outside any computation creations stay unowned', () => {
+        let log: string[] = [],
+            stop = untrack(() => {
+                onCleanup(() => { log.push('dropped'); });
+
+                return effect(() => {
+                    onCleanup(() => { log.push('effect'); });
+                });
+            }),
+            c = untrack(() => computed(() => 1)) as Computed<unknown>;
+
+        expect(c.owner).toBe(null);
+
+        stop();
+
+        expect(log).toEqual(['effect']);
+    });
+
+    it('inside root((d) => ...) creations stay owned by the root', () => {
+        let log: string[] = [];
+
+        root((d) => {
+            untrack(() => {
+                onCleanup(() => { log.push('cleanup'); });
+                effect(() => {
+                    onCleanup(() => { log.push('effect'); });
+                });
+            });
+            d();
+        });
+
+        expect(log).toEqual(['cleanup', 'effect']);
+    });
+
+    it('nested untrack keeps the running computation as owner', async () => {
+        let log: number[] = [],
+            s = signal(0),
+            stop = effect(() => {
+                let v = read(s);
+
+                untrack(() => untrack(() => onCleanup(() => { log.push(v); })));
+            });
+
+        write(s, 1);
+        await Promise.resolve();
+        stop();
+
+        expect(log).toEqual([0, 1]);
+    });
+
+    it('a zero-arg root inside untrack stays detached', async () => {
+        let log: number[] = [],
+            s = signal(0),
+            stop = effect(() => {
+                let v = read(s);
+
+                untrack(() => root(() => {
+                    onCleanup(() => { log.push(-1); });
+                    untrack(() => effect(() => {
+                        onCleanup(() => { log.push(v); });
+                    }));
+                }));
+            });
+
+        write(s, 1);
+        await Promise.resolve();
+        stop();
+
+        // Neither the root's cleanup (no owner) nor its effects are torn down by the outer effect
+        expect(log).toEqual([]);
+    });
+
+    it('restores owner and observer when fn throws', async () => {
+        let a = signal(0),
+            runs = 0;
+
+        effect(() => {
+            runs++;
+
+            try {
+                untrack(() => {
+                    throw new Error('boom');
+                });
+            }
+            catch {
+                // only restoration is under test
+            }
+
+            read(a);
+        });
+
+        expect(untrack(() => hasOwner())).toBe(false);
+
+        write(a, 1);
+        await Promise.resolve();
+
+        expect(runs).toBe(2);
+    });
+
+    it('an async computed created inside untrack is owned by the running computation', async () => {
+        let log: string[] = [],
+            s = signal(0),
+            stop = effect(() => {
+                let v = read(s);
+
+                untrack(() => computed(async () => {
+                    onCleanup(() => { log.push(`factory ${v}`); });
+                    return v;
+                }));
+            });
+
+        write(s, 1);
+        await Promise.resolve();
+
+        expect(log).toEqual(['factory 0']);
+
+        stop();
+
+        expect(log).toEqual(['factory 0', 'factory 1']);
+    });
+});
+
+
 describe('peek', () => {
     it('returns the current value of a signal', () => {
         let s = signal(5);