@esportsplus/reactivity 0.12.3 → 0.13.0

package/src/reactive/object.ts

@@ -1,76 +1,87 @@
 import { defineProperty, isArray, isFunction, isObject, isPromise, Prettify } from '@esportsplus/utilities';
-import { computed, dispose, effect, isComputed, read, root, set, signal } from '~/system';
+import { computed, dispose, effect, read, root, set, signal } from '~/system';
 import { Computed, Infer, Signal } from '~/types';
 import { REACTIVE_OBJECT } from '~/constants';
-import array, { isReactiveArray } from './array';
+import array from './array';
 
 
-type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: Infer<T[K]> }> & ReactiveObject<T>;
+type API<T> = Prettify<{ [K in keyof T]: Infer<T[K]> } & { dispose: VoidFunction } >;
 
 
 class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     [REACTIVE_OBJECT] = true;
 
 
+    private disposers: VoidFunction[] | null = null;
+
+
     constructor(data: T) {
-        for (let key in data) {
-            let value = data[key];
+        let keys = Object.keys(data);
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let key = keys[i],
+                value = data[key];
 
             if (isArray(value)) {
-                let a = array(value);
+                let node = array(value);
+
+                (this.disposers ??= []).push( () => node.dispose() );
 
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        return a;
-                    }
+                    value: node
                 });
             }
             else if (isFunction(value)) {
-                let c: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
+                let node: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
 
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        if (c === undefined) {
+                    get: () => {
+                        if (node === undefined) {
                             root(() => {
-                                c = computed(value as Computed<T[typeof key]>['fn']);
+                                node = computed(value as Computed<T[typeof key]>['fn']);
 
-                                if (isPromise(c.value)) {
-                                    let factory = c,
+                                if (isPromise(node.value)) {
+                                    let factory = node,
                                         version = 0;
 
-                                    c = signal(undefined);
+                                    node = signal<T[typeof key] | undefined>(undefined);
 
-                                    effect(() => {
-                                        let id = ++version;
+                                    (this.disposers ??= []).push(
+                                        effect(() => {
+                                            let id = ++version;
 
-                                        (read(factory) as Promise<T[typeof key]>).then((value) => {
-                                            if (id !== version) {
-                                                return;
-                                            }
+                                            (read(factory) as Promise<T[typeof key]>).then((v) => {
+                                                if (id !== version) {
+                                                    return;
+                                                }
 
-                                            set(c as Signal<typeof value>, value);
-                                        });
-                                    });
+                                                set(node as Signal<typeof v>, v);
+                                            });
+                                        })
+                                    )
+                                }
+                                else {
+                                    (this.disposers ??= []).push(() => dispose(node as Computed<T[typeof key]>));
                                 }
                             });
                         }
 
-                        return read(c!);
+                        return read(node!);
                     }
                 });
             }
             else {
-                let s = signal(value);
+                let node = signal(value);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(s);
+                        return read(node);
                     },
                     set(v: typeof value) {
-                        set(s, v);
+                        set(node, v);
                     }
                 });
             }
@@ -79,17 +90,15 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
 
 
     dispose() {
-        let value;
+        let disposers = this.disposers,
+            disposer;
 
-        for (let key in this) {
-            value = this[key];
+        if (!disposers) {
+            return;
+        }
 
-            if (isReactiveArray(value) || isReactiveObject(value)) {
-                value.dispose();
-            }
-            else if (isComputed(value)) {
-                dispose(value);
-            }
+        while (disposer = disposers.pop()) {
+            disposer();
         }
     }
 }

package/src/system.ts

@@ -2,15 +2,15 @@ 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
+    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, Link, Signal } from './types';
 
 
 let depth = 0,
-    heap: (Computed<unknown> | undefined)[] = new Array(2048),
-    index = 0,
-    length = 0,
+    heap: (Computed<unknown> | undefined)[] = new Array(64),
+    heap_i = 0,
+    heap_n = 0,
     microtask = queueMicrotask,
     notified = false,
     observer: Computed<unknown> | null = null,
@@ -93,12 +93,12 @@ function insertIntoHeap<T>(computed: Computed<T>) {
         heapAtHeight.prevHeap = computed;
     }
 
-    if (height > length) {
-        length = height;
+    if (height > heap_n) {
+        heap_n = height;
 
         // Simple auto adjust to avoid manual management within apps.
         if (height >= heap.length) {
-            heap.length = Math.round(heap.length * 1.5);
+            heap.length = Math.max(height + 1, Math.ceil(heap.length * 2));
         }
     }
 }
@@ -163,7 +163,7 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
 function notify<T>(computed: Computed<T>, newState = STATE_DIRTY) {
     let state = computed.state;
 
-    if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
+    if ((state & STATE_NOTIFY_MASK) >= newState) {
         return;
     }
 
@@ -183,7 +183,9 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
         computed.prevHeap = computed;
     }
 
-    cleanup(computed);
+    if (computed.cleanup) {
+        cleanup(computed);
+    }
 
     let o = observer,
         ok = true,
@@ -258,10 +260,10 @@ function stabilize() {
     observer = null;
     stabilizer = STABILIZER_RUNNING;
 
-    for (index = 0; index <= length; index++) {
-        let computed = heap[index];
+    for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+        let computed = heap[heap_i];
 
-        heap[index] = undefined;
+        heap[heap_i] = undefined;
 
         while (computed !== undefined) {
             let next = computed.nextHeap;
@@ -272,6 +274,10 @@ function stabilize() {
         }
     }
 
+    while (heap_n > 0 && heap[heap_n] === undefined) {
+        heap_n--;
+    }
+
     observer = o;
 
     if (stabilizer === STABILIZER_RESCHEDULE) {
@@ -284,7 +290,10 @@ function stabilize() {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlink(link: Link): Link | null {
-    let { dep, nextDep, nextSub, prevSub } = link;
+    let dep = link.dep,
+        nextDep = link.nextDep,
+        nextSub = link.nextSub,
+        prevSub = link.prevSub;
 
     if (nextSub !== null) {
         nextSub.prevSub = prevSub;
@@ -377,7 +386,9 @@ const dispose = <T>(computed: Computed<T>) => {
 
     computed.deps = null;
 
-    cleanup(computed);
+    if (computed.cleanup) {
+        cleanup(computed);
+    }
 };
 
 const effect = <T>(fn: Computed<T>['fn']) => {
@@ -401,14 +412,16 @@ const onCleanup = (fn: VoidFunction): typeof fn => {
         return fn;
     }
 
-    if (!observer.cleanup) {
+    let cleanup = observer.cleanup;
+
+    if (!cleanup) {
         observer.cleanup = fn;
     }
-    else if (isArray(observer.cleanup)) {
-        observer.cleanup.push(fn);
+    else if (isArray(cleanup)) {
+        cleanup.push(fn);
     }
     else {
-        observer.cleanup = [observer.cleanup, fn];
+        observer.cleanup = [cleanup, fn];
     }
 
     return fn;
@@ -425,14 +438,11 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
                 observer.height = height + 1;
             }
 
-            if (
-                height >= index ||
-                node.state & (STATE_DIRTY | STATE_CHECK)
-            ) {
+            if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
                 if (!notified) {
                     notified = true;
 
-                    for (let i = 0; i <= length; i++) {
+                    for (let i = 0; i <= heap_n; i++) {
                         for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
                             notify(computed);
                         }

package/src/types.ts

@@ -1,5 +1,4 @@
 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';
 
 
@@ -29,7 +28,7 @@ type Infer<T> =
         : T extends (...args: any[]) => infer R
             ? R
             : T extends (infer U)[]
-                ? ReactiveArray<U>
+                ? Infer<U>[]
                 : T extends ReactiveObject<any>
                     ? T
                     : T extends Record<PropertyKey, unknown>
@@ -45,10 +44,6 @@ interface Link {
     version: number;
 }
 
-type Reactive<T> = T extends Record<PropertyKey, unknown>
-    ? ReactiveObject<T>
-    : ReactiveArray<T>;
-
 type Signal<T> = {
     [SIGNAL]: true;
     subs: Link | null;
@@ -62,5 +57,5 @@ export type {
     Infer,
     Link,
     Signal,
-    Reactive, ReactiveArray, ReactiveObject
+    ReactiveObject
 };