@esportsplus/reactivity 0.8.1 → 0.9.0

package/build/index.d.ts

@@ -1,3 +1,3 @@
 export { default as reactive } from './reactive/index.js';
-export * from './signal.js';
+export * from './system.js';
 export * from './types.js';

package/build/index.js

@@ -1,3 +1,3 @@
 export { default as reactive } from './reactive/index.js';
-export * from './signal.js';
+export * from './system.js';
 export * from './types.js';

package/build/reactive/array.js

@@ -1,5 +1,5 @@
 import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { computed, dispose, isComputed, read } from '../signal.js';
+import { computed, dispose, isComputed, read } from '../system.js';
 import object from './object.js';
 import { Disposable } from './disposable.js';
 class ReactiveArray extends Disposable {

package/build/reactive/async.js

@@ -1,5 +1,5 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { read, root, signal } from '../signal.js';
+import { read, root, signal } from '../system.js';
 let { set } = signal;
 class ReactiveAsyncFunction extends CustomFunction {
     arguments;

package/build/reactive/index.d.ts

@@ -1,9 +1,8 @@
-import { Computed } from '../types.js';
 import array from './array.js';
 import async from './async.js';
 import object from './object.js';
-type API<T> = T extends (...args: infer A) => Promise<infer R> ? ReturnType<typeof async<A, Promise<R>>> : T extends (...args: unknown[]) => unknown ? void : T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
-type Input<T> = T extends (...args: unknown[]) => Promise<unknown> ? T : T extends (...args: unknown[]) => unknown ? Computed<T>['fn'] : T extends {
+type API<T> = T extends (...args: infer A) => Promise<infer R> ? ReturnType<typeof async<A, Promise<R>>> : T extends Record<PropertyKey, unknown> ? ReturnType<typeof object<T>> : T extends unknown[] ? ReturnType<typeof array<T>> : never;
+type Input<T> = T extends (...args: unknown[]) => Promise<unknown> ? T : T extends {
     dispose: any;
 } | {
     signals: any;

package/build/reactive/index.js

@@ -1,5 +1,4 @@
-import { isArray, isAsyncFunction, isFunction, isObject } from '@esportsplus/utilities';
-import { computed } from '../signal.js';
+import { isArray, isAsyncFunction, isObject } from '@esportsplus/utilities';
 import array from './array.js';
 import async from './async.js';
 import object from './object.js';
@@ -10,10 +9,6 @@ export default (input) => {
     else if (isAsyncFunction(input)) {
         return async(input);
     }
-    else if (isFunction(input)) {
-        computed(input);
-        return undefined;
-    }
     else if (isObject(input)) {
         return object(input);
     }

package/build/reactive/object.js

@@ -1,6 +1,6 @@
 import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf } from '@esportsplus/utilities';
 import array from './array.js';
-import { computed, dispose, read, signal } from '../signal.js';
+import { computed, dispose, read, signal } from '../system.js';
 import { Disposable } from './disposable.js';
 import async from './async.js';
 let { set } = signal;

package/build/{signal.d.ts → system.d.ts}

@@ -1,6 +1,7 @@
 import { Computed, Signal } from './types.js';
 declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
 declare const dispose: <T>(computed: Computed<T>) => void;
+declare const effect: <T>(fn: Computed<T>["fn"]) => void;
 declare const isComputed: (value: unknown) => value is Computed<unknown>;
 declare const isSignal: (value: unknown) => value is Signal<unknown>;
 declare const onCleanup: (fn: VoidFunction) => typeof fn;
@@ -11,4 +12,4 @@ declare const signal: {
     set<T>(signal: Signal<T>, value: T): void;
 };
 declare const stabilize: () => void;
-export { computed, dispose, isComputed, isSignal, onCleanup, read, root, signal, stabilize };
+export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, stabilize };

package/build/{signal.js → system.js}

@@ -1,6 +1,6 @@
 import { defineProperty, isArray, isObject } from '@esportsplus/utilities';
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-let heap = new Array(2000), iHeap = 0, nHeap = 0, notifiedHeap = false, observer = null, scheduled = false, scheduler = null;
+let depth = 0, heap = new Array(2000), index = 0, length = 0, notified = false, observer = null, scheduled = false, scheduler = null, version = 0;
 function cleanup(node) {
     if (!node.cleanup) {
         return;
@@ -55,8 +55,8 @@ function insertIntoHeap(computed) {
         computed.prevHeap = tail;
         heapAtHeight.prevHeap = computed;
     }
-    if (height > nHeap) {
-        nHeap = height;
+    if (height > length) {
+        length = height;
         if (height >= heap.length) {
             heap.length += 250;
         }
@@ -71,17 +71,25 @@ function link(dep, sub) {
     if (sub.state & STATE_RECOMPUTING) {
         nextDep = prevDep !== null ? prevDep.nextDep : sub.deps;
         if (nextDep !== null && nextDep.dep === dep) {
+            nextDep.version = version;
             sub.depsTail = nextDep;
             return;
         }
     }
-    let prevSub = dep.subsTail, newLink = sub.depsTail =
+    let prevSub = dep.subsTail;
+    if (prevSub !== null &&
+        prevSub.version === version &&
+        prevSub.sub === sub) {
+        return;
+    }
+    let newLink = sub.depsTail =
         dep.subsTail = {
             dep,
             sub,
             nextDep,
             prevSub,
             nextSub: null,
+            version
         };
     if (prevDep !== null) {
         prevDep.nextDep = newLink;
@@ -119,6 +127,8 @@ function recompute(computed, del) {
     observer = computed;
     computed.depsTail = null;
     computed.state = STATE_RECOMPUTING;
+    depth++;
+    version++;
     try {
         value = computed.fn(onCleanup);
     }
@@ -149,16 +159,18 @@ function recompute(computed, del) {
             insertIntoHeap(o);
         }
     }
-    if (!scheduled && scheduler) {
-        scheduled = true;
-        scheduler(stabilize);
-    }
-    else {
-        throw new Error('@esportsplus/reactivity: stabilize.scheduler has not been set to process updates.');
+    if (!--depth) {
+        if (!scheduled && scheduler) {
+            scheduled = true;
+            scheduler(stabilize);
+        }
+        else {
+            throw new Error('@esportsplus/reactivity: stabilize.scheduler has not been set to process updates.');
+        }
     }
 }
 function unlink(link) {
-    let dep = link.dep, nextDep = link.nextDep, nextSub = link.nextSub, prevSub = link.prevSub;
+    let { dep, nextDep, nextSub, prevSub } = link;
     if (nextSub !== null) {
         nextSub.prevSub = prevSub;
     }
@@ -234,6 +246,9 @@ const dispose = (computed) => {
     computed.deps = null;
     cleanup(computed);
 };
+const effect = (fn) => {
+    computed(fn);
+};
 const isComputed = (value) => {
     return isObject(value) && REACTIVE in value && 'fn' in value;
 };
@@ -264,11 +279,11 @@ const read = (node) => {
             if (height >= observer.height) {
                 observer.height = height + 1;
             }
-            if (height >= iHeap ||
+            if (height >= index ||
                 node.state & (STATE_DIRTY | STATE_CHECK)) {
-                if (!notifiedHeap) {
-                    notifiedHeap = true;
-                    for (let i = 0; i <= nHeap; i++) {
+                if (!notified) {
+                    notified = true;
+                    for (let i = 0; i <= length; i++) {
                         for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
                             notify(computed);
                         }
@@ -299,7 +314,7 @@ signal.set = (signal, value) => {
     if (signal.value === value) {
         return;
     }
-    notifiedHeap = false;
+    notified = false;
     signal.value = value;
     for (let link = signal.subs; link !== null; link = link.nextSub) {
         insertIntoHeap(link.sub);
@@ -307,9 +322,9 @@ signal.set = (signal, value) => {
 };
 const stabilize = () => {
     root(() => {
-        for (iHeap = 0; iHeap <= nHeap; iHeap++) {
-            let computed = heap[iHeap];
-            heap[iHeap] = undefined;
+        for (index = 0; index <= length; index++) {
+            let computed = heap[index];
+            heap[index] = undefined;
             while (computed !== undefined) {
                 let next = computed.nextHeap;
                 recompute(computed, false);
@@ -327,4 +342,4 @@ defineProperty(stabilize, 'scheduler', {
         scheduler = s;
     },
 });
-export { computed, dispose, isComputed, isSignal, onCleanup, read, root, signal, stabilize };
+export { computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, stabilize };

package/build/types.d.ts

@@ -1,5 +1,5 @@
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-import { onCleanup } from './signal.js';
+import { onCleanup } from './system.js';
 import { ReactiveArray } from './reactive/array.js';
 import { ReactiveObject } from './reactive/object.js';
 interface Computed<T> extends Signal<T> {
@@ -22,6 +22,7 @@ interface Link {
     nextDep: Link | null;
     nextSub: Link | null;
     prevSub: Link | null;
+    version: number;
 }
 type Reactive<T> = T extends Record<PropertyKey, unknown> ? ReactiveObject<T> : ReactiveArray<T>;
 type Signal<T> = {

package/package.json

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

package/src/index.ts

@@ -1,3 +1,3 @@
 export { default as reactive } from './reactive';
-export * from './signal';
+export * from './system';
 export * from './types';

package/src/reactive/array.ts

@@ -1,5 +1,5 @@
 import { isFunction, isInstanceOf, isNumber, isObject } from '@esportsplus/utilities';
-import { computed, dispose, isComputed, read } from '~/signal';
+import { computed, dispose, isComputed, read } from '~/system';
 import { Computed, Infer } from '~/types';
 import object, { ReactiveObject } from './object';
 import { Disposable } from './disposable';

package/src/reactive/async.ts

@@ -1,5 +1,5 @@
 import CustomFunction from '@esportsplus/custom-function';
-import { read, root, signal } from '~/signal';
+import { read, root, signal } from '~/system';
 import { Signal } from '~/types';
 
 

package/src/reactive/index.ts

@@ -1,6 +1,4 @@
-import { isArray, isAsyncFunction, isFunction, isObject } from '@esportsplus/utilities';
-import { computed } from '~/signal';
-import { Computed } from '~/types';
+import { isArray, isAsyncFunction, isObject } from '@esportsplus/utilities';
 import array from './array';
 import async from './async';
 import object from './object';
@@ -9,24 +7,20 @@ import object from './object';
 type API<T> =
     T extends (...args: infer A) => Promise<infer R>
         ? ReturnType<typeof async<A, Promise<R>>>
-        : T extends (...args: unknown[]) => unknown
-            ? void
-            : T extends Record<PropertyKey, unknown>
-                ? ReturnType<typeof object<T>>
-                : T extends unknown[]
-                    ? ReturnType<typeof array<T>>
-                    : never;
+        : T extends Record<PropertyKey, unknown>
+            ? ReturnType<typeof object<T>>
+            : T extends unknown[]
+                ? ReturnType<typeof array<T>>
+                : never;
 
 type Input<T> =
     T extends (...args: unknown[]) => Promise<unknown>
         ? T
-        : T extends (...args: unknown[]) => unknown
-            ? Computed<T>['fn']
-            : T extends { dispose: any } | { signals: any }
-                ? { never: '[ dispose, signals ] are reserved keys' }
-                : T extends Record<PropertyKey, unknown> | unknown[]
-                    ? T
-                    : 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> => {
@@ -36,10 +30,6 @@ export default <T>(input: Input<T>): API<T> => {
     else if (isAsyncFunction(input)) {
         return async(input) as API<T>;
     }
-    else if (isFunction(input)) {
-        computed(input as Computed<T>['fn']);
-        return undefined as API<T>;
-    }
     else if (isObject(input)) {
         return object(input) as API<T>;
     }

package/src/reactive/object.ts

@@ -1,6 +1,6 @@
 import { defineProperty, isArray, isAsyncFunction, isFunction, isInstanceOf, Prettify } from '@esportsplus/utilities';
 import array, { ReactiveArray } from './array';
-import { computed, dispose, read, signal } from '~/signal';
+import { computed, dispose, read, signal } from '~/system';
 import { Computed, Infer, Signal } from '~/types';
 import { Disposable } from './disposable';
 import async from './async';

package/src/{signal.ts → system.ts}

@@ -3,13 +3,15 @@ import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RE
 import { Computed, Link, Signal, } from './types';
 
 
-let heap: (Computed<unknown> | undefined)[] = new Array(2000),
-    iHeap = 0,
-    nHeap = 0,
-    notifiedHeap = false,
+let depth = 0,
+    heap: (Computed<unknown> | undefined)[] = new Array(2000),
+    index = 0,
+    length = 0,
+    notified = false,
     observer: Computed<unknown> | null = null,
     scheduled = false,
-    scheduler: ((task: VoidFunction) => void) | null = null;
+    scheduler: ((task: VoidFunction) => void) | null = null,
+    version = 0;
 
 
 function cleanup<T>(node: Computed<T>): void {
@@ -87,8 +89,8 @@ function insertIntoHeap<T>(computed: Computed<T>) {
         heapAtHeight.prevHeap = computed;
     }
 
-    if (height > nHeap) {
-        nHeap = height;
+    if (height > length) {
+        length = height;
 
         // Simple auto adjust to avoid manual management within apps.
         if (height >= heap.length) {
@@ -111,13 +113,24 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
         nextDep = prevDep !== null ? prevDep.nextDep : sub.deps;
 
         if (nextDep !== null && nextDep.dep === dep) {
+            nextDep.version = version;
             sub.depsTail = nextDep;
             return;
         }
     }
 
-    let prevSub = dep.subsTail,
-        newLink =
+    let prevSub = dep.subsTail;
+
+    // https://github.com/stackblitz/alien-signals/commit/54fe1b3947fac5c0aecb73b0b0eaff000806c454
+    if (
+        prevSub !== null &&
+        prevSub.version === version &&
+        prevSub.sub === sub
+    ) {
+        return;
+    }
+
+    let newLink =
             sub.depsTail =
                 dep.subsTail = {
                     dep,
@@ -125,6 +138,7 @@ function link<T>(dep: Signal<T> | Computed<T>, sub: Computed<T>) {
                     nextDep,
                     prevSub,
                     nextSub: null,
+                    version
                 };
 
     if (prevDep !== null) {
@@ -175,6 +189,9 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
     computed.depsTail = null;
     computed.state = STATE_RECOMPUTING;
 
+    depth++;
+    version++;
+
     try {
         value = computed.fn(onCleanup);
     }
@@ -217,21 +234,20 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
         }
     }
 
-    if (!scheduled && scheduler) {
-        scheduled = true;
-        scheduler(stabilize);
-    }
-    else {
-        throw new Error('@esportsplus/reactivity: stabilize.scheduler has not been set to process updates.');
+    if (!--depth) {
+        if (!scheduled && scheduler) {
+            scheduled = true;
+            scheduler(stabilize);
+        }
+        else {
+            throw new Error('@esportsplus/reactivity: stabilize.scheduler has not been set to process updates.');
+        }
     }
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlink(link: Link): Link | null {
-    let dep = link.dep,
-        nextDep = link.nextDep,
-        nextSub = link.nextSub,
-        prevSub = link.prevSub;
+    let { dep, nextDep, nextSub, prevSub } = link;
 
     if (nextSub !== null) {
         nextSub.prevSub = prevSub;
@@ -328,6 +344,10 @@ const dispose = <T>(computed: Computed<T>) => {
     cleanup(computed);
 };
 
+const effect = <T>(fn: Computed<T>['fn']) => {
+    computed(fn);
+};
+
 const isComputed = (value: unknown): value is Computed<unknown> => {
     return isObject(value) && REACTIVE in value && 'fn' in value;
 };
@@ -368,13 +388,13 @@ const read = <T>(node: Signal<T> | Computed<T>): T => {
             }
 
             if (
-                height >= iHeap ||
+                height >= index ||
                 node.state & (STATE_DIRTY | STATE_CHECK)
             ) {
-                if (!notifiedHeap) {
-                    notifiedHeap = true;
+                if (!notified) {
+                    notified = true;
 
-                    for (let i = 0; i <= nHeap; i++) {
+                    for (let i = 0; i <= length; i++) {
                         for (let computed = heap[i]; computed !== undefined; computed = computed.nextHeap) {
                             notify(computed);
                         }
@@ -415,7 +435,7 @@ signal.set = <T>(signal: Signal<T>, value: T) => {
         return;
     }
 
-    notifiedHeap = false;
+    notified = false;
     signal.value = value;
 
     for (let link = signal.subs; link !== null; link = link.nextSub) {
@@ -425,10 +445,10 @@ signal.set = <T>(signal: Signal<T>, value: T) => {
 
 const stabilize = () => {
     root(() => {
-        for (iHeap = 0; iHeap <= nHeap; iHeap++) {
-            let computed = heap[iHeap];
+        for (index = 0; index <= length; index++) {
+            let computed = heap[index];
 
-            heap[iHeap] = undefined;
+            heap[index] = undefined;
 
             while (computed !== undefined) {
                 let next = computed.nextHeap;
@@ -456,6 +476,7 @@ defineProperty(stabilize, 'scheduler', {
 export {
     computed,
     dispose,
+    effect,
     isComputed, isSignal,
     onCleanup,
     read, root,

package/src/types.ts

@@ -1,5 +1,5 @@
 import { REACTIVE, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants';
-import { onCleanup } from './signal';
+import { onCleanup } from './system';
 import { ReactiveArray } from './reactive/array';
 import { ReactiveObject } from './reactive/object';
 
@@ -38,6 +38,7 @@ interface Link {
     nextDep: Link | null;
     nextSub: Link | null;
     prevSub: Link | null;
+    version: number;
 }
 
 type Reactive<T> = T extends Record<PropertyKey, unknown>