@esportsplus/reactivity 0.27.0 → 0.27.3

package/build/compiler/array.d.ts

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

package/build/compiler/array.js

@@ -1,7 +1,23 @@
-import { ast, code as c } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { COMPILER_TYPES } from '../constants.js';
+import { ast, code as c } from '@esportsplus/typescript/compiler';
+import { COMPILER_NAMESPACE, COMPILER_TYPES } from '../constants.js';
+import { isReactiveCall } from './index.js';
 function visit(ctx, node) {
+    if (ts.isCallExpression(node) && isReactiveCall(node, ctx.checker) && node.arguments.length > 0) {
+        let arg = node.arguments[0], expression = ts.isAsExpression(arg) ? arg.expression : arg;
+        if (ts.isArrayLiteralExpression(expression)) {
+            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+                ctx.bindings.set(node.parent.name.text, COMPILER_TYPES.Array);
+            }
+            ctx.replacements.push({
+                end: node.end,
+                newText: expression.elements.length > 0
+                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray(...${expression.getText(ctx.sourceFile)})`
+                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray()`,
+                start: node.pos
+            });
+        }
+    }
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
         if (ts.isIdentifier(node.initializer) && ctx.bindings.get(node.initializer.text) === COMPILER_TYPES.Array) {
             ctx.bindings.set(node.name.text, COMPILER_TYPES.Array);
@@ -42,24 +58,28 @@ function visit(ctx, node) {
     if (ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
         ts.isElementAccessExpression(node.left)) {
-        let elemAccess = node.left, objName = ast.getExpressionName(elemAccess.expression);
-        if (objName && ctx.bindings.get(objName) === COMPILER_TYPES.Array) {
-            let index = elemAccess.argumentExpression.getText(ctx.sourceFile), obj = elemAccess.expression.getText(ctx.sourceFile), value = node.right.getText(ctx.sourceFile);
+        let element = node.left, name = ast.getExpressionName(element.expression);
+        if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
+            let index = element.argumentExpression.getText(ctx.sourceFile), value = node.right.getText(ctx.sourceFile);
             ctx.replacements.push({
                 end: node.end,
-                newText: `${obj}.$set(${index}, ${value})`,
+                newText: `${element.expression.getText(ctx.sourceFile)}.$set(${index}, ${value})`,
                 start: node.pos
             });
         }
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, _ns, _checker) => {
+export default (sourceFile, bindings, checker) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
+        checker,
         replacements: [],
         sourceFile
     };
     visit(ctx, sourceFile);
+    if (ctx.replacements.length === 0) {
+        return code;
+    }
     return c.replace(code, ctx.replacements);
 };

package/build/compiler/index.d.ts

@@ -1,4 +1,7 @@
+import type { PluginContext } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import type { TransformResult } from '../types.js';
-declare const transform: (sourceFile: ts.SourceFile, program: ts.Program) => TransformResult;
-export { transform };
+declare const analyze: (sourceFile: ts.SourceFile, _program: ts.Program, context: PluginContext) => void;
+declare const isReactiveCall: (node: ts.CallExpression, _checker?: ts.TypeChecker) => boolean;
+declare const transform: (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
+export { analyze, isReactiveCall, transform };

package/build/compiler/index.js

@@ -1,57 +1,65 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, imports } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
+import { ast, imports } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
 import array from './array.js';
 import object from './object.js';
-import primitives from './primitives.js';
-let transforms = [object, array, primitives];
+const CONTEXT_KEY = 'reactivity:analyzed';
+let transforms = [object, array];
+function getAnalyzedFile(context, filename) {
+    return context?.get(CONTEXT_KEY)?.get(filename);
+}
 function hasReactiveImport(sourceFile) {
-    let found = imports.find(sourceFile, PACKAGE);
-    for (let i = 0, n = found.length; i < n; i++) {
-        if (found[i].specifiers.has(COMPILER_ENTRYPOINT)) {
-            return true;
-        }
-    }
-    return false;
+    return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
+}
+function isReactiveCallNode(node) {
+    return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === COMPILER_ENTRYPOINT;
 }
-function hasReactiveUsage(code) {
-    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
+const analyze = (sourceFile, _program, context) => {
+    if (!hasReactiveImport(sourceFile)) {
+        return;
+    }
+    let files = context.get(CONTEXT_KEY);
+    if (!files) {
+        files = new Map();
+        context.set(CONTEXT_KEY, files);
+    }
+    files.set(sourceFile.fileName, {
+        hasReactiveImport: true
+    });
+};
+const isReactiveCall = (node, _checker) => {
+    if (!ts.isIdentifier(node.expression)) {
         return false;
     }
-    let sourceFile = ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false), used = false;
-    function visit(node) {
-        if (used) {
-            return;
-        }
-        if (ts.isCallExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === COMPILER_ENTRYPOINT) {
-            used = true;
-            return;
+    return node.expression.text === COMPILER_ENTRYPOINT;
+};
+const transform = (sourceFile, program, context) => {
+    let bindings = new Map(), changed = false, checker = program.getTypeChecker(), code = sourceFile.getFullText(), current = sourceFile, filename = sourceFile.fileName, result;
+    let analyzed = getAnalyzedFile(context, filename);
+    if (!analyzed) {
+        if (!hasReactiveImport(sourceFile)) {
+            return { changed: false, code, sourceFile };
         }
-        ts.forEachChild(node, visit);
     }
-    visit(sourceFile);
-    return used;
-}
-const transform = (sourceFile, program) => {
-    let bindings = new Map(), changed = false, checker = program.getTypeChecker(), code = sourceFile.getFullText(), current = sourceFile, result;
-    if (!hasReactiveImport(sourceFile) || !hasReactiveUsage(code)) {
+    else if (!analyzed.hasReactiveImport) {
         return { changed: false, code, sourceFile };
     }
     for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, COMPILER_NAMESPACE, checker);
+        result = transforms[i](current, bindings, checker);
         if (result !== code) {
-            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
             code = result;
             changed = true;
+            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
         }
     }
     if (changed) {
-        code = imports.modify(code, current, PACKAGE, { remove: [COMPILER_ENTRYPOINT] });
-        code = `import * as ${COMPILER_NAMESPACE} from '@esportsplus/reactivity';\n` + code;
+        let remove = [];
+        if (!ast.hasMatch(current, isReactiveCallNode)) {
+            remove.push(COMPILER_ENTRYPOINT);
+        }
+        code = imports.modify(code, current, PACKAGE, { namespace: COMPILER_NAMESPACE, remove });
         sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     }
     return { changed, code, sourceFile };
 };
-export { transform };
+export { analyze, isReactiveCall, transform };

package/build/compiler/object.d.ts

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

package/build/compiler/object.js

@@ -1,6 +1,7 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, imports } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../constants.js';
+import { code as c, uid } from '@esportsplus/typescript/compiler';
+import { COMPILER_NAMESPACE, COMPILER_TYPES } from '../constants.js';
+import { isReactiveCall } from './index.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -12,62 +13,103 @@ function analyzeProperty(prop, sourceFile) {
     else {
         return null;
     }
-    let value = prop.initializer, valueText = value.getText(sourceFile);
-    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-        return { key, type: COMPILER_TYPES.Computed, valueText };
+    let unwrapped = prop.initializer, value = unwrapped, valueText = value.getText(sourceFile);
+    while (ts.isAsExpression(unwrapped) || ts.isTypeAssertionExpression(unwrapped) || ts.isParenthesizedExpression(unwrapped)) {
+        unwrapped = unwrapped.expression;
     }
-    if (ts.isArrayLiteralExpression(value)) {
-        let elements = value.elements, elementsText = '';
+    if (ts.isArrowFunction(unwrapped) || ts.isFunctionExpression(unwrapped)) {
+        return { isStatic: false, key, type: COMPILER_TYPES.Computed, valueText };
+    }
+    if (ts.isArrayLiteralExpression(unwrapped)) {
+        let elements = unwrapped.elements, isStatic = value === unwrapped;
         for (let i = 0, n = elements.length; i < n; i++) {
-            if (i > 0) {
-                elementsText += ', ';
+            if (isStatic && !isStaticValue(elements[i])) {
+                isStatic = false;
             }
-            elementsText += elements[i].getText(sourceFile);
         }
-        return { key, type: COMPILER_TYPES.Array, valueText: elementsText };
+        return { isStatic, key, type: COMPILER_TYPES.Array, valueText };
     }
-    return { key, type: COMPILER_TYPES.Signal, valueText };
+    return { isStatic: isStaticValue(value), key, type: COMPILER_TYPES.Signal, valueText };
 }
-function buildClassCode(className, properties, ns) {
-    let accessors = [], disposeStatements = [], fields = [], paramCounter = 0;
-    fields.push(`[${ns}.REACTIVE_OBJECT] = true;`);
+function buildClassCode(className, properties) {
+    let accessors = [], body = [], fields = [], generics = [], parameters = [], setters = 0;
     for (let i = 0, n = properties.length; i < n; i++) {
-        let { key, type, valueText } = properties[i];
+        let { isStatic, key, type, valueText } = properties[i], generic = `T${parameters.length}`, parameter = `_p${parameters.length}`;
         if (type === COMPILER_TYPES.Signal) {
-            let param = `_v${paramCounter++}`;
-            accessors.push(`get ${key}() { return ${ns}.read(this.#${key}); }`);
-            accessors.push(`set ${key}(${param}) { ${ns}.write(this.#${key}, ${param}); }`);
-            fields.push(`#${key} = ${ns}.signal(${valueText});`);
+            let value = `_v${setters++}`;
+            if (isStatic) {
+                accessors.push(`
+                    get ${key}() {
+                        return ${COMPILER_NAMESPACE}.read(this.#${key});
+                    }
+                    set ${key}(${value}) {
+                        ${COMPILER_NAMESPACE}.write(this.#${key}, ${value});
+                    }
+                `);
+                fields.push(`#${key} = this[${COMPILER_NAMESPACE}.SIGNAL](${valueText});`);
+            }
+            else {
+                accessors.push(`
+                    get ${key}() {
+                        return ${COMPILER_NAMESPACE}.read(this.#${key}) as ${generic};
+                    }
+                    set ${key}(${value}) {
+                        ${COMPILER_NAMESPACE}.write(this.#${key}, ${value});
+                    }
+                `);
+                body.push(`this.#${key} = this[${COMPILER_NAMESPACE}.SIGNAL](${parameter});`);
+                fields.push(`#${key};`);
+                generics.push(generic);
+                parameters.push(`${parameter}: ${generic}`);
+            }
         }
         else if (type === COMPILER_TYPES.Array) {
-            disposeStatements.push(`this.${key}.dispose();`);
-            fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
+            accessors.push(`
+                get ${key}() {
+                    return this.#${key};
+                }
+            `);
+            body.push(`this.#${key} = this[${COMPILER_NAMESPACE}.REACTIVE_ARRAY](${parameter});`);
+            fields.push(`#${key};`);
+            generics.push(`${generic} extends unknown[]`);
+            parameters.push(`${parameter}: ${generic}`);
         }
         else if (type === COMPILER_TYPES.Computed) {
-            accessors.push(`get ${key}() { return ${ns}.read(this.#${key} ??= ${ns}.computed(${valueText})); }`);
-            disposeStatements.push(`if (this.#${key}) ${ns}.dispose(this.#${key});`);
-            fields.push(`#${key} = null;`);
+            accessors.push(`
+                get ${key}() {
+                    return ${COMPILER_NAMESPACE}.read(this.#${key});
+                }
+            `);
+            body.push(`this.#${key} = this[${COMPILER_NAMESPACE}.COMPUTED](${parameter});`);
+            fields.push(`#${key};`);
+            generics.push(`${generic} extends ${COMPILER_NAMESPACE}.Computed<ReturnType<${generic}>>['fn']`);
+            parameters.push(`${parameter}: ${generic}`);
         }
     }
     return `
-        class ${className} {
+        class ${className}${generics.length > 0 ? `<${generics.join(', ')}>` : ''} extends ${COMPILER_NAMESPACE}.ReactiveObject<any> {
             ${fields.join('\n')}
-            ${accessors.join('\n')}
-
-            dispose() {
-                ${disposeStatements.length > 0 ? disposeStatements.join('\n') : ''}
+            constructor(${parameters.join(', ')}) {
+                super(null);
+                ${body.join('\n')}
             }
+            ${accessors.join('\n')}
         }
     `;
 }
-function isReactiveCall(node, checker) {
-    if (!ts.isIdentifier(node.expression)) {
-        return false;
+function isStaticValue(node) {
+    if (ts.isNumericLiteral(node) ||
+        ts.isStringLiteral(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword ||
+        node.kind === ts.SyntaxKind.UndefinedKeyword) {
+        return true;
     }
-    if (node.expression.text !== COMPILER_ENTRYPOINT) {
-        return false;
+    if (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand)) {
+        return true;
     }
-    return imports.isFromPackage(node.expression, PACKAGE, checker);
+    return false;
 }
 function visit(ctx, node) {
     if (ts.isImportDeclaration(node)) {
@@ -99,7 +141,7 @@ function visit(ctx, node) {
                 }
             }
             ctx.calls.push({
-                className: `_RO${ctx.classCounter++}`,
+                className: uid('ReactiveObject'),
                 end: node.end,
                 properties,
                 start: node.pos,
@@ -109,21 +151,20 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, ns, checker) => {
+export default (sourceFile, bindings, checker) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
         calls: [],
         checker,
         classCounter: 0,
         lastImportEnd: 0,
-        ns,
         sourceFile
     };
     visit(ctx, sourceFile);
     if (ctx.calls.length === 0) {
         return code;
     }
-    let classes = ctx.calls.map(c => buildClassCode(c.className, c.properties, ns)).join('\n'), replacements = [];
+    let classes = ctx.calls.map(c => buildClassCode(c.className, c.properties)).join('\n'), replacements = [];
     replacements.push({
         end: ctx.lastImportEnd,
         newText: code.substring(0, ctx.lastImportEnd) + '\n' + classes + '\n',
@@ -133,7 +174,10 @@ export default (sourceFile, bindings, ns, checker) => {
         let call = ctx.calls[i];
         replacements.push({
             end: call.end,
-            newText: ` new ${call.className}()`,
+            newText: ` new ${call.className}(${call.properties
+                .filter(({ isStatic, type }) => !isStatic || type === COMPILER_TYPES.Computed)
+                .map(p => p.valueText)
+                .join(', ')})`,
             start: call.start
         });
     }

package/build/compiler/plugins/tsc.js

@@ -1,3 +1,3 @@
 import { plugin } from '@esportsplus/typescript/compiler';
-import { transform } from '../index.js';
-export default plugin.tsc(transform);
+import { analyze, transform } from '../index.js';
+export default plugin.tsc({ analyze, transform });

package/build/compiler/plugins/vite.d.ts

@@ -1,13 +1,13 @@
 declare const _default: ({ root }?: {
     root?: string;
 }) => {
-    configResolved(config: import("vite").ResolvedConfig): void;
-    enforce: string;
+    configResolved: (config: unknown) => void;
+    enforce: "pre";
     name: string;
-    transform(code: string, id: string): {
+    transform: (code: string, id: string) => {
         code: string;
         map: null;
     } | null;
-    watchChange(id: string): void;
+    watchChange: (id: string) => void;
 };
 export default _default;

package/build/compiler/plugins/vite.js

@@ -1,7 +1,8 @@
 import { PACKAGE } from '../../constants.js';
 import { plugin } from '@esportsplus/typescript/compiler';
-import { transform } from '../index.js';
+import { analyze, transform } from '../index.js';
 export default plugin.vite({
+    analyze,
     name: PACKAGE,
     transform
 });

package/build/constants.js

@@ -1,7 +1,7 @@
 import { uid } from '@esportsplus/typescript/compiler';
 const COMPILER_ENTRYPOINT = 'reactive';
 const COMPILER_ENTRYPOINT_REGEX = /\breactive\b/;
-const COMPILER_NAMESPACE = uid(COMPILER_ENTRYPOINT);
+const COMPILER_NAMESPACE = uid('reactivity');
 var COMPILER_TYPES;
 (function (COMPILER_TYPES) {
     COMPILER_TYPES[COMPILER_TYPES["Array"] = 0] = "Array";

package/build/index.d.ts

@@ -1,4 +1,5 @@
-export { REACTIVE_OBJECT } from './constants.js';
-export { default as reactive, ReactiveArray } from './reactive/index.js';
+export { isPromise } from '@esportsplus/utilities';
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from './constants.js';
+export { default as reactive, ReactiveArray, ReactiveObject } from './reactive/index.js';
 export * from './system.js';
 export * from './types.js';

package/build/index.js

@@ -1,4 +1,5 @@
-export { REACTIVE_OBJECT } from './constants.js';
-export { default as reactive, ReactiveArray } from './reactive/index.js';
+export { isPromise } from '@esportsplus/utilities';
+export { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from './constants.js';
+export { default as reactive, ReactiveArray, ReactiveObject } from './reactive/index.js';
 export * from './system.js';
 export * from './types.js';

package/build/reactive/array.js

@@ -1,8 +1,9 @@
 import { isArray } from '@esportsplus/utilities';
 import { read, signal, write } from '../system.js';
-import { REACTIVE_ARRAY, REACTIVE_OBJECT } from '../constants.js';
+import { REACTIVE_ARRAY } from '../constants.js';
+import { isReactiveObject } from './object.js';
 function dispose(value) {
-    if (value !== null && typeof value === 'object' && value[REACTIVE_OBJECT] === true) {
+    if (isReactiveObject(value)) {
         value.dispose();
     }
 }

package/build/reactive/index.d.ts

@@ -1,10 +1,12 @@
-import { ReactiveArray } from './array.js';
 import { 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;
 } ? {
     never: '[ dispose ] is a reserved key';
 } : T : never;
-declare function reactive<T extends Record<PropertyKey, any>>(_input: Guard<T>): Reactive<T>;
+declare function reactive<T extends unknown[]>(input: T): Reactive<T>;
+declare function reactive<T extends Record<PropertyKey, unknown>>(input: Guard<T>): Reactive<T>;
 export default reactive;
-export { reactive, ReactiveArray };
+export { reactive, ReactiveArray, ReactiveObject };

package/build/reactive/index.js

@@ -1,8 +1,29 @@
+import { onCleanup, root } from '@esportsplus/reactivity';
+import { isArray, isObject } from '@esportsplus/utilities';
 import { ReactiveArray } from './array.js';
-import { COMPILER_ENTRYPOINT, PACKAGE } from '../constants.js';
-function reactive(_input) {
-    throw new Error(`${PACKAGE}: ${COMPILER_ENTRYPOINT}() called at runtime. ` +
-        'Ensure vite plugin is configured.');
+import { ReactiveObject } from './object.js';
+import { PACKAGE } from '../constants.js';
+function reactive(input) {
+    let dispose = false, value = root(() => {
+        let response;
+        if (isObject(input)) {
+            response = new ReactiveObject(input);
+        }
+        else if (isArray(input)) {
+            response = new ReactiveArray(...input);
+        }
+        if (response) {
+            if (root.disposables) {
+                dispose = true;
+            }
+            return response;
+        }
+        throw new Error(`${PACKAGE}: 'reactive' received invalid input - ${JSON.stringify(input)}`);
+    });
+    if (dispose) {
+        onCleanup(() => value.dispose());
+    }
+    return value;
 }
 export default reactive;
-export { reactive, ReactiveArray };
+export { reactive, ReactiveArray, ReactiveObject };

package/build/reactive/object.d.ts

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

package/build/reactive/object.js

@@ -0,0 +1,86 @@
+import { defineProperty, isArray, isPromise } from '@esportsplus/utilities';
+import { computed, dispose, effect, read, root, signal, write } from '../system.js';
+import { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from '../constants.js';
+import { ReactiveArray } from './array.js';
+class ReactiveObject {
+    disposers = null;
+    constructor(data) {
+        if (data == null) {
+            return;
+        }
+        for (let key in data) {
+            let value = data[key], type = typeof value;
+            if (type === 'function') {
+                let node = this[COMPUTED](value);
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get: () => read(node)
+                });
+                continue;
+            }
+            if (value == null || type !== 'object') {
+            }
+            else if (isArray(value)) {
+                defineProperty(this, key, {
+                    enumerable: true,
+                    value: this[REACTIVE_ARRAY](value)
+                });
+                continue;
+            }
+            let node = signal(value);
+            defineProperty(this, key, {
+                enumerable: true,
+                get() {
+                    return read(node);
+                },
+                set(v) {
+                    write(node, v);
+                }
+            });
+        }
+    }
+    [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, version = 0;
+                node = signal(undefined);
+                (this.disposers ??= []).push(effect(() => {
+                    let id = ++version;
+                    read(factory).then((v) => {
+                        if (id !== version) {
+                            return;
+                        }
+                        write(node, v);
+                    });
+                }));
+            }
+            else {
+                (this.disposers ??= []).push(() => dispose(node));
+            }
+            return node;
+        });
+    }
+    [SIGNAL](value) {
+        return signal(value);
+    }
+    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/build/types.d.ts

@@ -29,8 +29,8 @@ type Reactive<T> = T extends (...args: unknown[]) => Promise<infer R> ? (R | und
     readonly [READONLY]: true;
 } : T extends (...args: any[]) => infer R ? R & {
     readonly [READONLY]: true;
-} : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'on' | 'once'> : T extends Record<PropertyKey, unknown> ? {
-    [K in keyof T]: T[K];
+} : T extends (infer U)[] ? U[] & Pick<ReactiveArray<U>, 'clear' | 'dispose' | 'on' | 'once'> : T extends Record<PropertyKey, unknown> ? {
+    [K in keyof T]: Reactive<T[K]>;
 } & {
     dispose: VoidFunction;
 } : T;

package/package.json

@@ -4,9 +4,9 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.22.0",
+    "@esportsplus/typescript": "^0.24.2",
     "@types/node": "^25.0.3",
-    "vite": "^7.3.0"
+    "vite": "^7.3.1"
   },
   "exports": {
     ".": {
@@ -31,7 +31,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.27.0",
+  "version": "0.27.3",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",