@esportsplus/reactivity 0.24.1 → 0.24.3

package/build/transformer/factory.d.ts

@@ -0,0 +1,13 @@
+import { ts } from '@esportsplus/typescript';
+declare function createReadCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression;
+declare function createSetCall(factory: ts.NodeFactory, ns: string, target: ts.Expression, value: ts.Expression): ts.CallExpression;
+declare function createSignalCall(factory: ts.NodeFactory, ns: string, initialValue: ts.Expression): ts.CallExpression;
+declare function createComputedCall(factory: ts.NodeFactory, ns: string, fn: ts.Expression): ts.CallExpression;
+declare function createArrayLengthCall(factory: ts.NodeFactory, arrayExpr: ts.Expression): ts.CallExpression;
+declare function createArraySetCall(factory: ts.NodeFactory, arrayExpr: ts.Expression, index: ts.Expression, value: ts.Expression): ts.CallExpression;
+declare function createReactiveArrayNew(factory: ts.NodeFactory, ns: string, elements: ts.Expression[]): ts.NewExpression;
+declare function createDisposeCall(factory: ts.NodeFactory, ns: string, expr: ts.Expression): ts.CallExpression;
+declare function createBinaryExpr(factory: ts.NodeFactory, left: ts.Expression, op: ts.BinaryOperator, right: ts.Expression): ts.BinaryExpression;
+declare function createCommaExpr(factory: ts.NodeFactory, first: ts.Expression, second: ts.Expression): ts.ParenthesizedExpression;
+declare function createPostfixIncrementExpr(factory: ts.NodeFactory, ns: string, tmpName: string, signalName: string, op: ts.SyntaxKind.PlusToken | ts.SyntaxKind.MinusToken): ts.CallExpression;
+export { createArrayLengthCall, createArraySetCall, createBinaryExpr, createCommaExpr, createComputedCall, createDisposeCall, createPostfixIncrementExpr, createReactiveArrayNew, createReadCall, createSetCall, createSignalCall };

package/build/transformer/factory.js

@@ -0,0 +1,36 @@
+import { ts } from '@esportsplus/typescript';
+function createReadCall(factory, ns, expr) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'read'), undefined, [expr]);
+}
+function createSetCall(factory, ns, target, value) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'set'), undefined, [target, value]);
+}
+function createSignalCall(factory, ns, initialValue) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'signal'), undefined, [initialValue]);
+}
+function createComputedCall(factory, ns, fn) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'computed'), undefined, [fn]);
+}
+function createArrayLengthCall(factory, arrayExpr) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(arrayExpr, '$length'), undefined, []);
+}
+function createArraySetCall(factory, arrayExpr, index, value) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(arrayExpr, '$set'), undefined, [index, value]);
+}
+function createReactiveArrayNew(factory, ns, elements) {
+    return factory.createNewExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'ReactiveArray'), undefined, elements);
+}
+function createDisposeCall(factory, ns, expr) {
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier(ns), 'dispose'), undefined, [expr]);
+}
+function createBinaryExpr(factory, left, op, right) {
+    return factory.createBinaryExpression(left, op, right);
+}
+function createCommaExpr(factory, first, second) {
+    return factory.createParenthesizedExpression(factory.createBinaryExpression(first, ts.SyntaxKind.CommaToken, second));
+}
+function createPostfixIncrementExpr(factory, ns, tmpName, signalName, op) {
+    let tmpIdent = factory.createIdentifier(tmpName), signalIdent = factory.createIdentifier(signalName);
+    return factory.createCallExpression(factory.createParenthesizedExpression(factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, tmpIdent)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), createCommaExpr(factory, createSetCall(factory, ns, signalIdent, factory.createBinaryExpression(tmpIdent, op, factory.createNumericLiteral(1))), tmpIdent))), undefined, [factory.createPropertyAccessExpression(signalIdent, 'value')]);
+}
+export { createArrayLengthCall, createArraySetCall, createBinaryExpr, createCommaExpr, createComputedCall, createDisposeCall, createPostfixIncrementExpr, createReactiveArrayNew, createReadCall, createSetCall, createSignalCall };

package/build/transformer/index.d.ts

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

package/build/transformer/index.js

@@ -1,46 +1,106 @@
+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';
-const createTransformer = () => {
-    return () => {
+function addImportsTransformer(neededImports, ns) {
+    return (context) => {
         return (sourceFile) => {
-            let result = transform(sourceFile);
-            return result.transformed ? result.sourceFile : 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 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 updatedStatements = [
+                ...statements.slice(0, insertIndex),
+                ...newStatements,
+                ...statements.slice(insertIndex)
+            ];
+            return factory.updateSourceFile(sourceFile, updatedStatements);
         };
     };
-};
-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
+}
+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 (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;
+        };
     };
 };
-export { createTransformer, mightNeedTransform, transform };
-export { transformReactiveArrays } from './transforms/array.js';
-export { transformReactiveObjects } from './transforms/object.js';
-export { transformReactivePrimitives } from './transforms/primitives.js';
+export { createTransformer, mightNeedTransform };
+export { createArrayTransformer } from './transforms/array.js';
+export { createObjectTransformer } from './transforms/object.js';
+export { createPrimitivesTransformer } from './transforms/primitives.js';

package/build/transformer/plugins/vite.js

@@ -1,5 +1,5 @@
 import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
-import { mightNeedTransform, transform } from '../../transformer/index.js';
+import { createTransformer, mightNeedTransform } from '../../transformer/index.js';
 import { ts } from '@esportsplus/typescript';
 export default () => {
     return {
@@ -13,11 +13,14 @@ export default () => {
                 return null;
             }
             try {
-                let sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile);
-                if (!result.transformed) {
+                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();
                     return null;
                 }
-                return { code: result.code, map: null };
+                let output = printer.printFile(transformed);
+                result.dispose();
+                return { code: output, 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 transformReactiveArrays: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
-export { transformReactiveArrays };
+declare const createArrayTransformer: (bindings: Bindings) => (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
+export { createArrayTransformer };

package/build/transformer/transforms/array.js

@@ -1,4 +1,4 @@
-import { applyReplacements } from './utilities.js';
+import { createArrayLengthCall, createArraySetCall } from '../factory.js';
 import { ts } from '@esportsplus/typescript';
 function getExpressionName(node) {
     if (ts.isIdentifier(node)) {
@@ -23,6 +23,9 @@ 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)) {
@@ -58,12 +61,8 @@ function visit(ctx, node) {
         !isAssignmentTarget(node)) {
         let name = getExpressionName(node.expression);
         if (name && ctx.bindings.get(name) === 'array') {
-            let objText = node.expression.getText(ctx.sourceFile);
-            ctx.replacements.push({
-                end: node.end,
-                newText: `${objText}.$length()`,
-                start: node.pos
-            });
+            let transformedExpr = ts.visitEachChild(node.expression, n => visit(ctx, n), ctx.context);
+            return createArrayLengthCall(ctx.factory, transformedExpr);
         }
     }
     if (ts.isBinaryExpression(node) &&
@@ -71,23 +70,22 @@ function visit(ctx, node) {
         ts.isElementAccessExpression(node.left)) {
         let elemAccess = node.left, objName = getExpressionName(elemAccess.expression);
         if (objName && ctx.bindings.get(objName) === 'array') {
-            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
-            });
+            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);
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
 }
-const transformReactiveArrays = (sourceFile, bindings) => {
-    let code = sourceFile.getFullText(), ctx = {
-        bindings,
-        replacements: [],
-        sourceFile
+const createArrayTransformer = (bindings) => {
+    return (context) => {
+        return (sourceFile) => {
+            let ctx = {
+                bindings,
+                context,
+                factory: context.factory
+            };
+            return ts.visitNode(sourceFile, n => visit(ctx, n));
+        };
     };
-    visit(ctx, sourceFile);
-    return applyReplacements(code, ctx.replacements);
 };
-export { transformReactiveArrays };
+export { createArrayTransformer };

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

@@ -1,4 +1,10 @@
-import type { Bindings } from '../../types.js';
+import type { Bindings, Namespaces } from '../../types.js';
 import { ts } from '@esportsplus/typescript';
-declare const transformReactiveObjects: (sourceFile: ts.SourceFile, bindings: Bindings) => string;
-export { transformReactiveObjects };
+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 };

package/build/transformer/transforms/object.js

@@ -1,12 +1,6 @@
 import { uid } from '@esportsplus/typescript/transformer';
-import { addMissingImports, applyReplacements } from './utilities.js';
 import { ts } from '@esportsplus/typescript';
-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) {
+function analyzeProperty(prop) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
     }
@@ -17,51 +11,71 @@ function analyzeProperty(prop, sourceFile) {
     else {
         return null;
     }
-    let value = prop.initializer, valueText = value.getText(sourceFile);
+    let value = prop.initializer;
     if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-        return { key, type: 'computed', valueText };
+        return { key, type: 'computed', value };
     }
     if (ts.isArrayLiteralExpression(value)) {
-        return { key, type: 'array', valueText };
+        return { elements: [...value.elements], key, type: 'array', value };
     }
-    return { key, type: 'signal', valueText };
+    return { key, type: 'signal', value };
 }
-function buildClassCode(className, properties) {
-    let accessors = [], disposeStatements = [], fields = [];
-    fields.push(`[REACTIVE_OBJECT] = true;`);
+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 = [];
     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}); }`);
+        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)));
         }
-        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 === '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 === '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});`);
+        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)]))));
         }
     }
-    return `
-        class ${className} {
-            ${fields.join('\n')}
-            ${accessors.join('\n')}
-
-            dispose() {
-                ${disposeStatements.length > 0 ? disposeStatements.join('\n') : ''}
-            }
-        }
-    `;
+    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);
 }
 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;
@@ -81,83 +95,58 @@ function visit(ctx, 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 needsImports = new Set(), properties = [];
-            needsImports.add('REACTIVE_OBJECT');
-            let props = arg.properties;
+            let properties = [], props = arg.properties;
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
                 if (ts.isSpreadAssignment(prop)) {
-                    ts.forEachChild(node, n => visit(ctx, n));
-                    return;
+                    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
                 }
-                let analyzed = analyzeProperty(prop, ctx.sourceFile);
+                let analyzed = analyzeProperty(prop);
                 if (!analyzed) {
-                    ts.forEachChild(node, n => visit(ctx, n));
-                    return;
+                    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
                 }
                 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');
-                }
             }
-            needsImports.forEach(imp => ctx.allNeededImports.add(imp));
-            ctx.calls.push({
-                end: node.end,
-                generatedClass: buildClassCode(uid('ReactiveObject'), properties),
-                needsImports,
-                start: node.pos,
-                varName
+            let className = uid('ReactiveObject'), classDecl = buildReactiveClass(ctx, className, properties, varName);
+            ctx.generatedClasses.push({
+                classDecl,
+                className,
+                needsImports: new Set(ctx.neededImports)
             });
+            return ctx.factory.createNewExpression(ctx.factory.createIdentifier(className), undefined, []);
         }
     }
-    ts.forEachChild(node, n => visit(ctx, n));
+    return ts.visitEachChild(node, n => visit(ctx, n), ctx.context);
 }
-const transformReactiveObjects = (sourceFile, bindings) => {
-    let code = sourceFile.getFullText(), ctx = {
-        allNeededImports: new Set(),
-        bindings,
-        calls: [],
-        hasReactiveImport: false,
-        lastImportEnd: 0,
-        sourceFile
+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));
+        };
     };
-    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 { transformReactiveObjects };
+export { createObjectTransformer };

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

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