@esportsplus/reactivity 0.11.5 → 0.11.7

package/build/reactive/index.d.ts

@@ -1,15 +1,12 @@
-import { NeverAsync } from '@esportsplus/utilities';
 import array from './array.js';
 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 unknown[] ? T : T extends {
+type Input<T> = T extends {
     dispose: any;
 } | {
     signals: any;
 } ? {
     never: '[ dispose, signals ] are reserved keys';
-} : T extends Record<PropertyKey, unknown> ? {
-    [K in keyof T]: T[K] extends (...args: unknown[]) => ((...args: unknown[]) => Promise<unknown>) ? T[K] : T[K] extends (...args: unknown[]) => unknown ? NeverAsync<T[K]> : T[K];
-} : never;
+} : T extends Record<PropertyKey, unknown> | unknown[] ? T : never;
 declare const _default: <T>(input: Input<T>) => API<T>;
 export default _default;

package/build/reactive/object.js

@@ -1,6 +1,6 @@
-import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf } from '@esportsplus/utilities';
+import { defineProperty, isArray, isFunction, isInstanceOf, isPromise } from '@esportsplus/utilities';
 import array from './array.js';
-import { computed, dispose, effect, read, signal } from '../system.js';
+import { computed, dispose, effect, read, root, signal } from '../system.js';
 import { Disposable } from './disposable.js';
 let { set } = signal;
 class ReactiveObject extends Disposable {
@@ -30,20 +30,22 @@ class ReactiveObject extends Disposable {
                     enumerable: true,
                     get() {
                         if (c === undefined) {
-                            c = disposable[key] = computed(value);
-                            if (isAsyncFunction(c.value)) {
-                                let factory = c, version = 0;
-                                c = signal(null);
-                                effect(() => {
-                                    let id = version++;
-                                    read(factory)().then((value) => {
-                                        if (id !== version) {
-                                            return;
-                                        }
-                                        set(c, value);
+                            root(() => {
+                                c = disposable[key] = computed(value);
+                                if (isPromise(c.value)) {
+                                    let factory = c, version = 0;
+                                    c = signal(undefined);
+                                    effect(() => {
+                                        let id = ++version;
+                                        read(factory).then((value) => {
+                                            if (id !== version) {
+                                                return;
+                                            }
+                                            set(c, value);
+                                        });
                                     });
-                                });
-                            }
+                                }
+                            });
                         }
                         return read(c);
                     }

package/build/system.js

@@ -58,12 +58,9 @@ function insertIntoHeap(computed) {
     if (height > length) {
         length = height;
         if (height >= heap.length) {
-            heap.length += 250;
+            heap.length *= 1.5;
         }
     }
-    if (stabilizer === STABILIZER_RUNNING && index > height) {
-        stabilizer = STABILIZER_RESCHEDULE;
-    }
 }
 function link(dep, sub) {
     let prevDep = sub.depsTail;
@@ -138,6 +135,7 @@ function recompute(computed, del) {
     catch (e) {
         ok = false;
     }
+    depth--;
     observer = o;
     computed.state = STATE_NONE;
     let depsTail = computed.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : computed.deps;
@@ -161,11 +159,17 @@ function recompute(computed, del) {
             }
             insertIntoHeap(o);
         }
+        schedule();
     }
-    if (!--depth && stabilizer === STABILIZER_IDLE) {
+}
+function schedule() {
+    if (stabilizer === STABILIZER_IDLE && !depth) {
         stabilizer = STABILIZER_SCHEDULED;
         scheduler(stabilize);
     }
+    else if (stabilizer === STABILIZER_RUNNING) {
+        stabilizer = STABILIZER_RESCHEDULE;
+    }
 }
 function stabilize() {
     root(() => {
@@ -247,6 +251,7 @@ const computed = (fn) => {
         else {
             self.height = observer.height + 1;
             insertIntoHeap(self);
+            schedule();
         }
         link(self, observer);
     }
@@ -337,8 +342,12 @@ signal.set = (signal, value) => {
     }
     notified = false;
     signal.value = value;
+    if (signal.subs === null) {
+        return;
+    }
     for (let link = signal.subs; link !== null; link = link.nextSub) {
         insertIntoHeap(link.sub);
     }
+    schedule();
 };
 export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal };

package/build/types.d.ts

@@ -13,7 +13,7 @@ interface Computed<T> extends Signal<T> {
     prevHeap: Computed<unknown>;
     state: typeof STATE_CHECK | typeof STATE_DIRTY | typeof STATE_IN_HEAP | typeof STATE_NONE | typeof STATE_RECOMPUTING;
 }
-type Infer<T> = T extends (...args: unknown[]) => ((...args: unknown[]) => Promise<infer R>) ? R : T extends (...args: any[]) => infer R ? R | null : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
+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];
 } : T;
 interface Link {

package/package.json

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

package/src/reactive/index.ts

@@ -1,4 +1,4 @@
-import { isArray, isObject, NeverAsync } from '@esportsplus/utilities';
+import { isArray, isObject } from '@esportsplus/utilities';
 import array from './array';
 import object from './object';
 
@@ -11,20 +11,11 @@ type API<T> =
             : never;
 
 type Input<T> =
-    T extends unknown[]
-        ? T
-        : T extends { dispose: any } | { signals: any }
-            ? { never: '[ dispose, signals ] are reserved keys' }
-            : T extends Record<PropertyKey, unknown>
-                    ? {
-                        [K in keyof T]:
-                            T[K] extends (...args: unknown[]) => ((...args: unknown[]) => Promise<unknown>)
-                                ? T[K]
-                                : T[K] extends (...args: unknown[]) => unknown
-                                    ? NeverAsync<T[K]>
-                                    : T[K]
-                    }
-                    : never;
+    T extends { dispose: any } | { signals: any }
+        ? { never: '[ dispose, signals ] are reserved keys' }
+        : T extends Record<PropertyKey, unknown> | unknown[]
+                ? T
+                : never;
 
 
 export default <T>(input: Input<T>): API<T> => {

package/src/reactive/object.ts

@@ -1,6 +1,6 @@
-import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf, Prettify } from '@esportsplus/utilities';
+import { defineProperty, isArray, isFunction, isInstanceOf, isPromise, Prettify } from '@esportsplus/utilities';
 import array, { ReactiveArray } from './array';
-import { computed, dispose, effect, read, signal } from '~/system';
+import { computed, dispose, effect, read, root, signal } from '~/system';
 import { Computed, Infer, Signal } from '~/types';
 import { Disposable } from './disposable';
 
@@ -44,35 +44,37 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
                 });
             }
             else if (isFunction(value)) {
-                let c: Computed<T[typeof key]> | Signal<T[typeof key] | null> | undefined;
+                let c: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         if (c === undefined) {
-                            c = disposable[key] = computed(value as Computed<T[typeof key]>['fn']);
+                            root(() => {
+                                c = disposable[key] = computed(value as Computed<T[typeof key]>['fn']);
 
-                            if (isAsyncFunction(c.value)) {
-                                let factory = c,
-                                    version = 0;
+                                if (isPromise(c.value)) {
+                                    let factory = c,
+                                        version = 0;
 
-                                c = signal(null);
+                                    c = signal(undefined);
 
-                                effect(() => {
-                                    let id = version++;
+                                    effect(() => {
+                                        let id = ++version;
 
-                                    (read(factory) as any as () => Promise<T[typeof key]>)().then((value) => {
-                                        if (id !== version) {
-                                            return;
-                                        }
+                                        (read(factory) as Promise<T[typeof key]>).then((value) => {
+                                            if (id !== version) {
+                                                return;
+                                            }
 
-                                        set(c!, value);
+                                            set(c!, value);
+                                        });
                                     });
-                                });
-                            }
+                                }
+                            });
                         }
 
-                        return read(c);
+                        return read(c!);
                     }
                 });
             }

package/src/system.ts

@@ -98,13 +98,9 @@ function insertIntoHeap<T>(computed: Computed<T>) {
 
         // Simple auto adjust to avoid manual management within apps.
         if (height >= heap.length) {
-            heap.length += 250;
+            heap.length *= 1.5;
         }
     }
-
-    if (stabilizer === STABILIZER_RUNNING && index > height) {
-        stabilizer = STABILIZER_RESCHEDULE;
-    }
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
@@ -207,6 +203,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
         ok = false;
     }
 
+    depth--;
     observer = o;
     computed.state = STATE_NONE;
 
@@ -240,12 +237,19 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 
             insertIntoHeap(o);
         }
+
+        schedule();
     }
+}
 
-    if (!--depth && stabilizer === STABILIZER_IDLE) {
+function schedule() {
+    if (stabilizer === STABILIZER_IDLE && !depth) {
         stabilizer = STABILIZER_SCHEDULED;
         scheduler(stabilize);
     }
+    else if (stabilizer === STABILIZER_RUNNING) {
+        stabilizer = STABILIZER_RESCHEDULE;
+    }
 }
 
 function stabilize() {
@@ -349,6 +353,7 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
         else {
             self.height = observer.height + 1;
             insertIntoHeap(self);
+            schedule();
         }
 
         link(self, observer);
@@ -472,9 +477,15 @@ signal.set = <T>(signal: Signal<T>, value: T) => {
     notified = false;
     signal.value = value;
 
-    for (let link = signal.subs; link !== null; link = link.nextSub) {
+    if (signal.subs === null) {
+        return;
+    }
+
+    for (let link: Link | null = signal.subs; link !== null; link = link.nextSub) {
         insertIntoHeap(link.sub);
     }
+
+    schedule();
 };
 
 

package/src/types.ts

@@ -22,10 +22,10 @@ interface Computed<T> extends Signal<T> {
 }
 
 type Infer<T> =
-    T extends (...args: unknown[]) => ((...args: unknown[]) => Promise<infer R>)
-        ? R
+    T extends (...args: unknown[]) => Promise<infer R>
+        ? R | undefined
         : T extends (...args: any[]) => infer R
-            ? R | null
+            ? R
             : T extends (infer U)[]
                 ? ReactiveArray<U>
                 : T extends ReactiveObject<any>