@esportsplus/reactivity 0.27.3 → 0.28.1

package/build/compiler/array.d.ts

@@ -1,4 +1,5 @@
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import type { Bindings } from '../types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => string;
+declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ReplacementIntent[];
 export default _default;

package/build/compiler/array.js

@@ -1,20 +1,42 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c } from '@esportsplus/typescript/compiler';
+import { ast } from '@esportsplus/typescript/compiler';
 import { COMPILER_NAMESPACE, COMPILER_TYPES } from '../constants.js';
-import { isReactiveCall } from './index.js';
+function getElementTypeText(typeNode, sourceFile) {
+    if (ts.isArrayTypeNode(typeNode)) {
+        return typeNode.elementType.getText(sourceFile);
+    }
+    if (ts.isTypeReferenceNode(typeNode) &&
+        ts.isIdentifier(typeNode.typeName) &&
+        typeNode.typeName.text === 'Array' &&
+        typeNode.typeArguments &&
+        typeNode.typeArguments.length > 0) {
+        return typeNode.typeArguments[0].getText(sourceFile);
+    }
+    return null;
+}
+function isReactiveCall(node) {
+    return ts.isIdentifier(node.expression) && node.expression.text === 'reactive';
+}
 function visit(ctx, node) {
-    if (ts.isCallExpression(node) && isReactiveCall(node, ctx.checker) && node.arguments.length > 0) {
+    if (ts.isCallExpression(node) && isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0], expression = ts.isAsExpression(arg) ? arg.expression : arg;
         if (ts.isArrayLiteralExpression(expression)) {
+            let elementType = null;
+            if (ts.isAsExpression(arg) && arg.type) {
+                elementType = getElementTypeText(arg.type, ctx.sourceFile);
+            }
+            else if (node.parent && ts.isVariableDeclaration(node.parent) && node.parent.type) {
+                elementType = getElementTypeText(node.parent.type, ctx.sourceFile);
+            }
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 ctx.bindings.set(node.parent.name.text, COMPILER_TYPES.Array);
             }
+            let typeParam = elementType ? `<${elementType}>` : '';
             ctx.replacements.push({
-                end: node.end,
-                newText: expression.elements.length > 0
-                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray(...${expression.getText(ctx.sourceFile)})`
-                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray()`,
-                start: node.pos
+                node,
+                generate: (sf) => expression.elements.length > 0
+                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}(...${expression.getText(sf)})`
+                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}()`
             });
         }
     }
@@ -49,9 +71,8 @@ function visit(ctx, node) {
         let name = ast.getExpressionName(node.expression);
         if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
             ctx.replacements.push({
-                end: node.end,
-                newText: `${node.expression.getText(ctx.sourceFile)}.$length()`,
-                start: node.pos
+                node,
+                generate: (sf) => `${node.expression.getText(sf)}.$length()`
             });
         }
     }
@@ -60,26 +81,24 @@ function visit(ctx, node) {
         ts.isElementAccessExpression(node.left)) {
         let element = node.left, name = ast.getExpressionName(element.expression);
         if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
-            let index = element.argumentExpression.getText(ctx.sourceFile), value = node.right.getText(ctx.sourceFile);
             ctx.replacements.push({
-                end: node.end,
-                newText: `${element.expression.getText(ctx.sourceFile)}.$set(${index}, ${value})`,
-                start: node.pos
+                node,
+                generate: (sf) => {
+                    let index = element.argumentExpression.getText(sf), value = node.right.getText(sf);
+                    return `${element.expression.getText(sf)}.$set(${index}, ${value})`;
+                }
             });
         }
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
 export default (sourceFile, bindings, checker) => {
-    let code = sourceFile.getFullText(), ctx = {
+    let ctx = {
         bindings,
         checker,
         replacements: [],
         sourceFile
     };
     visit(ctx, sourceFile);
-    if (ctx.replacements.length === 0) {
-        return code;
-    }
-    return c.replace(code, ctx.replacements);
+    return ctx.replacements;
 };

package/build/compiler/index.d.ts

@@ -1,7 +1,3 @@
-import type { PluginContext } from '@esportsplus/typescript/compiler';
-import { ts } from '@esportsplus/typescript';
-import type { TransformResult } from '../types.js';
-declare const analyze: (sourceFile: ts.SourceFile, _program: ts.Program, context: PluginContext) => void;
-declare const isReactiveCall: (node: ts.CallExpression, _checker?: ts.TypeChecker) => boolean;
-declare const transform: (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
-export { analyze, isReactiveCall, transform };
+import type { Plugin } from '@esportsplus/typescript/compiler';
+declare const plugin: Plugin;
+export default plugin;

package/build/compiler/index.js

@@ -3,63 +3,40 @@ import { ast, imports } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
 import array from './array.js';
 import object from './object.js';
-const CONTEXT_KEY = 'reactivity:analyzed';
-let transforms = [object, array];
-function getAnalyzedFile(context, filename) {
-    return context?.get(CONTEXT_KEY)?.get(filename);
-}
 function hasReactiveImport(sourceFile) {
     return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
 }
 function isReactiveCallNode(node) {
     return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === COMPILER_ENTRYPOINT;
 }
-const analyze = (sourceFile, _program, context) => {
-    if (!hasReactiveImport(sourceFile)) {
-        return;
-    }
-    let files = context.get(CONTEXT_KEY);
-    if (!files) {
-        files = new Map();
-        context.set(CONTEXT_KEY, files);
-    }
-    files.set(sourceFile.fileName, {
-        hasReactiveImport: true
-    });
-};
-const isReactiveCall = (node, _checker) => {
-    if (!ts.isIdentifier(node.expression)) {
-        return false;
-    }
-    return node.expression.text === COMPILER_ENTRYPOINT;
-};
-const transform = (sourceFile, program, context) => {
-    let bindings = new Map(), changed = false, checker = program.getTypeChecker(), code = sourceFile.getFullText(), current = sourceFile, filename = sourceFile.fileName, result;
-    let analyzed = getAnalyzedFile(context, filename);
-    if (!analyzed) {
-        if (!hasReactiveImport(sourceFile)) {
-            return { changed: false, code, sourceFile };
+const plugin = {
+    patterns: ['reactive(', 'reactive<'],
+    transform: (ctx) => {
+        if (!hasReactiveImport(ctx.sourceFile)) {
+            return {};
         }
-    }
-    else if (!analyzed.hasReactiveImport) {
-        return { changed: false, code, sourceFile };
-    }
-    for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, checker);
-        if (result !== code) {
-            code = result;
-            changed = true;
-            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        }
-    }
-    if (changed) {
-        let remove = [];
-        if (!ast.hasMatch(current, isReactiveCallNode)) {
-            remove.push(COMPILER_ENTRYPOINT);
+        let bindings = new Map(), importsIntent = [], prepend = [], replacements = [];
+        let objectResult = object(ctx.sourceFile, bindings, ctx.checker);
+        prepend.push(...objectResult.prepend);
+        replacements.push(...objectResult.replacements);
+        let arrayResult = array(ctx.sourceFile, bindings, ctx.checker);
+        replacements.push(...arrayResult);
+        if (replacements.length > 0 || prepend.length > 0) {
+            let remove = [];
+            if (!ast.hasMatch(ctx.sourceFile, isReactiveCallNode) || replacements.length > 0) {
+                remove.push(COMPILER_ENTRYPOINT);
+            }
+            importsIntent.push({
+                namespace: COMPILER_NAMESPACE,
+                package: PACKAGE,
+                remove
+            });
         }
-        code = imports.modify(code, current, PACKAGE, { namespace: COMPILER_NAMESPACE, remove });
-        sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
+        return {
+            imports: importsIntent,
+            prepend,
+            replacements
+        };
     }
-    return { changed, code, sourceFile };
 };
-export { analyze, isReactiveCall, transform };
+export default plugin;

package/build/compiler/object.d.ts

@@ -1,4 +1,9 @@
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import type { Bindings } from '../types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => string;
+type ObjectTransformResult = {
+    prepend: string[];
+    replacements: ReplacementIntent[];
+};
+declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker) => ObjectTransformResult;
 export default _default;

package/build/compiler/object.js

@@ -1,7 +1,6 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, uid } from '@esportsplus/typescript/compiler';
+import { uid } from '@esportsplus/typescript/compiler';
 import { COMPILER_NAMESPACE, COMPILER_TYPES } from '../constants.js';
-import { isReactiveCall } from './index.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -111,12 +110,11 @@ function isStaticValue(node) {
     }
     return false;
 }
+function isReactiveCall(node) {
+    return ts.isIdentifier(node.expression) && node.expression.text === "reactive";
+}
 function visit(ctx, node) {
-    if (ts.isImportDeclaration(node)) {
-        ctx.lastImportEnd = node.end;
-    }
-    if (ts.isCallExpression(node) &&
-        isReactiveCall(node, ctx.checker)) {
+    if (ts.isCallExpression(node) && isReactiveCall(node)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
             let properties = [], props = arg.properties, varName = null;
@@ -142,9 +140,8 @@ function visit(ctx, node) {
             }
             ctx.calls.push({
                 className: uid('ReactiveObject'),
-                end: node.end,
+                node,
                 properties,
-                start: node.pos,
                 varName
             });
         }
@@ -152,34 +149,27 @@ function visit(ctx, node) {
     ts.forEachChild(node, n => visit(ctx, n));
 }
 export default (sourceFile, bindings, checker) => {
-    let code = sourceFile.getFullText(), ctx = {
+    let ctx = {
         bindings,
         calls: [],
         checker,
-        classCounter: 0,
-        lastImportEnd: 0,
         sourceFile
     };
     visit(ctx, sourceFile);
     if (ctx.calls.length === 0) {
-        return code;
+        return { prepend: [], replacements: [] };
     }
-    let classes = ctx.calls.map(c => buildClassCode(c.className, c.properties)).join('\n'), replacements = [];
-    replacements.push({
-        end: ctx.lastImportEnd,
-        newText: code.substring(0, ctx.lastImportEnd) + '\n' + classes + '\n',
-        start: 0
-    });
+    let prepend = [], replacements = [];
     for (let i = 0, n = ctx.calls.length; i < n; i++) {
         let call = ctx.calls[i];
+        prepend.push(buildClassCode(call.className, call.properties));
         replacements.push({
-            end: call.end,
-            newText: ` new ${call.className}(${call.properties
+            node: call.node,
+            generate: () => ` new ${call.className}(${call.properties
                 .filter(({ isStatic, type }) => !isStatic || type === COMPILER_TYPES.Computed)
                 .map(p => p.valueText)
-                .join(', ')})`,
-            start: call.start
+                .join(', ')})`
         });
     }
-    return c.replace(code, replacements);
+    return { prepend, replacements };
 };

package/build/compiler/plugins/tsc.d.ts

@@ -1,3 +1,2 @@
-import { plugin } from '@esportsplus/typescript/compiler';
-declare const _default: ReturnType<typeof plugin.tsc>;
-export default _default;
+import plugin from '../index.js';
+export default plugin;

package/build/compiler/plugins/tsc.js

@@ -1,3 +1,2 @@
-import { plugin } from '@esportsplus/typescript/compiler';
-import { analyze, transform } from '../index.js';
-export default plugin.tsc({ analyze, transform });
+import plugin from '../index.js';
+export default plugin;

package/build/compiler/plugins/vite.js

@@ -1,8 +1,7 @@
-import { PACKAGE } from '../../constants.js';
 import { plugin } from '@esportsplus/typescript/compiler';
-import { analyze, transform } from '../index.js';
+import { PACKAGE } from '../../constants.js';
+import reactivityPlugin from '../index.js';
 export default plugin.vite({
-    analyze,
     name: PACKAGE,
-    transform
+    plugins: [reactivityPlugin]
 });

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.24.2",
+    "@esportsplus/typescript": "^0.25.0",
     "@types/node": "^25.0.3",
     "vite": "^7.3.1"
   },
@@ -31,7 +31,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.27.3",
+  "version": "0.28.1",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/src/compiler/array.ts

@@ -1,34 +1,66 @@
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c, type Replacement } from '@esportsplus/typescript/compiler';
+import { ast } from '@esportsplus/typescript/compiler';
 import { COMPILER_NAMESPACE, COMPILER_TYPES } from '~/constants';
 import type { Bindings } from '~/types';
-import { isReactiveCall } from '.';
 
 
-interface TransformContext {
+interface VisitContext {
     bindings: Bindings;
     checker?: ts.TypeChecker;
-    replacements: Replacement[];
+    replacements: ReplacementIntent[];
     sourceFile: ts.SourceFile;
 }
 
 
-function visit(ctx: TransformContext, node: ts.Node): void {
-    if (ts.isCallExpression(node) && isReactiveCall(node, ctx.checker) && node.arguments.length > 0) {
+function getElementTypeText(typeNode: ts.TypeNode, sourceFile: ts.SourceFile): string | null {
+    if (ts.isArrayTypeNode(typeNode)) {
+        return typeNode.elementType.getText(sourceFile);
+    }
+
+    if (
+        ts.isTypeReferenceNode(typeNode) &&
+        ts.isIdentifier(typeNode.typeName) &&
+        typeNode.typeName.text === 'Array' &&
+        typeNode.typeArguments &&
+        typeNode.typeArguments.length > 0
+    ) {
+        return typeNode.typeArguments[0].getText(sourceFile);
+    }
+
+    return null;
+}
+
+function isReactiveCall(node: ts.CallExpression): boolean {
+    return ts.isIdentifier(node.expression) && node.expression.text === 'reactive';
+}
+
+function visit(ctx: VisitContext, node: ts.Node): void {
+    if (ts.isCallExpression(node) && isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0],
             expression = ts.isAsExpression(arg) ? arg.expression : arg;
 
         if (ts.isArrayLiteralExpression(expression)) {
+            let elementType: string | null = null;
+
+            if (ts.isAsExpression(arg) && arg.type) {
+                elementType = getElementTypeText(arg.type, ctx.sourceFile);
+            }
+            else if (node.parent && ts.isVariableDeclaration(node.parent) && node.parent.type) {
+                elementType = getElementTypeText(node.parent.type, ctx.sourceFile);
+            }
+
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 ctx.bindings.set(node.parent.name.text, COMPILER_TYPES.Array);
             }
 
+            let typeParam = elementType ? `<${elementType}>` : '';
+
             ctx.replacements.push({
-                end: node.end,
-                newText: expression.elements.length > 0
-                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray(...${expression.getText(ctx.sourceFile)})`
-                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray()`,
-                start: node.pos
+                node,
+                generate: (sf) => expression.elements.length > 0
+                    ? ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}(...${expression.getText(sf)})`
+                    : ` new ${COMPILER_NAMESPACE}.ReactiveArray${typeParam}()`
             });
         }
     }
@@ -77,9 +109,8 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
         if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
             ctx.replacements.push({
-                end: node.end,
-                newText: `${node.expression.getText(ctx.sourceFile)}.$length()`,
-                start: node.pos
+                node,
+                generate: (sf) => `${node.expression.getText(sf)}.$length()`
             });
         }
     }
@@ -93,13 +124,14 @@ function visit(ctx: TransformContext, node: ts.Node): void {
             name = ast.getExpressionName(element.expression);
 
         if (name && ctx.bindings.get(name) === COMPILER_TYPES.Array) {
-            let index = element.argumentExpression.getText(ctx.sourceFile),
-                value = node.right.getText(ctx.sourceFile);
-
             ctx.replacements.push({
-                end: node.end,
-                newText: `${element.expression.getText(ctx.sourceFile)}.$set(${index}, ${value})`,
-                start: node.pos
+                node,
+                generate: (sf) => {
+                    let index = element.argumentExpression.getText(sf),
+                        value = node.right.getText(sf);
+
+                    return `${element.expression.getText(sf)}.$set(${index}, ${value})`;
+                }
             });
         }
     }
@@ -108,9 +140,8 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): string => {
-    let code = sourceFile.getFullText(),
-        ctx: TransformContext = {
+export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ReplacementIntent[] => {
+    let ctx: VisitContext = {
             bindings,
             checker,
             replacements: [],
@@ -119,9 +150,5 @@ export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.Type
 
     visit(ctx, sourceFile);
 
-    if (ctx.replacements.length === 0) {
-        return code;
-    }
-
-    return c.replace(code, ctx.replacements);
+    return ctx.replacements;
 };

package/src/compiler/index.ts

@@ -1,27 +1,12 @@
-import type { PluginContext } from '@esportsplus/typescript/compiler';
+import type { ImportIntent, Plugin, ReplacementIntent, TransformContext } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
 import { ast, imports } from '@esportsplus/typescript/compiler';
 import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, PACKAGE } from '~/constants';
-import type { Bindings, TransformResult } from '~/types';
+import type { Bindings } from '~/types';
 import array from './array';
 import object from './object';
 
 
-type AnalyzedFile = {
-    hasReactiveImport: boolean;
-};
-
-
-const CONTEXT_KEY = 'reactivity:analyzed';
-
-
-let transforms = [object, array];
-
-
-function getAnalyzedFile(context: PluginContext | undefined, filename: string): AnalyzedFile | undefined {
-    return (context?.get(CONTEXT_KEY) as Map<string, AnalyzedFile> | undefined)?.get(filename);
-}
-
 function hasReactiveImport(sourceFile: ts.SourceFile): boolean {
     return imports.find(sourceFile, PACKAGE).some(i => i.specifiers.has(COMPILER_ENTRYPOINT));
 }
@@ -31,76 +16,54 @@ function isReactiveCallNode(node: ts.Node): boolean {
 }
 
 
-const analyze = (sourceFile: ts.SourceFile, _program: ts.Program, context: PluginContext): void => {
-    if (!hasReactiveImport(sourceFile)) {
-        return;
-    }
-
-    let files = context.get(CONTEXT_KEY) as Map<string, AnalyzedFile> | undefined;
+const plugin: Plugin = {
+    patterns: ['reactive(', 'reactive<'],
 
-    if (!files) {
-        files = new Map();
-        context.set(CONTEXT_KEY, files);
-    }
+    transform: (ctx: TransformContext) => {
+        if (!hasReactiveImport(ctx.sourceFile)) {
+            return {};
+        }
 
-    files.set(sourceFile.fileName, {
-        hasReactiveImport: true
-    });
-};
+        let bindings: Bindings = new Map(),
+            importsIntent: ImportIntent[] = [],
+            prepend: string[] = [],
+            replacements: ReplacementIntent[] = [];
 
-const isReactiveCall = (node: ts.CallExpression, _checker?: ts.TypeChecker): boolean => {
-    if (!ts.isIdentifier(node.expression)) {
-        return false;
-    }
+        // Run object transform
+        let objectResult = object(ctx.sourceFile, bindings, ctx.checker);
 
-    return node.expression.text === COMPILER_ENTRYPOINT;
-};
+        prepend.push(...objectResult.prepend);
+        replacements.push(...objectResult.replacements);
 
-const transform = (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext): TransformResult => {
-    let bindings: Bindings = new Map(),
-        changed = false,
-        checker = program.getTypeChecker(),
-        code = sourceFile.getFullText(),
-        current = sourceFile,
-        filename = sourceFile.fileName,
-        result: string;
-
-    // Try to get pre-analyzed data from context
-    let analyzed = getAnalyzedFile(context, filename);
-
-    // Fall back to inline check (for Vite or when context unavailable)
-    if (!analyzed) {
-        if (!hasReactiveImport(sourceFile)) {
-            return { changed: false, code, sourceFile };
-        }
-    }
-    else if (!analyzed.hasReactiveImport) {
-        return { changed: false, code, sourceFile };
-    }
+        // Run array transform
+        let arrayResult = array(ctx.sourceFile, bindings, ctx.checker);
 
-    for (let i = 0, n = transforms.length; i < n; i++) {
-        result = transforms[i](current, bindings, checker);
+        replacements.push(...arrayResult);
 
-        if (result !== code) {
-            code = result;
-            changed = true;
-            current = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        }
-    }
+        // Build import intent
+        if (replacements.length > 0 || prepend.length > 0) {
+            let remove: string[] = [];
 
-    if (changed) {
-        let remove: string[] = [];
+            // Check if we still have reactive() calls after transform
+            // This is a heuristic - if we have no replacements for reactive calls, keep the import
+            if (!ast.hasMatch(ctx.sourceFile, isReactiveCallNode) || replacements.length > 0) {
+                remove.push(COMPILER_ENTRYPOINT);
+            }
 
-        if (!ast.hasMatch(current, isReactiveCallNode)) {
-            remove.push(COMPILER_ENTRYPOINT);
+            importsIntent.push({
+                namespace: COMPILER_NAMESPACE,
+                package: PACKAGE,
+                remove
+            });
         }
 
-        code = imports.modify(code, current, PACKAGE, { namespace: COMPILER_NAMESPACE, remove });
-        sourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
+        return {
+            imports: importsIntent,
+            prepend,
+            replacements
+        };
     }
-
-    return { changed, code, sourceFile };
 };
 
 
-export { analyze, isReactiveCall, transform };
+export default plugin;

package/src/compiler/object.ts

@@ -1,8 +1,8 @@
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import { code as c, uid, type Replacement } from '@esportsplus/typescript/compiler';
+import { uid } from '@esportsplus/typescript/compiler';
 import { COMPILER_NAMESPACE, COMPILER_TYPES } from '~/constants';
 import type { Bindings } from '~/types';
-import { isReactiveCall } from '.';
 
 
 interface AnalyzedProperty {
@@ -14,18 +14,15 @@ interface AnalyzedProperty {
 
 interface ReactiveObjectCall {
     className: string;
-    end: number;
+    node: ts.CallExpression;
     properties: AnalyzedProperty[];
-    start: number;
     varName: string | null;
 }
 
-interface TransformContext {
+interface VisitContext {
     bindings: Bindings;
     calls: ReactiveObjectCall[];
     checker?: ts.TypeChecker;
-    classCounter: number;
-    lastImportEnd: number;
     sourceFile: ts.SourceFile;
 }
 
@@ -169,15 +166,12 @@ function isStaticValue(node: ts.Node): boolean {
     return false;
 }
 
-function visit(ctx: TransformContext, node: ts.Node): void {
-    if (ts.isImportDeclaration(node)) {
-        ctx.lastImportEnd = node.end;
-    }
+function isReactiveCall(node: ts.CallExpression): boolean {
+    return ts.isIdentifier(node.expression) && node.expression.text === "reactive";
+}
 
-    if (
-        ts.isCallExpression(node) &&
-        isReactiveCall(node, ctx.checker)
-    ) {
+function visit(ctx: VisitContext, node: ts.Node): void {
+    if (ts.isCallExpression(node) && isReactiveCall(node)) {
         let arg = node.arguments[0];
 
         if (arg && ts.isObjectLiteralExpression(arg)) {
@@ -214,9 +208,8 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 
             ctx.calls.push({
                 className: uid('ReactiveObject'),
-                end: node.end,
+                node,
                 properties,
-                start: node.pos,
                 varName
             });
         }
@@ -226,46 +219,44 @@ function visit(ctx: TransformContext, node: ts.Node): void {
 }
 
 
-export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): string => {
-    let code = sourceFile.getFullText(),
-        ctx: TransformContext = {
+type ObjectTransformResult = {
+    prepend: string[];
+    replacements: ReplacementIntent[];
+};
+
+
+export default (sourceFile: ts.SourceFile, bindings: Bindings, checker?: ts.TypeChecker): ObjectTransformResult => {
+    let ctx: VisitContext = {
             bindings,
             calls: [],
             checker,
-            classCounter: 0,
-            lastImportEnd: 0,
             sourceFile
         };
 
     visit(ctx, sourceFile);
 
     if (ctx.calls.length === 0) {
-        return code;
+        return { prepend: [], replacements: [] };
     }
 
-    let classes = ctx.calls.map(c => buildClassCode(c.className, c.properties)).join('\n'),
-        replacements: Replacement[] = [];
-
-    replacements.push({
-        end: ctx.lastImportEnd,
-        newText: code.substring(0, ctx.lastImportEnd) + '\n' + classes + '\n',
-        start: 0
-    });
+    let prepend: string[] = [],
+        replacements: ReplacementIntent[] = [];
 
     for (let i = 0, n = ctx.calls.length; i < n; i++) {
         let call = ctx.calls[i];
 
+        prepend.push(buildClassCode(call.className, call.properties));
+
         replacements.push({
-            end: call.end,
-            newText: ` new ${call.className}(${
+            node: call.node,
+            generate: () => ` new ${call.className}(${
                 call.properties
                     .filter(({ isStatic, type }) => !isStatic || type === COMPILER_TYPES.Computed)
                     .map(p => p.valueText)
                     .join(', ')
-            })`,
-            start: call.start
+            })`
         });
     }
 
-    return c.replace(code, replacements);
+    return { prepend, replacements };
 };

package/src/compiler/plugins/tsc.ts

@@ -1,5 +1,4 @@
-import { plugin } from '@esportsplus/typescript/compiler';
-import { analyze, transform } from '..';
+import plugin from '..';
 
 
-export default plugin.tsc({ analyze, transform }) as ReturnType<typeof plugin.tsc>;
+export default plugin;

package/src/compiler/plugins/vite.ts

@@ -1,10 +1,9 @@
-import { PACKAGE } from '../../constants';
 import { plugin } from '@esportsplus/typescript/compiler';
-import { analyze, transform } from '..';
+import { PACKAGE } from '~/constants';
+import reactivityPlugin from '..';
 
 
 export default plugin.vite({
-    analyze,
     name: PACKAGE,
-    transform
-});
+    plugins: [reactivityPlugin]
+});