@esportsplus/reactivity 0.26.1 → 0.27.2

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) => 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) => {
+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) => 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,61 +1,65 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REGEX, COMPILER_NAMESPACE } 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];
-function contains(code) {
-    if (!c.contains(code, { regex: COMPILER_ENTRYPOINT_REGEX })) {
-        return false;
-    }
-    let ctx = {
-        imported: false,
-        used: false
-    };
-    visit(ctx, ts.createSourceFile('detect.ts', code, ts.ScriptTarget.Latest, false));
-    return ctx.imported && ctx.used;
+const CONTEXT_KEY = 'reactivity:analyzed';
+let transforms = [object, array];
+function getAnalyzedFile(context, filename) {
+    return context?.get(CONTEXT_KEY)?.get(filename);
+}
+function hasReactiveImport(sourceFile) {
+    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 visit(ctx, node) {
-    if (ctx.imported && ctx.used) {
+const analyze = (sourceFile, _program, context) => {
+    if (!hasReactiveImport(sourceFile)) {
         return;
     }
-    if (ts.isImportDeclaration(node) &&
-        node.importClause?.namedBindings &&
-        ts.isNamedImports(node.importClause.namedBindings)) {
-        let elements = node.importClause.namedBindings.elements;
-        for (let i = 0, n = elements.length; i < n; i++) {
-            let element = elements[i];
-            if ((element.propertyName?.text ?? element.name.text) === COMPILER_ENTRYPOINT) {
-                ctx.imported = true;
-                break;
-            }
-        }
+    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;
     }
-    if (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === COMPILER_ENTRYPOINT) {
-        ctx.used = true;
+    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, n => visit(ctx, n));
-}
-const transform = (sourceFile) => {
-    let bindings = new Map(), changed = false, code = sourceFile.getFullText(), current = sourceFile, result;
-    if (!contains(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);
+        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 = `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) => 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 } from '@esportsplus/typescript/compiler';
-import { 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,75 +13,110 @@ 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 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 (ts.isPrefixUnaryExpression(node) && ts.isNumericLiteral(node.operand)) {
+        return true;
+    }
+    return false;
+}
 function visit(ctx, node) {
     if (ts.isImportDeclaration(node)) {
         ctx.lastImportEnd = node.end;
-        if (ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text.includes(PACKAGE)) {
-            let clause = node.importClause;
-            if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-                let elements = clause.namedBindings.elements;
-                for (let i = 0, n = elements.length; i < n; i++) {
-                    if (elements[i].name.text === 'reactive') {
-                        ctx.hasReactiveImport = true;
-                        break;
-                    }
-                }
-            }
-        }
     }
-    if (ctx.hasReactiveImport &&
-        ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive') {
+    if (ts.isCallExpression(node) &&
+        isReactiveCall(node, ctx.checker)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let properties = [], props = arg.properties, varName = null;
@@ -105,7 +141,7 @@ function visit(ctx, node) {
                 }
             }
             ctx.calls.push({
-                className: `_RO${ctx.classCounter++}`,
+                className: uid('ReactiveObject'),
                 end: node.end,
                 properties,
                 start: node.pos,
@@ -115,21 +151,20 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-export default (sourceFile, bindings, ns) => {
+export default (sourceFile, bindings, checker) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
         calls: [],
+        checker,
         classCounter: 0,
-        hasReactiveImport: false,
         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',
@@ -139,7 +174,10 @@ export default (sourceFile, bindings, ns) => {
         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.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,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.21.0",
+    "@esportsplus/typescript": "^0.24.1",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0"
   },
@@ -31,7 +31,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.26.1",
+  "version": "0.27.2",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",