@esportsplus/reactivity 0.12.0 → 0.12.1

package/build/reactive/array.d.ts

@@ -35,6 +35,7 @@ type Listener<V> = {
 type Value<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends Array<infer U> ? API<U> : T;
 declare class ReactiveArray<T> {
     [REACTIVE_ARRAY]: boolean;
+    disposables: number;
     private data;
     private listeners;
     private proxy;

package/build/reactive/array.js

@@ -1,9 +1,10 @@
 import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '../constants.js';
-import { computed, dispose, isComputed, onCleanup, read, root } from '../system.js';
+import { computed, dispose, isComputed, read } from '../system.js';
 import object, { isReactiveObject } from './object.js';
 class ReactiveArray {
     [REACTIVE_ARRAY] = true;
+    disposables = 0;
     data;
     listeners = null;
     proxy;
@@ -171,36 +172,32 @@ const isReactiveArray = (value) => {
     return isObject(value) && REACTIVE_ARRAY in value;
 };
 export default function array(input) {
-    let { array, proxy } = root(() => {
-        let proxy = new Proxy({}, {
-            get(_, key) {
-                if (isNumber(key)) {
-                    let value = wrapped[key];
-                    if (isComputed(value)) {
-                        return read(value);
-                    }
-                    return value;
+    let proxy = new Proxy({}, {
+        get(_, key) {
+            if (isNumber(key)) {
+                let value = wrapped[key];
+                if (isComputed(value)) {
+                    return read(value);
                 }
-                else if (key in array) {
-                    return array[key];
-                }
-                return wrapped[key];
-            },
-            set(_, key, value) {
-                if (isNumber(key)) {
-                    array.splice(key, 1, value);
-                    return true;
-                }
-                else if (key === 'length') {
-                    return array.length = value;
-                }
-                return false;
+                return value;
+            }
+            else if (key in array) {
+                return array[key];
             }
-        }), wrapped = factory(input);
-        let array = new ReactiveArray(wrapped, proxy);
-        return { array, proxy };
-    });
-    onCleanup(() => array.dispose());
+            return wrapped[key];
+        },
+        set(_, key, value) {
+            if (isNumber(key)) {
+                array.splice(key, 1, value);
+                return true;
+            }
+            else if (key === 'length') {
+                return array.length = value;
+            }
+            return false;
+        }
+    }), wrapped = factory(input);
+    let array = new ReactiveArray(wrapped, proxy);
     return proxy;
 }
 ;

package/build/reactive/index.js

@@ -1,12 +1,22 @@
 import { isArray, isObject } from '@esportsplus/utilities';
+import { onCleanup, root } from '../system.js';
 import array from './array.js';
 import object from './object.js';
 export default (input) => {
-    if (isArray(input)) {
-        return array(input);
-    }
-    else if (isObject(input)) {
-        return object(input);
-    }
-    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
+    let value;
+    return root(() => {
+        if (isArray(input)) {
+            value = array(input);
+        }
+        else if (isObject(input)) {
+            value = object(input);
+        }
+        if (value) {
+            if (root.disposables) {
+                onCleanup(() => value.dispose());
+            }
+            return value;
+        }
+        throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
+    });
 };

package/build/reactive/object.js

@@ -1,5 +1,5 @@
 import { defineProperty, isArray, isFunction, isObject, isPromise } from '@esportsplus/utilities';
-import { computed, dispose, effect, isComputed, onCleanup, read, root, set, signal } from '../system.js';
+import { computed, dispose, effect, isComputed, read, root, set, signal } from '../system.js';
 import { REACTIVE_OBJECT } from '../constants.js';
 import array, { isReactiveArray } from './array.js';
 class ReactiveObject {
@@ -74,9 +74,7 @@ const isReactiveObject = (value) => {
     return isObject(value) && REACTIVE_OBJECT in value;
 };
 export default function object(input) {
-    let object = root(() => new ReactiveObject(input));
-    onCleanup(() => object.dispose());
-    return object;
+    return new ReactiveObject(input);
 }
 ;
 export { isReactiveObject };

package/build/system.d.ts

@@ -6,7 +6,10 @@ 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;
 declare const read: <T>(node: Signal<T> | Computed<T>) => T;
-declare const root: <T>(fn: () => T) => T;
+declare const root: {
+    <T>(fn: () => T): T;
+    disposables: number;
+};
 declare const set: <T>(signal: Signal<T>, value: T) => void;
 declare const signal: <T>(value: T) => Signal<T>;
 export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, set, signal };

package/build/system.js

@@ -1,20 +1,20 @@
-import { isArray, isObject, } from '@esportsplus/utilities';
+import { isArray, isObject } from '@esportsplus/utilities';
 import { COMPUTED, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
 let depth = 0, heap = new Array(2048), index = 0, length = 0, microtask = queueMicrotask, notified = false, observer = null, stabilizer = STABILIZER_IDLE, version = 0;
-function cleanup(node) {
-    if (!node.cleanup) {
+function cleanup(computed) {
+    if (!computed.cleanup) {
         return;
     }
-    let cleanup = node.cleanup;
-    if (isArray(cleanup)) {
-        for (let i = 0, n = cleanup.length; i < n; i++) {
-            cleanup[i]();
+    let value = computed.cleanup;
+    if (isArray(value)) {
+        for (let i = 0, n = value.length; i < n; i++) {
+            value[i]();
         }
     }
     else {
-        cleanup();
+        value();
     }
-    node.cleanup = null;
+    computed.cleanup = null;
 }
 function deleteFromHeap(computed) {
     let state = computed.state;
@@ -138,11 +138,11 @@ function recompute(computed, del) {
     depth--;
     observer = o;
     computed.state = STATE_NONE;
-    let depsTail = computed.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : computed.deps;
-    if (toRemove !== null) {
+    let depsTail = computed.depsTail, remove = depsTail !== null ? depsTail.nextDep : computed.deps;
+    if (remove !== null) {
         do {
-            toRemove = unlink(toRemove);
-        } while (toRemove !== null);
+            remove = unlink(remove);
+        } while (remove !== null);
         if (depsTail !== null) {
             depsTail.nextDep = null;
         }
@@ -153,11 +153,11 @@ function recompute(computed, del) {
     if (ok && value !== computed.value) {
         computed.value = value;
         for (let c = computed.subs; c !== null; c = c.nextSub) {
-            let o = c.sub, state = o.state;
+            let s = c.sub, state = s.state;
             if (state & STATE_CHECK) {
-                o.state = state | STATE_DIRTY;
+                s.state = state | STATE_DIRTY;
             }
-            insertIntoHeap(o);
+            insertIntoHeap(s);
         }
         schedule();
     }
@@ -172,24 +172,24 @@ function schedule() {
     }
 }
 function stabilize() {
-    let o = observer;
-    stabilizer = STABILIZER_RUNNING;
-    for (index = 0; index <= length; index++) {
-        let computed = heap[index];
-        heap[index] = undefined;
-        while (computed !== undefined) {
-            let next = computed.nextHeap;
-            recompute(computed, false);
-            computed = next;
+    root(() => {
+        stabilizer = STABILIZER_RUNNING;
+        for (index = 0; index <= length; index++) {
+            let computed = heap[index];
+            heap[index] = undefined;
+            while (computed !== undefined) {
+                let next = computed.nextHeap;
+                recompute(computed, false);
+                computed = next;
+            }
         }
-    }
-    observer = o;
-    if (stabilizer === STABILIZER_RESCHEDULE) {
-        microtask(stabilize);
-    }
-    else {
-        stabilizer = STABILIZER_IDLE;
-    }
+        if (stabilizer === STABILIZER_RESCHEDULE) {
+            microtask(stabilize);
+        }
+        else {
+            stabilizer = STABILIZER_IDLE;
+        }
+    });
 }
 function unlink(link) {
     let { dep, nextDep, nextSub, prevSub } = link;
@@ -255,6 +255,7 @@ const computed = (fn) => {
     }
     else {
         recompute(self, false);
+        root.disposables++;
     }
     return self;
 };
@@ -319,12 +320,15 @@ const read = (node) => {
     return node.value;
 };
 const root = (fn) => {
-    let o = observer;
+    let d = root.disposables, o = observer;
     observer = null;
+    root.disposables = 0;
     let value = fn();
     observer = o;
+    root.disposables = d;
     return value;
 };
+root.disposables = 0;
 const set = (signal, value) => {
     if (signal.value === value) {
         return;

package/package.json

@@ -12,7 +12,7 @@
   "private": false,
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/array.ts

@@ -1,6 +1,6 @@
 import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
 import { REACTIVE_ARRAY } from '~/constants';
-import { computed, dispose, isComputed, onCleanup, read, root } from '~/system';
+import { computed, dispose, isComputed, read } from '~/system';
 import { Computed, Infer } from '~/types';
 import object, { isReactiveObject, ReactiveObject } from './object';
 
@@ -50,6 +50,7 @@ type Value<T> =
 
 class ReactiveArray<T> {
     [REACTIVE_ARRAY] = true;
+    disposables: number = 0;
 
     private data: Item<T>[];
     private listeners: Record<string, (Listener<any> | null)[]> | null = null;
@@ -294,44 +295,38 @@ const isReactiveArray = (value: any): value is ReactiveArray<any> => {
 
 
 export default function array<T>(input: T[]) {
-    let { array, proxy } = root(() => {
-            let proxy = new Proxy({}, {
-                    get(_: any, key: any) {
-                        if (isNumber(key)) {
-                            let value = wrapped[key];
-
-                            if (isComputed(value)) {
-                                return read(value);
-                            }
-
-                            return value;
-                        }
-                        else if (key in array) {
-                            return array[key as keyof typeof array];
-                        }
-
-                        return wrapped[key];
-                    },
-                    set(_: any, key: any, value: any) {
-                        if (isNumber(key)) {
-                            array.splice(key, 1, value);
-                            return true;
-                        }
-                        else if (key === 'length') {
-                            return array.length = value;
-                        }
-
-                        return false;
+    let proxy = new Proxy({}, {
+            get(_: any, key: any) {
+                if (isNumber(key)) {
+                    let value = wrapped[key];
+
+                    if (isComputed(value)) {
+                        return read(value);
                     }
-                }) as API<T>,
-                wrapped = factory(input);
 
-            let array = new ReactiveArray(wrapped, proxy);
+                    return value;
+                }
+                else if (key in array) {
+                    return array[key as keyof typeof array];
+                }
 
-            return { array, proxy };
-        });
+                return wrapped[key];
+            },
+            set(_: any, key: any, value: any) {
+                if (isNumber(key)) {
+                    array.splice(key, 1, value);
+                    return true;
+                }
+                else if (key === 'length') {
+                    return array.length = value;
+                }
+
+                return false;
+            }
+        }) as API<T>,
+        wrapped = factory(input);
 
-    onCleanup(() => array.dispose());
+    let array = new ReactiveArray(wrapped, proxy);
 
     return proxy;
 };

package/src/reactive/index.ts

@@ -1,4 +1,5 @@
 import { isArray, isObject } from '@esportsplus/utilities';
+import { onCleanup, root } from '~/system';
 import array from './array';
 import object from './object';
 
@@ -21,13 +22,25 @@ type Input<T> =
 
 
 export default <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input<T>): API<T> => {
-    if (isArray(input)) {
-        return array(input) as API<T>;
-    }
-    else if (isObject(input)) {
-        return object(input) as API<T>;
-    }
-
-    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
+    let value: API<T> | undefined;
+
+    return root(() => {
+        if (isArray(input)) {
+            value = array(input) as API<T>;
+        }
+        else if (isObject(input)) {
+            value = object(input) as API<T>;
+        }
+
+        if (value) {
+            if (root.disposables) {
+                onCleanup(() => value!.dispose());
+            }
+
+            return value;
+        }
+
+        throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
+    });
 };
 export type { Input };

package/src/reactive/object.ts

@@ -1,5 +1,5 @@
 import { defineProperty, isArray, isFunction, isObject, isPromise, Prettify } from '@esportsplus/utilities';
-import { computed, dispose, effect, isComputed, onCleanup, read, root, set, signal } from '~/system';
+import { computed, dispose, effect, isComputed, read, root, set, signal } from '~/system';
 import { Computed, Infer, Signal } from '~/types';
 import { REACTIVE_OBJECT } from '~/constants';
 import array, { isReactiveArray } from './array';
@@ -11,6 +11,7 @@ type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: In
 class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT] = true;
 
+
     constructor(data: T) {
         for (let key in data) {
             let value = data[key];
@@ -100,11 +101,7 @@ const isReactiveObject = (value: any): value is ReactiveObject<any> => {
 
 
 export default function object<T extends Record<PropertyKey, unknown>>(input: T) {
-    let object = root(() => new ReactiveObject<T>(input));
-
-    onCleanup(() => object.dispose());
-
-    return object;
+    return new ReactiveObject<T>(input);
 };
 export { isReactiveObject };
 export type { API as ReactiveObject };

package/src/system.ts

@@ -1,4 +1,4 @@
-import { isArray, isObject, } from '@esportsplus/utilities';
+import { isArray, isObject } from '@esportsplus/utilities';
 import {
     COMPUTED, SIGNAL,
     STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
@@ -18,23 +18,23 @@ let depth = 0,
     version = 0;
 
 
-function cleanup<T>(node: Computed<T>): void {
-    if (!node.cleanup) {
+function cleanup<T>(computed: Computed<T>): void {
+    if (!computed.cleanup) {
         return;
     }
 
-    let cleanup = node.cleanup;
+    let value = computed.cleanup;
 
-    if (isArray(cleanup)) {
-        for (let i = 0, n = cleanup.length; i < n; i++) {
-            cleanup[i]();
+    if (isArray(value)) {
+        for (let i = 0, n = value.length; i < n; i++) {
+            value[i]();
         }
     }
     else {
-        cleanup();
+        value();
     }
 
-    node.cleanup = null;
+    computed.cleanup = null;
 }
 
 function deleteFromHeap<T>(computed: Computed<T>) {
@@ -208,13 +208,13 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
     computed.state = STATE_NONE;
 
     let depsTail = computed.depsTail as Link | null,
-        toRemove = depsTail !== null ? depsTail.nextDep : computed.deps;
+        remove = depsTail !== null ? depsTail.nextDep : computed.deps;
 
-    if (toRemove !== null) {
+    if (remove !== null) {
         do {
-            toRemove = unlink(toRemove);
+            remove = unlink(remove);
         }
-        while (toRemove !== null);
+        while (remove !== null);
 
         if (depsTail !== null) {
             depsTail.nextDep = null;
@@ -228,14 +228,14 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
         computed.value = value as T;
 
         for (let c = computed.subs; c !== null; c = c.nextSub) {
-            let o = c.sub,
-                state = o.state;
+            let s = c.sub,
+                state = s.state;
 
             if (state & STATE_CHECK) {
-                o.state = state | STATE_DIRTY;
+                s.state = state | STATE_DIRTY;
             }
 
-            insertIntoHeap(o);
+            insertIntoHeap(s);
         }
 
         schedule();
@@ -253,32 +253,30 @@ function schedule() {
 }
 
 function stabilize() {
-    let o = observer;
+    root(() => {
+        stabilizer = STABILIZER_RUNNING;
 
-    stabilizer = STABILIZER_RUNNING;
+        for (index = 0; index <= length; index++) {
+            let computed = heap[index];
 
-    for (index = 0; index <= length; index++) {
-        let computed = heap[index];
+            heap[index] = undefined;
 
-        heap[index] = undefined;
+            while (computed !== undefined) {
+                let next = computed.nextHeap;
 
-        while (computed !== undefined) {
-            let next = computed.nextHeap;
+                recompute(computed, false);
 
-            recompute(computed, false);
-
-            computed = next;
+                computed = next;
+            }
         }
-    }
 
-    observer = o;
-
-    if (stabilizer === STABILIZER_RESCHEDULE) {
-        microtask(stabilize);
-    }
-    else {
-        stabilizer = STABILIZER_IDLE;
-    }
+        if (stabilizer === STABILIZER_RESCHEDULE) {
+            microtask(stabilize);
+        }
+        else {
+            stabilizer = STABILIZER_IDLE;
+        }
+    });
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
@@ -359,6 +357,7 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     }
     else {
         recompute(self, false);
+        root.disposables++;
     }
 
     return self;
@@ -446,17 +445,22 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
 };
 
 const root = <T>(fn: () => T) => {
-    let o = observer;
+    let d = root.disposables,
+        o = observer;
 
     observer = null;
+    root.disposables = 0;
 
     let value = fn();
 
     observer = o;
+    root.disposables = d;
 
     return value;
 };
 
+root.disposables = 0;
+
 const set = <T>(signal: Signal<T>, value: T) => {
     if (signal.value === value) {
         return;