@esportsplus/reactivity 0.22.1 → 0.23.0

package/test/primitives.ts

@@ -0,0 +1,171 @@
+// Test: Reactive Primitives (Standalone + Object-wrapped)
+import { effect, reactive } from '@esportsplus/reactivity';
+
+
+// =============================================================================
+// Standalone Signal Primitives
+// =============================================================================
+
+console.log('=== Standalone Signal Primitives ===');
+
+let count = reactive(0);
+let name = reactive('initial');
+let flag = reactive(true);
+
+console.log('Initial count:', count);
+console.log('Initial name:', name);
+console.log('Initial flag:', flag);
+
+// Simple assignment
+count = 10;
+name = 'updated';
+flag = false;
+
+console.log('After assignment - count:', count);
+console.log('After assignment - name:', name);
+console.log('After assignment - flag:', flag);
+
+
+// =============================================================================
+// Standalone Computed Primitives
+// =============================================================================
+
+console.log('\n=== Standalone Computed Primitives ===');
+
+let base = reactive(10);
+let doubled = reactive(() => base * 2);
+let quadrupled = reactive(() => doubled * 2);
+
+console.log('base:', base);
+console.log('doubled:', doubled);
+console.log('quadrupled:', quadrupled);
+
+base = 5;
+console.log('After base = 5:');
+console.log('  doubled:', doubled);
+console.log('  quadrupled:', quadrupled);
+
+
+// =============================================================================
+// Compound Assignments with Standalone Primitives
+// =============================================================================
+
+console.log('\n=== Compound Assignments ===');
+
+let value = reactive(10);
+
+value += 5;
+console.log('After += 5:', value);
+
+value -= 3;
+console.log('After -= 3:', value);
+
+value *= 2;
+console.log('After *= 2:', value);
+
+
+// =============================================================================
+// Increment/Decrement with Standalone Primitives
+// =============================================================================
+
+console.log('\n=== Increment/Decrement ===');
+
+let counter = reactive(0);
+
+counter++;
+console.log('After counter++:', counter);
+
+++counter;
+console.log('After ++counter:', counter);
+
+counter--;
+console.log('After counter--:', counter);
+
+
+// =============================================================================
+// Mixed Standalone and Object Primitives
+// =============================================================================
+
+console.log('\n=== Mixed Standalone and Object ===');
+
+let multiplier = reactive(2);
+
+let obj = reactive({
+    value: 10,
+    scaled: () => obj.value * multiplier
+});
+
+console.log('obj.value:', obj.value);
+console.log('obj.scaled:', obj.scaled);
+
+multiplier = 3;
+console.log('After multiplier = 3:');
+console.log('  obj.scaled:', obj.scaled);
+
+obj.value = 20;
+console.log('After obj.value = 20:');
+console.log('  obj.scaled:', obj.scaled);
+
+
+// =============================================================================
+// Effects with Standalone Primitives
+// =============================================================================
+
+console.log('\n=== Effects with Standalone Primitives ===');
+
+let effectCount = 0;
+let watched = reactive(0);
+
+let cleanup = effect(() => {
+    effectCount++;
+    console.log(`Effect #${effectCount}: watched = ${watched}`);
+});
+
+watched = 1;
+watched = 2;
+watched = 3;
+
+cleanup();
+
+watched = 4; // Should not trigger effect
+console.log('After cleanup, watched set to 4 (no effect should run)');
+console.log('Total effect runs:', effectCount);
+
+
+// =============================================================================
+// String Template Computeds
+// =============================================================================
+
+console.log('\n=== String Template Computeds ===');
+
+let firstName = reactive('John');
+let lastName = reactive('Doe');
+let fullName = reactive(() => `${firstName} ${lastName}`);
+
+console.log('Full name:', fullName);
+
+firstName = 'Jane';
+console.log('After firstName = Jane:', fullName);
+
+
+// =============================================================================
+// Object-wrapped Primitives (original tests)
+// =============================================================================
+
+console.log('\n=== Object-wrapped Primitives ===');
+
+let state = reactive({
+    count: 0,
+    flag: true,
+    name: 'initial'
+});
+
+console.log('Initial count:', state.count);
+
+state.count = 10;
+state.name = 'updated';
+state.flag = false;
+
+console.log('After assignment - count:', state.count);
+console.log('After assignment - name:', state.name);
+console.log('After assignment - flag:', state.flag);

package/test/vite.config.ts

@@ -0,0 +1,40 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+import { plugin as reactivity } from '../build/plugins/vite.js';
+
+
+export default defineConfig({
+    build: {
+        lib: {
+            entry: {
+                arrays: resolve(__dirname, 'arrays.ts'),
+                effects: resolve(__dirname, 'effects.ts'),
+                index: resolve(__dirname, 'index.ts'),
+                nested: resolve(__dirname, 'nested.ts'),
+                objects: resolve(__dirname, 'objects.ts'),
+                primitives: resolve(__dirname, 'primitives.ts')
+            },
+            formats: ['es']
+        },
+        minify: false,
+        outDir: resolve(__dirname, 'build'),
+        rollupOptions: {
+            external: ['@esportsplus/utilities'],
+            output: {
+                entryFileNames: '[name].js'
+            }
+        },
+        target: 'esnext'
+    },
+    plugins: [
+        reactivity()
+    ],
+    resolve: {
+        alias: {
+            '@esportsplus/reactivity/constants': resolve(__dirname, '../src/constants'),
+            '@esportsplus/reactivity/reactive/array': resolve(__dirname, '../src/reactive/array'),
+            '@esportsplus/reactivity': resolve(__dirname, '../src'),
+            '~': resolve(__dirname, '../src')
+        }
+    }
+});

package/build/reactive/object.d.ts

@@ -1,7 +0,0 @@
-declare class ReactiveObject<T extends Record<PropertyKey, unknown>> {
-    private disposers;
-    constructor(data: T);
-    dispose(): void;
-}
-declare const isReactiveObject: (value: any) => value is ReactiveObject<any>;
-export { isReactiveObject, ReactiveObject };

package/build/reactive/object.js

@@ -1,79 +0,0 @@
-import { defineProperty, isArray, isPromise } from '@esportsplus/utilities';
-import { computed, dispose, effect, read, root, set, signal } from '../system.js';
-import { REACTIVE_OBJECT } from '../constants.js';
-import { ReactiveArray } from './array.js';
-class ReactiveObject {
-    disposers = null;
-    constructor(data) {
-        let keys = Object.keys(data);
-        for (let i = 0, n = keys.length; i < n; ++i) {
-            let key = keys[i], value = data[key], type = typeof value;
-            if (type === 'function') {
-                let node;
-                defineProperty(this, key, {
-                    enumerable: true,
-                    get: () => {
-                        if (node === undefined) {
-                            root(() => {
-                                node = computed(value);
-                                if (isPromise(node.value)) {
-                                    let factory = node, version = 0;
-                                    node = signal(undefined);
-                                    (this.disposers ??= []).push(effect(() => {
-                                        let id = ++version;
-                                        read(factory).then((v) => {
-                                            if (id !== version) {
-                                                return;
-                                            }
-                                            set(node, v);
-                                        });
-                                    }));
-                                }
-                                else {
-                                    (this.disposers ??= []).push(() => dispose(node));
-                                }
-                            });
-                        }
-                        return read(node);
-                    }
-                });
-                continue;
-            }
-            if (value == null || type !== 'object') {
-            }
-            else if (isArray(value)) {
-                let node = new ReactiveArray(...value);
-                (this.disposers ??= []).push(() => node.dispose());
-                defineProperty(this, key, {
-                    enumerable: true,
-                    value: node
-                });
-                continue;
-            }
-            let node = signal(value);
-            defineProperty(this, key, {
-                enumerable: true,
-                get() {
-                    return read(node);
-                },
-                set(v) {
-                    set(node, v);
-                }
-            });
-        }
-    }
-    dispose() {
-        let disposers = this.disposers, disposer;
-        if (!disposers) {
-            return;
-        }
-        while (disposer = disposers.pop()) {
-            disposer();
-        }
-    }
-}
-Object.defineProperty(ReactiveObject.prototype, REACTIVE_OBJECT, { value: true });
-const isReactiveObject = (value) => {
-    return typeof value === 'object' && value !== null && value[REACTIVE_OBJECT] === true;
-};
-export { isReactiveObject, ReactiveObject };

package/src/reactive/object.ts

@@ -1,116 +0,0 @@
-import { defineProperty, isArray, isPromise } from '@esportsplus/utilities';
-import { computed, dispose, effect, read, root, set, signal } from '~/system';
-import { Computed, Signal } from '~/types';
-import { REACTIVE_OBJECT } from '~/constants';
-import { ReactiveArray } from './array';
-
-
-class ReactiveObject<T extends Record<PropertyKey, unknown>> {
-    private disposers: VoidFunction[] | null = null;
-
-
-    constructor(data: T) {
-        let keys = Object.keys(data);
-
-        for (let i = 0, n = keys.length; i < n; ++i) {
-            let key: keyof T | undefined = keys[i],
-                value = data[key],
-                type = typeof value;
-
-            if (type === 'function') {
-                let node: Computed<T[typeof key]> | Signal<T[typeof key] | undefined> | undefined;
-
-                defineProperty(this, key, {
-                    enumerable: true,
-                    get: () => {
-                        if (node === undefined) {
-                            root(() => {
-                                node = computed(value as Computed<T[keyof T]>['fn']);
-
-                                if (isPromise(node.value)) {
-                                    let factory = node,
-                                        version = 0;
-
-                                    node = signal<T[keyof T] | undefined>(undefined);
-
-                                    (this.disposers ??= []).push(
-                                        effect(() => {
-                                            let id = ++version;
-
-                                            (read(factory) as Promise<T[keyof T]>).then((v) => {
-                                                if (id !== version) {
-                                                    return;
-                                                }
-
-                                                set(node as Signal<typeof v>, v);
-                                            });
-                                        })
-                                    )
-                                }
-                                else {
-                                    (this.disposers ??= []).push(() => dispose(node as Computed<T[keyof T]>));
-                                }
-                            });
-                        }
-
-                        return read(node!);
-                    }
-                });
-
-                continue;
-            }
-
-            if (value == null || type !== 'object') {
-                // Skip isArray when possible
-            }
-            else if (isArray(value)) {
-                let node = new ReactiveArray(...value);
-
-                (this.disposers ??= []).push( () => node.dispose() );
-
-                defineProperty(this, key, {
-                    enumerable: true,
-                    value: node
-                });
-
-                continue;
-            }
-
-            let node = signal(value);
-
-            defineProperty(this, key, {
-                enumerable: true,
-                get() {
-                    return read(node);
-                },
-                set(v: typeof value) {
-                    set(node, v);
-                }
-            });
-        }
-    }
-
-
-    dispose() {
-        let disposers = this.disposers,
-            disposer;
-
-        if (!disposers) {
-            return;
-        }
-
-        while (disposer = disposers.pop()) {
-            disposer();
-        }
-    }
-}
-
-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;
-};
-
-
-export { isReactiveObject, ReactiveObject };