@esportsplus/reactivity 0.22.3 → 0.23.0

package/build/index.d.ts

@@ -1,4 +1,4 @@
-export { default as reactive } from './reactive/index.js';
 export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants.js';
+export { default as reactive } from './reactive/index.js';
 export * from './system.js';
 export * from './types.js';

package/build/index.js

@@ -1,4 +1,4 @@
-export { default as reactive } from './reactive/index.js';
 export { STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED } from './constants.js';
+export { default as reactive } from './reactive/index.js';
 export * from './system.js';
 export * from './types.js';

package/build/reactive/array.d.ts

@@ -35,8 +35,11 @@ type Listener<V> = {
 };
 type Listeners = Record<string, (Listener<any> | null)[]>;
 declare class ReactiveArray<T> extends Array<T> {
+    private _length;
     listeners: Listeners;
     constructor(...items: T[]);
+    $length(): number;
+    $set(i: number, value: T): void;
     clear(): void;
     concat(...items: ConcatArray<T>[]): ReactiveArray<T>;
     concat(...items: (T | ConcatArray<T>)[]): ReactiveArray<T>;

package/build/reactive/array.js

@@ -1,13 +1,33 @@
 import { isArray } from '@esportsplus/utilities';
-import { REACTIVE_ARRAY } from '../constants.js';
-import { isReactiveObject } from './object.js';
+import { read, set, signal } from '../system.js';
+import { REACTIVE_ARRAY, REACTIVE_OBJECT } from '../constants.js';
+function isReactiveObject(value) {
+    return value !== null && typeof value === 'object' && value[REACTIVE_OBJECT] === true;
+}
 class ReactiveArray extends Array {
+    _length;
     listeners = {};
     constructor(...items) {
         super(...items);
+        this._length = signal(items.length);
+    }
+    $length() {
+        return read(this._length);
+    }
+    $set(i, value) {
+        let prev = this[i];
+        if (prev === value) {
+            return;
+        }
+        this[i] = value;
+        if (i >= super.length) {
+            set(this._length, i + 1);
+        }
+        this.dispatch('set', { index: i, item: value });
     }
     clear() {
         this.dispose();
+        set(this._length, 0);
         this.dispatch('clear');
     }
     concat(...items) {
@@ -26,6 +46,7 @@ class ReactiveArray extends Array {
             }
         }
         if (added.length) {
+            set(this._length, super.length);
             this.dispatch('concat', { items: added });
         }
         return this;
@@ -62,6 +83,7 @@ class ReactiveArray extends Array {
                 item.dispose();
             }
         }
+        set(this._length, 0);
     }
     on(event, listener) {
         let listeners = this.listeners[event];
@@ -92,6 +114,7 @@ class ReactiveArray extends Array {
     pop() {
         let item = super.pop();
         if (item !== undefined) {
+            set(this._length, super.length);
             if (isReactiveObject(item)) {
                 item.dispose();
             }
@@ -100,7 +123,11 @@ class ReactiveArray extends Array {
         return item;
     }
     push(...items) {
+        if (!items.length) {
+            return super.length;
+        }
         let length = super.push(...items);
+        set(this._length, length);
         this.dispatch('push', { items });
         return length;
     }
@@ -112,6 +139,7 @@ class ReactiveArray extends Array {
     shift() {
         let item = super.shift();
         if (item !== undefined) {
+            set(this._length, super.length);
             if (isReactiveObject(item)) {
                 item.dispose();
             }
@@ -151,6 +179,7 @@ class ReactiveArray extends Array {
     splice(start, deleteCount = this.length, ...items) {
         let removed = super.splice(start, deleteCount, ...items);
         if (items.length > 0 || removed.length > 0) {
+            set(this._length, super.length);
             for (let i = 0, n = removed.length; i < n; i++) {
                 let item = removed[i];
                 if (isReactiveObject(item)) {
@@ -163,6 +192,7 @@ class ReactiveArray extends Array {
     }
     unshift(...items) {
         let length = super.unshift(...items);
+        set(this._length, length);
         this.dispatch('unshift', { items });
         return length;
     }

package/build/reactive/index.d.ts

@@ -1,18 +1,21 @@
-import { Prettify } from '@esportsplus/utilities';
+import { REACTIVE_OBJECT } from '../constants.js';
 import { ReactiveArray } from './array.js';
-import { ReactiveObject } from './object.js';
-type API<T> = T extends Record<PropertyKey, unknown> ? Prettify<{
-    [K in keyof T]: Infer<T[K]>;
-} & {
-    dispose: VoidFunction;
-}> : T extends (infer U)[] ? ReactiveArray<U> : never;
-type Guard<T> = T extends {
+declare const READONLY: unique symbol;
+type ReactiveObject<T extends Record<PropertyKey, unknown>> = T & {
+    [REACTIVE_OBJECT]: true;
+    dispose(): void;
+};
+type ReactiveObjectGuard<T> = T extends {
     dispose: any;
 } ? {
-    never: '[ dispose ] are reserved keys';
+    never: '[ dispose ] is a reserved key';
 } : T;
-type Infer<T> = T extends (...args: unknown[]) => Promise<infer R> ? R | undefined : T extends (...args: any[]) => infer R ? R : T extends (infer U)[] ? ReactiveArray<U> : T extends ReactiveObject<any> ? T : T extends Record<PropertyKey, unknown> ? {
-    [K in keyof T]: T[K];
-} : T;
-declare const _default: <T extends Record<PropertyKey, any> | unknown[]>(input: Guard<T>) => API<T>;
-export default _default;
+declare function reactive<T extends () => unknown>(_input: T): ReturnType<T> & {
+    readonly [READONLY]: true;
+};
+declare function reactive<T extends Record<PropertyKey, any>>(_input: ReactiveObjectGuard<T>): ReactiveObject<T>;
+declare function reactive<T>(_input: T[]): ReactiveArray<T>;
+declare function reactive<T>(_input: T): T;
+export default reactive;
+export { reactive, ReactiveArray };
+export type { ReactiveObject };

package/build/reactive/index.js

@@ -1,26 +1,8 @@
-import { isArray, isObject } from '@esportsplus/utilities';
-import { onCleanup, root } from '../system.js';
+import { REACTIVE_OBJECT } from '../constants.js';
 import { ReactiveArray } from './array.js';
-import { ReactiveObject } from './object.js';
-export default (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(`@esportsplus/reactivity: 'reactive' received invalid input - ${JSON.stringify(input)}`);
-    });
-    if (dispose) {
-        onCleanup(() => value.dispose());
-    }
-    return value;
-};
+function reactive(_input) {
+    throw new Error('@esportsplus/reactivity: reactive() called at runtime. ' +
+        'Ensure vite-plugin-reactivity-compile is configured.');
+}
+export default reactive;
+export { reactive, ReactiveArray };

package/build/system.js

@@ -1,5 +1,5 @@
-import { isObject } from '@esportsplus/utilities';
 import { COMPUTED, SIGNAL, STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING } from './constants.js';
+import { isObject } from '@esportsplus/utilities';
 let depth = 0, heap = new Array(64), heap_i = 0, heap_n = 0, linkPool = [], linkPoolMax = 1000, microtask = queueMicrotask, notified = false, observer = null, scope = null, stabilizer = STABILIZER_IDLE, version = 0;
 function cleanup(computed) {
     if (!computed.cleanup) {

package/build/transformer/core/detector.d.ts

@@ -0,0 +1,2 @@
+declare const mightNeedTransform: (code: string) => boolean;
+export { mightNeedTransform };

package/build/transformer/core/detector.js

@@ -0,0 +1,6 @@
+import { mightNeedTransform as checkTransform } from '@esportsplus/typescript/transformer';
+let regex = /import\s*\{[^}]*\breactive\b[^}]*\}\s*from\s*['"]@esportsplus\/reactivity/;
+const mightNeedTransform = (code) => {
+    return checkTransform(code, { regex });
+};
+export { mightNeedTransform };

package/build/transformer/core/index.d.ts

@@ -0,0 +1,10 @@
+import type { TransformOptions, TransformResult } from '../../types.js';
+import { mightNeedTransform } from './detector.js';
+import ts from 'typescript';
+declare const createTransformer: (options?: TransformOptions) => ts.TransformerFactory<ts.SourceFile>;
+declare const transform: (sourceFile: ts.SourceFile, options?: TransformOptions) => TransformResult;
+export { createTransformer, mightNeedTransform, transform };
+export { injectAutoDispose } from './transforms/auto-dispose.js';
+export { transformReactiveArrays } from './transforms/reactive-array.js';
+export { transformReactiveObjects } from './transforms/reactive-object.js';
+export { transformReactivePrimitives } from './transforms/reactive-primitives.js';

package/build/transformer/core/index.js

@@ -0,0 +1,55 @@
+import { injectAutoDispose } from './transforms/auto-dispose.js';
+import { mightNeedTransform } from './detector.js';
+import { transformReactiveArrays } from './transforms/reactive-array.js';
+import { transformReactiveObjects } from './transforms/reactive-object.js';
+import { transformReactivePrimitives } from './transforms/reactive-primitives.js';
+import ts from 'typescript';
+const createTransformer = (options) => {
+    return () => {
+        return (sourceFile) => {
+            let result = transform(sourceFile, options);
+            return result.transformed ? result.sourceFile : sourceFile;
+        };
+    };
+};
+const transform = (sourceFile, options) => {
+    let bindings = new Map(), code = sourceFile.getFullText(), current = sourceFile, original = code, result;
+    if (!mightNeedTransform(code)) {
+        return { code, sourceFile, transformed: false };
+    }
+    result = transformReactiveObjects(current, bindings);
+    if (result !== code) {
+        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        code = result;
+    }
+    result = transformReactiveArrays(current, bindings);
+    if (result !== code) {
+        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        code = result;
+    }
+    result = transformReactivePrimitives(current, bindings);
+    if (result !== code) {
+        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        code = result;
+    }
+    if (options?.autoDispose) {
+        result = injectAutoDispose(current);
+        if (result !== code) {
+            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+            code = result;
+        }
+    }
+    if (code === original) {
+        return { code, sourceFile, transformed: false };
+    }
+    return {
+        code,
+        sourceFile: current,
+        transformed: true
+    };
+};
+export { createTransformer, mightNeedTransform, transform };
+export { injectAutoDispose } from './transforms/auto-dispose.js';
+export { transformReactiveArrays } from './transforms/reactive-array.js';
+export { transformReactiveObjects } from './transforms/reactive-object.js';
+export { transformReactivePrimitives } from './transforms/reactive-primitives.js';

package/build/transformer/core/transforms/auto-dispose.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const injectAutoDispose: (sourceFile: ts.SourceFile) => string;
+export { injectAutoDispose };

package/build/transformer/core/transforms/auto-dispose.js

@@ -0,0 +1,116 @@
+import { uid } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+import { applyReplacements } from './utilities.js';
+const TRAILING_SEMICOLON = /;$/;
+function visitFunctionBody(body, parentBody) {
+    let disposables = [], effectsToCapture = [], returnStatement = null;
+    function visit(n) {
+        if (ts.isVariableDeclaration(n) &&
+            ts.isIdentifier(n.name) &&
+            n.initializer &&
+            ts.isCallExpression(n.initializer) &&
+            ts.isIdentifier(n.initializer.expression) &&
+            n.initializer.expression.text === 'reactive') {
+            disposables.push({ name: n.name.text, type: 'reactive' });
+        }
+        if (ts.isCallExpression(n) &&
+            ts.isIdentifier(n.expression) &&
+            n.expression.text === 'effect') {
+            if (ts.isVariableDeclaration(n.parent) && ts.isIdentifier(n.parent.name)) {
+                disposables.push({ name: n.parent.name.text, type: 'effect' });
+            }
+            else if (ts.isExpressionStatement(n.parent)) {
+                let name = uid('effect');
+                effectsToCapture.push({
+                    end: n.parent.end,
+                    name,
+                    start: n.parent.pos
+                });
+                disposables.push({ name, type: 'effect' });
+            }
+        }
+        if (ts.isReturnStatement(n) &&
+            n.expression &&
+            (ts.isArrowFunction(n.expression) || ts.isFunctionExpression(n.expression)) &&
+            n.parent === parentBody) {
+            returnStatement = n;
+        }
+        ts.forEachChild(n, visit);
+    }
+    visit(body);
+    return { disposables, effectsToCapture, returnStatement };
+}
+function processFunction(node, sourceFile, edits) {
+    if (!node.body || !ts.isBlock(node.body)) {
+        return;
+    }
+    let result = visitFunctionBody(node.body, node.body), disposables = result.disposables, effectsToCapture = result.effectsToCapture, returnStatement = result.returnStatement;
+    if (disposables.length === 0 || !returnStatement || !returnStatement.expression) {
+        return;
+    }
+    let cleanupFn = returnStatement.expression;
+    if (!cleanupFn.body) {
+        return;
+    }
+    let disposeStatements = [];
+    for (let i = disposables.length - 1; i >= 0; i--) {
+        let d = disposables[i];
+        if (d.type === 'reactive') {
+            disposeStatements.push(`${d.name}.dispose();`);
+        }
+        else {
+            disposeStatements.push(`${d.name}();`);
+        }
+    }
+    let disposeCode = disposeStatements.join('\n');
+    if (ts.isBlock(cleanupFn.body)) {
+        edits.push({
+            cleanupBodyEnd: cleanupFn.body.statements[0]?.pos ?? cleanupFn.body.end - 1,
+            cleanupBodyStart: cleanupFn.body.pos + 1,
+            disposeCode,
+            effectsToCapture
+        });
+    }
+    else {
+        edits.push({
+            cleanupBodyEnd: cleanupFn.body.end,
+            cleanupBodyStart: cleanupFn.body.pos,
+            disposeCode: `{ ${disposeCode}\n return ${cleanupFn.body.getText(sourceFile)}; }`,
+            effectsToCapture
+        });
+    }
+}
+const injectAutoDispose = (sourceFile) => {
+    let code = sourceFile.getFullText(), edits = [];
+    function visit(node) {
+        if (ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node)) {
+            processFunction(node, sourceFile, edits);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (edits.length === 0) {
+        return code;
+    }
+    let replacements = [];
+    for (let i = 0, n = edits.length; i < n; i++) {
+        let edit = edits[i], effects = edit.effectsToCapture;
+        for (let j = 0, m = effects.length; j < m; j++) {
+            let effect = effects[j], original = code.substring(effect.start, effect.end).trim();
+            replacements.push({
+                end: effect.end,
+                newText: `const ${effect.name} = ${original.replace(TRAILING_SEMICOLON, '')}`,
+                start: effect.start
+            });
+        }
+        replacements.push({
+            end: edit.cleanupBodyEnd,
+            newText: `\n${edit.disposeCode}`,
+            start: edit.cleanupBodyStart
+        });
+    }
+    return applyReplacements(code, replacements);
+};
+export { injectAutoDispose };

package/build/transformer/core/transforms/reactive-array.d.ts

@@ -0,0 +1,4 @@
+import type { Bindings } from '../../../types.js';
+import ts from 'typescript';
+declare const transformReactiveArrays: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
+export { transformReactiveArrays };

package/build/transformer/core/transforms/reactive-array.js

@@ -0,0 +1,89 @@
+import ts from 'typescript';
+import { applyReplacements } from './utilities.js';
+function getPropertyPath(node) {
+    let current = node, parts = [];
+    while (ts.isPropertyAccessExpression(current)) {
+        parts.unshift(current.name.text);
+        current = current.expression;
+    }
+    if (ts.isIdentifier(current)) {
+        parts.unshift(current.text);
+        return parts.join('.');
+    }
+    return null;
+}
+function getExpressionName(node) {
+    if (ts.isIdentifier(node)) {
+        return node.text;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return getPropertyPath(node);
+    }
+    return null;
+}
+function isAssignmentTarget(node) {
+    let parent = node.parent;
+    if ((ts.isBinaryExpression(parent) && parent.left === node) ||
+        ts.isPostfixUnaryExpression(parent) ||
+        ts.isPrefixUnaryExpression(parent)) {
+        return true;
+    }
+    return false;
+}
+const transformReactiveArrays = (sourceFile, bindings) => {
+    let code = sourceFile.getFullText(), replacements = [];
+    function visit(node) {
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+            if (ts.isIdentifier(node.initializer) && bindings.get(node.initializer.text) === 'array') {
+                bindings.set(node.name.text, 'array');
+            }
+            if (ts.isPropertyAccessExpression(node.initializer)) {
+                let path = getPropertyPath(node.initializer);
+                if (path && bindings.get(path) === 'array') {
+                    bindings.set(node.name.text, 'array');
+                }
+            }
+        }
+        if ((ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) && node.parameters) {
+            for (let i = 0, n = node.parameters.length; i < n; i++) {
+                let param = node.parameters[i];
+                if ((ts.isIdentifier(param.name) && param.type) &&
+                    ts.isTypeReferenceNode(param.type) &&
+                    ts.isIdentifier(param.type.typeName) &&
+                    param.type.typeName.text === 'ReactiveArray') {
+                    bindings.set(param.name.text, 'array');
+                }
+            }
+        }
+        if (ts.isPropertyAccessExpression(node) &&
+            node.name.text === 'length' &&
+            !isAssignmentTarget(node)) {
+            let objName = getExpressionName(node.expression);
+            if (objName && bindings.get(objName) === 'array') {
+                let objText = node.expression.getText(sourceFile);
+                replacements.push({
+                    end: node.end,
+                    newText: `${objText}.$length()`,
+                    start: node.pos
+                });
+            }
+        }
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isElementAccessExpression(node.left)) {
+            let elemAccess = node.left, objName = getExpressionName(elemAccess.expression);
+            if (objName && bindings.get(objName) === 'array') {
+                let indexText = elemAccess.argumentExpression.getText(sourceFile), objText = elemAccess.expression.getText(sourceFile), valueText = node.right.getText(sourceFile);
+                replacements.push({
+                    end: node.end,
+                    newText: `${objText}.$set(${indexText}, ${valueText})`,
+                    start: node.pos
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return applyReplacements(code, replacements);
+};
+export { transformReactiveArrays };

package/build/transformer/core/transforms/reactive-object.d.ts

@@ -0,0 +1,4 @@
+import type { Bindings } from '../../../types.js';
+import ts from 'typescript';
+declare const transformReactiveObjects: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
+export { transformReactiveObjects };

package/build/transformer/core/transforms/reactive-object.js

@@ -0,0 +1,155 @@
+import { uid } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+import { addMissingImports, applyReplacements } from './utilities.js';
+const CLASS_NAME_REGEX = /class (\w+)/;
+const EXTRA_IMPORTS = [
+    { module: '@esportsplus/reactivity/constants', specifier: 'REACTIVE_OBJECT' },
+    { module: '@esportsplus/reactivity/reactive/array', specifier: 'ReactiveArray' }
+];
+function analyzeProperty(prop, sourceFile) {
+    if (!ts.isPropertyAssignment(prop)) {
+        return null;
+    }
+    let key;
+    if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) {
+        key = prop.name.text;
+    }
+    else {
+        return null;
+    }
+    let value = prop.initializer, valueText = value.getText(sourceFile);
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+        return { key, type: 'computed', valueText };
+    }
+    if (ts.isArrayLiteralExpression(value)) {
+        return { key, type: 'array', valueText };
+    }
+    return { key, type: 'signal', valueText };
+}
+function buildClassCode(className, properties) {
+    let accessors = [], disposeStatements = [], fields = [];
+    fields.push(`[REACTIVE_OBJECT] = true;`);
+    for (let i = 0, n = properties.length; i < n; i++) {
+        let { key, type, valueText } = properties[i];
+        if (type === 'signal') {
+            let param = uid('v');
+            fields.push(`#${key} = signal(${valueText});`);
+            accessors.push(`get ${key}() { return read(this.#${key}); }`);
+            accessors.push(`set ${key}(${param}) { set(this.#${key}, ${param}); }`);
+        }
+        else if (type === 'array') {
+            let elements = valueText.slice(1, -1);
+            fields.push(`${key} = new ReactiveArray(${elements});`);
+            disposeStatements.push(`this.${key}.dispose();`);
+        }
+        else if (type === 'computed') {
+            fields.push(`#${key}: Computed<unknown> | null = null;`);
+            accessors.push(`get ${key}() { return read(this.#${key} ??= computed(${valueText})); }`);
+            disposeStatements.push(`if (this.#${key}) dispose(this.#${key});`);
+        }
+    }
+    let disposeBody = disposeStatements.length > 0 ? disposeStatements.join('\n') : '';
+    return `
+        class ${className} {
+            ${fields.join('\n')}
+            ${accessors.join('\n')}
+
+            dispose() {
+                ${disposeBody}
+            }
+        }
+    `;
+}
+const transformReactiveObjects = (sourceFile, bindings) => {
+    let allNeededImports = new Set(), calls = [], code = sourceFile.getFullText(), hasReactiveImport = false, lastImportEnd = 0;
+    function visit(node) {
+        if (ts.isImportDeclaration(node)) {
+            lastImportEnd = node.end;
+            if (ts.isStringLiteral(node.moduleSpecifier) &&
+                node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
+                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') {
+                            hasReactiveImport = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (hasReactiveImport &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'reactive') {
+            let arg = node.arguments[0];
+            if (arg && ts.isObjectLiteralExpression(arg)) {
+                let varName = null;
+                if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+                    varName = node.parent.name.text;
+                    bindings.set(varName, 'object');
+                }
+                let needsImports = new Set(), properties = [];
+                needsImports.add('REACTIVE_OBJECT');
+                let props = arg.properties;
+                for (let i = 0, n = props.length; i < n; i++) {
+                    let prop = props[i];
+                    if (ts.isSpreadAssignment(prop)) {
+                        return;
+                    }
+                    let analyzed = analyzeProperty(prop, sourceFile);
+                    if (!analyzed) {
+                        return;
+                    }
+                    properties.push(analyzed);
+                    if (analyzed.type === 'signal') {
+                        needsImports.add('read');
+                        needsImports.add('set');
+                        needsImports.add('signal');
+                    }
+                    else if (analyzed.type === 'array') {
+                        needsImports.add('ReactiveArray');
+                        if (varName) {
+                            bindings.set(`${varName}.${analyzed.key}`, 'array');
+                        }
+                    }
+                    else if (analyzed.type === 'computed') {
+                        needsImports.add('computed');
+                        needsImports.add('dispose');
+                        needsImports.add('read');
+                    }
+                }
+                needsImports.forEach(imp => allNeededImports.add(imp));
+                calls.push({
+                    end: node.end,
+                    generatedClass: buildClassCode(uid('ReactiveObject'), properties),
+                    needsImports,
+                    start: node.pos,
+                    varName
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (calls.length === 0) {
+        return code;
+    }
+    let replacements = [];
+    replacements.push({
+        end: lastImportEnd,
+        newText: code.substring(0, lastImportEnd) + '\n' + calls.map(c => c.generatedClass).join('\n') + '\n',
+        start: 0
+    });
+    for (let i = 0, n = calls.length; i < n; i++) {
+        let call = calls[i], classMatch = call.generatedClass.match(CLASS_NAME_REGEX);
+        replacements.push({
+            end: call.end,
+            newText: ` new ${classMatch ? classMatch[1] : 'ReactiveObject'}()`,
+            start: call.start
+        });
+    }
+    return addMissingImports(applyReplacements(code, replacements), allNeededImports, EXTRA_IMPORTS);
+};
+export { transformReactiveObjects };

package/build/transformer/core/transforms/reactive-primitives.d.ts

@@ -0,0 +1,4 @@
+import type { Bindings } from '../../../types.js';
+import ts from 'typescript';
+declare const transformReactivePrimitives: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
+export { transformReactivePrimitives };