@esportsplus/reactivity 0.11.2 → 0.11.3

package/build/reactive/index.d.ts

@@ -2,12 +2,14 @@ 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 (...args: unknown[]) => unknown ? NeverAsync<T> : T extends {
+type Input<T> = T extends unknown[] ? T : T extends {
     dispose: any;
 } | {
     signals: any;
 } ? {
     never: '[ dispose, signals ] are reserved keys';
-} : T extends Record<PropertyKey, unknown> | unknown[] ? T : never;
+} : 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;
 declare const _default: <T>(input: Input<T>) => API<T>;
 export default _default;

package/build/reactive/object.js

@@ -1,6 +1,6 @@
-import { defineProperty, isArray, isFunction, isInstanceOf } from '@esportsplus/utilities';
+import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf } from '@esportsplus/utilities';
 import array from './array.js';
-import { computed, dispose, read, signal } from '../system.js';
+import { computed, dispose, effect, read, signal } from '../system.js';
 import { Disposable } from './disposable.js';
 let { set } = signal;
 class ReactiveObject extends Disposable {
@@ -31,6 +31,19 @@ class ReactiveObject extends Disposable {
                     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);
+                                    });
+                                });
+                            }
                         }
                         return read(c);
                     }

package/build/system.js

@@ -1,5 +1,5 @@
 import { isArray, isObject } from '@esportsplus/utilities';
-import { REACTIVE, STABILIZER_IDLE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
+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) {
@@ -62,7 +62,7 @@ function insertIntoHeap(computed) {
         }
     }
     if (stabilizer === STABILIZER_RUNNING && index > height) {
-        stabilizer = STABILIZER_SCHEDULED;
+        stabilizer = STABILIZER_RESCHEDULE;
     }
 }
 function link(dep, sub) {
@@ -179,7 +179,7 @@ function stabilize() {
                 computed = next;
             }
         }
-        if (stabilizer === STABILIZER_SCHEDULED) {
+        if (stabilizer === STABILIZER_RESCHEDULE) {
             scheduler(stabilize);
         }
         else {

package/build/types.d.ts

@@ -2,19 +2,18 @@ import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RE
 import { onCleanup } from './system.js';
 import { ReactiveArray } from './reactive/array.js';
 import { ReactiveObject } from './reactive/object.js';
-import { NeverAsync } from '@esportsplus/utilities';
 interface Computed<T> extends Signal<T> {
     [REACTIVE]: true;
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: NeverAsync<(oc?: typeof onCleanup) => T>;
+    fn: (oc?: typeof onCleanup) => 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;
 }
-type Infer<T> = T extends (...args: unknown[]) => unknown ? ReturnType<T> : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
+type Infer<T> = T extends (...args: unknown[]) => ((...args: unknown[]) => Promise<infer R>) ? R : 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.2",
+  "version": "0.11.3",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/index.ts

@@ -11,13 +11,20 @@ type API<T> =
             : never;
 
 type Input<T> =
-    T extends (...args: unknown[]) => unknown
-        ? NeverAsync<T>
+    T extends unknown[]
+        ? T
         : T extends { dispose: any } | { signals: any }
             ? { never: '[ dispose, signals ] are reserved keys' }
-            : T extends Record<PropertyKey, unknown> | unknown[]
-                ? T
-                : never;
+            : 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;
 
 
 export default <T>(input: Input<T>): API<T> => {

package/src/reactive/object.ts

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

package/src/system.ts

@@ -1,7 +1,7 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import {
     REACTIVE,
-    STABILIZER_IDLE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
+    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';
@@ -103,7 +103,7 @@ function insertIntoHeap<T>(computed: Computed<T>) {
     }
 
     if (stabilizer === STABILIZER_RUNNING && index > height) {
-        stabilizer = STABILIZER_SCHEDULED;
+        stabilizer = STABILIZER_RESCHEDULE;
     }
 }
 
@@ -266,7 +266,7 @@ function stabilize() {
             }
         }
 
-        if (stabilizer === STABILIZER_SCHEDULED) {
+        if (stabilizer === STABILIZER_RESCHEDULE) {
             scheduler(stabilize);
         }
         else {

package/src/types.ts

@@ -2,7 +2,6 @@ import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RE
 import { onCleanup } from './system';
 import { ReactiveArray } from './reactive/array';
 import { ReactiveObject } from './reactive/object';
-import { NeverAsync } from '@esportsplus/utilities';
 
 
 interface Computed<T> extends Signal<T> {
@@ -10,7 +9,7 @@ interface Computed<T> extends Signal<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: NeverAsync<(oc?: typeof onCleanup) => T>;
+    fn: (oc?: typeof onCleanup) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
@@ -23,15 +22,17 @@ interface Computed<T> extends Signal<T> {
 }
 
 type Infer<T> =
-    T extends (...args: unknown[]) => unknown
-        ? ReturnType<T>
-        : T extends (infer U)[]
-            ? ReactiveArray<U>
-            : T extends ReactiveObject<any>
-                ? T
-                : T extends Record<PropertyKey, unknown>
-                    ? { [K in keyof T]: T[K] }
-                    : T;
+    T extends (...args: unknown[]) => ((...args: unknown[]) => Promise<infer R>)
+        ? R
+        : 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 {
     dep: Signal<unknown> | Computed<unknown>;