@esportsplus/reactivity 0.38.1 → 0.39.0

package/bench/ownership.bench.ts

@@ -0,0 +1,212 @@
+import { test } from 'vitest';
+import { computed, dispose, effect, flush, onCleanup, read, root, signal, write } from '~/system';
+import type { Computed } from '~/system';
+
+
+const CHURN = 1000;
+
+
+function noop() {
+}
+
+// Owner registrations still held after churn: user cleanups plus owned children (`owned` is absent
+// before the owned list existed, so this also counts a baseline tree's closure array)
+function retained(node: Computed<unknown>): number {
+    let n = node.cleanup === null ? 0 : typeof node.cleanup === 'function' ? 1 : node.cleanup.length;
+
+    for (let child = node.owned; child; child = child.nextOwned) {
+        n++;
+    }
+
+    return n;
+}
+
+
+test('ownership churn', async ({ bench }) => {
+    await bench.compare(
+        bench(`${CHURN} child roots created + disposed under one owner`, () => {
+            let owner = computed(() => {
+                for (let i = 0; i < CHURN; i++) {
+                    root((d) => {
+                        onCleanup(noop);
+                        d();
+                    });
+                }
+
+                return 0;
+            });
+
+            dispose(owner);
+        }),
+        bench(`${CHURN} child effects created + disposed under one owner`, () => {
+            let owner = computed(() => {
+                for (let i = 0; i < CHURN; i++) {
+                    effect(() => {
+                        onCleanup(noop);
+                    })();
+                }
+
+                return 0;
+            });
+
+            dispose(owner);
+        })
+    );
+});
+
+
+test('ownership churn retention', () => {
+    let gc = (globalThis as { gc?: () => void }).gc,
+        heap = 0;
+
+    for (let n of [1000, 10000]) {
+        gc?.();
+
+        let before = process.memoryUsage().heapUsed,
+            owner = computed(() => {
+                for (let i = 0; i < n; i++) {
+                    root((d) => {
+                        onCleanup(noop);
+                        d();
+                    });
+                }
+
+                return 0;
+            });
+
+        gc?.();
+        heap = process.memoryUsage().heapUsed - before;
+
+        console.log(`[ownership] churn ${n}: retained registrations = ${retained(owner as Computed<unknown>)}, heap delta = ${gc ? `${(heap / 1024).toFixed(1)} KiB` : 'n/a (run with --expose-gc)'}`);
+        dispose(owner);
+    }
+});
+
+
+test('ownership effect re-run', async ({ bench }) => {
+    let s = signal(0),
+        nested = signal(0),
+        i = 0;
+
+    let stop = effect(() => {
+        read(s);
+
+        for (let j = 0; j < 10; j++) {
+            effect(() => {
+                read(nested);
+                onCleanup(noop);
+            });
+        }
+    });
+
+    await bench.compare(
+        bench('re-run effect owning 10 child effects', () => {
+            write(s, ++i);
+            flush();
+        }),
+        bench('re-run 10 child effects (parent stable)', () => {
+            write(nested, ++i);
+            flush();
+        })
+    );
+
+    stop();
+});
+
+
+test('ownership tree dispose', async ({ bench }) => {
+    await bench.compare(
+        bench('deep owner tree (1000 nested roots) disposed at once', () => {
+            root((d) => {
+                let parent = (depth: number): void => {
+                    if (depth === 0) {
+                        return;
+                    }
+
+                    root(() => {
+                        onCleanup(noop);
+                        parent(depth - 1);
+                    });
+                };
+
+                parent(1000);
+                d();
+            });
+        }),
+        bench('deep owner tree (200 nested effects) disposed at once', () => {
+            root((d) => {
+                let parent = (depth: number): void => {
+                    if (depth === 0) {
+                        return;
+                    }
+
+                    effect(() => {
+                        onCleanup(noop);
+                        parent(depth - 1);
+                    });
+                };
+
+                parent(200);
+                d();
+            });
+        }),
+        bench('wide owner tree (1000 child effects) disposed at once', () => {
+            root((d) => {
+                for (let i = 0; i < 1000; i++) {
+                    effect(() => {
+                        onCleanup(noop);
+                    });
+                }
+
+                d();
+            });
+        }),
+        bench('wide x deep owner tree (32 x 32 effects) disposed at once', () => {
+            root((d) => {
+                for (let i = 0; i < 32; i++) {
+                    effect(() => {
+                        for (let j = 0; j < 32; j++) {
+                            effect(() => {
+                                onCleanup(noop);
+                            });
+                        }
+                    });
+                }
+
+                d();
+            });
+        })
+    );
+});
+
+
+test('ownership single cleanup', async ({ bench }) => {
+    let s = signal(0),
+        i = 0;
+
+    let stop = effect(() => {
+        read(s);
+        onCleanup(noop);
+    });
+
+    await bench.compare(
+        bench('effect re-run with 1 cleanup', () => {
+            write(s, ++i);
+            flush();
+        }),
+        bench('computed create + dispose with 1 cleanup', () => {
+            dispose(computed(() => {
+                onCleanup(noop);
+                return 0;
+            }));
+        }),
+        bench('root create + dispose with 1 cleanup', () => {
+            root((d) => {
+                onCleanup(noop);
+                d();
+            });
+        })
+    );
+
+    stop();
+});

package/build/reactive/array.d.ts

@@ -50,8 +50,9 @@ declare class ReactiveArray<T> extends Array<T> {
     concat(...items: (T | ConcatArray<T>)[]): ReactiveArray<T>;
     dispatch<K extends keyof Events<T>>(event: K, value?: Events<T>[K]): void;
     dispose(): void;
-    on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
-    once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
+    on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): VoidFunction;
+    once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): VoidFunction;
+    private prune;
     pop(): T | undefined;
     push(...items: T[]): number;
     reverse(): this;

package/build/reactive/array.js

@@ -77,7 +77,7 @@ class ReactiveArray extends Array {
         let dirty = false, errors = null;
         for (let i = 0, n = listeners.length; i < n; i++) {
             let listener = listeners[i];
-            if (listener === null) {
+            if (listener == null) {
                 continue;
             }
             try {
@@ -94,9 +94,7 @@ class ReactiveArray extends Array {
             }
         }
         if (dirty) {
-            while (listeners.length && listeners[listeners.length - 1] === null) {
-                listeners.pop();
-            }
+            this.prune(event, listeners);
         }
         if (errors !== null) {
             let error = errors.length === 1
@@ -119,25 +117,45 @@ class ReactiveArray extends Array {
             this.listeners[event] = [entry];
         }
         else {
-            let hole = listeners.length;
+            let hole = listeners.length, registered = false;
             for (let i = 0, n = hole; i < n; i++) {
                 let l = listeners[i];
                 if (l === entry) {
-                    return;
+                    registered = true;
+                    break;
                 }
                 else if (l === null && hole === n) {
                     hole = i;
                 }
             }
-            listeners[hole] = entry;
-            while (listeners.length && listeners[listeners.length - 1] === null) {
-                listeners.pop();
+            if (!registered) {
+                listeners[hole] = entry;
+                this.prune(event, listeners);
             }
         }
+        return () => {
+            let current = this.listeners[event];
+            if (current === undefined) {
+                return;
+            }
+            let i = current.indexOf(entry);
+            if (i !== -1) {
+                current[i] = null;
+                this.prune(event, current);
+            }
+        };
     }
     once(event, listener) {
         listener.once = true;
-        this.on(event, listener);
+        return this.on(event, listener);
+    }
+    prune(event, listeners) {
+        while (listeners.length && listeners[listeners.length - 1] === null) {
+            listeners.pop();
+        }
+        if (listeners.length === 0 && this.listeners[event] === listeners) {
+            delete this.listeners[event];
+        }
     }
     pop() {
         if (this.length === 0) {

package/build/reactive/index.js

@@ -1,6 +1,6 @@
-import { onCleanup, root } from '@esportsplus/reactivity';
 import { isArray, isObject } from '@esportsplus/utilities';
 import { PACKAGE_NAME } from '../constants.js';
+import { onCleanup, root } from '../system.js';
 import { ReactiveArray } from './array.js';
 import { ReactiveObject } from './object.js';
 function reactive(input) {

package/build/system.d.ts

@@ -7,6 +7,7 @@ declare namespace computed {
 declare const dispose: <T>(computed: Computed<T>) => void;
 declare const effect: <T>(fn: Computed<T>['fn'], apply?: (value: T, prev: T | undefined) => void) => () => void;
 declare const flush: () => void;
+declare const hasOwner: () => boolean;
 declare const isComputed: (value: unknown) => value is Computed<unknown>;
 declare const isSignal: (value: unknown) => value is Signal<unknown>;
 declare const onCleanup: (fn: VoidFunction) => typeof fn;
@@ -19,5 +20,5 @@ declare namespace signal {
 }
 declare const untrack: <T>(fn: () => T) => T;
 declare const write: <T>(signal: Signal<T>, value: T) => void;
-export { batch, computed, dispose, effect, flush, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };
+export { batch, computed, dispose, effect, flush, hasOwner, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };
 export type { Computed, Signal };

package/build/system.js

@@ -1,6 +1,6 @@
 import { PACKAGE_NAME, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
 import { isObject, isPromise } from '@esportsplus/utilities';
-let asyncMeta = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, pulled = null, puller = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
+let asyncFactory = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, pulled = null, puller = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
 function noop() {
 }
 function walkPop(walk) {
@@ -23,30 +23,33 @@ function walkPush(computed, link, prev) {
     return { computed, link, prev };
 }
 function cleanup(computed) {
-    if (!computed.cleanup) {
+    let child = computed.owned, value = computed.cleanup;
+    computed.cleanup = null;
+    if (child === null && typeof value === 'function') {
+        value();
         return;
     }
-    let errors = [], value = computed.cleanup;
-    computed.cleanup = null;
-    if (typeof value === 'function') {
-        try {
-            value();
-        }
-        catch (e) {
-            errors.push(e);
+    let errors = null, n = value === null ? 0 : typeof value === 'function' ? 1 : value.length;
+    for (let i = 0; i <= n; i++) {
+        while ((child = computed.owned) !== null && (i === n || child.ownerSlot <= i)) {
+            disown(child);
+            try {
+                dispose(child);
+            }
+            catch (e) {
+                (errors ??= []).push(e);
+            }
         }
-    }
-    else {
-        for (let i = 0, n = value.length; i < n; i++) {
+        if (i < n) {
             try {
-                value[i]();
+                (typeof value === 'function' ? value : value[i])();
             }
             catch (e) {
-                errors.push(e);
+                (errors ??= []).push(e);
             }
         }
     }
-    if (errors.length) {
+    if (errors !== null) {
         throw errors.length === 1 ? errors[0] : new AggregateError(errors, `${PACKAGE_NAME}: cleanup produced multiple errors`);
     }
 }
@@ -73,6 +76,20 @@ function deleteFromHeap(computed) {
     computed.nextHeap = undefined;
     computed.prevHeap = computed;
 }
+function disown(child) {
+    let next = child.nextOwned, owner = child.owner, prev = child.prevOwned;
+    if (owner.owned === child) {
+        owner.owned = next;
+        if (next !== null) {
+            next.prevOwned = prev;
+        }
+    }
+    else {
+        prev.nextOwned = next;
+        (next ?? owner.owned).prevOwned = prev;
+    }
+    child.nextOwned = child.owner = child.prevOwned = null;
+}
 function drainPending() {
     let node = pendingHead;
     pendingHead = null;
@@ -198,6 +215,21 @@ function notify(computed, newState) {
         stack = walkPop(stack);
     }
 }
+function own(owner, child) {
+    let head = owner.owned, value = owner.cleanup;
+    child.owner = owner;
+    child.ownerSlot = value === null ? 0 : typeof value === 'function' ? 1 : value.length;
+    if (head === null) {
+        owner.owned = child;
+        child.prevOwned = child;
+    }
+    else {
+        let tail = head.prevOwned;
+        tail.nextOwned = child;
+        child.prevOwned = tail;
+        head.prevOwned = child;
+    }
+}
 function pull(node) {
     if (!notified) {
         notified = true;
@@ -238,7 +270,7 @@ function recompute(computed) {
     if (computed.state & STATE_IN_HEAP) {
         deleteFromHeap(computed);
     }
-    if (computed.cleanup) {
+    if (computed.cleanup !== null || computed.owned !== null) {
         try {
             cleanup(computed);
         }
@@ -486,7 +518,7 @@ function makeAsyncComputed(factory) {
         return read(node);
     });
     wrapper.pending = pending;
-    asyncMeta.set(wrapper, { factory: factory });
+    asyncFactory.set(wrapper, factory);
     wrapper.disposal = stop;
     return wrapper;
 }
@@ -507,12 +539,12 @@ function makeComputed(fn, eager = false) {
             schedule();
         }
         link(self, observer);
-        onCleanup(() => dispose(self));
+        own(observer, self);
     }
     else {
         recompute(self);
         if (scope) {
-            onCleanup(() => dispose(self));
+            own(scope, self);
         }
     }
     return self;
@@ -529,8 +561,13 @@ function makeNode(fn) {
         gv: 0,
         height: 0,
         nextHeap: undefined,
+        nextOwned: null,
+        owned: null,
+        owner: null,
+        ownerSlot: 0,
         pending: null,
         prevHeap: null,
+        prevOwned: null,
         rv: 0,
         state: STATE_COMPUTED,
         subs: null,
@@ -556,18 +593,19 @@ const batch = (fn) => {
 const computed = (fn, equals = null) => {
     let o = observer, self = makeComputed(fn, true), value = self.value;
     if (isPromise(value) || (value != null && typeof value[Symbol.asyncIterator] === 'function')) {
-        self = untrack(() => makeAsyncComputed(self));
-        if (o) {
-            onCleanup(() => dispose(self));
+        let owner = o || scope;
+        self = root(() => makeAsyncComputed(self));
+        if (owner !== null) {
+            own(owner, self);
         }
     }
     self.equals = equals;
     return self;
 };
 computed.invalidate = (c) => {
-    let meta = asyncMeta.get(c);
-    if (meta) {
-        computed.invalidate(meta.factory);
+    let factory = asyncFactory.get(c);
+    if (factory) {
+        computed.invalidate(factory);
         return;
     }
     writes++;
@@ -581,7 +619,7 @@ const dispose = (computed) => {
         return;
     }
     draining = true;
-    let node = computed;
+    let errors = null, node = computed;
     try {
         for (;;) {
             deleteFromHeap(node);
@@ -590,13 +628,26 @@ const dispose = (computed) => {
                 dep = unlink(dep);
             }
             node.deps = null;
-            if (node.cleanup) {
-                cleanup(node);
+            if (node.owner !== null) {
+                disown(node);
+            }
+            if (node.cleanup !== null || node.owned !== null) {
+                try {
+                    cleanup(node);
+                }
+                catch (e) {
+                    (errors ??= []).push(e);
+                }
             }
             if (node.disposal) {
                 let d = node.disposal;
                 node.disposal = null;
-                d();
+                try {
+                    d();
+                }
+                catch (e) {
+                    (errors ??= []).push(e);
+                }
             }
             if (disposeHead === null) {
                 break;
@@ -608,6 +659,9 @@ const dispose = (computed) => {
     finally {
         draining = false;
     }
+    if (errors !== null) {
+        throw errors.length === 1 ? errors[0] : new AggregateError(errors, `${PACKAGE_NAME}: dispose produced multiple errors`);
+    }
 };
 const effect = (fn, apply) => {
     let prev;
@@ -635,6 +689,7 @@ const flush = () => {
         stabilize();
     }
 };
+const hasOwner = () => observer !== null || scope !== null;
 const isComputed = (value) => {
     return isObject(value) && !!(value.state & STATE_COMPUTED);
 };
@@ -697,12 +752,16 @@ const read = (node) => {
     return node.value;
 };
 const root = (fn) => {
-    let c, o = observer, s = scope, self = null, tracking = fn.length, value;
+    let o = observer, s = scope, tracking = fn.length, value;
     observer = null;
     try {
         if (tracking) {
-            scope = self = makeNode(noop);
-            value = fn(c = () => dispose(self));
+            let self = makeNode(noop), owner = o || s;
+            if (owner !== null) {
+                own(owner, self);
+            }
+            scope = self;
+            value = fn(() => dispose(self));
         }
         else {
             scope = null;
@@ -713,9 +772,6 @@ const root = (fn) => {
         observer = o;
         scope = s;
     }
-    if (c) {
-        onCleanup(c);
-    }
     return value;
 };
 const signal = (value, equals = null) => {
@@ -792,4 +848,4 @@ const write = (signal, value) => {
     }
     schedule();
 };
-export { batch, computed, dispose, effect, flush, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };
+export { batch, computed, dispose, effect, flush, hasOwner, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };

package/build/types.d.ts

@@ -11,8 +11,13 @@ interface Computed<T> {
     gv: number;
     height: number;
     nextHeap: Computed<unknown> | undefined;
+    nextOwned: Computed<unknown> | null;
+    owned: Computed<unknown> | null;
+    owner: Computed<unknown> | null;
+    ownerSlot: number;
     pending: Signal<boolean> | null;
     prevHeap: Computed<unknown>;
+    prevOwned: Computed<unknown> | null;
     rv: number;
     state: number;
     subs: Link | null;

package/package.json

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