@esportsplus/reactivity 0.16.7 → 0.17.0

package/src/reactive/object.ts

@@ -1,24 +1,8 @@
-import { defineProperty, isArray, isFunction, isObject, isPromise, Prettify } from '@esportsplus/utilities';
+import { defineProperty, isArray, isObject, isPromise } from '@esportsplus/utilities';
 import { computed, dispose, effect, read, root, set, signal } from '~/system';
 import { Computed, Signal } from '~/types';
 import { REACTIVE_OBJECT } from '~/constants';
-import array, { ReactiveArray } from './array';
-
-
-type API<T> = Prettify<{ [K in keyof T]: Infer<T[K]> } & { dispose: VoidFunction } >;
-
-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;
+import { ReactiveArray } from './array';
 
 
 class ReactiveObject<T extends Record<PropertyKey, unknown>> {
@@ -35,17 +19,9 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
             let key = keys[i],
                 value = data[key];
 
-            if (isArray(value)) {
-                let node = array(value);
-
-                (this.disposers ??= []).push( () => node.dispose() );
+            let type = typeof value;
 
-                defineProperty(this, key, {
-                    enumerable: true,
-                    value: node
-                });
-            }
-            else if (isFunction(value)) {
+            if (type === 'function') {
                 let node: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
 
                 defineProperty(this, key, {
@@ -84,20 +60,37 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
                         return read(node!);
                     }
                 });
+
+                continue;
+            }
+
+            if (value == null || type !== 'object') {
+                // Avoid isArray when possible
             }
-            else {
-                let node = signal(value);
+            else if (isArray(value)) {
+                let node = new ReactiveArray(value);
+
+                (this.disposers ??= []).push( () => node.dispose() );
 
                 defineProperty(this, key, {
                     enumerable: true,
-                    get() {
-                        return read(node);
-                    },
-                    set(v: typeof value) {
-                        set(node, v);
-                    }
+                    value: node
                 });
+
+                continue;
             }
+
+            let node = signal(value);
+
+            defineProperty(this, key, {
+                enumerable: true,
+                get() {
+                    return read(node);
+                },
+                set(v: typeof value) {
+                    set(node, v);
+                }
+            });
         }
     }
 
@@ -122,8 +115,4 @@ const isReactiveObject = (value: any): value is ReactiveObject<any> => {
 };
 
 
-export default <T extends Record<PropertyKey, unknown>>(input: T) => {
-    return new ReactiveObject<T>(input) as API<T>;
-};
-export { isReactiveObject };
-export type { API as ReactiveObject };
+export { isReactiveObject, ReactiveObject };

package/src/system.ts

@@ -1,4 +1,4 @@
-import { isArray, isObject } from '@esportsplus/utilities';
+import { isObject } from '@esportsplus/utilities';
 import {
     COMPUTED, SIGNAL,
     STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
@@ -26,14 +26,14 @@ function cleanup<T>(computed: Computed<T>): void {
 
     let value = computed.cleanup;
 
-    if (isArray(value)) {
+    if (typeof value === 'function') {
+        value();
+    }
+    else {
         for (let i = 0, n = value.length; i < n; i++) {
             value[i]();
         }
     }
-    else {
-        value();
-    }
 
     computed.cleanup = null;
 }
@@ -108,16 +108,16 @@ function insertIntoHeap<T>(computed: Computed<T>) {
 function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
     let prevDep = sub.depsTail;
 
-    if (prevDep !== null && prevDep.dep === dep) {
+    if (prevDep && prevDep.dep === dep) {
         return;
     }
 
     let nextDep: Link | null = null;
 
     if (sub.state & STATE_RECOMPUTING) {
-        nextDep = prevDep !== null ? prevDep.nextDep : sub.deps;
+        nextDep = prevDep ? prevDep.nextDep : sub.deps;
 
-        if (nextDep !== null && nextDep.dep === dep) {
+        if (nextDep && nextDep.dep === dep) {
             nextDep.version = version;
             sub.depsTail = nextDep;
             return;
@@ -128,7 +128,7 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
 
     // https://github.com/stackblitz/alien-signals/commit/54fe1b3947fac5c0aecb73b0b0eaff000806c454
     if (
-        prevSub !== null &&
+        prevSub &&
         prevSub.version === version &&
         prevSub.sub === sub
     ) {
@@ -146,14 +146,14 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
                     version
                 };
 
-    if (prevDep !== null) {
+    if (prevDep) {
         prevDep.nextDep = newLink;
     }
     else {
         sub.deps = newLink;
     }
 
-    if (prevSub !== null) {
+    if (prevSub) {
         prevSub.nextSub = newLink;
     }
     else {
@@ -170,7 +170,7 @@ function notify<T>(computed: Computed<T>, newState = STATE_DIRTY) {
 
     computed.state = state | newState;
 
-    for (let link = computed.subs; link !== null; link = link.nextSub) {
+    for (let link = computed.subs; link; link = link.nextSub) {
         notify(link.sub, STATE_CHECK);
     }
 }
@@ -211,15 +211,15 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
     computed.state = STATE_NONE;
 
     let depsTail = computed.depsTail as Link | null,
-        remove = depsTail !== null ? depsTail.nextDep : computed.deps;
+        remove = depsTail ? depsTail.nextDep : computed.deps;
 
-    if (remove !== null) {
+    if (remove) {
         do {
             remove = unlink(remove);
         }
-        while (remove !== null);
+        while (remove);
 
-        if (depsTail !== null) {
+        if (depsTail) {
             depsTail.nextDep = null;
         }
         else {
@@ -230,7 +230,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
     if (ok && value !== computed.value) {
         computed.value = value as T;
 
-        for (let c = computed.subs; c !== null; c = c.nextSub) {
+        for (let c = computed.subs; c; c = c.nextSub) {
             let s = c.sub,
                 state = s.state;
 
@@ -246,6 +246,10 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
 }
 
 function schedule() {
+    if (stabilizer === STABILIZER_SCHEDULED) {
+        return;
+    }
+
     if (stabilizer === STABILIZER_IDLE && !depth) {
         stabilizer = STABILIZER_SCHEDULED;
         microtask(stabilize);
@@ -296,14 +300,14 @@ function unlink(link: Link): Link | null {
         nextSub = link.nextSub,
         prevSub = link.prevSub;
 
-    if (nextSub !== null) {
+    if (nextSub) {
         nextSub.prevSub = prevSub;
     }
     else {
         dep.subsTail = prevSub;
     }
 
-    if (prevSub !== null) {
+    if (prevSub) {
         prevSub.nextSub = nextSub;
     }
     else if ((dep.subs = nextSub) === null && 'fn' in dep) {
@@ -385,7 +389,7 @@ const dispose = <T>(computed: Computed<T>) => {
 
     let dep = computed.deps;
 
-    while (dep !== null) {
+    while (dep) {
         dep = unlink(dep);
     }
 
@@ -424,11 +428,11 @@ const onCleanup = (fn: VoidFunction): typeof fn => {
     if (!cleanup) {
         parent.cleanup = fn;
     }
-    else if (isArray(cleanup)) {
-        cleanup.push(fn);
+    else if (typeof cleanup === 'function') {
+        parent.cleanup = [cleanup, fn];
     }
     else {
-        parent.cleanup = [cleanup, fn];
+        cleanup.push(fn);
     }
 
     return fn;
@@ -510,7 +514,7 @@ const set = <T>(signal: Signal<T>, value: T) => {
         return;
     }
 
-    for (let link: Link | null = signal.subs; link !== null; link = link.nextSub) {
+    for (let link: Link | null = signal.subs; link; link = link.nextSub) {
         insertIntoHeap(link.sub);
     }