@esportsplus/reactivity 0.24.5 → 0.25.0

package/src/transformer/index.ts

@@ -1,209 +1,67 @@
-import { uid } from '@esportsplus/typescript/transformer';
-import type { Bindings, Namespaces } from '~/types';
-import { createArrayTransformer } from './transforms/array';
-import { createObjectTransformer, type GeneratedClass } from './transforms/object';
-import { createPrimitivesTransformer } from './transforms/primitives';
+import type { Bindings, TransformResult } from '~/types';
 import { mightNeedTransform } from './detector';
+import { transformReactiveArrays } from './transforms/array';
+import { transformReactiveObjects } from './transforms/object';
+import { transformReactivePrimitives } from './transforms/primitives';
 import { ts } from '@esportsplus/typescript';
 
 
-function addImportsTransformer(
-    neededImports: Set<string>,
-    ns: Namespaces
-): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile {
-    return (context: ts.TransformationContext) => {
-        return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            if (neededImports.size === 0) {
-                return sourceFile;
-            }
-
-            let factory = context.factory,
-                needsArray = false,
-                needsConstants = false,
-                needsReactivity = false,
-                newStatements: ts.Statement[] = [];
-
-            for (let imp of neededImports) {
-                if (imp === 'ReactiveArray') {
-                    needsArray = true;
-                }
-                else if (imp === 'REACTIVE_OBJECT') {
-                    needsConstants = true;
-                }
-                else {
-                    needsReactivity = true;
-                }
-            }
-
-            // Add namespace imports
-            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')
-                    )
-                );
-            }
-
-            // Filter out original @esportsplus/reactivity imports (they lose symbol bindings)
-            let filteredStatements: ts.Statement[] = [],
-                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;
-
-                    // Skip imports from @esportsplus/reactivity packages
-                    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: GeneratedClass[]
-): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile {
-    return (context: ts.TransformationContext) => {
+const createTransformer = (): ts.TransformerFactory<ts.SourceFile> => {
+    return () => {
         return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            if (generatedClasses.length === 0) {
-                return sourceFile;
-            }
-
-            let factory = context.factory;
-
-            // Find position after imports
-            let insertIndex = 0,
-                statements = sourceFile.statements;
+            let result = transform(sourceFile);
 
-            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);
+            return result.transformed ? result.sourceFile : sourceFile;
         };
     };
-}
-
-
-const createTransformer = (): ts.TransformerFactory<ts.SourceFile> => {
-    return (context: ts.TransformationContext) => {
-        return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            let code = sourceFile.getFullText();
-
-            if (!mightNeedTransform(code)) {
-                return sourceFile;
-            }
-
-            let bindings: Bindings = new Map(),
-                generatedClasses: GeneratedClass[] = [],
-                neededImports = new Set<string>(),
-                ns: Namespaces = {
-                    array: uid('ra'),
-                    constants: uid('rc'),
-                    reactivity: uid('r')
-                };
-
-            // Run object transformer first (generates classes, tracks array bindings)
-            let objectTransformer = createObjectTransformer(bindings, neededImports, generatedClasses, ns)(context);
+};
 
-            sourceFile = objectTransformer(sourceFile);
+const transform = (sourceFile: ts.SourceFile): TransformResult => {
+    let bindings: Bindings = new Map(),
+        code = sourceFile.getFullText(),
+        current = sourceFile,
+        original = code,
+        result: string;
 
-            // Run array transformer (handles array.length, array[i] = v)
-            let arrayTransformer = createArrayTransformer(bindings)(context);
+    if (!mightNeedTransform(code)) {
+        return { code, sourceFile, transformed: false };
+    }
 
-            sourceFile = arrayTransformer(sourceFile);
+    // Run all transforms, only re-parse between transforms if code changed
+    result = transformReactiveObjects(current, bindings);
 
-            // Run primitives transformer (handles signal/computed, reads/writes)
-            let primitivesTransformer = createPrimitivesTransformer(bindings, neededImports, ns)(context);
+    if (result !== code) {
+        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        code = result;
+    }
 
-            sourceFile = primitivesTransformer(sourceFile);
+    result = transformReactiveArrays(current, bindings);
 
-            // Insert generated classes after imports
-            let classInserter = insertClassesTransformer(generatedClasses)(context);
+    if (result !== code) {
+        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        code = result;
+    }
 
-            sourceFile = classInserter(sourceFile);
+    result = transformReactivePrimitives(current, bindings);
 
-            // Add namespace imports
-            let importAdder = addImportsTransformer(neededImports, ns)(context);
+    if (result !== code) {
+        current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        code = result;
+    }
 
-            sourceFile = importAdder(sourceFile);
+    if (code === original) {
+        return { code, sourceFile, transformed: false };
+    }
 
-            return sourceFile;
-        };
+    return {
+        code,
+        sourceFile: current,
+        transformed: true
     };
 };
 
 
-export { createTransformer, mightNeedTransform };
-export { createArrayTransformer } from './transforms/array';
-export { createObjectTransformer } from './transforms/object';
-export { createPrimitivesTransformer } from './transforms/primitives';
+export { createTransformer, mightNeedTransform, transform };
+export { transformReactiveArrays } from './transforms/array';
+export { transformReactiveObjects } from './transforms/object';
+export { transformReactivePrimitives } from './transforms/primitives';

package/src/transformer/plugins/vite.ts

@@ -1,5 +1,5 @@
 import { TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
-import { createTransformer, mightNeedTransform } from '~/transformer';
+import { mightNeedTransform, transform } from '~/transformer';
 import type { Plugin } from 'vite';
 import { ts } from '@esportsplus/typescript';
 
@@ -19,22 +19,14 @@ export default (): Plugin => {
             }
 
             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];
+                let sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true),
+                    result = transform(sourceFile);
 
-                if (transformed === sourceFile) {
-                    result.dispose();
+                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/src/transformer/transforms/array.ts

@@ -1,12 +1,12 @@
 import type { Bindings } from '~/types';
-import { createArrayLengthCall, createArraySetCall } from '../factory';
+import { applyReplacements, Replacement } from './utilities';
 import { ts } from '@esportsplus/typescript';
 
 
 interface TransformContext {
     bindings: Bindings;
-    context: ts.TransformationContext;
-    factory: ts.NodeFactory;
+    replacements: Replacement[];
+    sourceFile: ts.SourceFile;
 }
 
 
@@ -42,10 +42,6 @@ function getPropertyPath(node: ts.PropertyAccessExpression): string | null {
 function isAssignmentTarget(node: ts.Node): boolean {
     let parent = node.parent;
 
-    if (!parent) {
-        return false;
-    }
-
     if (
         (ts.isBinaryExpression(parent) && parent.left === node) ||
         ts.isPostfixUnaryExpression(parent) ||
@@ -57,13 +53,7 @@ function isAssignmentTarget(node: ts.Node): boolean {
     return false;
 }
 
-function visit(ctx: TransformContext, node: ts.Node): ts.Node {
-    // Skip import declarations - don't visit their children
-    if (ts.isImportDeclaration(node)) {
-        return node;
-    }
-
-    // Track array bindings from variable declarations
+function visit(ctx: TransformContext, node: ts.Node): void {
     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');
@@ -78,7 +68,6 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
         }
     }
 
-    // Track array bindings from function parameters with ReactiveArray type
     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];
@@ -94,7 +83,6 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
         }
     }
 
-    // Transform array.length → array.$length()
     if (
         ts.isPropertyAccessExpression(node) &&
         node.name.text === 'length' &&
@@ -103,14 +91,16 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
         let name = getExpressionName(node.expression);
 
         if (name && ctx.bindings.get(name) === 'array') {
-            // First visit children to transform the expression if needed
-            let transformedExpr = ts.visitEachChild(node.expression, n => visit(ctx, n), ctx.context) as ts.Expression;
+            let objText = node.expression.getText(ctx.sourceFile);
 
-            return createArrayLengthCall(ctx.factory, transformedExpr);
+            ctx.replacements.push({
+                end: node.end,
+                newText: `${objText}.$length()`,
+                start: node.pos
+            });
         }
     }
 
-    // Transform array[index] = value → array.$set(index, value)
     if (
         ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
@@ -120,33 +110,34 @@ function visit(ctx: TransformContext, node: ts.Node): ts.Node {
             objName = getExpressionName(elemAccess.expression);
 
         if (objName && ctx.bindings.get(objName) === 'array') {
-            let transformedArray = ts.visitEachChild(elemAccess.expression, n => visit(ctx, n), ctx.context) as ts.Expression,
-                transformedIndex = ts.visitEachChild(elemAccess.argumentExpression, n => visit(ctx, n), ctx.context) as ts.Expression,
-                transformedValue = ts.visitEachChild(node.right, n => visit(ctx, n), ctx.context) as ts.Expression;
-
-            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: Bindings
-): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile => {
-    return (context: ts.TransformationContext) => {
-        return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            let ctx: TransformContext = {
-                bindings,
-                context,
-                factory: context.factory
-            };
-
-            return ts.visitNode(sourceFile, n => visit(ctx, n)) as ts.SourceFile;
+const transformReactiveArrays = (sourceFile: ts.SourceFile, bindings: Bindings): string => {
+    let code = sourceFile.getFullText(),
+        ctx: TransformContext = {
+            bindings,
+            replacements: [],
+            sourceFile
         };
-    };
+
+    visit(ctx, sourceFile);
+
+    return applyReplacements(code, ctx.replacements);
 };
 
 
-export { createArrayTransformer };
+export { transformReactiveArrays };