@esportsplus/reactivity 0.31.3 → 0.33.0

package/build/types.d.ts

@@ -5,15 +5,23 @@ interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
+    disposal: VoidFunction | null;
+    equals: ((a: unknown, b: unknown) => boolean) | null;
+    error: unknown;
     fn: (onCleanup: (fn: VoidFunction) => typeof fn) => T;
+    gv: number;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;
+    rv: number;
     state: number;
     subs: Link | null;
     subsTail: Link | null;
     value: T;
 }
+type ComputedResult<T> = T extends Promise<any> | AsyncIterable<any> ? Computed<Settled<T>> & {
+    pending: Signal<boolean>;
+} : Computed<Settled<T>>;
 interface Link {
     dep: Signal<unknown> | Computed<unknown>;
     nextDep: Link | null;
@@ -23,16 +31,26 @@ interface Link {
     version: number;
 }
 declare const READONLY: unique symbol;
-type Reactive<T> = T extends (...args: unknown[]) => Promise<infer R> ? (R | undefined) & {
-    readonly [READONLY]: true;
-} : T extends (...args: any[]) => infer R ? R & {
+type Reactive<T> = T extends (...args: never[]) => infer R ? Settled<R> & {
     readonly [READONLY]: true;
 } : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'dispose' | 'on' | 'once'> : T extends Record<PropertyKey, unknown> ? {
     [K in keyof T]: T[K] extends (infer U)[] ? Reactive<U[]> : T[K];
 } & {
     dispose: VoidFunction;
 } : T;
+type SelectorSignal<T> = Signal<boolean> & {
+    key: T;
+    parent: Signal<T>;
+};
+type Settled<T> = T extends Promise<infer U> ? Awaited<U> | undefined : T extends AsyncIterable<infer U> ? U | undefined : T;
 type Signal<T> = {
+    equals: ((a: unknown, b: unknown) => boolean) | null;
+    key: unknown;
+    keys: Map<T, SelectorSignal<T>> | null;
+    nextPending: Signal<unknown> | null;
+    parent: Signal<unknown> | undefined;
+    rv: number;
+    state: number;
     subs: Link | null;
     subsTail: Link | null;
     type: typeof SIGNAL;
@@ -43,4 +61,4 @@ interface TransformResult {
     code: string;
     sourceFile: ts.SourceFile;
 }
-export type { Computed, Link, Reactive, Signal, TransformResult };
+export type { Computed, ComputedResult, Link, Reactive, SelectorSignal, Settled, Signal, TransformResult };

package/package.json

@@ -1,13 +1,13 @@
 {
   "author": "ICJR",
   "dependencies": {
-    "@esportsplus/utilities": "^0.27.3"
+    "@esportsplus/utilities": "^0.28.0"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.29.1",
-    "@types/node": "^25.6.0",
-    "vite": "^8.0.8",
-    "vitest": "^4.1.4"
+    "@esportsplus/typescript": "^0.29.5",
+    "@types/node": "^26.1.1",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
   },
   "exports": {
     ".": {
@@ -36,10 +36,13 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.31.3",
+  "version": "0.33.0",
   "scripts": {
+    "agent:bench": "vitest bench --run",
+    "agent:test": "tsc --noEmit && vitest run",
+    "bench": "vitest bench --run",
     "build": "tsc",
-    "build:test": "pnpm build && vite build --config test/vite.config.ts",
+    "test": "vitest run",
     "-": "-"
   }
 }

package/src/compiler/array.ts

@@ -1,6 +1,6 @@
-import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import { ast, imports } from '@esportsplus/typescript/compiler';
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants';
 import type { Bindings } from './types';
 

package/src/compiler/constants.ts

@@ -8,12 +8,14 @@ const ENTRYPOINT_REGEX = /\breactive\b/;
 const NAMESPACE = uid('reactivity');
 
 
-const enum TYPES {
-    Array,
-    Computed,
-    Object,
-    Signal
-}
+const TYPES = {
+    Array: 0,
+    Computed: 1,
+    Object: 2,
+    Signal: 3
+} as const;
+
+type TYPES = typeof TYPES[keyof typeof TYPES];
 
 
 export { ENTRYPOINT, ENTRYPOINT_REGEX, NAMESPACE, TYPES };

package/src/compiler/index.ts

@@ -1,8 +1,9 @@
-import type { ImportIntent, ReplacementIntent, TransformContext } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import { imports } from '@esportsplus/typescript/compiler';
+import type { ImportIntent, ReplacementIntent, TransformContext } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME } from './constants';
 import type { Bindings } from './types';
+
 import array from './array';
 import object from './object';
 import primitives from './primitives';

package/src/compiler/object.ts

@@ -1,6 +1,6 @@
-import { code, imports, type ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { uid } from '@esportsplus/typescript/compiler';
+import { code, imports, uid } from '@esportsplus/typescript/compiler';
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME, TYPES } from './constants';
 import type { Bindings } from './types';
 

package/src/compiler/plugins/vite.ts

@@ -1,5 +1,6 @@
 import { plugin } from '@esportsplus/typescript/compiler';
 import { PACKAGE_NAME } from '../constants';
+
 import reactivity from '..';
 
 

package/src/compiler/primitives.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 { NAMESPACE, TYPES } from './constants';
 import type { Bindings } from './types';
 

package/src/constants.ts

@@ -28,14 +28,18 @@ 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,
+    REACTIVE_ARRAY, REACTIVE_OBJECT,
     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
+    STATE_CHECK, STATE_COMPUTED, STATE_DIRTY, STATE_EFFECT, STATE_ERROR, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 };

package/src/reactive/array.ts

@@ -1,6 +1,6 @@
 import { isArray } from '@esportsplus/utilities';
-import { read, signal, write } from '~/system';
 import { REACTIVE_ARRAY } from '~/constants';
+import { read, signal, write } from '~/system';
 import type { Signal } from '~/types';
 import { isReactiveObject } from './object';
 
@@ -42,7 +42,9 @@ type Listener<V> = {
     (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)[] };
 
 
 function dispose(value: unknown) {
@@ -52,10 +54,13 @@ function dispose(value: unknown) {
 }
 
 
+// Derived arrays (splice removals, map/filter/slice) must be plain Arrays: species-creating a
+// ReactiveArray runs the reactive constructor per call and seeds _length from the length argument.
 class ReactiveArray<T> extends Array<T> {
+
     private _length: Signal<number>;
 
-    listeners: Listeners = {};
+    listeners: Listeners<T> = {};
 
 
     constructor(...items: T[]) {
@@ -64,6 +69,11 @@ class ReactiveArray<T> extends Array<T> {
     }
 
 
+    static get [Symbol.species]() {
+        return Array;
+    }
+
+
     get $length() {
         return read(this._length);
     }
@@ -130,7 +140,7 @@ class ReactiveArray<T> extends Array<T> {
         return this;
     }
 
-    dispatch<K extends keyof Events<T>, V>(event: K, value?: V) {
+    dispatch<K extends keyof Events<T>>(event: K, value?: Events<T>[K]) {
         let listeners = this.listeners[event];
 
         if (!listeners) {
@@ -147,7 +157,7 @@ class ReactiveArray<T> extends Array<T> {
             }
 
             try {
-                listener(value);
+                listener(value as Events<T>[K]);
 
                 if (listener.once !== undefined) {
                     dirty = true;
@@ -176,10 +186,11 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     on<K extends keyof Events<T>>(event: K, listener: Listener<Events<T>[K]>) {
-        let listeners = this.listeners[event];
+        let entry = listener as AnyListener<T>,
+            listeners = this.listeners[event];
 
         if (listeners === undefined) {
-            this.listeners[event] = [listener];
+            this.listeners[event] = [entry];
         }
         else {
             let hole = listeners.length;
@@ -187,7 +198,7 @@ class ReactiveArray<T> extends Array<T> {
             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) {
@@ -195,7 +206,7 @@ class ReactiveArray<T> extends Array<T> {
                 }
             }
 
-            listeners[hole] = listener;
+            listeners[hole] = entry;
 
             while (listeners.length && listeners[listeners.length - 1] === null) {
                 listeners.pop();
@@ -214,7 +225,6 @@ class ReactiveArray<T> extends Array<T> {
         if (item !== undefined) {
             dispose(item);
             write(this._length, this.length);
-
             this.dispatch('pop', { item });
         }
 
@@ -229,6 +239,7 @@ class ReactiveArray<T> extends Array<T> {
         let length = super.push(...items);
 
         write(this._length, length);
+
         this.dispatch('push', { items });
 
         return length;
@@ -247,7 +258,6 @@ class ReactiveArray<T> extends Array<T> {
         if (item !== undefined) {
             dispose(item);
             write(this._length, this.length);
-
             this.dispatch('shift', { item });
         }
 
@@ -255,41 +265,46 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     sort(fn?: (a: T, b: T) => number) {
-        let n = this.length,
-            before = new Array(n) as T[];
-
-        for (let i = 0; i < n; i++) {
-            before[i] = this[i];
+        if (this.listeners.sort === undefined) {
+            super.sort(fn);
         }
+        else {
+            let n = this.length,
+                before = new Array(n) as T[];
 
-        super.sort(fn);
+            for (let i = 0; i < n; i++) {
+                before[i] = this[i];
+            }
 
-        let buckets = new Map<any, number[]>(),
-            order = new Array(n);
+            super.sort(fn);
 
-        for (let i = 0; i < n; i++) {
-            let value = before[i],
-                list = buckets.get(value);
+            let buckets = new Map<T, number[]>(),
+                order = new Array(n);
 
-            if (!list) {
-                buckets.set(value, [i]);
-            }
-            else {
-                list.push(i);
+            for (let i = 0; i < n; i++) {
+                let value = before[i],
+                    list = buckets.get(value);
+
+                if (!list) {
+                    buckets.set(value, [i]);
+                }
+                else {
+                    list.push(i);
+                }
             }
-        }
 
-        for (let i = 0; i < n; i++) {
-            let list = buckets.get(this[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];
+                order[i] = list.length === 1 ? list[0] : list[list.length - 1];
 
-            if (list.length > 1) {
-                list.pop();
+                if (list.length > 1) {
+                    list.pop();
+                }
             }
-        }
 
-        this.dispatch('sort', { order });
+            this.dispatch('sort', { order });
+        }
 
         return this;
     }

package/src/reactive/index.ts

@@ -1,14 +1,14 @@
 import { onCleanup, root } from '@esportsplus/reactivity';
 import { isArray, isObject } from '@esportsplus/utilities';
-import { Reactive } from '~/types';
+import { PACKAGE_NAME } from '~/constants';
+import type { Reactive } from '~/types';
 import { ReactiveArray } from './array';
 import { ReactiveObject } from './object';
-import { PACKAGE_NAME } from '~/constants';
 
 
 type Guard<T> =
     T extends Record<PropertyKey, unknown>
-        ? T extends { dispose: any }
+        ? T extends { dispose: unknown }
             ? { never: '[ dispose ] is a reserved key' }
             : T
         : never;
@@ -23,10 +23,10 @@ function reactive<T>(input: T): Reactive<T> {
             let response: Reactive<T> | undefined;
 
             if (isObject(input)) {
-                response = new ReactiveObject(input) as any as Reactive<T>;
+                response = new ReactiveObject(input) as unknown as Reactive<T>;
             }
             else if (isArray(input)) {
-                response = new ReactiveArray(...input) as any as Reactive<T>;
+                response = new ReactiveArray(...input) as unknown as Reactive<T>;
             }
 
             if (response) {
@@ -41,7 +41,7 @@ function reactive<T>(input: T): Reactive<T> {
         });
 
     if (dispose) {
-        onCleanup(() => (value as any as { dispose: VoidFunction }).dispose());
+        onCleanup(() => (value as unknown as { dispose: VoidFunction }).dispose());
     }
 
     return value;

package/src/reactive/object.ts

@@ -1,7 +1,7 @@
-import { defineProperty, isArray, isPromise } from '@esportsplus/utilities';
-import { computed, dispose, effect, read, root, signal, write } from '~/system';
-import { Computed, Signal } from '~/types';
+import { defineProperty, isArray } from '@esportsplus/utilities';
 import { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from '~/constants';
+import { computed, dispose, read, root, signal, write } from '~/system';
+import { Computed } from '~/types';
 import { ReactiveArray } from './array';
 
 
@@ -32,10 +32,7 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
                 continue;
             }
 
-            if (value == null || type !== 'object') {
-                // Skip isArray when possible
-            }
-            else if (isArray(value)) {
+            if (value != null && type === 'object' && isArray(value)) {
                 defineProperty(this, key, {
                     enumerable: true,
                     value: this[REACTIVE_ARRAY](value)
@@ -59,44 +56,22 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
     }
 
 
-    protected [REACTIVE_ARRAY]<U>(value: U[]): ReactiveArray<U> {
-        let node = new ReactiveArray(...value);
-
-        (this.disposers ??= []).push( () => node.dispose() );
-
-        return node;
-    }
-
     protected [COMPUTED]<T extends Computed<ReturnType<T>>['fn']>(value: T) {
         return root(() => {
-            let node: Computed<ReturnType<T>> | Signal<ReturnType<T> | undefined> = computed(value);
-
-            if (isPromise(node.value)) {
-                let factory = node as Computed<ReturnType<T>>,
-                    out = signal<ReturnType<T> | undefined>(undefined),
-                    v = 0;
-
-                (this.disposers ??= []).push(
-                    effect(() => {
-                        let id = ++v;
+            let node = computed(value);
 
-                        (read(factory) as Promise<ReturnType<T>>).then((resolved) => {
-                            if (id !== v) {
-                                return;
-                            }
+            (this.disposers ??= []).push(() => dispose(node));
 
-                            write(out as Signal<typeof resolved>, resolved);
-                        });
-                    })
-                );
+            return node;
+        });
+    }
 
-                return out;
-            }
+    protected [REACTIVE_ARRAY]<U>(value: U[]): ReactiveArray<U> {
+        let node = new ReactiveArray(...value);
 
-            (this.disposers ??= []).push(() => dispose(node as Computed<ReturnType<T>>));
+        (this.disposers ??= []).push( () => node.dispose() );
 
-            return node;
-        });
+        return node;
     }
 
     protected [SIGNAL]<T>(value: T) {
@@ -121,9 +96,9 @@ class ReactiveObject<T extends Record<PropertyKey, unknown>> {
 Object.defineProperty(ReactiveObject.prototype, REACTIVE_OBJECT, { value: true });
 
 
-const isReactiveObject = (value: any): value is ReactiveObject<any> => {
-    return typeof value === 'object' && value !== null && value[REACTIVE_OBJECT] === true;
+const isReactiveObject = (value: unknown): value is ReactiveObject<Record<PropertyKey, unknown>> => {
+    return typeof value === 'object' && value !== null && (value as Record<PropertyKey, unknown>)[REACTIVE_OBJECT] === true;
 };
 
 
-export { isReactiveObject, ReactiveObject };
+export { isReactiveObject, ReactiveObject };