@esportsplus/reactivity 0.11.7 → 0.12.0

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,21 @@ 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;
     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 +56,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,13 @@
-import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { computed, dispose, isComputed, read } from '../system.js';
-import object from './object.js';
-import { Disposable } from './disposable.js';
-class ReactiveArray extends Disposable {
+import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
+import { REACTIVE_ARRAY } from '../constants.js';
+import { computed, dispose, isComputed, onCleanup, read, root } from '../system.js';
+import object, { isReactiveObject } from './object.js';
+class ReactiveArray {
+    [REACTIVE_ARRAY] = true;
     data;
     listeners = null;
     proxy;
     constructor(data, proxy) {
-        super();
         this.data = data;
         this.proxy = proxy;
     }
@@ -20,6 +20,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 +57,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 +103,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 +121,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 +135,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,39 +167,41 @@ 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) {
-            if (isNumber(key)) {
-                let value = wrapped[key];
-                if (isComputed(value)) {
-                    return read(value);
+    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;
                 }
-                return value;
-            }
-            else if (key in a) {
-                return a[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 if (key in array) {
+                    return array[key];
                 }
-                else {
-                    return false;
+                return wrapped[key];
+            },
+            set(_, key, value) {
+                if (isNumber(key)) {
+                    array.splice(key, 1, value);
+                    return true;
                 }
-                return true;
-            }
-            else if (key === 'length') {
-                return a.length = value;
+                else if (key === 'length') {
+                    return array.length = value;
+                }
+                return false;
             }
-            return false;
-        }
-    }), wrapped = factory(input);
-    let a = new ReactiveArray(wrapped, proxy);
+        }), wrapped = factory(input);
+        let array = new ReactiveArray(wrapped, proxy);
+        return { array, proxy };
+    });
+    onCleanup(() => array.dispose());
     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 extends Record<PropertyKey, unknown> | unknown[] ? T : never;
-declare const _default: <T>(input: Input<T>) => API<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/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, onCleanup, 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,25 @@ 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);
+    let object = root(() => new ReactiveObject(input));
+    onCleanup(() => object.dispose());
+    return object;
 }
 ;
+export { isReactiveObject };

package/build/system.d.ts

@@ -7,8 +7,7 @@ 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;
-};
-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,13 +1,13 @@
-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;
+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) {
         return;
     }
     let cleanup = node.cleanup;
     if (isArray(cleanup)) {
-        for (let i = 0; i < cleanup.length; i++) {
+        for (let i = 0, n = cleanup.length; i < n; i++) {
             cleanup[i]();
         }
     }
@@ -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);
         }
     }
 }
@@ -165,31 +165,31 @@ 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;
     }
 }
 function stabilize() {
-    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;
-            }
-        }
-        if (stabilizer === STABILIZER_RESCHEDULE) {
-            scheduler(stabilize);
-        }
-        else {
-            stabilizer = STABILIZER_IDLE;
+    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;
         }
-    });
+    }
+    observer = o;
+    if (stabilizer === STABILIZER_RESCHEDULE) {
+        microtask(stabilize);
+    }
+    else {
+        stabilizer = STABILIZER_IDLE;
+    }
 }
 function unlink(link) {
     let { dep, nextDep, nextSub, prevSub } = link;
@@ -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,6 +251,7 @@ const computed = (fn) => {
             schedule();
         }
         link(self, observer);
+        onCleanup(() => dispose(self));
     }
     else {
         recompute(self, false);
@@ -276,24 +274,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;
 };
@@ -328,15 +325,7 @@ const root = (fn) => {
     observer = o;
     return value;
 };
-const signal = (value) => {
-    return {
-        [REACTIVE]: true,
-        subs: null,
-        subsTail: null,
-        value,
-    };
-};
-signal.set = (signal, value) => {
+const set = (signal, value) => {
     if (signal.value === value) {
         return;
     }
@@ -350,4 +339,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.7",
+  "version": "0.12.0",
   "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 { computed, dispose, isComputed, read } from '~/system';
+import { isFunction, isNumber, isObject } from '@esportsplus/utilities';
+import { REACTIVE_ARRAY } from '~/constants';
+import { computed, dispose, isComputed, onCleanup, read, root } 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,15 @@ type Value<T> =
             : T;
 
 
-class ReactiveArray<T> extends Disposable {
+class ReactiveArray<T> {
+    [REACTIVE_ARRAY] = true;
+
     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 +75,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 +123,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 +193,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 +220,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 +243,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,48 +288,52 @@ function factory<T>(input: T[]) {
 }
 
 
-export default function array<T>(input: T[]) {
-    let proxy = new Proxy({}, {
-            get(_: any, key: any) {
-                if (isNumber(key)) {
-                    let value = wrapped[key];
-
-                    if (isComputed(value)) {
-                        return read(value);
-                    }
+const isReactiveArray = (value: any): value is ReactiveArray<any> => {
+    return isObject(value) && REACTIVE_ARRAY in value;
+};
 
-                    return value;
-                }
-                else if (key in a) {
-                    return a[key as keyof typeof a];
-                }
 
-                return wrapped[key];
-            },
-            set(_: any, key: any, value: any) {
-                if (isNumber(key)) {
-                    let host = wrapped[key];
+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;
+                        }
 
-                    if (host === undefined || !isComputed(host)) {
-                        a.splice(key, 1, value);
-                    }
-                    else {
                         return false;
                     }
+                }) as API<T>,
+                wrapped = factory(input);
 
-                    return true;
-                }
-                else if (key === 'length') {
-                    return a.length = value;
-                }
+            let array = new ReactiveArray(wrapped, proxy);
 
-                return false;
-            }
-        }) as API<T>,
-        wrapped = factory(input);
+            return { array, proxy };
+        });
 
-    let a = new ReactiveArray(wrapped, proxy);
+    onCleanup(() => array.dispose());
 
     return proxy;
 };
+export { isReactiveArray };
 export type { API as ReactiveArray };

package/src/reactive/index.ts

@@ -11,14 +11,16 @@ type API<T> =
             : never;
 
 type Input<T> =
-    T extends { dispose: any } | { signals: any }
-        ? { never: '[ dispose, signals ] are reserved keys' }
-        : T extends Record<PropertyKey, unknown> | unknown[]
-                ? T
+    T extends { dispose: any }
+        ? never
+        : T extends Record<PropertyKey, unknown>
+            ? T
+            : T extends unknown[]
+                ? Input<T[number]>[]
                 : never;
 
 
-export default <T>(input: Input<T>): API<T> => {
+export default <T extends Record<PropertyKey, unknown> | unknown[]>(input: Input<T>): API<T> => {
     if (isArray(input)) {
         return array(input) as API<T>;
     }
@@ -27,4 +29,5 @@ export default <T>(input: Input<T>): API<T> => {
     }
 
     throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
-};
+};
+export type { Input };

package/src/reactive/object.ts

@@ -1,45 +1,27 @@
-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, onCleanup, 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 +33,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 +49,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
                                                 return;
                                             }
 
-                                            set(c!, value);
+                                            set(c as Signal<typeof value>, value);
                                         });
                                     });
                                 }
@@ -96,23 +78,33 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
 
 
     dispose() {
-        for (let key in this.disposable) {
-            let value = this.disposable[key];
+        let value;
+
+        for (let key in this) {
+            value = this[key];
 
-            if (isInstanceOf(value, Disposable)) {
+            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>;
+    let object = root(() => new ReactiveObject<T>(input));
+
+    onCleanup(() => object.dispose());
+
+    return object;
 };
+export { isReactiveObject };
 export type { API as ReactiveObject };

package/src/system.ts

@@ -1,19 +1,19 @@
-import { isArray, isObject } from '@esportsplus/utilities';
+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;
 
@@ -26,7 +26,7 @@ function cleanup<T>(node: Computed<T>): void {
     let cleanup = node.cleanup;
 
     if (isArray(cleanup)) {
-        for (let i = 0; i < cleanup.length; i++) {
+        for (let i = 0, n = cleanup.length; i < n; i++) {
             cleanup[i]();
         }
     }
@@ -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);
         }
     }
 }
@@ -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;
@@ -253,30 +253,32 @@ function schedule() {
 }
 
 function stabilize() {
-    root(() => {
-        stabilizer = STABILIZER_RUNNING;
+    let o = observer;
 
-        for (index = 0; index <= length; index++) {
-            let computed = heap[index];
+    stabilizer = STABILIZER_RUNNING;
 
-            heap[index] = undefined;
+    for (index = 0; index <= length; index++) {
+        let computed = heap[index];
 
-            while (computed !== undefined) {
-                let next = computed.nextHeap;
+        heap[index] = undefined;
 
-                recompute(computed, false);
+        while (computed !== undefined) {
+            let next = computed.nextHeap;
 
-                computed = next;
-            }
-        }
+            recompute(computed, false);
 
-        if (stabilizer === STABILIZER_RESCHEDULE) {
-            scheduler(stabilize);
-        }
-        else {
-            stabilizer = STABILIZER_IDLE;
+            computed = next;
         }
-    });
+    }
+
+    observer = o;
+
+    if (stabilizer === STABILIZER_RESCHEDULE) {
+        microtask(stabilize);
+    }
+    else {
+        stabilizer = STABILIZER_IDLE;
+    }
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
@@ -293,12 +295,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 +309,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 +327,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,6 +355,7 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
         }
 
         link(self, observer);
+        onCleanup(() => dispose(self));
     }
     else {
         recompute(self, false);
@@ -388,11 +387,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 +399,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;
@@ -460,16 +457,7 @@ const root = <T>(fn: () => T) => {
     return value;
 };
 
-const signal = <T>(value: T): Signal<T> => {
-    return {
-        [REACTIVE]: true,
-        subs: null,
-        subsTail: null,
-        value,
-    };
-};
-
-signal.set = <T>(signal: Signal<T>, value: T) => {
+const set = <T>(signal: Signal<T>, value: T) => {
     if (signal.value === value) {
         return;
     }
@@ -488,6 +476,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 +493,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 };