@esportsplus/reactivity 0.11.8 → 0.12.1

package/build/constants.d.ts

@@ -1,4 +1,7 @@
-declare const REACTIVE: unique symbol;
+declare const COMPUTED: unique symbol;
+declare const REACTIVE_ARRAY: unique symbol;
+declare const REACTIVE_OBJECT: unique symbol;
+declare const SIGNAL: unique symbol;
 declare const STABILIZER_IDLE = 0;
 declare const STABILIZER_RESCHEDULE = 1;
 declare const STABILIZER_RUNNING = 2;
@@ -8,4 +11,4 @@ declare const STATE_CHECK: number;
 declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
 declare const STATE_IN_HEAP: number;
-export { REACTIVE, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/constants.js

@@ -1,4 +1,7 @@
-const REACTIVE = Symbol('reactive');
+const COMPUTED = Symbol('computed');
+const REACTIVE_ARRAY = Symbol('reactive.array');
+const REACTIVE_OBJECT = Symbol('reactive.object');
+const SIGNAL = Symbol('signal');
 const STABILIZER_IDLE = 0;
 const STABILIZER_RESCHEDULE = 1;
 const STABILIZER_RUNNING = 2;
@@ -8,4 +11,4 @@ const STATE_CHECK = 1 << 0;
 const STATE_DIRTY = 1 << 1;
 const STATE_RECOMPUTING = 1 << 2;
 const STATE_IN_HEAP = 1 << 3;
-export { REACTIVE, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING };

package/build/index.d.ts

@@ -1,3 +1,4 @@
 export { default as reactive } from './reactive/index.js';
+export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants.js';
 export * from './system.js';
 export * from './types.js';

package/build/index.js

@@ -1,3 +1,4 @@
 export { default as reactive } from './reactive/index.js';
+export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants.js';
 export * from './system.js';
 export * from './types.js';

package/build/reactive/array.d.ts

@@ -1,6 +1,6 @@
+import { REACTIVE_ARRAY } from '../constants.js';
 import { Computed, Infer } from '../types.js';
 import { ReactiveObject } from './object.js';
-import { Disposable } from './disposable.js';
 type API<T> = Infer<T>[] & ReactiveArray<T>;
 type Events<T> = {
     pop: {
@@ -27,19 +27,22 @@ type Events<T> = {
         items: Item<T>[];
     };
 };
-type Item<T> = Computed<T> | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
+type Item<T> = T | Computed<T> | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
 type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
 type Value<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : T extends Array<infer U> ? API<U> : T;
-declare class ReactiveArray<T> extends Disposable {
+declare class ReactiveArray<T> {
+    [REACTIVE_ARRAY]: boolean;
+    disposables: number;
     private data;
     private listeners;
     private proxy;
     constructor(data: Item<T>[], proxy: API<T>);
     get length(): number;
     set length(n: number);
+    private cleanup;
     at(i: number): T | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never>;
     dispatch<K extends keyof Events<T>, V>(event: K, value?: V): void;
     dispose(): void;
@@ -54,5 +57,7 @@ declare class ReactiveArray<T> extends Disposable {
     splice(start: number, deleteCount?: number, ...input: T[]): Item<T>[];
     unshift(...input: T[]): number;
 }
+declare const isReactiveArray: (value: any) => value is ReactiveArray<any>;
 export default function array<T>(input: T[]): API<T>;
+export { isReactiveArray };
 export type { API as ReactiveArray };

package/build/reactive/array.js

@@ -1,13 +1,14 @@
-import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
+import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
+import { REACTIVE_ARRAY } from '../constants.js';
 import { computed, dispose, isComputed, read } from '../system.js';
-import object from './object.js';
-import { Disposable } from './disposable.js';
-class ReactiveArray extends Disposable {
+import object, { isReactiveObject } from './object.js';
+class ReactiveArray {
+    [REACTIVE_ARRAY] = true;
+    disposables = 0;
     data;
     listeners = null;
     proxy;
     constructor(data, proxy) {
-        super();
         this.data = data;
         this.proxy = proxy;
     }
@@ -20,6 +21,14 @@ class ReactiveArray extends Disposable {
         }
         this.splice(n);
     }
+    cleanup(item) {
+        if (isReactiveObject(item)) {
+            item.dispose();
+        }
+        else if (isComputed(item)) {
+            dispose(item);
+        }
+    }
     at(i) {
         let value = this.data[i];
         if (isComputed(value)) {
@@ -49,17 +58,9 @@ class ReactiveArray extends Disposable {
         }
     }
     dispose() {
-        let data = this.data;
-        for (let i = 0, n = data.length; i < n; i++) {
-            let value = data[i];
-            if (isInstanceOf(value, Disposable)) {
-                value.dispose();
-            }
-            else if (isComputed(value)) {
-                dispose(value);
-            }
+        for (let i = 0, n = this.data.length; i < n; i++) {
+            this.cleanup(this.data[i]);
         }
-        this.listeners = null;
     }
     map(fn, i, n) {
         let { data, proxy } = this, values = [];
@@ -103,9 +104,7 @@ class ReactiveArray extends Disposable {
     pop() {
         let item = this.data.pop();
         if (item !== undefined) {
-            if (isComputed(item)) {
-                dispose(item);
-            }
+            this.cleanup(item);
             this.dispatch('pop', { item });
         }
         return item;
@@ -123,9 +122,7 @@ class ReactiveArray extends Disposable {
     shift() {
         let item = this.data.shift();
         if (item !== undefined) {
-            if (isComputed(item)) {
-                dispose(item);
-            }
+            this.cleanup(item);
             this.dispatch('shift', { item });
         }
         return item;
@@ -139,10 +136,7 @@ class ReactiveArray extends Disposable {
         let items = factory(input), removed = this.data.splice(start, deleteCount, ...items);
         if (items.length > 0 || removed.length > 0) {
             for (let i = 0, n = removed.length; i < n; i++) {
-                let item = removed[i];
-                if (isComputed(item)) {
-                    dispose(item);
-                }
+                this.cleanup(removed[i]);
             }
             this.dispatch('splice', {
                 deleteCount,
@@ -174,6 +168,9 @@ function factory(input) {
     }
     return items;
 }
+const isReactiveArray = (value) => {
+    return isObject(value) && REACTIVE_ARRAY in value;
+};
 export default function array(input) {
     let proxy = new Proxy({}, {
         get(_, key) {
@@ -184,29 +181,24 @@ export default function array(input) {
                 }
                 return value;
             }
-            else if (key in a) {
-                return a[key];
+            else if (key in array) {
+                return array[key];
             }
             return wrapped[key];
         },
         set(_, key, value) {
             if (isNumber(key)) {
-                let host = wrapped[key];
-                if (host === undefined || !isComputed(host)) {
-                    a.splice(key, 1, value);
-                }
-                else {
-                    return false;
-                }
+                array.splice(key, 1, value);
                 return true;
             }
             else if (key === 'length') {
-                return a.length = value;
+                return array.length = value;
             }
             return false;
         }
     }), wrapped = factory(input);
-    let a = new ReactiveArray(wrapped, proxy);
+    let array = new ReactiveArray(wrapped, proxy);
     return proxy;
 }
 ;
+export { isReactiveArray };

package/build/reactive/index.d.ts

@@ -3,10 +3,7 @@ import object from './object.js';
 type API<T> = T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
 type Input<T> = T extends {
     dispose: any;
-} | {
-    signals: any;
-} ? {
-    never: '[ dispose, signals ] are reserved keys';
-} : T;
+} ? never : T extends Record<PropertyKey, unknown> ? T : T extends unknown[] ? Input<T[number]>[] : never;
 declare const _default: <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input<T>) => API<T>;
 export default _default;
+export type { Input };

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.d.ts

@@ -1,13 +1,15 @@
 import { Prettify } from '@esportsplus/utilities';
 import { Infer } from '../types.js';
-import { Disposable } from './disposable.js';
+import { REACTIVE_OBJECT } from '../constants.js';
 type API<T extends Record<PropertyKey, unknown>> = Prettify<{
     [K in keyof T]: Infer<T[K]>;
 }> & ReactiveObject<T>;
-declare class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable {
-    private disposable;
+declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
+    [REACTIVE_OBJECT]: boolean;
     constructor(data: T);
     dispose(): void;
 }
-export default function object<T extends Record<PropertyKey, unknown>>(input: T): API<T>;
+declare const isReactiveObject: (value: any) => value is ReactiveObject<any>;
+export default function object<T extends Record<PropertyKey, unknown>>(input: T): ReactiveObject<T>;
+export { isReactiveObject };
 export type { API as ReactiveObject };

package/build/reactive/object.js

@@ -1,26 +1,18 @@
-import { defineProperty, isArray, isFunction, isInstanceOf, isPromise } from '@esportsplus/utilities';
-import array from './array.js';
-import { computed, dispose, effect, read, root, signal } from '../system.js';
-import { Disposable } from './disposable.js';
-let { set } = signal;
-class ReactiveObject extends Disposable {
-    disposable = {};
+import { defineProperty, isArray, isFunction, isObject, isPromise } from '@esportsplus/utilities';
+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 {
+    [REACTIVE_OBJECT] = true;
     constructor(data) {
-        super();
-        let disposable = this.disposable, triggers = {};
         for (let key in data) {
             let value = data[key];
             if (isArray(value)) {
-                let a = disposable[key] = array(value), t = triggers[key] = signal(false);
+                let a = array(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        read(t);
                         return a;
-                    },
-                    set(v) {
-                        a = disposable[key] = array(v);
-                        set(t, !!t.value);
                     }
                 });
             }
@@ -31,7 +23,7 @@ class ReactiveObject extends Disposable {
                     get() {
                         if (c === undefined) {
                             root(() => {
-                                c = disposable[key] = computed(value);
+                                c = computed(value);
                                 if (isPromise(c.value)) {
                                     let factory = c, version = 0;
                                     c = signal(undefined);
@@ -66,19 +58,23 @@ class ReactiveObject extends Disposable {
         }
     }
     dispose() {
-        for (let key in this.disposable) {
-            let value = this.disposable[key];
-            if (isInstanceOf(value, Disposable)) {
+        let value;
+        for (let key in this) {
+            value = this[key];
+            if (isReactiveArray(value) || isReactiveObject(value)) {
                 value.dispose();
             }
-            else {
+            else if (isComputed(value)) {
                 dispose(value);
             }
         }
-        this.disposable = {};
     }
 }
+const isReactiveObject = (value) => {
+    return isObject(value) && REACTIVE_OBJECT in value;
+};
 export default function object(input) {
     return new ReactiveObject(input);
 }
 ;
+export { isReactiveObject };

package/build/system.d.ts

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

package/build/system.js

@@ -1,20 +1,20 @@
 import { isArray, isObject } from '@esportsplus/utilities';
-import { REACTIVE, 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(2000), index = 0, length = 0, notified = false, observer = null, scheduler = queueMicrotask, stabilizer = STABILIZER_IDLE, version = 0;
-function cleanup(node) {
-    if (!node.cleanup) {
+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(computed) {
+    if (!computed.cleanup) {
         return;
     }
-    let cleanup = node.cleanup;
-    if (isArray(cleanup)) {
-        for (let i = 0; i < cleanup.length; 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;
@@ -58,7 +58,7 @@ function insertIntoHeap(computed) {
     if (height > length) {
         length = height;
         if (height >= heap.length) {
-            heap.length *= 1.5;
+            heap.length = Math.round(heap.length * 1.5);
         }
     }
 }
@@ -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();
     }
@@ -165,7 +165,7 @@ function recompute(computed, del) {
 function schedule() {
     if (stabilizer === STABILIZER_IDLE && !depth) {
         stabilizer = STABILIZER_SCHEDULED;
-        scheduler(stabilize);
+        microtask(stabilize);
     }
     else if (stabilizer === STABILIZER_RUNNING) {
         stabilizer = STABILIZER_RESCHEDULE;
@@ -184,7 +184,7 @@ function stabilize() {
             }
         }
         if (stabilizer === STABILIZER_RESCHEDULE) {
-            scheduler(stabilize);
+            microtask(stabilize);
         }
         else {
             stabilizer = STABILIZER_IDLE;
@@ -202,11 +202,8 @@ function unlink(link) {
     if (prevSub !== null) {
         prevSub.nextSub = nextSub;
     }
-    else {
-        dep.subs = nextSub;
-        if (nextSub === null && 'fn' in dep) {
-            dispose(dep);
-        }
+    else if ((dep.subs = nextSub) === null && 'fn' in dep) {
+        dispose(dep);
     }
     return nextDep;
 }
@@ -216,9 +213,9 @@ function update(computed) {
             let dep = link.dep;
             if ('fn' in dep) {
                 update(dep);
-            }
-            if (computed.state & STATE_DIRTY) {
-                break;
+                if (computed.state & STATE_DIRTY) {
+                    break;
+                }
             }
         }
     }
@@ -229,7 +226,7 @@ function update(computed) {
 }
 const computed = (fn) => {
     let self = {
-        [REACTIVE]: true,
+        [COMPUTED]: true,
         cleanup: null,
         deps: null,
         depsTail: null,
@@ -254,9 +251,11 @@ const computed = (fn) => {
             schedule();
         }
         link(self, observer);
+        onCleanup(() => dispose(self));
     }
     else {
         recompute(self, false);
+        root.disposables++;
     }
     return self;
 };
@@ -276,24 +275,23 @@ const effect = (fn) => {
     };
 };
 const isComputed = (value) => {
-    return isObject(value) && REACTIVE in value && 'fn' in value;
+    return isObject(value) && COMPUTED in value;
 };
 const isSignal = (value) => {
-    return isObject(value) && REACTIVE in value && 'fn' in value === false;
+    return isObject(value) && SIGNAL in value;
 };
 const onCleanup = (fn) => {
     if (!observer) {
         return fn;
     }
-    let node = observer;
-    if (!node.cleanup) {
-        node.cleanup = fn;
+    if (!observer.cleanup) {
+        observer.cleanup = fn;
     }
-    else if (isArray(node.cleanup)) {
-        node.cleanup.push(fn);
+    else if (isArray(observer.cleanup)) {
+        observer.cleanup.push(fn);
     }
     else {
-        node.cleanup = [node.cleanup, fn];
+        observer.cleanup = [observer.cleanup, fn];
     }
     return fn;
 };
@@ -322,21 +320,16 @@ 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;
 };
-const signal = (value) => {
-    return {
-        [REACTIVE]: true,
-        subs: null,
-        subsTail: null,
-        value,
-    };
-};
-signal.set = (signal, value) => {
+root.disposables = 0;
+const set = (signal, value) => {
     if (signal.value === value) {
         return;
     }
@@ -350,4 +343,12 @@ signal.set = (signal, value) => {
     }
     schedule();
 };
-export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal };
+const signal = (value) => {
+    return {
+        [SIGNAL]: true,
+        subs: null,
+        subsTail: null,
+        value,
+    };
+};
+export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, set, signal };

package/build/types.d.ts

@@ -1,17 +1,19 @@
-import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-import { onCleanup } from './system.js';
+import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
 import { ReactiveArray } from './reactive/array.js';
 import { ReactiveObject } from './reactive/object.js';
-interface Computed<T> extends Signal<T> {
-    [REACTIVE]: true;
+interface Computed<T> {
+    [COMPUTED]: true;
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: (oc?: typeof onCleanup) => T;
+    fn: (onCleanup?: (fn: VoidFunction) => typeof fn) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
     state: typeof STATE_CHECK | typeof STATE_DIRTY | typeof STATE_IN_HEAP | typeof STATE_NONE | typeof STATE_RECOMPUTING;
+    subs: Link | null;
+    subsTail: Link | null;
+    value: T;
 }
 type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K];
@@ -26,7 +28,7 @@ interface Link {
 }
 type Reactive<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : ReactiveArray<T>;
 type Signal<T> = {
-    [REACTIVE]: true;
+    [SIGNAL]: true;
     subs: Link | null;
     subsTail: Link | null;
     value: T;

package/build/types.js

@@ -1 +1 @@
-import { REACTIVE } from './constants.js';
+import { COMPUTED, SIGNAL } from './constants.js';

package/package.json

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

package/src/constants.ts

@@ -1,4 +1,10 @@
-const REACTIVE = Symbol('reactive');
+const COMPUTED = Symbol('computed');
+
+const REACTIVE_ARRAY = Symbol('reactive.array');
+
+const REACTIVE_OBJECT = Symbol('reactive.object');
+
+const SIGNAL = Symbol('signal');
 
 
 const STABILIZER_IDLE = 0;
@@ -22,7 +28,10 @@ const STATE_IN_HEAP = 1 << 3;
 
 
 export {
-    REACTIVE,
+    COMPUTED,
+    REACTIVE_ARRAY,
+    REACTIVE_OBJECT,
+    SIGNAL,
     STABILIZER_IDLE,
     STABILIZER_RESCHEDULE,
     STABILIZER_RUNNING,

package/src/index.ts

@@ -1,3 +1,4 @@
 export { default as reactive } from './reactive';
+export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants';
 export * from './system';
 export * from './types';

package/src/reactive/array.ts

@@ -1,8 +1,8 @@
-import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
+import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
+import { REACTIVE_ARRAY } from '~/constants';
 import { computed, dispose, isComputed, read } from '~/system';
 import { Computed, Infer } from '~/types';
-import object, { ReactiveObject } from './object';
-import { Disposable } from './disposable';
+import object, { isReactiveObject, ReactiveObject } from './object';
 
 
 type API<T> = Infer<T>[] & ReactiveArray<T>;
@@ -33,7 +33,7 @@ type Events<T> = {
     };
 };
 
-type Item<T> = Computed<T> | API<T> | ReactiveObject<T extends Record<PropertyKey, unknown> ? T : never> | T;
+type Item<T> = T | Computed<T> | API<T> | ReactiveObject< T extends Record<PropertyKey, unknown> ? T : never >;
 
 type Listener<V> = {
     once?: boolean;
@@ -48,15 +48,16 @@ type Value<T> =
             : T;
 
 
-class ReactiveArray<T> extends Disposable {
+class ReactiveArray<T> {
+    [REACTIVE_ARRAY] = true;
+    disposables: number = 0;
+
     private data: Item<T>[];
     private listeners: Record<string, (Listener<any> | null)[]> | null = null;
     private proxy: API<T>;
 
 
     constructor(data: Item<T>[], proxy: API<T>) {
-        super();
-
         this.data = data;
         this.proxy = proxy;
     }
@@ -75,6 +76,16 @@ class ReactiveArray<T> extends Disposable {
     }
 
 
+    private cleanup(item: Item<T>) {
+        if (isReactiveObject(item)) {
+            item.dispose();
+        }
+        else if (isComputed(item)) {
+            dispose(item);
+        }
+    }
+
+
     at(i: number) {
         let value = this.data[i];
 
@@ -113,20 +124,9 @@ class ReactiveArray<T> extends Disposable {
     }
 
     dispose() {
-        let data = this.data;
-
-        for (let i = 0, n = data.length; i < n; i++) {
-            let value = data[i];
-
-            if (isInstanceOf(value, Disposable)) {
-                value.dispose();
-            }
-            else if (isComputed(value)) {
-                dispose(value);
-            }
+        for (let i = 0, n = this.data.length; i < n; i++) {
+            this.cleanup(this.data[i]);
         }
-
-        this.listeners = null;
     }
 
     map<R>(
@@ -194,10 +194,7 @@ class ReactiveArray<T> extends Disposable {
         let item = this.data.pop();
 
         if (item !== undefined) {
-            if (isComputed(item)) {
-                dispose(item);
-            }
-
+            this.cleanup(item);
             this.dispatch('pop', { item });
         }
 
@@ -224,10 +221,7 @@ class ReactiveArray<T> extends Disposable {
         let item = this.data.shift();
 
         if (item !== undefined) {
-            if (isComputed(item)) {
-                dispose(item);
-            }
-
+            this.cleanup(item);
             this.dispatch('shift', { item });
         }
 
@@ -250,11 +244,7 @@ class ReactiveArray<T> extends Disposable {
 
         if (items.length > 0 || removed.length > 0) {
             for (let i = 0, n = removed.length; i < n; i++) {
-                let item = removed[i];
-
-                if (isComputed(item)) {
-                    dispose(item);
-                }
+                this.cleanup(removed[i]);
             }
 
             this.dispatch('splice', {
@@ -299,6 +289,11 @@ function factory<T>(input: T[]) {
 }
 
 
+const isReactiveArray = (value: any): value is ReactiveArray<any> => {
+    return isObject(value) && REACTIVE_ARRAY in value;
+};
+
+
 export default function array<T>(input: T[]) {
     let proxy = new Proxy({}, {
             get(_: any, key: any) {
@@ -311,27 +306,19 @@ export default function array<T>(input: T[]) {
 
                     return value;
                 }
-                else if (key in a) {
-                    return a[key as keyof typeof a];
+                else if (key in array) {
+                    return array[key as keyof typeof array];
                 }
 
                 return wrapped[key];
             },
             set(_: any, key: any, value: any) {
                 if (isNumber(key)) {
-                    let host = wrapped[key];
-
-                    if (host === undefined || !isComputed(host)) {
-                        a.splice(key, 1, value);
-                    }
-                    else {
-                        return false;
-                    }
-
+                    array.splice(key, 1, value);
                     return true;
                 }
                 else if (key === 'length') {
-                    return a.length = value;
+                    return array.length = value;
                 }
 
                 return false;
@@ -339,8 +326,9 @@ export default function array<T>(input: T[]) {
         }) as API<T>,
         wrapped = factory(input);
 
-    let a = new ReactiveArray(wrapped, proxy);
+    let array = new ReactiveArray(wrapped, proxy);
 
     return proxy;
 };
+export { isReactiveArray };
 export type { API as ReactiveArray };

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';
 
@@ -11,18 +12,35 @@ type API<T> =
             : never;
 
 type Input<T> =
-    T extends { dispose: any } | { signals: any }
-        ? { never: '[ dispose, signals ] are reserved keys' }
-        : T;
+    T extends { dispose: any }
+        ? never
+        : T extends Record<PropertyKey, unknown>
+            ? T
+            : T extends unknown[]
+                ? Input<T[number]>[]
+                : never;
 
 
 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,45 +1,28 @@
-import { defineProperty, isArray, isFunction, isInstanceOf, isPromise, Prettify } from '@esportsplus/utilities';
-import array, { ReactiveArray } from './array';
-import { computed, dispose, effect, read, root, signal } from '~/system';
+import { defineProperty, isArray, isFunction, isObject, isPromise, Prettify } from '@esportsplus/utilities';
+import { computed, dispose, effect, isComputed, read, root, set, signal } from '~/system';
 import { Computed, Infer, Signal } from '~/types';
-import { Disposable } from './disposable';
+import { REACTIVE_OBJECT } from '~/constants';
+import array, { isReactiveArray } from './array';
 
 
 type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: Infer<T[K]> }> & ReactiveObject<T>;
 
 
-let { set } = signal;
-
-
-class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable {
-    private disposable: Record<
-        PropertyKey,
-        Computed<any> | ReactiveArray<any> | ReactiveObject<any>
-    > = {};
+class ReactiveObject<T extends Record<PropertyKey, unknown>> {
+    [REACTIVE_OBJECT] = true;
 
 
     constructor(data: T) {
-        super();
-
-        let disposable = this.disposable,
-            triggers: Record<string, Signal<boolean>> = {};
-
         for (let key in data) {
             let value = data[key];
 
             if (isArray(value)) {
-                let a = disposable[key] = array(value),
-                    t = triggers[key] = signal(false);
+                let a = array(value);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        read(t);
                         return a;
-                    },
-                    set(v: typeof value) {
-                        a = disposable[key] = array(v);
-                        set(t, !!t.value);
                     }
                 });
             }
@@ -51,7 +34,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
                     get() {
                         if (c === undefined) {
                             root(() => {
-                                c = disposable[key] = computed(value as Computed<T[typeof key]>['fn']);
+                                c = computed(value as Computed<T[typeof key]>['fn']);
 
                                 if (isPromise(c.value)) {
                                     let factory = c,
@@ -67,7 +50,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
                                                 return;
                                             }
 
-                                            set(c!, value);
+                                            set(c as Signal<typeof value>, value);
                                         });
                                     });
                                 }
@@ -96,23 +79,29 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
 
 
     dispose() {
-        for (let key in this.disposable) {
-            let value = this.disposable[key];
+        let value;
 
-            if (isInstanceOf(value, Disposable)) {
+        for (let key in this) {
+            value = this[key];
+
+            if (isReactiveArray(value) || isReactiveObject(value)) {
                 value.dispose();
             }
-            else {
+            else if (isComputed(value)) {
                 dispose(value);
             }
         }
-
-        this.disposable = {};
     }
 }
 
 
+const isReactiveObject = (value: any): value is ReactiveObject<any> => {
+    return isObject(value) && REACTIVE_OBJECT in value;
+};
+
+
 export default function object<T extends Record<PropertyKey, unknown>>(input: T) {
-    return new ReactiveObject(input) as API<T>;
+    return new ReactiveObject<T>(input);
 };
+export { isReactiveObject };
 export type { API as ReactiveObject };

package/src/system.ts

@@ -1,40 +1,40 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import {
-    REACTIVE,
+    COMPUTED, SIGNAL,
     STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
     STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING
 } from './constants';
-import { Computed, Link, Signal, } from './types';
+import { Computed, Link, Signal } from './types';
 
 
 let depth = 0,
-    heap: (Computed<unknown> | undefined)[] = new Array(2000),
+    heap: (Computed<unknown> | undefined)[] = new Array(2048),
     index = 0,
     length = 0,
+    microtask = queueMicrotask,
     notified = false,
     observer: Computed<unknown> | null = null,
-    scheduler = queueMicrotask,
     stabilizer = STABILIZER_IDLE,
     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; i < cleanup.length; 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>) {
@@ -98,7 +98,7 @@ function insertIntoHeap<T>(computed: Computed<T>) {
 
         // Simple auto adjust to avoid manual management within apps.
         if (height >= heap.length) {
-            heap.length *= 1.5;
+            heap.length = Math.round(heap.length * 1.5);
         }
     }
 }
@@ -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();
@@ -245,7 +245,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 function schedule() {
     if (stabilizer === STABILIZER_IDLE && !depth) {
         stabilizer = STABILIZER_SCHEDULED;
-        scheduler(stabilize);
+        microtask(stabilize);
     }
     else if (stabilizer === STABILIZER_RUNNING) {
         stabilizer = STABILIZER_RESCHEDULE;
@@ -271,7 +271,7 @@ function stabilize() {
         }
 
         if (stabilizer === STABILIZER_RESCHEDULE) {
-            scheduler(stabilize);
+            microtask(stabilize);
         }
         else {
             stabilizer = STABILIZER_IDLE;
@@ -293,12 +293,8 @@ function unlink(link: Link): Link | null {
     if (prevSub !== null) {
         prevSub.nextSub = nextSub;
     }
-     else {
-        dep.subs = nextSub;
-
-        if (nextSub === null && 'fn' in dep) {
-            dispose(dep);
-        }
+    else if ((dep.subs = nextSub) === null && 'fn' in dep) {
+        dispose(dep);
     }
 
     return nextDep;
@@ -311,10 +307,10 @@ function update<T>(computed: Computed<T>): void {
 
             if ('fn' in dep) {
                 update(dep);
-            }
 
-            if (computed.state & STATE_DIRTY) {
-                break;
+                if (computed.state & STATE_DIRTY) {
+                    break;
+                }
             }
         }
     }
@@ -329,7 +325,7 @@ function update<T>(computed: Computed<T>): void {
 
 const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     let self: Computed<T> = {
-            [REACTIVE]: true,
+            [COMPUTED]: true,
             cleanup: null,
             deps: null,
             depsTail: null,
@@ -357,9 +353,11 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
         }
 
         link(self, observer);
+        onCleanup(() => dispose(self));
     }
     else {
         recompute(self, false);
+        root.disposables++;
     }
 
     return self;
@@ -388,11 +386,11 @@ const effect = <T>(fn: Computed<T>['fn']) => {
 };
 
 const isComputed = (value: unknown): value is Computed<unknown> => {
-    return isObject(value) && REACTIVE in value && 'fn' in value;
+    return isObject(value) && COMPUTED in value;
 };
 
 const isSignal = (value: unknown): value is Signal<unknown> => {
-    return isObject(value) && REACTIVE in value && 'fn' in value === false;
+    return isObject(value) && SIGNAL in value;
 };
 
 const onCleanup = (fn: VoidFunction): typeof fn => {
@@ -400,16 +398,14 @@ const onCleanup = (fn: VoidFunction): typeof fn => {
         return fn;
     }
 
-    let node = observer;
-
-    if (!node.cleanup) {
-        node.cleanup = fn;
+    if (!observer.cleanup) {
+        observer.cleanup = fn;
     }
-    else if (isArray(node.cleanup)) {
-        node.cleanup.push(fn);
+    else if (isArray(observer.cleanup)) {
+        observer.cleanup.push(fn);
     }
     else {
-        node.cleanup = [node.cleanup, fn];
+        observer.cleanup = [observer.cleanup, fn];
     }
 
     return fn;
@@ -449,27 +445,23 @@ 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;
 };
 
-const signal = <T>(value: T): Signal<T> => {
-    return {
-        [REACTIVE]: true,
-        subs: null,
-        subsTail: null,
-        value,
-    };
-};
+root.disposables = 0;
 
-signal.set = <T>(signal: Signal<T>, value: T) => {
+const set = <T>(signal: Signal<T>, value: T) => {
     if (signal.value === value) {
         return;
     }
@@ -488,6 +480,15 @@ signal.set = <T>(signal: Signal<T>, value: T) => {
     schedule();
 };
 
+const signal = <T>(value: T): Signal<T> => {
+    return {
+        [SIGNAL]: true,
+        subs: null,
+        subsTail: null,
+        value,
+    };
+};
+
 
 export {
     computed,
@@ -496,5 +497,6 @@ export {
     isComputed, isSignal,
     onCleanup,
     read, root,
-    signal
-};
+    set, signal
+};
+export type { Computed, Signal };

package/src/types.ts

@@ -1,15 +1,14 @@
-import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
-import { onCleanup } from './system';
+import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
 import { ReactiveArray } from './reactive/array';
 import { ReactiveObject } from './reactive/object';
 
 
-interface Computed<T> extends Signal<T> {
-    [REACTIVE]: true;
+interface Computed<T> {
+    [COMPUTED]: true;
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: (oc?: typeof onCleanup) => T;
+    fn: (onCleanup?: (fn: VoidFunction) => typeof fn) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
@@ -19,6 +18,9 @@ interface Computed<T> extends Signal<T> {
         typeof STATE_IN_HEAP |
         typeof STATE_NONE |
         typeof STATE_RECOMPUTING;
+    subs: Link | null;
+    subsTail: Link | null;
+    value: T;
 }
 
 type Infer<T> =
@@ -48,7 +50,7 @@ type Reactive<T> = T extends Record<PropertyKey, unknown>
     : ReactiveArray<T>;
 
 type Signal<T> = {
-    [REACTIVE]: true;
+    [SIGNAL]: true;
     subs: Link | null;
     subsTail: Link | null;
     value: T;

package/build/reactive/disposable.d.ts

@@ -1,4 +0,0 @@
-declare class Disposable {
-    dispose(): void;
-}
-export { Disposable };

package/build/reactive/disposable.js

@@ -1,6 +0,0 @@
-class Disposable {
-    dispose() {
-        throw new Error('@esportsplus/reactivity: Disposable should not be instantiated directly.');
-    }
-}
-export { Disposable };

package/src/reactive/disposable.ts

@@ -1,8 +0,0 @@
-class Disposable {
-    dispose(): void {
-        throw new Error('@esportsplus/reactivity: Disposable should not be instantiated directly.');
-    }
-}
-
-
-export { Disposable };