@esportsplus/reactivity 0.24.5 → 0.25.0

package/build/reactive/index.d.ts

@@ -1,10 +1,16 @@
+import { Prettify } from '@esportsplus/utilities';
 import { REACTIVE_OBJECT } from '../constants.js';
 import { ReactiveArray } from './array.js';
 declare const READONLY: unique symbol;
-type ReactiveObject<T extends Record<PropertyKey, unknown>> = 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;
+type ReactiveObject<T> = T extends Record<PropertyKey, unknown> ? Prettify<{
+    [K in keyof T]: Infer<T[K]>;
+} & {
     [REACTIVE_OBJECT]: true;
-    dispose(): void;
-};
+    dispose: VoidFunction;
+}> : T extends (infer U)[] ? ReactiveArray<U> : never;
 type ReactiveObjectGuard<T> = T extends {
     dispose: any;
 } ? {
@@ -15,7 +21,6 @@ declare function reactive<T extends () => unknown>(_input: T): ReturnType<T> & {
 };
 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/transformer/index.d.ts

@@ -1,7 +1,9 @@
+import type { TransformResult } from '../types.js';
 import { mightNeedTransform } from './detector.js';
 import { ts } from '@esportsplus/typescript';
 declare const createTransformer: () => ts.TransformerFactory<ts.SourceFile>;
-export { createTransformer, mightNeedTransform };
-export { createArrayTransformer } from './transforms/array.js';
-export { createObjectTransformer } from './transforms/object.js';
-export { createPrimitivesTransformer } from './transforms/primitives.js';
+declare const transform: (sourceFile: ts.SourceFile) => TransformResult;
+export { createTransformer, mightNeedTransform, transform };
+export { transformReactiveArrays } from './transforms/array.js';
+export { transformReactiveObjects } from './transforms/object.js';
+export { transformReactivePrimitives } from './transforms/primitives.js';

package/build/transformer/index.js

@@ -1,113 +1,46 @@
-import { uid } from '@esportsplus/typescript/transformer';
-import { createArrayTransformer } from './transforms/array.js';
-import { createObjectTransformer } from './transforms/object.js';
-import { createPrimitivesTransformer } from './transforms/primitives.js';
 import { mightNeedTransform } from './detector.js';
+import { transformReactiveArrays } from './transforms/array.js';
+import { transformReactiveObjects } from './transforms/object.js';
+import { transformReactivePrimitives } from './transforms/primitives.js';
 import { ts } from '@esportsplus/typescript';
-function addImportsTransformer(neededImports, ns) {
-    return (context) => {
-        return (sourceFile) => {
-            if (neededImports.size === 0) {
-                return sourceFile;
-            }
-            let factory = context.factory, needsArray = false, needsConstants = false, needsReactivity = false, newStatements = [];
-            for (let imp of neededImports) {
-                if (imp === 'ReactiveArray') {
-                    needsArray = true;
-                }
-                else if (imp === 'REACTIVE_OBJECT') {
-                    needsConstants = true;
-                }
-                else {
-                    needsReactivity = true;
-                }
-            }
-            if (needsReactivity) {
-                newStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamespaceImport(factory.createIdentifier(ns.reactivity))), factory.createStringLiteral('@esportsplus/reactivity')));
-            }
-            if (needsArray) {
-                newStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamespaceImport(factory.createIdentifier(ns.array))), factory.createStringLiteral('@esportsplus/reactivity/reactive/array')));
-            }
-            if (needsConstants) {
-                newStatements.push(factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamespaceImport(factory.createIdentifier(ns.constants))), factory.createStringLiteral('@esportsplus/reactivity/constants')));
-            }
-            let filteredStatements = [], insertIndex = 0, statements = sourceFile.statements;
-            for (let i = 0, n = statements.length; i < n; i++) {
-                let stmt = statements[i];
-                if (ts.isImportDeclaration(stmt)) {
-                    insertIndex = filteredStatements.length + 1;
-                    if (ts.isStringLiteral(stmt.moduleSpecifier)) {
-                        let module = stmt.moduleSpecifier.text;
-                        if (module === '@esportsplus/reactivity' ||
-                            module === '@esportsplus/reactivity/reactive/array' ||
-                            module === '@esportsplus/reactivity/constants') {
-                            continue;
-                        }
-                    }
-                }
-                filteredStatements.push(stmt);
-            }
-            let updatedStatements = [
-                ...filteredStatements.slice(0, insertIndex),
-                ...newStatements,
-                ...filteredStatements.slice(insertIndex)
-            ];
-            return factory.updateSourceFile(sourceFile, updatedStatements);
-        };
-    };
-}
-function insertClassesTransformer(generatedClasses) {
-    return (context) => {
-        return (sourceFile) => {
-            if (generatedClasses.length === 0) {
-                return sourceFile;
-            }
-            let factory = context.factory;
-            let insertIndex = 0, statements = sourceFile.statements;
-            for (let i = 0, n = statements.length; i < n; i++) {
-                if (ts.isImportDeclaration(statements[i])) {
-                    insertIndex = i + 1;
-                }
-                else {
-                    break;
-                }
-            }
-            let classDecls = generatedClasses.map(gc => gc.classDecl), updatedStatements = [
-                ...statements.slice(0, insertIndex),
-                ...classDecls,
-                ...statements.slice(insertIndex)
-            ];
-            return factory.updateSourceFile(sourceFile, updatedStatements);
-        };
-    };
-}
 const createTransformer = () => {
-    return (context) => {
+    return () => {
         return (sourceFile) => {
-            let code = sourceFile.getFullText();
-            if (!mightNeedTransform(code)) {
-                return sourceFile;
-            }
-            let bindings = new Map(), generatedClasses = [], neededImports = new Set(), ns = {
-                array: uid('ra'),
-                constants: uid('rc'),
-                reactivity: uid('r')
-            };
-            let objectTransformer = createObjectTransformer(bindings, neededImports, generatedClasses, ns)(context);
-            sourceFile = objectTransformer(sourceFile);
-            let arrayTransformer = createArrayTransformer(bindings)(context);
-            sourceFile = arrayTransformer(sourceFile);
-            let primitivesTransformer = createPrimitivesTransformer(bindings, neededImports, ns)(context);
-            sourceFile = primitivesTransformer(sourceFile);
-            let classInserter = insertClassesTransformer(generatedClasses)(context);
-            sourceFile = classInserter(sourceFile);
-            let importAdder = addImportsTransformer(neededImports, ns)(context);
-            sourceFile = importAdder(sourceFile);
-            return sourceFile;
+            let result = transform(sourceFile);
+            return result.transformed ? result.sourceFile : sourceFile;
         };
     };
 };
-export { createTransformer, mightNeedTransform };
-export { createArrayTransformer } from './transforms/array.js';
-export { createObjectTransformer } from './transforms/object.js';
-export { createPrimitivesTransformer } from './transforms/primitives.js';
+const transform = (sourceFile) => {
+    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 (code === original) {
+        return { code, sourceFile, transformed: false };
+    }
+    return {
+        code,
+        sourceFile: current,
+        transformed: true
+    };
+};
+export { createTransformer, mightNeedTransform, transform };
+export { transformReactiveArrays } from './transforms/array.js';
+export { transformReactiveObjects } from './transforms/object.js';
+export { transformReactivePrimitives } from './transforms/primitives.js';

package/build/transformer/plugins/vite.js

@@ -1,5 +1,5 @@
 import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
-import { createTransformer, mightNeedTransform } from '../../transformer/index.js';
+import { mightNeedTransform, transform } from '../../transformer/index.js';
 import { ts } from '@esportsplus/typescript';
 export default () => {
     return {
@@ -13,14 +13,11 @@ export default () => {
                 return null;
             }
             try {
-                let printer = ts.createPrinter(), sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), transformer = createTransformer(), result = ts.transform(sourceFile, [transformer]), transformed = result.transformed[0];
-                if (transformed === sourceFile) {
-                    result.dispose();
+                let sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile);
+                if (!result.transformed) {
                     return null;
                 }
-                let output = printer.printFile(transformed);
-                result.dispose();
-                return { code: output, map: null };
+                return { code: result.code, map: null };
             }
             catch (error) {
                 console.error(`@esportsplus/reactivity: Error transforming ${id}:`, error);

package/build/transformer/transforms/array.d.ts

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

package/build/transformer/transforms/array.js

@@ -1,4 +1,4 @@
-import { createArrayLengthCall, createArraySetCall } from '../factory.js';
+import { applyReplacements } from './utilities.js';
 import { ts } from '@esportsplus/typescript';
 function getExpressionName(node) {
     if (ts.isIdentifier(node)) {
@@ -23,9 +23,6 @@ function getPropertyPath(node) {
 }
 function isAssignmentTarget(node) {
     let parent = node.parent;
-    if (!parent) {
-        return false;
-    }
     if ((ts.isBinaryExpression(parent) && parent.left === node) ||
         ts.isPostfixUnaryExpression(parent) ||
         ts.isPrefixUnaryExpression(parent)) {
@@ -34,9 +31,6 @@ function isAssignmentTarget(node) {
     return false;
 }
 function visit(ctx, node) {
-    if (ts.isImportDeclaration(node)) {
-        return node;
-    }
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
         if (ts.isIdentifier(node.initializer) && ctx.bindings.get(node.initializer.text) === 'array') {
             ctx.bindings.set(node.name.text, 'array');
@@ -64,8 +58,12 @@ function visit(ctx, node) {
         !isAssignmentTarget(node)) {
         let name = getExpressionName(node.expression);
         if (name && ctx.bindings.get(name) === 'array') {
-            let transformedExpr = ts.visitEachChild(node.expression, n => visit(ctx, n), ctx.context);
-            return createArrayLengthCall(ctx.factory, transformedExpr);
+            let objText = node.expression.getText(ctx.sourceFile);
+            ctx.replacements.push({
+                end: node.end,
+                newText: `${objText}.$length()`,
+                start: node.pos
+            });
         }
     }
     if (ts.isBinaryExpression(node) &&
@@ -73,22 +71,23 @@ function visit(ctx, node) {
         ts.isElementAccessExpression(node.left)) {
         let elemAccess = node.left, objName = getExpressionName(elemAccess.expression);
         if (objName && ctx.bindings.get(objName) === 'array') {
-            let transformedArray = ts.visitEachChild(elemAccess.expression, n => visit(ctx, n), ctx.context), transformedIndex = ts.visitEachChild(elemAccess.argumentExpression, n => visit(ctx, n), ctx.context), transformedValue = ts.visitEachChild(node.right, n => visit(ctx, n), ctx.context);
-            return createArraySetCall(ctx.factory, transformedArray, transformedIndex, transformedValue);
+            let indexText = elemAccess.argumentExpression.getText(ctx.sourceFile), objText = elemAccess.expression.getText(ctx.sourceFile), valueText = node.right.getText(ctx.sourceFile);
+            ctx.replacements.push({
+                end: node.end,
+                newText: `${objText}.$set(${indexText}, ${valueText})`,
+                start: node.pos
+            });
         }
     }
-    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+    ts.forEachChild(node, n => visit(ctx, n));
 }
-const createArrayTransformer = (bindings) => {
-    return (context) => {
-        return (sourceFile) => {
-            let ctx = {
-                bindings,
-                context,
-                factory: context.factory
-            };
-            return ts.visitNode(sourceFile, n => visit(ctx, n));
-        };
+const transformReactiveArrays = (sourceFile, bindings) => {
+    let code = sourceFile.getFullText(), ctx = {
+        bindings,
+        replacements: [],
+        sourceFile
     };
+    visit(ctx, sourceFile);
+    return applyReplacements(code, ctx.replacements);
 };
-export { createArrayTransformer };
+export { transformReactiveArrays };

package/build/transformer/transforms/object.d.ts

@@ -1,10 +1,4 @@
-import type { Bindings, Namespaces } from '../../types.js';
+import type { Bindings } from '../../types.js';
 import { ts } from '@esportsplus/typescript';
-interface GeneratedClass {
-    classDecl: ts.ClassDeclaration;
-    className: string;
-    needsImports: Set<string>;
-}
-declare const createObjectTransformer: (bindings: Bindings, neededImports: Set<string>, generatedClasses: GeneratedClass[], ns: Namespaces) => (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
-export { createObjectTransformer };
-export type { GeneratedClass };
+declare const transformReactiveObjects: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
+export { transformReactiveObjects };

package/build/transformer/transforms/object.js

@@ -1,6 +1,12 @@
 import { uid } from '@esportsplus/typescript/transformer';
+import { addMissingImports, applyReplacements } from './utilities.js';
 import { ts } from '@esportsplus/typescript';
-function analyzeProperty(prop) {
+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;
     }
@@ -11,71 +17,51 @@ function analyzeProperty(prop) {
     else {
         return null;
     }
-    let value = prop.initializer;
+    let value = prop.initializer, valueText = value.getText(sourceFile);
     if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-        return { key, type: 'computed', value };
+        return { key, type: 'computed', valueText };
     }
     if (ts.isArrayLiteralExpression(value)) {
-        return { elements: [...value.elements], key, type: 'array', value };
+        return { key, type: 'array', valueText };
     }
-    return { key, type: 'signal', value };
+    return { key, type: 'signal', valueText };
 }
-function buildReactiveClass(ctx, className, properties, varName) {
-    let factory = ctx.factory, members = [], needsImports = new Set();
-    needsImports.add('REACTIVE_OBJECT');
-    members.push(factory.createPropertyDeclaration(undefined, factory.createComputedPropertyName(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.constants), 'REACTIVE_OBJECT')), undefined, undefined, factory.createTrue()));
-    let disposeStatements = [];
+function buildClassCode(className, properties) {
+    let accessors = [], disposeStatements = [], fields = [];
+    fields.push(`[REACTIVE_OBJECT] = true;`);
     for (let i = 0, n = properties.length; i < n; i++) {
-        let prop = properties[i];
-        if (prop.type === 'signal') {
-            needsImports.add('read');
-            needsImports.add('set');
-            needsImports.add('signal');
-            let privateName = factory.createPrivateIdentifier(`#${prop.key}`), paramName = uid('v');
-            members.push(factory.createPropertyDeclaration(undefined, privateName, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.reactivity), 'signal'), undefined, [prop.value])));
-            members.push(factory.createGetAccessorDeclaration(undefined, factory.createIdentifier(prop.key), [], undefined, factory.createBlock([
-                factory.createReturnStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.reactivity), 'read'), undefined, [factory.createPropertyAccessExpression(factory.createThis(), privateName)]))
-            ], true)));
-            members.push(factory.createSetAccessorDeclaration(undefined, factory.createIdentifier(prop.key), [factory.createParameterDeclaration(undefined, undefined, paramName)], factory.createBlock([
-                factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.reactivity), 'set'), undefined, [
-                    factory.createPropertyAccessExpression(factory.createThis(), privateName),
-                    factory.createIdentifier(paramName)
-                ]))
-            ], true)));
+        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 (prop.type === 'array') {
-            needsImports.add('ReactiveArray');
-            members.push(factory.createPropertyDeclaration(undefined, factory.createIdentifier(prop.key), undefined, undefined, factory.createNewExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.array), 'ReactiveArray'), undefined, prop.elements || [])));
-            if (varName) {
-                ctx.bindings.set(`${varName}.${prop.key}`, 'array');
-            }
-            disposeStatements.push(factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), prop.key), 'dispose'), undefined, [])));
+        else if (type === 'array') {
+            let elements = valueText.slice(1, -1);
+            fields.push(`${key} = new ReactiveArray(${elements});`);
+            disposeStatements.push(`this.${key}.dispose();`);
         }
-        else if (prop.type === 'computed') {
-            needsImports.add('computed');
-            needsImports.add('dispose');
-            needsImports.add('read');
-            let privateName = factory.createPrivateIdentifier(`#${prop.key}`);
-            members.push(factory.createPropertyDeclaration(undefined, privateName, undefined, factory.createUnionTypeNode([
-                factory.createTypeReferenceNode('Computed', [
-                    factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
-                ]),
-                factory.createLiteralTypeNode(factory.createNull())
-            ]), factory.createNull()));
-            members.push(factory.createGetAccessorDeclaration(undefined, factory.createIdentifier(prop.key), [], undefined, factory.createBlock([
-                factory.createReturnStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.reactivity), 'read'), undefined, [
-                    factory.createBinaryExpression(factory.createPropertyAccessExpression(factory.createThis(), privateName), ts.SyntaxKind.QuestionQuestionEqualsToken, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.reactivity), 'computed'), undefined, [prop.value]))
-                ]))
-            ], true)));
-            disposeStatements.push(factory.createIfStatement(factory.createPropertyAccessExpression(factory.createThis(), privateName), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ctx.ns.reactivity), 'dispose'), undefined, [factory.createPropertyAccessExpression(factory.createThis(), privateName)]))));
+        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});`);
         }
     }
-    members.push(factory.createMethodDeclaration(undefined, undefined, 'dispose', undefined, undefined, [], undefined, factory.createBlock(disposeStatements, true)));
-    needsImports.forEach(imp => ctx.neededImports.add(imp));
-    return factory.createClassDeclaration(undefined, className, undefined, undefined, members);
+    return `
+        class ${className} {
+            ${fields.join('\n')}
+            ${accessors.join('\n')}
+
+            dispose() {
+                ${disposeStatements.length > 0 ? disposeStatements.join('\n') : ''}
+            }
+        }
+    `;
 }
 function visit(ctx, node) {
     if (ts.isImportDeclaration(node)) {
+        ctx.lastImportEnd = node.end;
         if (ts.isStringLiteral(node.moduleSpecifier) &&
             node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
             let clause = node.importClause;
@@ -89,65 +75,89 @@ function visit(ctx, node) {
                 }
             }
         }
-        return node;
     }
     if (ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
         node.expression.text === 'reactive') {
         let arg = node.arguments[0];
-        if (arg && ts.isArrayLiteralExpression(arg)) {
-            let varName = null;
-            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                varName = node.parent.name.text;
-                ctx.bindings.set(varName, 'array');
-            }
-            ctx.neededImports.add('ReactiveArray');
-            return ctx.factory.createNewExpression(ctx.factory.createPropertyAccessExpression(ctx.factory.createIdentifier(ctx.ns.array), 'ReactiveArray'), undefined, [...arg.elements]);
-        }
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let varName = null;
             if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varName = node.parent.name.text;
                 ctx.bindings.set(varName, 'object');
             }
-            let properties = [], props = arg.properties;
+            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 ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+                    ts.forEachChild(node, n => visit(ctx, n));
+                    return;
                 }
-                let analyzed = analyzeProperty(prop);
+                let analyzed = analyzeProperty(prop, ctx.sourceFile);
                 if (!analyzed) {
-                    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+                    ts.forEachChild(node, n => visit(ctx, n));
+                    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) {
+                        ctx.bindings.set(`${varName}.${analyzed.key}`, 'array');
+                    }
+                }
+                else if (analyzed.type === 'computed') {
+                    needsImports.add('computed');
+                    needsImports.add('dispose');
+                    needsImports.add('read');
+                }
             }
-            let className = uid('ReactiveObject'), classDecl = buildReactiveClass(ctx, className, properties, varName);
-            ctx.generatedClasses.push({
-                classDecl,
-                className,
-                needsImports: new Set(ctx.neededImports)
+            needsImports.forEach(imp => ctx.allNeededImports.add(imp));
+            ctx.calls.push({
+                end: node.end,
+                generatedClass: buildClassCode(uid('ReactiveObject'), properties),
+                needsImports,
+                start: node.pos,
+                varName
             });
-            return ctx.factory.createNewExpression(ctx.factory.createIdentifier(className), undefined, []);
         }
     }
-    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
+    ts.forEachChild(node, n => visit(ctx, n));
 }
-const createObjectTransformer = (bindings, neededImports, generatedClasses, ns) => {
-    return (context) => {
-        return (sourceFile) => {
-            let ctx = {
-                bindings,
-                context,
-                factory: context.factory,
-                generatedClasses,
-                hasReactiveImport: false,
-                neededImports,
-                ns
-            };
-            return ts.visitNode(sourceFile, n => visit(ctx, n));
-        };
+const transformReactiveObjects = (sourceFile, bindings) => {
+    let code = sourceFile.getFullText(), ctx = {
+        allNeededImports: new Set(),
+        bindings,
+        calls: [],
+        hasReactiveImport: false,
+        lastImportEnd: 0,
+        sourceFile
     };
+    visit(ctx, sourceFile);
+    if (ctx.calls.length === 0) {
+        return code;
+    }
+    let replacements = [];
+    replacements.push({
+        end: ctx.lastImportEnd,
+        newText: code.substring(0, ctx.lastImportEnd) + '\n' + ctx.calls.map(c => c.generatedClass).join('\n') + '\n',
+        start: 0
+    });
+    for (let i = 0, n = ctx.calls.length; i < n; i++) {
+        let call = ctx.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), ctx.allNeededImports, EXTRA_IMPORTS);
 };
-export { createObjectTransformer };
+export { transformReactiveObjects };

package/build/transformer/transforms/primitives.d.ts

@@ -1,4 +1,4 @@
-import type { Bindings, Namespaces } from '../../types.js';
+import type { Bindings } from '../../types.js';
 import { ts } from '@esportsplus/typescript';
-declare const createPrimitivesTransformer: (bindings: Bindings, neededImports: Set<string>, ns: Namespaces) => (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
-export { createPrimitivesTransformer };
+declare const transformReactivePrimitives: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
+export { transformReactivePrimitives };