@esportsplus/reactivity 0.34.0 → 0.36.0

package/build/constants.js

@@ -3,11 +3,11 @@ const PACKAGE_NAME = '@esportsplus/reactivity';
 const REACTIVE_ARRAY = Symbol('reactivity.reactive.array');
 const REACTIVE_OBJECT = Symbol('reactivity.reactive.object');
 const SIGNAL = Symbol('reactivity.signal');
+const STABILIZER_DEFERRED = 4;
 const STABILIZER_IDLE = 0;
 const STABILIZER_RESCHEDULE = 1;
 const STABILIZER_RUNNING = 2;
 const STABILIZER_SCHEDULED = 3;
-const STATE_NONE = 0;
 const STATE_CHECK = 1 << 0;
 const STATE_DIRTY = 1 << 1;
 const STATE_RECOMPUTING = 1 << 2;
@@ -16,4 +16,4 @@ const STATE_COMPUTED = 1 << 4;
 const STATE_ERROR = 1 << 5;
 const STATE_EFFECT = 1 << 6;
 const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
-export { COMPUTED, PACKAGE_NAME, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+export { COMPUTED, PACKAGE_NAME, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING };

package/build/reactive/array.d.ts

@@ -40,7 +40,7 @@ type Listeners<T> = {
 declare class ReactiveArray<T> extends Array<T> {
     private _length;
     listeners: Listeners<T>;
-    constructor(...items: T[]);
+    constructor(items?: readonly T[]);
     static get [Symbol.species](): ArrayConstructor;
     get $length(): number;
     set $length(value: number);

package/build/reactive/array.js

@@ -1,5 +1,5 @@
 import { isArray } from '@esportsplus/utilities';
-import { REACTIVE_ARRAY } from '../constants.js';
+import { PACKAGE_NAME, REACTIVE_ARRAY } from '../constants.js';
 import { read, signal, write } from '../system.js';
 import { isReactiveObject } from './object.js';
 function dispose(value) {
@@ -10,9 +10,13 @@ function dispose(value) {
 class ReactiveArray extends Array {
     _length;
     listeners = {};
-    constructor(...items) {
-        super(...items);
-        this._length = signal(items.length);
+    constructor(items) {
+        super();
+        let n = items ? items.length : 0;
+        for (let i = 0; i < n; i++) {
+            this[i] = items[i];
+        }
+        this._length = signal(n);
     }
     static get [Symbol.species]() {
         return Array;
@@ -37,6 +41,7 @@ class ReactiveArray extends Array {
             write(this._length, i + 1);
         }
         this.dispatch('set', { index: i, item: value });
+        dispose(prev);
     }
     clear() {
         this.dispose();
@@ -69,7 +74,7 @@ class ReactiveArray extends Array {
         if (!listeners) {
             return;
         }
-        let dirty = false;
+        let dirty = false, errors = null;
         for (let i = 0, n = listeners.length; i < n; i++) {
             let listener = listeners[i];
             if (listener === null) {
@@ -82,9 +87,10 @@ class ReactiveArray extends Array {
                     listeners[i] = null;
                 }
             }
-            catch {
+            catch (e) {
                 dirty = true;
                 listeners[i] = null;
+                (errors ??= []).push(e);
             }
         }
         if (dirty) {
@@ -92,6 +98,14 @@ class ReactiveArray extends Array {
                 listeners.pop();
             }
         }
+        if (errors !== null) {
+            let error = errors.length === 1
+                ? errors[0]
+                : new AggregateError(errors, `${PACKAGE_NAME}: dispatch produced multiple errors`);
+            queueMicrotask(() => {
+                throw error;
+            });
+        }
     }
     dispose() {
         while (this.length) {
@@ -169,20 +183,17 @@ class ReactiveArray extends Array {
             super.sort(fn);
             let buckets = new Map(), order = new Array(n);
             for (let i = 0; i < n; i++) {
-                let value = before[i], list = buckets.get(value);
-                if (!list) {
-                    buckets.set(value, [i]);
+                let value = before[i], bucket = buckets.get(value);
+                if (bucket === undefined) {
+                    buckets.set(value, { indices: [i], next: 0 });
                 }
                 else {
-                    list.push(i);
+                    bucket.indices.push(i);
                 }
             }
             for (let i = 0; i < n; i++) {
-                let list = buckets.get(this[i]);
-                order[i] = list.length === 1 ? list[0] : list[list.length - 1];
-                if (list.length > 1) {
-                    list.pop();
-                }
+                let bucket = buckets.get(this[i]);
+                order[i] = bucket.indices[bucket.next++];
             }
             this.dispatch('sort', { order });
         }

package/build/reactive/index.js

@@ -4,25 +4,16 @@ import { PACKAGE_NAME } from '../constants.js';
 import { ReactiveArray } from './array.js';
 import { ReactiveObject } from './object.js';
 function reactive(input) {
-    let dispose = false, value = root(() => {
-        let response;
+    let value = root(() => {
         if (isObject(input)) {
-            response = new ReactiveObject(input);
+            return new ReactiveObject(input);
         }
-        else if (isArray(input)) {
-            response = new ReactiveArray(...input);
-        }
-        if (response) {
-            if (root.disposables) {
-                dispose = true;
-            }
-            return response;
+        if (isArray(input)) {
+            return new ReactiveArray(input);
         }
         throw new Error(`${PACKAGE_NAME}: 'reactive' received invalid input - ${JSON.stringify(input)}`);
     });
-    if (dispose) {
-        onCleanup(() => value.dispose());
-    }
+    onCleanup(() => value.dispose());
     return value;
 }
 export default reactive;

package/build/reactive/object.js

@@ -46,7 +46,7 @@ class ReactiveObject {
         });
     }
     [REACTIVE_ARRAY](value) {
-        let node = new ReactiveArray(...value);
+        let node = new ReactiveArray(value);
         (this.disposers ??= []).push(() => node.dispose());
         return node;
     }

package/build/system.d.ts

@@ -12,10 +12,7 @@ declare const isSignal: (value: unknown) => value is Signal<unknown>;
 declare const onCleanup: (fn: VoidFunction) => typeof fn;
 declare const peek: <T>(node: Signal<T> | Computed<T>) => T;
 declare const read: <T>(node: Signal<T> | Computed<T>) => T;
-declare function root<T>(fn: ((dispose: VoidFunction) => T) | (() => T)): T;
-declare namespace root {
-    var disposables: number;
-}
+declare const root: <T>(fn: ((dispose: VoidFunction) => T) | (() => T)) => T;
 declare function signal<T>(value: T, equals?: ((a: T, b: T) => boolean) | null): Signal<T>;
 declare namespace signal {
     var selector: <T>(node: Signal<T>, key: T) => boolean;

package/build/system.js

@@ -1,6 +1,8 @@
-import { PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
+import { PACKAGE_NAME, SIGNAL, STABILIZER_DEFERRED, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
 import { isObject, isPromise } from '@esportsplus/utilities';
-let asyncMeta = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
+let asyncMeta = new WeakMap(), depth = 0, disposeHead = null, draining = false, heap = new Array(64), heap_i = 0, heap_n = 0, linkPoolHead = null, microtask = queueMicrotask, notified = false, observer = null, pendingHead = null, pulled = null, puller = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0, walkPoolHead = null, writes = 0;
+function noop() {
+}
 function walkPop(walk) {
     let prev = walk.prev;
     walk.computed = null;
@@ -105,6 +107,9 @@ function insertIntoHeap(computed) {
             heap.length = Math.max(height + 1, Math.ceil(heap.length * 2));
         }
     }
+    else if (height < heap_i) {
+        stabilizer = STABILIZER_RESCHEDULE;
+    }
 }
 function link(dep, sub) {
     if (dep.rv === version) {
@@ -204,12 +209,24 @@ function pull(node) {
     }
     let o = observer;
     observer = null;
+    pulled = node;
+    puller = o;
     update(node);
     observer = o;
+    pulled = null;
+    puller = null;
 }
 function propagate(computed) {
-    for (let c = computed.subs; c; c = c.nextSub) {
+    let c = computed.subs;
+    if (c === null) {
+        return;
+    }
+    let skip = computed === pulled ? puller : null;
+    for (; c; c = c.nextSub) {
         let s = c.sub, state = s.state;
+        if (s === skip) {
+            continue;
+        }
         if (state & STATE_CHECK) {
             s.state = state | STATE_DIRTY;
         }
@@ -217,14 +234,10 @@ function propagate(computed) {
     }
     schedule();
 }
-function recompute(computed, del) {
-    if (del) {
+function recompute(computed) {
+    if (computed.state & STATE_IN_HEAP) {
         deleteFromHeap(computed);
     }
-    else {
-        computed.nextHeap = undefined;
-        computed.prevHeap = computed;
-    }
     if (computed.cleanup) {
         try {
             cleanup(computed);
@@ -251,7 +264,7 @@ function recompute(computed, del) {
     depth--;
     version++;
     observer = o;
-    computed.state = STATE_COMPUTED | flags;
+    computed.state = STATE_COMPUTED | flags | (computed.state & STATE_IN_HEAP);
     computed.gv = w;
     let depsTail = computed.depsTail, remove = depsTail ? depsTail.nextDep : computed.deps;
     if (remove) {
@@ -287,46 +300,44 @@ function recompute(computed, del) {
             propagate(computed);
         }
     }
+    if (!depth && stabilizer === STABILIZER_DEFERRED) {
+        stabilizer = STABILIZER_SCHEDULED;
+        microtask(stabilize);
+    }
 }
 function schedule() {
-    if (stabilizer === STABILIZER_SCHEDULED) {
+    if (stabilizer !== STABILIZER_IDLE) {
         return;
     }
-    if (stabilizer === STABILIZER_IDLE && !depth) {
+    if (depth) {
+        stabilizer = STABILIZER_DEFERRED;
+    }
+    else {
         stabilizer = STABILIZER_SCHEDULED;
         microtask(stabilize);
     }
-    else if (stabilizer === STABILIZER_RUNNING) {
-        stabilizer = STABILIZER_RESCHEDULE;
-    }
 }
 function stabilize() {
     let o = observer;
     observer = null;
-    stabilizer = STABILIZER_RUNNING;
-    for (heap_i = 0; heap_i <= heap_n; heap_i++) {
-        if (pendingHead !== null) {
-            drainPending();
+    do {
+        stabilizer = STABILIZER_RUNNING;
+        for (heap_i = 0; heap_i <= heap_n; heap_i++) {
+            if (pendingHead !== null) {
+                drainPending();
+            }
+            let computed;
+            while ((computed = heap[heap_i]) !== undefined) {
+                recompute(computed);
+            }
         }
-        let computed = heap[heap_i];
-        heap[heap_i] = undefined;
-        while (computed !== undefined) {
-            let next = computed.nextHeap;
-            recompute(computed, false);
-            computed = next;
+        while (heap_n > 0 && heap[heap_n] === undefined) {
+            heap_n--;
         }
-    }
-    while (heap_n > 0 && heap[heap_n] === undefined) {
-        heap_n--;
-    }
+        heap_i = 0;
+    } while (pendingHead !== null || stabilizer === STABILIZER_RESCHEDULE);
+    stabilizer = STABILIZER_IDLE;
     observer = o;
-    if (stabilizer === STABILIZER_RESCHEDULE) {
-        stabilizer = STABILIZER_SCHEDULED;
-        microtask(stabilize);
-    }
-    else {
-        stabilizer = STABILIZER_IDLE;
-    }
 }
 function unlink(link) {
     let dep = link.dep, nextDep = link.nextDep, nextSub = link.nextSub, prevSub = link.prevSub;
@@ -369,7 +380,7 @@ function update(root) {
                 resuming = true;
             }
             else if (node.state & STATE_DIRTY) {
-                recompute(node, true);
+                recompute(node);
                 node.state &= ~STATE_NOTIFY_MASK;
             }
             else {
@@ -394,7 +405,7 @@ function update(root) {
                 continue;
             }
             if (node.state & STATE_DIRTY) {
-                recompute(node, true);
+                recompute(node);
             }
             else {
                 node.gv = w;
@@ -414,18 +425,23 @@ function update(root) {
 function makeAsyncComputed(factory) {
     let error = signal(undefined), node = signal(undefined), pending = signal(false), v = 0;
     let stop = effect(() => {
-        let fail = (e) => {
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+        let id = ++v, stale = () => {
+            if (pendingHead !== null) {
+                drainPending();
+            }
+            return id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK)) !== 0;
+        }, fail = (e) => {
+            if (!stale()) {
                 write(error, e === undefined ? new Error('reactivity: async computed rejected with undefined') : e);
                 write(pending, false);
             }
-        }, id = ++v, result = read(factory);
+        }, result = read(factory);
         if (isPromise(result)) {
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+            if (!stale()) {
                 write(pending, true);
             }
             result.then((value) => {
-                if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                if (!stale()) {
                     write(error, undefined);
                     write(node, value);
                     write(pending, false);
@@ -438,7 +454,7 @@ function makeAsyncComputed(factory) {
                 it.return?.();
             });
             let step = (r) => {
-                if (id !== v || (factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+                if (stale()) {
                     return;
                 }
                 if (!r.done) {
@@ -451,7 +467,7 @@ function makeAsyncComputed(factory) {
                     write(pending, false);
                 }
             };
-            if (id === v && !(factory.state & (STATE_IN_HEAP | STATE_NOTIFY_MASK))) {
+            if (!stale()) {
                 write(pending, true);
             }
             untrack(() => it.next()).then(step, fail);
@@ -475,33 +491,15 @@ function makeAsyncComputed(factory) {
     return wrapper;
 }
 function makeComputed(fn, eager = false) {
-    let self = {
-        cleanup: null,
-        deps: null,
-        depsTail: null,
-        disposal: null,
-        equals: null,
-        error: null,
-        fn: fn,
-        gv: 0,
-        height: 0,
-        nextHeap: undefined,
-        prevHeap: null,
-        rv: 0,
-        state: STATE_COMPUTED,
-        subs: null,
-        subsTail: null,
-        value: undefined,
-    };
-    self.prevHeap = self;
+    let self = makeNode(fn);
     if (observer) {
         if (observer.depsTail === null) {
             self.height = observer.height;
-            recompute(self, false);
+            recompute(self);
         }
         else if (eager) {
             self.height = observer.height + 1;
-            recompute(self, false);
+            recompute(self);
         }
         else {
             self.height = observer.height + 1;
@@ -512,14 +510,36 @@ function makeComputed(fn, eager = false) {
         onCleanup(() => dispose(self));
     }
     else {
-        recompute(self, false);
-        root.disposables++;
+        recompute(self);
         if (scope) {
             onCleanup(() => dispose(self));
         }
     }
     return self;
 }
+function makeNode(fn) {
+    let self = {
+        cleanup: null,
+        deps: null,
+        depsTail: null,
+        disposal: null,
+        equals: null,
+        error: null,
+        fn,
+        gv: 0,
+        height: 0,
+        nextHeap: undefined,
+        pending: null,
+        prevHeap: null,
+        rv: 0,
+        state: STATE_COMPUTED,
+        subs: null,
+        subsTail: null,
+        value: undefined,
+    };
+    self.prevHeap = self;
+    return self;
+}
 const batch = (fn) => {
     depth++;
     try {
@@ -527,8 +547,9 @@ const batch = (fn) => {
     }
     finally {
         depth--;
-        if (!depth) {
-            schedule();
+        if (!depth && stabilizer === STABILIZER_DEFERRED) {
+            stabilizer = STABILIZER_SCHEDULED;
+            microtask(stabilize);
         }
     }
 };
@@ -610,7 +631,7 @@ const effect = (fn, apply) => {
     };
 };
 const flush = () => {
-    while (stabilizer === STABILIZER_SCHEDULED) {
+    if (stabilizer === STABILIZER_SCHEDULED) {
         stabilize();
     }
 };
@@ -671,26 +692,27 @@ const read = (node) => {
     return node.value;
 };
 const root = (fn) => {
-    let c, d = root.disposables, o = observer, s = scope, self = null, tracking = fn.length, value;
+    let c, o = observer, s = scope, self = null, tracking = fn.length, value;
     observer = null;
-    root.disposables = 0;
-    if (tracking) {
-        scope = self = { cleanup: null, state: STATE_COMPUTED };
-        value = fn(c = () => dispose(self));
+    try {
+        if (tracking) {
+            scope = self = makeNode(noop);
+            value = fn(c = () => dispose(self));
+        }
+        else {
+            scope = null;
+            value = fn();
+        }
     }
-    else {
-        scope = null;
-        value = fn();
+    finally {
+        observer = o;
+        scope = s;
     }
-    observer = o;
-    root.disposables = d;
-    scope = s;
     if (c) {
         onCleanup(c);
     }
     return value;
 };
-root.disposables = 0;
 const signal = (value, equals = null) => {
     return {
         equals: equals,

package/build/types.d.ts

@@ -1,4 +1,3 @@
-import { ts } from '@esportsplus/typescript';
 import { SIGNAL } from './constants.js';
 import { ReactiveArray } from './reactive/index.js';
 interface Computed<T> {
@@ -12,6 +11,7 @@ interface Computed<T> {
     gv: number;
     height: number;
     nextHeap: Computed<unknown> | undefined;
+    pending: Signal<boolean> | null;
     prevHeap: Computed<unknown>;
     rv: number;
     state: number;
@@ -56,9 +56,4 @@ type Signal<T> = {
     type: typeof SIGNAL;
     value: T;
 };
-interface TransformResult {
-    changed: boolean;
-    code: string;
-    sourceFile: ts.SourceFile;
-}
-export type { Computed, ComputedResult, Link, Reactive, SelectorSignal, Settled, Signal, TransformResult };
+export type { Computed, ComputedResult, Link, Reactive, SelectorSignal, Settled, Signal };

package/package.json

@@ -4,10 +4,10 @@
     "@esportsplus/utilities": "^0.28.0"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.31.0",
-    "@types/node": "^26.1.1",
-    "vite": "^8.1.5",
-    "vitest": "^4.1.10"
+    "@esportsplus/typescript": "^0.32.0",
+    "@types/node": "^26.4.1",
+    "vite": "^8.2.2",
+    "vitest": "^4.1.11"
   },
   "exports": {
     ".": {
@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "scripts": {
     "agent:bench": "vitest bench --run",
     "agent:test": "tsc --noEmit && vitest run",

package/pnpm-workspace.yaml

@@ -1,4 +1,5 @@
 allowBuilds:
   esbuild: true
 minimumReleaseAgeExclude:
-  - '@esportsplus/typescript@0.31.0'
+  - '@esportsplus/typescript@0.31.0 || 0.32.0'
+  - tsc-alias@1.9.4