@esportsplus/reactivity 0.5.0 → 0.6.1

package/build/reactive/index.d.ts

@@ -1,10 +1,13 @@
-import { Reactive } from '../types.js';
-type Guard<T> = T extends {
+import array from './array.js';
+import object from './object.js';
+import promise from './promise.js';
+type API<T> = T extends (...args: infer A) => Promise<infer R> ? ReturnType<typeof promise<A, Promise<R>>> : T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
+type Guard<T> = T extends (...args: unknown[]) => Promise<unknown> ? 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>(data: Guard<T>) => Reactive<T>;
+declare const _default: <T>(data: Guard<T>) => API<T>;
 export default _default;

package/build/reactive/index.js

@@ -1,16 +1,16 @@
-import { isArray, isObject } from '@esportsplus/utilities';
-import { default as array } from './array.js';
-import { default as object } from './object.js';
+import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import array from './array.js';
+import object from './object.js';
+import promise from './promise.js';
 export default (data) => {
-    let value;
     if (isArray(data)) {
-        value = array(data);
+        return array(data);
     }
     else if (isObject(data)) {
-        value = object(data);
+        return object(data);
     }
-    else {
-        throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);
+    else if (isPromise(data)) {
+        return promise(data);
     }
-    return value;
+    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);
 };

package/build/reactive/object.d.ts

@@ -5,7 +5,7 @@ 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 signals;
+    private disposable;
     constructor(data: T);
     dispose(): void;
 }

package/build/reactive/object.js

@@ -1,59 +1,69 @@
-import { defineProperty, isArray, isFunction, isInstanceOf, isObject } from '@esportsplus/utilities';
+import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf, isObject } from '@esportsplus/utilities';
 import array from './array.js';
-import { computed, dispose, isComputed, read, signal } from '../signal.js';
+import { computed, dispose, read, signal } from '../signal.js';
 import { Disposable } from './disposable.js';
+import promise from './promise.js';
 let { set } = signal;
 class ReactiveObject extends Disposable {
-    signals = {};
+    disposable = {};
     constructor(data) {
         super();
-        let signals = this.signals, triggers = {};
+        let disposable = this.disposable, triggers = {};
         for (let key in data) {
             let value = data[key];
             if (isArray(value)) {
-                let s = signals[key] = array(value), t = triggers[key] = signal(false);
+                let a = disposable[key] = array(value), t = triggers[key] = signal(false);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         read(t);
-                        return s;
+                        return a;
                     },
                     set(v) {
                         set(t, !!t.value);
-                        s = signals[key] = array(v);
+                        a = disposable[key] = array(v);
+                    }
+                });
+            }
+            if (isAsyncFunction(value)) {
+                let p = promise(value);
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get() {
+                        return p;
                     }
                 });
             }
             else if (isFunction(value)) {
-                let s = signals[key] = computed(value);
+                let c = disposable[key] = computed(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(s);
+                        return read(c);
                     }
                 });
             }
             else if (isObject(value)) {
-                let s = signals[key] = new ReactiveObject(value), t = triggers[key] = signal(false);
+                let o = disposable[key] = new ReactiveObject(value), t = triggers[key] = signal(false);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         read(t);
-                        return s;
+                        return o;
                     },
                     set(v) {
                         set(t, !!t.value);
-                        s = signals[key] = new ReactiveObject(v);
+                        o = disposable[key] = new ReactiveObject(v);
                     }
                 });
             }
             else {
-                let s = signals[key] = signal(value);
+                let s = signal(value);
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         if (s === undefined) {
-                            s = signals[key] = signal(value);
+                            s = signal(value);
                         }
                         return read(s);
                     },
@@ -65,16 +75,16 @@ class ReactiveObject extends Disposable {
         }
     }
     dispose() {
-        for (let key in this.signals) {
-            let value = this.signals[key];
+        for (let key in this.disposable) {
+            let value = this.disposable[key];
             if (isInstanceOf(value, Disposable)) {
                 value.dispose();
             }
-            else if (isComputed(value)) {
+            else {
                 dispose(value);
             }
         }
-        this.signals = {};
+        this.disposable = {};
     }
 }
 export default function object(input) {

package/build/reactive/promise.d.ts

@@ -0,0 +1,13 @@
+import CustomFunction from '@esportsplus/custom-function';
+declare class ReactivePromise<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
+    private arguments;
+    private okay;
+    private response;
+    stop: boolean | null;
+    constructor(fn: (...args: A) => R);
+    get data(): Awaited<R> | null;
+    get input(): A | null;
+    get ok(): boolean | null;
+}
+declare const _default: <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R) => ReactivePromise<A, R>;
+export default _default;

package/build/reactive/promise.js

@@ -0,0 +1,48 @@
+import CustomFunction from '@esportsplus/custom-function';
+import { read, root, signal } from '../signal.js';
+let { set } = signal;
+class ReactivePromise extends CustomFunction {
+    arguments;
+    okay;
+    response;
+    stop = null;
+    constructor(fn) {
+        super((...args) => {
+            this.stop = null;
+            set(this.arguments, args);
+            set(this.okay, null);
+            return root(() => {
+                return fn(...args)
+                    .then((value) => {
+                    if (this.stop === true) {
+                        return;
+                    }
+                    set(this.response, value);
+                    set(this.okay, true);
+                })
+                    .catch(() => {
+                    if (this.stop === true) {
+                        return;
+                    }
+                    set(this.response, null);
+                    set(this.okay, false);
+                });
+            });
+        });
+        this.response = signal(null);
+        this.arguments = signal(null);
+        this.okay = signal(null);
+    }
+    get data() {
+        return read(this.response);
+    }
+    get input() {
+        return read(this.arguments);
+    }
+    get ok() {
+        return read(this.okay);
+    }
+}
+export default (fn) => {
+    return new ReactivePromise(fn);
+};

package/build/signal.d.ts

@@ -1,6 +1,6 @@
 import { Computed, Signal } from './types.js';
 declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
-declare const dispose: (el: Computed<unknown>) => void;
+declare const dispose: <T>(el: Computed<T>) => void;
 declare const isComputed: (value: unknown) => value is Computed<unknown>;
 declare const isReactive: (value: unknown) => value is Computed<unknown> | Signal<unknown>;
 declare const isSignal: (value: unknown) => value is Signal<unknown>;
@@ -9,7 +9,7 @@ declare const read: <T>(el: Signal<T> | Computed<T>) => T;
 declare const root: <T>(fn: () => T) => T;
 declare const signal: {
     <T>(value: T): Signal<T>;
-    set(el: Signal<unknown>, v: unknown): void;
+    set<T>(el: Signal<T>, v: T): void;
 };
 declare const stabilize: () => void;
 export { computed, dispose, isComputed, isReactive, isSignal, oncleanup, read, root, signal, stabilize };

package/build/signal.js

@@ -1,6 +1,6 @@
 import { isArray, isObject } from '@esportsplus/utilities';
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-let context = null, dirtyHeap = new Array(2000), maxDirty = 0, markedHeap = false, minDirty = 0;
+let dirtyHeap = new Array(2000), maxDirty = 0, markedHeap = false, minDirty = 0, observer = null;
 function cleanup(node) {
     if (!node.cleanup) {
         return;
@@ -125,8 +125,8 @@ function recompute(el, del) {
         el.prevHeap = el;
     }
     cleanup(el);
-    let oldcontext = context, ok = true, value;
-    context = el;
+    let o = observer, ok = true, value;
+    observer = el;
     el.depsTail = null;
     el.state = STATE_RECOMPUTING;
     try {
@@ -135,7 +135,7 @@ function recompute(el, del) {
     catch (e) {
         ok = false;
     }
-    context = oldcontext;
+    observer = o;
     el.state = STATE_NONE;
     let depsTail = el.depsTail, toRemove = depsTail !== null ? depsTail.nextDep : el.deps;
     if (toRemove !== null) {
@@ -212,16 +212,16 @@ const computed = (fn) => {
         value: undefined,
     };
     self.prevHeap = self;
-    if (context) {
-        if (context.depsTail === null) {
-            self.height = context.height;
+    if (observer) {
+        if (observer.depsTail === null) {
+            self.height = observer.height;
             recompute(self, false);
         }
         else {
-            self.height = context.height + 1;
+            self.height = observer.height + 1;
             insertIntoHeap(self);
         }
-        link(self, context);
+        link(self, observer);
     }
     else {
         recompute(self, false);
@@ -247,10 +247,10 @@ const isSignal = (value) => {
     return isObject(value) && REACTIVE in value && 'fn' in value === false;
 };
 const oncleanup = (fn) => {
-    if (!context) {
+    if (!observer) {
         return fn;
     }
-    let node = context;
+    let node = observer;
     if (!node.cleanup) {
         node.cleanup = fn;
     }
@@ -263,12 +263,12 @@ const oncleanup = (fn) => {
     return fn;
 };
 const read = (el) => {
-    if (context) {
-        link(el, context);
+    if (observer) {
+        link(el, observer);
         if ('fn' in el) {
             let height = el.height;
-            if (height >= context.height) {
-                context.height = height + 1;
+            if (height >= observer.height) {
+                observer.height = height + 1;
             }
             if (height >= minDirty ||
                 el.state & (STATE_DIRTY | STATE_CHECK)) {
@@ -280,10 +280,10 @@ const read = (el) => {
     return el.value;
 };
 const root = (fn) => {
-    let c = context;
-    context = null;
+    let o = observer;
+    observer = null;
     let value = fn();
-    context = c;
+    observer = o;
     return value;
 };
 const signal = (value) => {

package/package.json

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

package/src/reactive/index.ts

@@ -1,29 +1,38 @@
-import { isArray, isObject } from '@esportsplus/utilities';
-import { Reactive } from '~/types';
-import { default as array } from './array';
-import { default as object } from './object';
+import { isArray, isObject, isPromise } from '@esportsplus/utilities';
+import array from './array';
+import object from './object';
+import promise from './promise';
 
 
-type Guard<T> =
-    T extends { dispose: any } | { signals: any }
-        ? { never: '[ dispose, signals ] are reserved keys' }
-        : T extends Record<PropertyKey, unknown> | unknown[]
-            ? T
-            : never;
+type API<T> =
+    T extends (...args: infer A) => Promise<infer R>
+        ? ReturnType<typeof promise<A, Promise<R>>>
+        : T extends Record<PropertyKey, unknown>
+            ? ReturnType<typeof object<T>>
+            : T extends unknown[]
+                ? ReturnType<typeof array<T>>
+                : never;
 
+type Guard<T> =
+    T extends (...args: unknown[]) => Promise<unknown>
+        ? T
+        : T extends { dispose: any } | { signals: any }
+            ? { never: '[ dispose, signals ] are reserved keys' }
+            : T extends Record<PropertyKey, unknown> | unknown[]
+                ? T
+                : never;
 
-export default <T>(data: Guard<T>) => {
-    let value;
 
+export default <T>(data: Guard<T>): API<T> => {
     if (isArray(data)) {
-        value = array(data);
+        return array(data) as API<T>;
     }
     else if (isObject(data)) {
-        value = object(data as { [K in keyof T]: T[K] });
+        return object(data) as API<T>;
     }
-    else {
-        throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);
+    else if (isPromise(data)) {
+        return promise(data) as API<T>;
     }
 
-    return value as Reactive<T>;
+    throw new Error(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(data)}`);
 };

package/src/reactive/object.ts

@@ -1,8 +1,9 @@
-import { defineProperty, isArray, isFunction, isInstanceOf, isObject, Prettify } from '@esportsplus/utilities';
+import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf, isObject, Prettify } from '@esportsplus/utilities';
 import array, { ReactiveArray } from './array';
-import { computed, dispose, isComputed, read, signal } from '~/signal';
+import { computed, dispose, read, signal } from '~/signal';
 import { Computed, Infer, Signal } from '~/types';
 import { Disposable } from './disposable';
+import promise from './promise';
 
 
 type API<T extends Record<PropertyKey, unknown>> = Prettify<{ [K in keyof T]: Infer<T[K]> }> & ReactiveObject<T>;
@@ -12,71 +13,81 @@ let { set } = signal;
 
 
 class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable {
-    private signals: Record<
+    private disposable: Record<
         PropertyKey,
-        Computed<any> | ReactiveArray<any> | ReactiveObject<any> | Signal<any>
+        Computed<any> | ReactiveArray<any> | ReactiveObject<any>
     > = {};
 
 
     constructor(data: T) {
         super();
 
-        let signals = this.signals,
+        let disposable = this.disposable,
             triggers: Record<string, Signal<boolean>> = {};
 
         for (let key in data) {
             let value = data[key];
 
             if (isArray(value)) {
-                let s = signals[key] = array(value),
+                let a = disposable[key] = array(value),
                     t = triggers[key] = signal(false);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         read(t);
-                        return s;
+                        return a;
                     },
                     set(v: typeof value) {
                         set(t, !!t.value);
-                        s = signals[key] = array(v);
+                        a = disposable[key] = array(v);
+                    }
+                });
+            }
+            if (isAsyncFunction(value)) {
+                let p = promise(value);
+
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get() {
+                        return p;
                     }
                 });
             }
             else if (isFunction(value)) {
-                let s = signals[key] = computed(value as Computed<T>['fn']);
+                let c = disposable[key] = computed(value as Computed<T>['fn']);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
-                        return read(s as Computed<T>);
+                        return read(c as Computed<T>);
                     }
                 });
             }
             else if (isObject(value)) {
-                let s = signals[key] = new ReactiveObject(value),
+                let o = disposable[key] = new ReactiveObject(value),
                     t = triggers[key] = signal(false);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         read(t);
-                        return s;
+                        return o;
                     },
                     set(v: typeof value) {
                         set(t, !!t.value);
-                        s = signals[key] = new ReactiveObject(v);
+                        o = disposable[key] = new ReactiveObject(v);
                     }
                 });
             }
             else {
-                let s = signals[key] = signal(value);
+                let s = signal(value);
 
                 defineProperty(this, key, {
                     enumerable: true,
                     get() {
                         if (s === undefined) {
-                            s = signals[key] = signal(value);
+                            s = signal(value);
                         }
 
                         return read(s as Signal<typeof value>);
@@ -91,18 +102,18 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> extends Disposable
 
 
     dispose() {
-        for (let key in this.signals) {
-            let value = this.signals[key];
+        for (let key in this.disposable) {
+            let value = this.disposable[key];
 
             if (isInstanceOf(value, Disposable)) {
                 value.dispose();
             }
-            else if (isComputed(value)) {
+            else {
                 dispose(value);
             }
         }
 
-        this.signals = {};
+        this.disposable = {};
     }
 }
 

package/src/reactive/promise.ts

@@ -0,0 +1,67 @@
+import CustomFunction from '@esportsplus/custom-function';
+import { read, root, signal } from '~/signal';
+import { Signal } from '~/types';
+
+
+let { set } = signal;
+
+
+class ReactivePromise<A extends unknown[], R extends Promise<unknown>> extends CustomFunction {
+    private arguments: Signal<A | null>;
+    private okay: Signal<boolean | null>;
+    private response: Signal<Awaited<R> | null>;
+
+    stop: boolean | null = null;
+
+
+    constructor(fn: (...args: A) => R) {
+        super((...args: A) => {
+            this.stop = null;
+
+            set(this.arguments, args);
+            set(this.okay, null);
+
+            return root(() => {
+                return fn(...args)
+                    .then((value) => {
+                        if (this.stop === true) {
+                            return;
+                        }
+
+                        set(this.response, value as Awaited<R>);
+                        set(this.okay, true);
+                    })
+                    .catch(() => {
+                        if (this.stop === true) {
+                            return;
+                        }
+
+                        set(this.response, null);
+                        set(this.okay, false);
+                    });
+            });
+        });
+
+        this.response = signal(null);
+        this.arguments = signal(null);
+        this.okay = signal(null);
+    }
+
+
+    get data() {
+        return read(this.response);
+    }
+
+    get input() {
+        return read(this.arguments);
+    }
+
+    get ok() {
+        return read(this.okay);
+    }
+}
+
+
+export default <A extends unknown[], R extends Promise<unknown>>(fn: (...args: A) => R) => {
+    return new ReactivePromise(fn);
+};

package/src/signal.ts

@@ -3,14 +3,14 @@ import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RE
 import { Computed, Link, Signal, } from './types';
 
 
-let context: Computed<unknown> | null = null,
-    dirtyHeap: (Computed<unknown> | undefined)[] = new Array(2000),
+let dirtyHeap: (Computed<unknown> | undefined)[] = new Array(2000),
     maxDirty = 0,
     markedHeap = false,
-    minDirty = 0;
+    minDirty = 0,
+    observer: Computed<unknown> | null = null;
 
 
-function cleanup(node: Computed<unknown>): void {
+function cleanup<T>(node: Computed<T>): void {
     if (!node.cleanup) {
         return;
     }
@@ -27,7 +27,7 @@ function cleanup(node: Computed<unknown>): void {
     node.cleanup = null;
 }
 
-function deleteFromHeap(n: Computed<unknown>) {
+function deleteFromHeap<T>(n: Computed<T>) {
     let state = n.state;
 
     if (!(state & STATE_IN_HEAP)) {
@@ -60,7 +60,7 @@ function deleteFromHeap(n: Computed<unknown>) {
     n.prevHeap = n;
 }
 
-function insertIntoHeap(n: Computed<unknown>) {
+function insertIntoHeap<T>(n: Computed<T>) {
     let state = n.state;
 
     if (state & STATE_IN_HEAP) {
@@ -94,7 +94,7 @@ function insertIntoHeap(n: Computed<unknown>) {
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(dep: Signal<unknown> | Computed<unknown>, sub: Computed<unknown>) {
+function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
     let prevDep = sub.depsTail;
 
     if (prevDep !== null && prevDep.dep === dep) {
@@ -152,7 +152,7 @@ function markHeap() {
     }
 }
 
-function markNode(el: Computed<unknown>, newState = STATE_DIRTY) {
+function markNode<T>(el: Computed<T>, newState = STATE_DIRTY) {
     let state = el.state;
 
     if ((state & (STATE_CHECK | STATE_DIRTY)) >= newState) {
@@ -166,7 +166,7 @@ function markNode(el: Computed<unknown>, newState = STATE_DIRTY) {
     }
 }
 
-function recompute(el: Computed<unknown>, del: boolean) {
+function recompute<T>(el: Computed<T>, del: boolean) {
     if (del) {
         deleteFromHeap(el);
     }
@@ -177,11 +177,11 @@ function recompute(el: Computed<unknown>, del: boolean) {
 
     cleanup(el);
 
-    let oldcontext = context,
+    let o = observer,
         ok = true,
         value;
 
-    context = el;
+    observer = el;
     el.depsTail = null;
     el.state = STATE_RECOMPUTING;
 
@@ -192,7 +192,7 @@ function recompute(el: Computed<unknown>, del: boolean) {
         ok = false;
     }
 
-    context = oldcontext;
+    observer = o;
     el.state = STATE_NONE;
 
     let depsTail = el.depsTail as Link | null,
@@ -213,7 +213,7 @@ function recompute(el: Computed<unknown>, del: boolean) {
     }
 
     if (ok && value !== el.value) {
-        el.value = value;
+        el.value = value as T;
 
         for (let s = el.subs; s !== null; s = s.nextSub) {
             let o = s.sub,
@@ -256,7 +256,7 @@ function unlink(link: Link): Link | null {
     return nextDep;
 }
 
-function update(el: Computed<unknown>): void {
+function update<T>(el: Computed<T>): void {
     if (el.state & STATE_CHECK) {
         for (let d = el.deps; d; d = d.nextDep) {
             let dep = d.dep;
@@ -297,17 +297,17 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
 
     self.prevHeap = self;
 
-    if (context) {
-        if (context.depsTail === null) {
-            self.height = context.height;
+    if (observer) {
+        if (observer.depsTail === null) {
+            self.height = observer.height;
             recompute(self, false);
         }
         else {
-            self.height = context.height + 1;
+            self.height = observer.height + 1;
             insertIntoHeap(self);
         }
 
-        link(self, context);
+        link(self, observer);
     }
     else {
         recompute(self, false);
@@ -316,7 +316,7 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     return self;
 };
 
-const dispose = (el: Computed<unknown>) => {
+const dispose = <T>(el: Computed<T>) => {
     deleteFromHeap(el);
 
     let dep = el.deps;
@@ -343,11 +343,11 @@ const isSignal = (value: unknown): value is Signal<unknown> => {
 };
 
 const oncleanup = (fn: VoidFunction): typeof fn => {
-    if (!context) {
+    if (!observer) {
         return fn;
     }
 
-    let node = context;
+    let node = observer;
 
     if (!node.cleanup) {
         node.cleanup = fn;
@@ -363,14 +363,14 @@ const oncleanup = (fn: VoidFunction): typeof fn => {
 };
 
 const read = <T>(el: Signal<T> | Computed<T>): T => {
-    if (context) {
-        link(el, context);
+    if (observer) {
+        link(el, observer);
 
         if ('fn' in el) {
             let height = el.height;
 
-            if (height >= context.height) {
-                context.height = height + 1;
+            if (height >= observer.height) {
+                observer.height = height + 1;
             }
 
             if (
@@ -387,13 +387,13 @@ const read = <T>(el: Signal<T> | Computed<T>): T => {
 };
 
 const root = <T>(fn: () => T) => {
-    let c = context;
+    let o = observer;
 
-    context = null;
+    observer = null;
 
     let value = fn();
 
-    context = c;
+    observer = o;
 
     return value;
 };
@@ -407,7 +407,7 @@ const signal = <T>(value: T): Signal<T> => {
     };
 };
 
-signal.set = (el: Signal<unknown>, v: unknown) => {
+signal.set = <T>(el: Signal<T>, v: T) => {
     if (el.value === v) {
         return;
     }