@esportsplus/reactivity 0.31.2 → 0.32.0

package/package.json

@@ -36,10 +36,13 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.31.2",
+  "version": "0.32.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/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

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) {
@@ -55,7 +57,7 @@ function dispose(value: unknown) {
 class ReactiveArray<T> extends Array<T> {
     private _length: Signal<number>;
 
-    listeners: Listeners = {};
+    listeners: Listeners<T> = {};
 
 
     constructor(...items: T[]) {
@@ -64,19 +66,6 @@ class ReactiveArray<T> extends Array<T> {
     }
 
 
-    get $length() {
-        return read(this._length);
-    }
-
-    set $length(value: number) {
-        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: number, value: T) {
         let prev = this[i];
 
@@ -130,7 +119,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 +136,7 @@ class ReactiveArray<T> extends Array<T> {
             }
 
             try {
-                listener(value);
+                listener(value as Events<T>[K]);
 
                 if (listener.once !== undefined) {
                     dirty = true;
@@ -176,10 +165,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 +177,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 +185,7 @@ class ReactiveArray<T> extends Array<T> {
                 }
             }
 
-            listeners[hole] = listener;
+            listeners[hole] = entry;
 
             while (listeners.length && listeners[listeners.length - 1] === null) {
                 listeners.pop();
@@ -264,7 +254,7 @@ class ReactiveArray<T> extends Array<T> {
 
         super.sort(fn);
 
-        let buckets = new Map<any, number[]>(),
+        let buckets = new Map<T, number[]>(),
             order = new Array(n);
 
         for (let i = 0; i < n; i++) {
@@ -322,6 +312,19 @@ class ReactiveArray<T> extends Array<T> {
 
         return length;
     }
+
+
+    get $length() {
+        return read(this._length);
+    }
+
+    set $length(value: number) {
+        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 });

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 };