@esportsplus/reactivity 0.31.3 → 0.32.0

package/bench/molbench.bench.ts

@@ -0,0 +1,75 @@
+import { bench, describe } from 'vitest';
+import { assert, framework } from './lib/reactive-adapter';
+
+
+// Ported from milomg/js-reactivity-benchmark packages/core/src/benches/kairo/molBench.ts (MIT)
+
+let numbers = Array.from({ length: 5 }, (_, i) => i);
+
+
+function fib(n: number): number {
+    if (n < 2) {
+        return 1;
+    }
+
+    return fib(n - 1) + fib(n - 2);
+}
+
+function hard(n: number) {
+    return n + fib(16);
+}
+
+function mol() {
+    let res: number[] = [];
+
+    let a = framework.signal(0);
+
+    let b = framework.signal(0);
+
+    let c = framework.computed(() => (a.read() % 2) + (b.read() % 2));
+
+    let d = framework.computed(() => numbers.map((i) => ({ x: i + (a.read() % 2) - (b.read() % 2) })));
+
+    let e = framework.computed(() => hard(c.read() + a.read() + d.read()[0].x));
+
+    let f = framework.computed(() => hard(d.read()[2].x || b.read()));
+
+    let g = framework.computed(() => c.read() + (c.read() || e.read() % 2) + d.read()[4].x + f.read());
+
+    // Keeper: G reads E conditionally; without a live subscriber E would auto-dispose on first drop
+    framework.effect(() => e.read());
+
+    framework.effect(() => res.push(hard(g.read())));
+
+    framework.effect(() => res.push(g.read()));
+
+    framework.effect(() => res.push(hard(f.read())));
+
+    let i = 0;
+
+    return async () => {
+        i++;
+        res.length = 0;
+
+        await framework.withBatch(() => {
+            b.write(1);
+            a.write(1 + i * 2);
+        });
+
+        await framework.withBatch(() => {
+            a.write(2 + i * 2);
+            b.write(2);
+        });
+
+        assert(res.length > 0, 'molBench: effects did not run');
+    };
+}
+
+
+describe('molBench', () => {
+    let molRun = framework.withBuild(mol);
+
+    bench('molBench', async () => {
+        await molRun();
+    });
+});

package/{tests/bench/system.ts → bench/system.bench.ts}

@@ -1,5 +1,5 @@
 import { bench, describe } from 'vitest';
-import { asyncComputed, computed, dispose, effect, onCleanup, read, root, signal, write } from '~/system';
+import { computed, dispose, effect, onCleanup, read, root, signal, write } from '~/system';
 
 
 describe('signal', () => {
@@ -78,13 +78,13 @@ describe('computed', () => {
 
 describe('asyncComputed', () => {
     bench('create asyncComputed', () => {
-        asyncComputed(() => Promise.resolve(0));
+        computed(() => Promise.resolve(0));
     });
 
     bench('create asyncComputed from signal', () => {
         let s = signal(0);
 
-        asyncComputed(() => Promise.resolve(read(s)));
+        computed(() => Promise.resolve(read(s)));
     });
 });
 

package/build/compiler/array.d.ts

@@ -1,5 +1,5 @@
-import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings } from './types.js';
 declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ReplacementIntent[];
 export default _default;

package/build/compiler/constants.d.ts

@@ -1,11 +1,12 @@
 declare const ENTRYPOINT = "reactive";
 declare const ENTRYPOINT_REGEX: RegExp;
 declare const NAMESPACE: string;
-declare const enum TYPES {
-    Array = 0,
-    Computed = 1,
-    Object = 2,
-    Signal = 3
-}
+declare const TYPES: {
+    readonly Array: 0;
+    readonly Computed: 1;
+    readonly Object: 2;
+    readonly Signal: 3;
+};
+type TYPES = typeof TYPES[keyof typeof TYPES];
 export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants.js';

package/build/compiler/constants.js

@@ -2,12 +2,11 @@ import { uid } from '@esportsplus/typescript/compiler';
 const ENTRYPOINT = 'reactive';
 const ENTRYPOINT_REGEX = /\breactive\b/;
 const NAMESPACE = uid('reactivity');
-var TYPES;
-(function (TYPES) {
-    TYPES[TYPES["Array"] = 0] = "Array";
-    TYPES[TYPES["Computed"] = 1] = "Computed";
-    TYPES[TYPES["Object"] = 2] = "Object";
-    TYPES[TYPES["Signal"] = 3] = "Signal";
-})(TYPES || (TYPES = {}));
+const TYPES = {
+    Array: 0,
+    Computed: 1,
+    Object: 2,
+    Signal: 3
+};
 export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };
 export { PACKAGE_NAME } from '../constants.js';

package/build/compiler/object.d.ts

@@ -1,5 +1,5 @@
-import { type ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings } from './types.js';
 type ObjectTransformResult = {
     prepend: string[];

package/build/compiler/object.js

@@ -1,6 +1,5 @@
-import { code, imports } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { uid } from '@esportsplus/typescript/compiler';
+import { code, imports, uid } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {

package/build/compiler/primitives.d.ts

@@ -1,5 +1,5 @@
-import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import type { Bindings } from './types.js';
 declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, isReactiveCall: (node: ts.Node) => boolean) => ReplacementIntent[];
 export default _default;

package/build/constants.d.ts

@@ -13,5 +13,7 @@ declare const STATE_DIRTY: number;
 declare const STATE_RECOMPUTING: number;
 declare const STATE_IN_HEAP: number;
 declare const STATE_COMPUTED: number;
+declare const STATE_ERROR: number;
+declare const STATE_EFFECT: number;
 declare const STATE_NOTIFY_MASK: number;
-export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+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 };

package/build/constants.js

@@ -13,5 +13,7 @@ const STATE_DIRTY = 1 << 1;
 const STATE_RECOMPUTING = 1 << 2;
 const STATE_IN_HEAP = 1 << 3;
 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, REACTIVE_ARRAY, REACTIVE_OBJECT, PACKAGE_NAME, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING };
+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 };

package/build/reactive/array.d.ts

@@ -33,18 +33,19 @@ type Listener<V> = {
     once?: boolean;
     (value: V): void;
 };
-type Listeners = Record<string, (Listener<any> | null)[]>;
+type AnyListener<T> = Listener<Events<T>[keyof Events<T>]>;
+type Listeners<T> = {
+    [K in keyof Events<T>]?: (AnyListener<T> | null)[];
+};
 declare class ReactiveArray<T> extends Array<T> {
     private _length;
-    listeners: Listeners;
+    listeners: Listeners<T>;
     constructor(...items: T[]);
-    get $length(): number;
-    set $length(value: number);
     $set(i: number, value: T): void;
     clear(): void;
     concat(...items: ConcatArray<T>[]): ReactiveArray<T>;
     concat(...items: (T | ConcatArray<T>)[]): ReactiveArray<T>;
-    dispatch<K extends keyof Events<T>, V>(event: K, value?: V): void;
+    dispatch<K extends keyof Events<T>>(event: K, value?: Events<T>[K]): void;
     dispose(): void;
     on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
     once<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>): void;
@@ -55,5 +56,7 @@ declare class ReactiveArray<T> extends Array<T> {
     sort(fn?: (a: T, b: T) => number): this;
     splice(start: number, deleteCount?: number, ...items: T[]): T[];
     unshift(...items: T[]): number;
+    get $length(): number;
+    set $length(value: number);
 }
 export { ReactiveArray };

package/build/reactive/array.js

@@ -1,6 +1,6 @@
 import { isArray } from '@esportsplus/utilities';
-import { read, signal, write } from '../system.js';
 import { REACTIVE_ARRAY } from '../constants.js';
+import { read, signal, write } from '../system.js';
 import { isReactiveObject } from './object.js';
 function dispose(value) {
     if (isReactiveObject(value)) {
@@ -14,15 +14,6 @@ class ReactiveArray extends Array {
         super(...items);
         this._length = signal(items.length);
     }
-    get $length() {
-        return read(this._length);
-    }
-    set $length(value) {
-        if (value > this.length) {
-            throw Error(`@esportsplus/reactivity: cannot set length to a value larger than the current length, use splice instead.`);
-        }
-        this.splice(value, this.length);
-    }
     $set(i, value) {
         let prev = this[i];
         if (prev === value) {
@@ -97,22 +88,22 @@ class ReactiveArray extends Array {
         write(this._length, 0);
     }
     on(event, listener) {
-        let listeners = this.listeners[event];
+        let entry = listener, listeners = this.listeners[event];
         if (listeners === undefined) {
-            this.listeners[event] = [listener];
+            this.listeners[event] = [entry];
         }
         else {
             let hole = listeners.length;
             for (let i = 0, n = hole; i < n; i++) {
                 let l = listeners[i];
-                if (l === listener) {
+                if (l === entry) {
                     return;
                 }
                 else if (l === null && hole === n) {
                     hole = i;
                 }
             }
-            listeners[hole] = listener;
+            listeners[hole] = entry;
             while (listeners.length && listeners[listeners.length - 1] === null) {
                 listeners.pop();
             }
@@ -200,6 +191,15 @@ class ReactiveArray extends Array {
         this.dispatch('unshift', { items });
         return length;
     }
+    get $length() {
+        return read(this._length);
+    }
+    set $length(value) {
+        if (value > this.length) {
+            throw Error(`@esportsplus/reactivity: cannot set length to a value larger than the current length, use splice instead.`);
+        }
+        this.splice(value, this.length);
+    }
 }
 Object.defineProperty(ReactiveArray.prototype, REACTIVE_ARRAY, { value: true });
 export { ReactiveArray };

package/build/reactive/index.d.ts

@@ -1,8 +1,8 @@
-import { Reactive } from '../types.js';
+import type { Reactive } from '../types.js';
 import { ReactiveArray } from './array.js';
 import { ReactiveObject } from './object.js';
 type Guard<T> = T extends Record<PropertyKey, unknown> ? T extends {
-    dispose: any;
+    dispose: unknown;
 } ? {
     never: '[ dispose ] is a reserved key';
 } : T : never;

package/build/reactive/index.js

@@ -1,8 +1,8 @@
 import { onCleanup, root } from '@esportsplus/reactivity';
 import { isArray, isObject } from '@esportsplus/utilities';
+import { PACKAGE_NAME } from '../constants.js';
 import { ReactiveArray } from './array.js';
 import { ReactiveObject } from './object.js';
-import { PACKAGE_NAME } from '../constants.js';
 function reactive(input) {
     let dispose = false, value = root(() => {
         let response;

package/build/reactive/object.d.ts

@@ -1,13 +1,13 @@
-import { Computed, Signal } from '../types.js';
 import { COMPUTED, REACTIVE_ARRAY, SIGNAL } from '../constants.js';
+import { Computed } from '../types.js';
 import { ReactiveArray } from './array.js';
 declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     protected disposers: VoidFunction[] | null;
     constructor(data: T | null);
+    protected [COMPUTED]<T extends Computed<ReturnType<T>>['fn']>(value: T): Computed<import("../types.js").Settled<ReturnType<T>>>;
     protected [REACTIVE_ARRAY]<U>(value: U[]): ReactiveArray<U>;
-    protected [COMPUTED]<T extends Computed<ReturnType<T>>['fn']>(value: T): Computed<ReturnType<T>> | Signal<ReturnType<T> | undefined>;
-    protected [SIGNAL]<T>(value: T): Signal<T>;
+    protected [SIGNAL]<T>(value: T): import("../types.js").Signal<T>;
     dispose(): void;
 }
-declare const isReactiveObject: (value: any) => value is ReactiveObject<any>;
+declare const isReactiveObject: (value: unknown) => value is ReactiveObject<Record<PropertyKey, unknown>>;
 export { isReactiveObject, ReactiveObject };

package/build/reactive/object.js

@@ -1,6 +1,6 @@
-import { defineProperty, isArray, isPromise } from '@esportsplus/utilities';
-import { computed, dispose, effect, read, root, signal, write } from '../system.js';
+import { defineProperty, isArray } from '@esportsplus/utilities';
 import { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from '../constants.js';
+import { computed, dispose, read, root, signal, write } from '../system.js';
 import { ReactiveArray } from './array.js';
 class ReactiveObject {
     disposers = null;
@@ -19,9 +19,7 @@ class ReactiveObject {
                 });
                 continue;
             }
-            if (value == null || type !== 'object') {
-            }
-            else if (isArray(value)) {
+            if (value != null && type === 'object' && isArray(value)) {
                 defineProperty(this, key, {
                     enumerable: true,
                     value: this[REACTIVE_ARRAY](value)
@@ -40,31 +38,18 @@ class ReactiveObject {
             });
         }
     }
-    [REACTIVE_ARRAY](value) {
-        let node = new ReactiveArray(...value);
-        (this.disposers ??= []).push(() => node.dispose());
-        return node;
-    }
     [COMPUTED](value) {
         return root(() => {
             let node = computed(value);
-            if (isPromise(node.value)) {
-                let factory = node, out = signal(undefined), v = 0;
-                (this.disposers ??= []).push(effect(() => {
-                    let id = ++v;
-                    read(factory).then((resolved) => {
-                        if (id !== v) {
-                            return;
-                        }
-                        write(out, resolved);
-                    });
-                }));
-                return out;
-            }
             (this.disposers ??= []).push(() => dispose(node));
             return node;
         });
     }
+    [REACTIVE_ARRAY](value) {
+        let node = new ReactiveArray(...value);
+        (this.disposers ??= []).push(() => node.dispose());
+        return node;
+    }
     [SIGNAL](value) {
         return signal(value);
     }

package/build/system.d.ts

@@ -1,17 +1,26 @@
-import { Computed, Signal } from './types.js';
-declare const asyncComputed: <T>(fn: Computed<Promise<T>>["fn"]) => Signal<T | undefined>;
-declare const computed: <T>(fn: Computed<T>["fn"]) => Computed<T>;
+import { Computed, Settled, Signal } from './types.js';
+declare const batch: <T>(fn: () => T) => T;
+declare const computed: {
+    <T>(fn: Computed<T>["fn"], equals?: ((a: Settled<T>, b: Settled<T>) => boolean) | null): Computed<Settled<T>>;
+    invalidate<T>(c: Computed<T>): void;
+};
 declare const dispose: <T>(computed: Computed<T>) => void;
-declare const effect: <T>(fn: Computed<T>["fn"]) => () => void;
+declare const effect: <T>(fn: Computed<T>["fn"], onError?: (e: unknown) => void) => () => void;
+declare const flush: () => 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;
+declare const peek: <T>(node: Signal<T> | Computed<T>) => T;
 declare const read: <T>(node: Signal<T> | Computed<T>) => T;
 declare const root: {
     <T>(fn: ((dispose: VoidFunction) => T) | (() => T)): T;
     disposables: number;
 };
-declare const signal: <T>(value: T) => Signal<T>;
+declare const signal: {
+    <T>(value: T, equals?: ((a: T, b: T) => boolean) | null): Signal<T>;
+    selector<T>(node: Signal<T>, key: T): boolean;
+};
+declare const untrack: <T>(fn: () => T) => T;
 declare const write: <T>(signal: Signal<T>, value: T) => void;
-export { asyncComputed, computed, dispose, effect, isComputed, isSignal, onCleanup, read, root, signal, write };
+export { batch, computed, dispose, effect, flush, isComputed, isSignal, onCleanup, peek, read, root, signal, untrack, write };
 export type { Computed, Signal };