@esportsplus/reactivity 0.30.2 → 0.31.0

package/src/system.ts

@@ -1,8 +1,7 @@
 import {
-    COMPUTED,
     SIGNAL,
     STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
-    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
+    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 } from './constants';
 import { Computed, Link, Signal } from './types';
 import { isObject } from '@esportsplus/utilities';
@@ -12,8 +11,7 @@ let depth = 0,
     heap: (Computed<unknown> | undefined)[] = new Array(64),
     heap_i = 0,
     heap_n = 0,
-    linkPool: Link[] = [],
-    linkPoolMax = 1000,
+    linkPoolHead: Link | null = null,
     microtask = queueMicrotask,
     notified = false,
     observer: Computed<unknown> | null = null,
@@ -138,11 +136,12 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
         return;
     }
 
-    let pooled = linkPool.pop(),
+    let pooled = linkPoolHead,
         newLink =
             sub.depsTail =
                 dep.subsTail = pooled
-                    ? (pooled.dep = dep,
+                    ? (linkPoolHead = pooled.nextDep,
+                       pooled.dep = dep,
                        pooled.sub = sub,
                        pooled.nextDep = nextDep,
                        pooled.prevSub = prevSub,
@@ -173,7 +172,7 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
     }
 }
 
-function notify<T>(computed: Computed<T>, newState = STATE_DIRTY) {
+function notify<T>(computed: Computed<T>, newState: number) {
     let state = computed.state;
 
     if ((state & STATE_NOTIFY_MASK) >= newState) {
@@ -206,7 +205,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 
     observer = computed;
     computed.depsTail = null;
-    computed.state = STATE_RECOMPUTING;
+    computed.state = STATE_COMPUTED | STATE_RECOMPUTING;
 
     depth++;
     version++;
@@ -220,7 +219,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 
     depth--;
     observer = o;
-    computed.state = STATE_NONE;
+    computed.state = STATE_COMPUTED;
 
     let depsTail = computed.depsTail as Link | null,
         remove = depsTail ? depsTail.nextDep : computed.deps;
@@ -298,6 +297,7 @@ function stabilize() {
     observer = o;
 
     if (stabilizer === STABILIZER_RESCHEDULE) {
+        stabilizer = STABILIZER_SCHEDULED;
         microtask(stabilize);
     }
     else {
@@ -322,16 +322,14 @@ function unlink(link: Link): Link | null {
     if (prevSub) {
         prevSub.nextSub = nextSub;
     }
-    else if ((dep.subs = nextSub) === null && dep.type === COMPUTED) {
-        dispose(dep);
+    else if ((dep.subs = nextSub) === null && (dep as Computed<unknown>).state & STATE_COMPUTED) {
+        dispose(dep as Computed<unknown>);
     }
 
-    // Release link back to pool
-    if (linkPool.length < linkPoolMax) {
-        link.dep = link.sub = null as any;
-        link.nextDep = link.nextSub = link.prevSub = null;
-        linkPool.push(link);
-    }
+    link.dep = link.sub = null as any;
+    link.nextSub = link.prevSub = null;
+    link.nextDep = linkPoolHead;
+    linkPoolHead = link;
 
     return nextDep;
 }
@@ -341,8 +339,8 @@ function update<T>(computed: Computed<T>): void {
         for (let link = computed.deps; link; link = link.nextDep) {
             let dep = link.dep;
 
-            if (dep.type === COMPUTED) {
-                update(dep);
+            if ((dep as Computed<unknown>).state & STATE_COMPUTED) {
+                update(dep as Computed<unknown>);
 
                 if (computed.state & STATE_DIRTY) {
                     break;
@@ -355,10 +353,28 @@ function update<T>(computed: Computed<T>): void {
         recompute(computed, true);
     }
 
-    computed.state = STATE_NONE;
+    computed.state = STATE_COMPUTED;
 }
 
 
+const asyncComputed = <T>(fn: Computed<Promise<T>>['fn']): Signal<T | undefined> => {
+    let factory = computed(fn),
+        node = signal<T | undefined>(undefined),
+        v = 0;
+
+    onCleanup(effect(() => {
+        let id = ++v;
+
+        (read(factory) as Promise<T>).then((value) => {
+            if (id === v) {
+                write(node, value);
+            }
+        }, () => {});
+    }));
+
+    return node;
+};
+
 const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
     let self: Computed<T> = {
             cleanup: null,
@@ -368,10 +384,9 @@ const computed = <T>(fn: Computed<T>['fn']): Computed<T> => {
             height: 0,
             nextHeap: undefined,
             prevHeap: null as any,
-            state: STATE_NONE,
+            state: STATE_COMPUTED,
             subs: null,
             subsTail: null,
-            type: COMPUTED,
             value: undefined as T,
         };
 
@@ -428,7 +443,7 @@ const effect = <T>(fn: Computed<T>['fn']) => {
 };
 
 const isComputed = (value: unknown): value is Computed<unknown> => {
-    return isObject(value) && value.type === COMPUTED;
+    return isObject(value) && !!((value as unknown as Computed<unknown>).state & STATE_COMPUTED);
 };
 
 const isSignal = (value: unknown): value is Signal<unknown> => {
@@ -461,25 +476,25 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
     if (observer) {
         link(node, observer);
 
-        if (node.type === COMPUTED) {
-            let height = node.height;
+        if ((node as Computed<unknown>).state & STATE_COMPUTED) {
+            let height = (node as Computed<T>).height;
 
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
 
-            if (height >= heap_i || node.state & STATE_NOTIFY_MASK) {
+            if (height >= heap_i || (node as Computed<T>).state & STATE_NOTIFY_MASK) {
                 if (!notified) {
                     notified = true;
 
                     for (let i = 0; i <= heap_n; i++) {
                         for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
-                            notify(computed);
+                            notify(computed, STATE_DIRTY);
                         }
                     }
                 }
 
-                update(node);
+                update(node as Computed<T>);
             }
         }
     }
@@ -500,7 +515,7 @@ const root = <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => {
     root.disposables = 0;
 
     if (tracking) {
-        scope = self = { cleanup: null } as Computed<unknown>;
+        scope = self = { cleanup: null, state: STATE_COMPUTED } as Computed<unknown>;
         value = (fn as (dispose: VoidFunction) => T)(c = () => dispose(self!));
     }
     else {
@@ -535,13 +550,14 @@ const write = <T>(signal: Signal<T>, value: T) => {
         return;
     }
 
-    notified = false;
     signal.value = value;
 
     if (signal.subs === null) {
         return;
     }
 
+    notified = false;
+
     for (let link: Link | null = signal.subs; link; link = link.nextSub) {
         insertIntoHeap(link.sub);
     }
@@ -551,7 +567,7 @@ const write = <T>(signal: Signal<T>, value: T) => {
 
 
 export {
-    computed,
+    asyncComputed, computed,
     dispose,
     effect,
     isComputed, isSignal,

package/src/types.ts

@@ -1,5 +1,5 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
+import { SIGNAL } from './constants';
 import { ReactiveArray } from './reactive';
 
 
@@ -11,15 +11,9 @@ interface Computed<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;
+    state: number;
     subs: Link | null;
     subsTail: Link | null;
-    type: typeof COMPUTED;
     value: T;
 }