@esportsplus/reactivity 0.30.3 → 0.31.1

package/tests/objects.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { computed, effect, read, signal, write } from '~/system';
+import { COMPUTED, REACTIVE_ARRAY } from '~/constants';
 import { ReactiveObject } from '~/reactive/object';
 import { ReactiveArray } from '~/reactive/array';
 import reactive from '~/reactive/index';
@@ -19,6 +20,15 @@ describe('reactive object patterns', () => {
             expect(obj.name).toBe('John');
         });
 
+        it('empty object constructor', () => {
+            let obj = new ReactiveObject({}) as any;
+
+            // No reactive properties created — only internal 'disposers' field
+            expect(Object.keys(obj).filter((k: string) => k !== 'disposers')).toEqual([]);
+
+            obj.dispose();
+        });
+
         it('updates multiple properties independently', async () => {
             let obj = new ReactiveObject({ age: 25, name: 'John' }) as any,
                 ages: number[] = [],
@@ -160,6 +170,65 @@ describe('reactive object patterns', () => {
     });
 
 
+    describe('subclass overrides', () => {
+        it('[COMPUTED] subclass creates computed field from external signal', async () => {
+            class Doubled extends ReactiveObject<Record<string, never>> {
+                private _doubled: ReturnType<typeof computed<number>>;
+
+                constructor(source: ReturnType<typeof signal<number>>) {
+                    super(null);
+                    this._doubled = this[COMPUTED](() => read(source) * 2);
+                }
+
+                get doubled() {
+                    return read(this._doubled);
+                }
+            }
+
+            let s = signal(5),
+                obj = new Doubled(s),
+                values: number[] = [];
+
+            expect(obj.doubled).toBe(10);
+
+            effect(() => {
+                values.push(obj.doubled);
+            });
+
+            expect(values).toEqual([10]);
+
+            write(s, 10);
+            await Promise.resolve();
+
+            expect(obj.doubled).toBe(20);
+            expect(values).toEqual([10, 20]);
+
+            obj.dispose();
+        });
+
+        it('[REACTIVE_ARRAY] subclass creates ReactiveArray field', () => {
+            class Collection extends ReactiveObject<Record<string, never>> {
+                items: ReactiveArray<number>;
+
+                constructor(values: number[]) {
+                    super(null);
+                    this.items = this[REACTIVE_ARRAY](values);
+                }
+            }
+
+            let obj = new Collection([10, 20, 30]);
+
+            expect(obj.items).toBeInstanceOf(ReactiveArray);
+            expect([...obj.items]).toEqual([10, 20, 30]);
+
+            obj.dispose();
+
+            // After dispose, array should be cleared
+            expect(obj.items.length).toBe(0);
+        });
+    });
+
+
     describe('dispose', () => {
         it('disposes object with computed properties', () => {
             let s = signal(42),
@@ -181,5 +250,20 @@ describe('reactive object patterns', () => {
 
             obj.dispose();
         });
+
+        it('calling dispose twice does not throw', () => {
+            let s = signal(1),
+                obj = new ReactiveObject({
+                    computed: () => read(s) * 2,
+                    items: [1, 2, 3]
+                }) as any;
+
+            expect(obj.computed).toBe(2);
+            expect([...obj.items]).toEqual([1, 2, 3]);
+
+            obj.dispose();
+
+            expect(() => obj.dispose()).not.toThrow();
+        });
     });
 });

package/tests/reactive.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import { computed, effect, onCleanup, read, root, signal, write } from '~/system';
+import { SIGNAL } from '~/constants';
 import { ReactiveObject, isReactiveObject } from '~/reactive/object';
 import reactive from '~/reactive/index';
 import { ReactiveArray } from '~/reactive/array';
@@ -108,6 +109,215 @@ describe('ReactiveObject', () => {
             obj.dispose();
         });
     });
+
+
+    describe('async computed', () => {
+        it('initial value undefined, resolves to correct value', async () => {
+            let s = signal(42),
+                obj = new ReactiveObject({
+                    data: () => Promise.resolve(read(s))
+                }) as any;
+
+            expect(obj.data).toBeUndefined();
+
+            await new Promise((r) => setTimeout(r, 10));
+
+            expect(obj.data).toBe(42);
+        });
+
+        it('updates when dependency changes — new promise resolves', async () => {
+            let s = signal('hello'),
+                obj = new ReactiveObject({
+                    data: () => Promise.resolve(read(s))
+                }) as any;
+
+            await new Promise((r) => setTimeout(r, 10));
+
+            expect(obj.data).toBe('hello');
+
+            write(s, 'world');
+            await new Promise((r) => setTimeout(r, 10));
+
+            expect(obj.data).toBe('world');
+        });
+
+        it('race condition — rapid changes, only latest promise writes', async () => {
+            let s = signal(1),
+                resolvers: ((v: number) => void)[] = [],
+                obj = new ReactiveObject({
+                    data: () => new Promise<number>((resolve) => {
+                        resolvers.push(resolve);
+                        read(s);
+                    })
+                }) as any;
+
+            expect(obj.data).toBeUndefined();
+
+            // Trigger second computation
+            write(s, 2);
+            await Promise.resolve();
+            await Promise.resolve();
+
+            // Trigger third computation
+            write(s, 3);
+            await Promise.resolve();
+            await Promise.resolve();
+
+            // Resolve first promise (stale — should be ignored)
+            resolvers[0](100);
+            await Promise.resolve();
+
+            expect(obj.data).toBeUndefined();
+
+            // Resolve second promise (stale — should be ignored)
+            resolvers[1](200);
+            await Promise.resolve();
+
+            expect(obj.data).toBeUndefined();
+
+            // Resolve latest promise — should write
+            resolvers[2](300);
+            await Promise.resolve();
+
+            expect(obj.data).toBe(300);
+        });
+
+        it('dispose prevents new computations but in-flight resolves still write', async () => {
+            let s = signal(1),
+                resolver: ((v: number) => void) | null = null,
+                obj = new ReactiveObject({
+                    data: () => new Promise<number>((resolve) => {
+                        resolver = resolve;
+                        read(s);
+                    })
+                }) as any;
+
+            expect(obj.data).toBeUndefined();
+
+            obj.dispose();
+
+            // After dispose, dependency changes don't spawn new effects
+            write(s, 2);
+            await Promise.resolve();
+
+            // Resolve the original in-flight promise
+            resolver!(999);
+            await Promise.resolve();
+
+            // In-flight promise still wrote (version matched)
+            expect(obj.data).toBe(999);
+
+            // But no further computations occur from new dependency changes
+            write(s, 3);
+            await new Promise((r) => setTimeout(r, 10));
+
+            expect(obj.data).toBe(999);
+        });
+    });
+
+
+    describe('null/undefined properties', () => {
+        it('creates reactive signal for null property', async () => {
+            let obj = new ReactiveObject({ key: null }) as any,
+                values: (null | number)[] = [];
+
+            expect(obj.key).toBeNull();
+
+            effect(() => {
+                values.push(obj.key);
+            });
+
+            expect(values).toEqual([null]);
+
+            obj.key = 42;
+            await Promise.resolve();
+
+            expect(values).toEqual([null, 42]);
+        });
+
+        it('creates reactive signal for undefined property', async () => {
+            let obj = new ReactiveObject({ key: undefined }) as any,
+                values: (undefined | string)[] = [];
+
+            expect(obj.key).toBeUndefined();
+
+            effect(() => {
+                values.push(obj.key);
+            });
+
+            expect(values).toEqual([undefined]);
+
+            obj.key = 'hello';
+            await Promise.resolve();
+
+            expect(values).toEqual([undefined, 'hello']);
+        });
+    });
+
+
+    describe('enumeration', () => {
+        it('Object.keys includes all defined property names', () => {
+            let keys = Object.keys(new ReactiveObject({ a: 1, b: 'two', c: null }));
+
+            expect(keys).toContain('a');
+            expect(keys).toContain('b');
+            expect(keys).toContain('c');
+        });
+
+        it('for...in iterates all defined properties', () => {
+            let obj = new ReactiveObject({ x: 10, y: 20, z: 30 }),
+                keys: string[] = [];
+
+            for (let key in obj) {
+                keys.push(key);
+            }
+
+            expect(keys).toContain('x');
+            expect(keys).toContain('y');
+            expect(keys).toContain('z');
+        });
+    });
+
+
+    describe('[SIGNAL] protected method', () => {
+        it('subclass creates reactive field via [SIGNAL]', async () => {
+            class Counter extends ReactiveObject<Record<string, never>> {
+                private _count: ReturnType<typeof signal<number>>;
+
+                constructor(initial: number) {
+                    super(null);
+                    this._count = this[SIGNAL](initial);
+                }
+
+                get count() {
+                    return read(this._count);
+                }
+
+                set count(value: number) {
+                    write(this._count, value);
+                }
+            }
+
+            let counter = new Counter(0),
+                values: number[] = [];
+
+            effect(() => {
+                values.push(counter.count);
+            });
+
+            expect(values).toEqual([0]);
+
+            counter.count = 5;
+            await Promise.resolve();
+
+            expect(values).toEqual([0, 5]);
+
+            counter.count = 10;
+            await Promise.resolve();
+
+            expect(values).toEqual([0, 5, 10]);
+        });
+    });
 });