@esportsplus/template 0.31.6 → 0.32.0

package/build/transformer/codegen.d.ts

@@ -12,8 +12,7 @@ declare const getNames: () => {
     event: string;
     slot: string;
 };
-declare const initNamespace: () => void;
 declare const needsArraySlotImport: (sourceFile: ts.SourceFile) => boolean;
 declare const setTypeChecker: (checker: ts.TypeChecker | undefined) => void;
-export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, initNamespace, needsArraySlotImport, setTypeChecker };
+export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, needsArraySlotImport, setTypeChecker };
 export type { CodegenResult };

package/build/transformer/codegen.js

@@ -1,10 +1,9 @@
-import { applyReplacementsReverse, uid } from '@esportsplus/typescript/transformer';
+import { addImport, applyReplacementsReverse, uid } from '@esportsplus/typescript/transformer';
 import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer.js';
 import { ts } from '@esportsplus/typescript';
 import parser from './parser.js';
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
-const TEMPLATE_IMPORT = /import\s+\{[^}]*\}\s+from\s+['"]@esportsplus\/template['"];?\s*\n?/g;
-let currentChecker, hoistedFactories = new Map(), htmlToTemplateId = new Map(), ns = '';
+let currentChecker, hoistedFactories = new Map(), htmlToTemplateId = new Map(), nameArraySlot = '', nameAttr = '', nameEffectSlot = '', nameEvent = '', nameSlot = '', nameTemplate = '', needsArraySlot = false, needsAttr = false, needsEffectSlot = false, needsEvent = false, needsSlot = false;
 function collectNestedTemplateReplacements(node, exprStart, sourceFile, replacements) {
     if (isNestedHtmlTemplate(node)) {
         replacements.push({
@@ -18,7 +17,24 @@ function collectNestedTemplateReplacements(node, exprStart, sourceFile, replacem
     }
 }
 function generateImports() {
-    return `import * as ${ns} from '@esportsplus/template';`;
+    let specifiers = [];
+    if (needsArraySlot) {
+        specifiers.push(`ArraySlot as ${nameArraySlot}`);
+    }
+    if (needsEffectSlot) {
+        specifiers.push(`EffectSlot as ${nameEffectSlot}`);
+    }
+    if (needsAttr) {
+        specifiers.push(`attributes as ${nameAttr}`);
+    }
+    if (needsEvent) {
+        specifiers.push(`event as ${nameEvent}`);
+    }
+    if (needsSlot) {
+        specifiers.push(`slot as ${nameSlot}`);
+    }
+    specifiers.push(`template as ${nameTemplate}`);
+    return `import { ${specifiers.join(', ')} } from '@esportsplus/template';`;
 }
 function generateNestedTemplateCode(node, sourceFile) {
     let expressions = [], exprTexts = [], literals = [], template = node.template;
@@ -38,7 +54,8 @@ function generateNestedTemplateCode(node, sourceFile) {
 }
 function generateNodeBinding(anchor, exprText, exprNode, sourceFile) {
     if (!exprNode) {
-        return `${ns}.slot(${anchor}, ${exprText});`;
+        needsSlot = true;
+        return `${nameSlot}(${anchor}, ${exprText});`;
     }
     if (isNestedHtmlTemplate(exprNode)) {
         return `${anchor}.parentNode.insertBefore(${generateNestedTemplateCode(exprNode, sourceFile)}, ${anchor});`;
@@ -46,15 +63,18 @@ function generateNodeBinding(anchor, exprText, exprNode, sourceFile) {
     let slotType = analyzeExpression(exprNode, currentChecker);
     switch (slotType) {
         case 'effect':
-            return `new ${ns}.EffectSlot(${anchor}, ${exprText});`;
+            needsEffectSlot = true;
+            return `new ${nameEffectSlot}(${anchor}, ${exprText});`;
         case 'array-slot':
-            return `new ${ns}.ArraySlot(${anchor}, ${exprText});`;
+            needsArraySlot = true;
+            return `new ${nameArraySlot}(${anchor}, ${exprText});`;
         case 'static':
             return `${anchor}.textContent = ${exprText};`;
         case 'document-fragment':
             return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
         default:
-            return `${ns}.slot(${anchor}, ${exprText});`;
+            needsSlot = true;
+            return `${nameSlot}(${anchor}, ${exprText});`;
     }
 }
 function generateTemplateCode({ html, slots }, exprTexts, exprNodes, sourceFile, isArrowBody) {
@@ -97,12 +117,14 @@ function generateTemplateCode({ html, slots }, exprTexts, exprNodes, sourceFile,
                 if (name === 'spread') {
                     let bindings = generateSpreadBindings(exprNodes[index], exprTexts[index] || 'undefined', elementVar, sourceFile, currentChecker);
                     for (let k = 0, o = bindings.length; k < o; k++) {
+                        trackBindingUsage(bindings[k]);
                         code.push(bindings[k]);
                     }
                     index++;
                 }
                 else {
                     let binding = generateAttributeBinding(elementVar, name, exprTexts[index++] || 'undefined', slot.attributes.statics[name] || '');
+                    trackBindingUsage(binding);
                     code.push(binding);
                 }
             }
@@ -198,13 +220,34 @@ function rewriteExpression(expr, sourceFile) {
     collectNestedTemplateReplacements(expr, exprStart, sourceFile, replacements);
     return applyReplacementsReverse(expr.getText(sourceFile), replacements);
 }
+function trackBindingUsage(binding) {
+    if (binding.startsWith(nameEvent + '.')) {
+        needsEvent = true;
+    }
+    else if (binding.startsWith(nameAttr + '.')) {
+        needsAttr = true;
+    }
+}
 const addArraySlotImport = (code) => {
-    return `import * as ${ns} from '@esportsplus/template';\n\n` + code.replace(TEMPLATE_IMPORT, '');
+    return addImport(code, '@esportsplus/template', ['ArraySlot']);
 };
 const generateCode = (templates, originalCode, sourceFile) => {
     if (templates.length === 0) {
         return { changed: false, code: originalCode };
     }
+    hoistedFactories.clear();
+    htmlToTemplateId.clear();
+    nameArraySlot = uid('ArraySlot');
+    nameAttr = uid('attr');
+    nameEffectSlot = uid('EffectSlot');
+    nameEvent = uid('event');
+    nameSlot = uid('slot');
+    nameTemplate = uid('template');
+    needsArraySlot = false;
+    needsAttr = false;
+    needsEffectSlot = false;
+    needsEvent = false;
+    needsSlot = false;
     let rootTemplates = templates.filter(t => !isNestedTemplate(t, templates));
     if (rootTemplates.length === 0) {
         return { changed: false, code: originalCode };
@@ -237,9 +280,8 @@ const generateCode = (templates, originalCode, sourceFile) => {
     if (changed && hoistedFactories.size > 0) {
         let factories = [];
         for (let [id, html] of hoistedFactories) {
-            factories.push(`const ${id} = ${ns}.template(\`${html}\`);`);
+            factories.push(`const ${id} = ${nameTemplate}(\`${html}\`);`);
         }
-        code = code.replace(TEMPLATE_IMPORT, '');
         code = generateImports() + '\n\n' + factories.join('\n') + '\n\n' + code;
     }
     return { changed, code };
@@ -252,7 +294,7 @@ const generateReactiveInlining = (calls, code, sourceFile) => {
     for (let i = calls.length - 1; i >= 0; i--) {
         let call = calls[i];
         result = result.slice(0, call.start);
-        result += `new ${ns}.ArraySlot(
+        result += `new ${nameArraySlot}(
                 ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                 ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
             )`;
@@ -261,19 +303,14 @@ const generateReactiveInlining = (calls, code, sourceFile) => {
     return result;
 };
 const getNames = () => ({
-    attr: `${ns}.attributes`,
-    event: `${ns}.event`,
-    slot: `${ns}.slot`
+    attr: nameAttr,
+    event: nameEvent,
+    slot: nameSlot
 });
-const initNamespace = () => {
-    hoistedFactories.clear();
-    htmlToTemplateId.clear();
-    ns = uid('t');
-};
 const needsArraySlotImport = (sourceFile) => {
     return hasArraySlotUsage(sourceFile) && !hasArraySlotImport(sourceFile);
 };
 const setTypeChecker = (checker) => {
     currentChecker = checker;
 };
-export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, initNamespace, needsArraySlotImport, setTypeChecker };
+export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, needsArraySlotImport, setTypeChecker };

package/build/transformer/index.js

@@ -1,19 +1,18 @@
 import { mightNeedTransform } from '@esportsplus/typescript/transformer';
-import { addArraySlotImport, generateCode, generateReactiveInlining, initNamespace, needsArraySlotImport, setTypeChecker } from './codegen.js';
+import { addArraySlotImport, generateCode, generateReactiveInlining, needsArraySlotImport, setTypeChecker } from './codegen.js';
 import { findHtmlTemplates, findReactiveCalls } from './ts-parser.js';
 import { ts } from '@esportsplus/typescript';
 const PATTERNS = ['html`', 'html.reactive'];
 function createTransformer(program) {
-    let printer = ts.createPrinter(), typeChecker = program.getTypeChecker();
+    let typeChecker = program.getTypeChecker();
     return (_context) => {
         return (sourceFile) => {
-            let code = printer.printFile(sourceFile);
+            let code = sourceFile.getFullText();
             if (!mightNeedTransform(code, { patterns: PATTERNS })) {
                 return sourceFile;
             }
-            let reparsed = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
             setTypeChecker(typeChecker);
-            let result = transformCode(code, reparsed);
+            let result = transformCode(code, sourceFile);
             if (!result.changed) {
                 return sourceFile;
             }
@@ -23,7 +22,6 @@ function createTransformer(program) {
 }
 function transformCode(code, sourceFile) {
     let changed = false, result = code;
-    initNamespace();
     let reactiveCalls = findReactiveCalls(sourceFile);
     if (reactiveCalls.length > 0) {
         result = generateReactiveInlining(reactiveCalls, result, sourceFile);
@@ -47,18 +45,18 @@ function transformCode(code, sourceFile) {
     return { changed, code: result, sourceFile };
 }
 const transform = (sourceFile, program) => {
-    let printer = ts.createPrinter(), code = printer.printFile(sourceFile);
+    let code = sourceFile.getFullText();
     if (!mightNeedTransform(code, { patterns: PATTERNS })) {
         return { changed: false, code, sourceFile };
     }
-    let reparsed = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
     let programSourceFile = program.getSourceFile(sourceFile.fileName);
     if (programSourceFile) {
         setTypeChecker(program.getTypeChecker());
+        sourceFile = programSourceFile;
     }
     else {
         setTypeChecker(undefined);
     }
-    return transformCode(code, reparsed);
+    return transformCode(code, sourceFile);
 };
 export { createTransformer, mightNeedTransform, PATTERNS, transform };

package/build/transformer/plugins/vite.js

@@ -1,4 +1,4 @@
-import { createTransformer, mightNeedTransform, PATTERNS } from '../index.js';
+import { mightNeedTransform, PATTERNS, transform } from '../index.js';
 import { program, TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
 import { ts } from '@esportsplus/typescript';
 export default (options) => {
@@ -17,14 +17,11 @@ export default (options) => {
                 return null;
             }
             try {
-                let p = program.get(root), printer = ts.createPrinter(), sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), transformer = createTransformer(p), 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, program.get(root));
+                if (!result.changed) {
                     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/template: Error transforming ${id}:`, error);

package/package.json

@@ -2,12 +2,12 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/queue": "^0.2.0",
-    "@esportsplus/reactivity": "^0.24.5",
+    "@esportsplus/reactivity": "^0.25.2",
     "@esportsplus/utilities": "^0.27.2",
     "serve": "^14.2.5"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.17.0",
+    "@esportsplus/typescript": "^0.17.3",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0",
     "vite-tsconfig-paths": "^6.0.3"
@@ -40,7 +40,7 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.31.6",
+  "version": "0.32.0",
   "scripts": {
     "build": "tsc",
     "build:test": "vite build --config test/vite.config.ts",

package/src/transformer/codegen.ts

@@ -1,4 +1,4 @@
-import { applyReplacementsReverse, uid } from '@esportsplus/typescript/transformer';
+import { addImport, applyReplacementsReverse, uid } from '@esportsplus/typescript/transformer';
 import type { Replacement } from '@esportsplus/typescript/transformer';
 import type { ReactiveCallInfo, TemplateInfo } from './ts-parser';
 import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer';
@@ -33,13 +33,21 @@ type ParseResult = {
 
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
 
-const TEMPLATE_IMPORT = /import\s+\{[^}]*\}\s+from\s+['"]@esportsplus\/template['"];?\s*\n?/g;
-
 
 let currentChecker: ts.TypeChecker | undefined,
     hoistedFactories = new Map<string, string>(),
     htmlToTemplateId = new Map<string, string>(),
-    ns = '';
+    nameArraySlot = '',
+    nameAttr = '',
+    nameEffectSlot = '',
+    nameEvent = '',
+    nameSlot = '',
+    nameTemplate = '',
+    needsArraySlot = false,
+    needsAttr = false,
+    needsEffectSlot = false,
+    needsEvent = false,
+    needsSlot = false;
 
 
 function collectNestedTemplateReplacements(
@@ -61,7 +69,31 @@ function collectNestedTemplateReplacements(
 }
 
 function generateImports(): string {
-    return `import * as ${ns} from '@esportsplus/template';`;
+    let specifiers: string[] = [];
+
+    if (needsArraySlot) {
+        specifiers.push(`ArraySlot as ${nameArraySlot}`);
+    }
+
+    if (needsEffectSlot) {
+        specifiers.push(`EffectSlot as ${nameEffectSlot}`);
+    }
+
+    if (needsAttr) {
+        specifiers.push(`attributes as ${nameAttr}`);
+    }
+
+    if (needsEvent) {
+        specifiers.push(`event as ${nameEvent}`);
+    }
+
+    if (needsSlot) {
+        specifiers.push(`slot as ${nameSlot}`);
+    }
+
+    specifiers.push(`template as ${nameTemplate}`);
+
+    return `import { ${specifiers.join(', ')} } from '@esportsplus/template';`;
 }
 
 function generateNestedTemplateCode(node: ts.TaggedTemplateExpression, sourceFile: ts.SourceFile): string {
@@ -96,7 +128,8 @@ function generateNestedTemplateCode(node: ts.TaggedTemplateExpression, sourceFil
 
 function generateNodeBinding(anchor: string, exprText: string, exprNode: ts.Expression | undefined, sourceFile: ts.SourceFile): string {
     if (!exprNode) {
-        return `${ns}.slot(${anchor}, ${exprText});`;
+        needsSlot = true;
+        return `${nameSlot}(${anchor}, ${exprText});`;
     }
 
     if (isNestedHtmlTemplate(exprNode)) {
@@ -107,10 +140,12 @@ function generateNodeBinding(anchor: string, exprText: string, exprNode: ts.Expr
 
     switch (slotType) {
         case 'effect':
-            return `new ${ns}.EffectSlot(${anchor}, ${exprText});`;
+            needsEffectSlot = true;
+            return `new ${nameEffectSlot}(${anchor}, ${exprText});`;
 
         case 'array-slot':
-            return `new ${ns}.ArraySlot(${anchor}, ${exprText});`;
+            needsArraySlot = true;
+            return `new ${nameArraySlot}(${anchor}, ${exprText});`;
 
         case 'static':
             return `${anchor}.textContent = ${exprText};`;
@@ -119,7 +154,8 @@ function generateNodeBinding(anchor: string, exprText: string, exprNode: ts.Expr
             return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
 
         default:
-            return `${ns}.slot(${anchor}, ${exprText});`;
+            needsSlot = true;
+            return `${nameSlot}(${anchor}, ${exprText});`;
     }
 }
 
@@ -201,6 +237,7 @@ function generateTemplateCode(
                         );
 
                     for (let k = 0, o = bindings.length; k < o; k++) {
+                        trackBindingUsage(bindings[k]);
                         code.push(bindings[k]);
                     }
 
@@ -214,6 +251,7 @@ function generateTemplateCode(
                             slot.attributes.statics[name] || ''
                         );
 
+                    trackBindingUsage(binding);
                     code.push(binding);
                 }
             }
@@ -343,11 +381,18 @@ function rewriteExpression(expr: ts.Expression, sourceFile: ts.SourceFile): stri
     return applyReplacementsReverse(expr.getText(sourceFile), replacements);
 }
 
+function trackBindingUsage(binding: string): void {
+    if (binding.startsWith(nameEvent + '.')) {
+        needsEvent = true;
+    }
+    else if (binding.startsWith(nameAttr + '.')) {
+        needsAttr = true;
+    }
+}
 
 
 const addArraySlotImport = (code: string): string => {
-    // Strip original @esportsplus/template imports (they lose symbol bindings in TS 5.9.3)
-    return `import * as ${ns} from '@esportsplus/template';\n\n` + code.replace(TEMPLATE_IMPORT, '');
+    return addImport(code, '@esportsplus/template', ['ArraySlot']);
 };
 
 const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile): CodegenResult => {
@@ -355,6 +400,20 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
         return { changed: false, code: originalCode };
     }
 
+    hoistedFactories.clear();
+    htmlToTemplateId.clear();
+    nameArraySlot = uid('ArraySlot');
+    nameAttr = uid('attr');
+    nameEffectSlot = uid('EffectSlot');
+    nameEvent = uid('event');
+    nameSlot = uid('slot');
+    nameTemplate = uid('template');
+    needsArraySlot = false;
+    needsAttr = false;
+    needsEffectSlot = false;
+    needsEvent = false;
+    needsSlot = false;
+
     let rootTemplates = templates.filter(t => !isNestedTemplate(t, templates));
 
     if (rootTemplates.length === 0) {
@@ -409,11 +468,9 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
         let factories: string[] = [];
 
         for (let [id, html] of hoistedFactories) {
-            factories.push(`const ${id} = ${ns}.template(\`${html}\`);`);
+            factories.push(`const ${id} = ${nameTemplate}(\`${html}\`);`);
         }
 
-        // Strip original @esportsplus/template imports (they lose symbol bindings in TS 5.9.3)
-        code = code.replace(TEMPLATE_IMPORT, '');
         code = generateImports() + '\n\n' + factories.join('\n') + '\n\n' + code;
     }
 
@@ -432,7 +489,7 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
         let call = calls[i];
 
         result = result.slice(0, call.start);
-        result += `new ${ns}.ArraySlot(
+        result += `new ${nameArraySlot}(
                 ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                 ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
             )`;
@@ -443,17 +500,11 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
 };
 
 const getNames = () => ({
-    attr: `${ns}.attributes`,
-    event: `${ns}.event`,
-    slot: `${ns}.slot`
+    attr: nameAttr,
+    event: nameEvent,
+    slot: nameSlot
 });
 
-const initNamespace = (): void => {
-    hoistedFactories.clear();
-    htmlToTemplateId.clear();
-    ns = uid('t');
-};
-
 const needsArraySlotImport = (sourceFile: ts.SourceFile): boolean => {
     return hasArraySlotUsage(sourceFile) && !hasArraySlotImport(sourceFile);
 };
@@ -463,5 +514,5 @@ const setTypeChecker = (checker: ts.TypeChecker | undefined): void => {
 };
 
 
-export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, initNamespace, needsArraySlotImport, setTypeChecker };
+export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, needsArraySlotImport, setTypeChecker };
 export type { CodegenResult };

package/src/transformer/index.ts

@@ -1,5 +1,5 @@
 import { mightNeedTransform } from '@esportsplus/typescript/transformer';
-import { addArraySlotImport, generateCode, generateReactiveInlining, initNamespace, needsArraySlotImport, setTypeChecker } from './codegen';
+import { addArraySlotImport, generateCode, generateReactiveInlining, needsArraySlotImport, setTypeChecker } from './codegen';
 import { findHtmlTemplates, findReactiveCalls } from './ts-parser';
 import { ts } from '@esportsplus/typescript';
 
@@ -15,24 +15,19 @@ const PATTERNS = ['html`', 'html.reactive'];
 
 
 function createTransformer(program: ts.Program): ts.TransformerFactory<ts.SourceFile> {
-    let printer = ts.createPrinter(),
-        typeChecker = program.getTypeChecker();
+    let typeChecker = program.getTypeChecker();
 
     return (_context: ts.TransformationContext) => {
         return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            // Use printer to get current text representation (handles chained transformers)
-            let code = printer.printFile(sourceFile);
+            let code = sourceFile.getFullText();
 
             if (!mightNeedTransform(code, { patterns: PATTERNS })) {
                 return sourceFile;
             }
 
-            // Re-parse the printed code to get accurate positions
-            let reparsed = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
-
             setTypeChecker(typeChecker);
 
-            let result = transformCode(code, reparsed);
+            let result = transformCode(code, sourceFile);
 
             if (!result.changed) {
                 return sourceFile;
@@ -47,8 +42,6 @@ function transformCode(code: string, sourceFile: ts.SourceFile): TransformResult
     let changed = false,
         result = code;
 
-    initNamespace();
-
     let reactiveCalls = findReactiveCalls(sourceFile);
 
     if (reactiveCalls.length > 0) {
@@ -81,27 +74,23 @@ function transformCode(code: string, sourceFile: ts.SourceFile): TransformResult
 
 
 const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformResult => {
-    // Use printer to get current text representation (handles chained transformers)
-    let printer = ts.createPrinter(),
-        code = printer.printFile(sourceFile);
+    let code = sourceFile.getFullText();
 
     if (!mightNeedTransform(code, { patterns: PATTERNS })) {
         return { changed: false, code, sourceFile };
     }
 
-    // Re-parse the printed code to get accurate positions
-    let reparsed = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
-
     let programSourceFile = program.getSourceFile(sourceFile.fileName);
 
     if (programSourceFile) {
         setTypeChecker(program.getTypeChecker());
+        sourceFile = programSourceFile;
     }
     else {
         setTypeChecker(undefined);
     }
 
-    return transformCode(code, reparsed);
+    return transformCode(code, sourceFile);
 };
 
 

package/src/transformer/plugins/vite.ts

@@ -1,4 +1,4 @@
-import { createTransformer, mightNeedTransform, PATTERNS } from '../index';
+import { mightNeedTransform, PATTERNS, transform } from '../index';
 import { program, TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
 import type { Plugin, ResolvedConfig } from 'vite';
 import { ts } from '@esportsplus/typescript';
@@ -25,23 +25,14 @@ export default (options?: { root?: string }): Plugin => {
             }
 
             try {
-                let p = program.get(root),
-                    printer = ts.createPrinter(),
-                    sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true),
-                    transformer = createTransformer(p),
-                    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, program.get(root));
+
+                if (!result.changed) {
                     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/template: Error transforming ${id}:`, error);