@esportsplus/template 0.39.0 → 0.40.0

package/README.md

@@ -26,50 +26,28 @@ The library requires a build-time transformer to convert template literals into
 ```typescript
 // vite.config.ts
 import { defineConfig } from 'vite';
-import templatePlugin from '@esportsplus/template/plugins/vite';
+import template from '@esportsplus/template/compiler/vite';
 
 export default defineConfig({
-    plugins: [
-        templatePlugin()
-    ]
+    plugins: [template]
 });
 ```
 
-**Options:**
-
-```typescript
-templatePlugin({
-    root: string  // Optional: project root (defaults to config.root)
-})
-```
-
 ### TypeScript Compiler (tsc)
 
-For direct `tsc` compilation, use the transformer factory:
+For direct `tsc` compilation, use the transformer:
 
 ```typescript
 // tsconfig.json (with ts-patch or ttypescript)
 {
     "compilerOptions": {
         "plugins": [
-            { "transform": "@esportsplus/template/plugins/tsc" }
+            { "transform": "@esportsplus/template/compiler/tsc" }
         ]
     }
 }
 ```
 
-Or programmatically:
-
-```typescript
-import { ts } from '@esportsplus/typescript';
-import templateTransformer from '@esportsplus/template/plugins/tsc';
-
-const program = ts.createProgram(['src/index.ts'], {});
-const result = ts.emit(program, undefined, undefined, false, {
-    before: [templateTransformer(program)]
-});
-```
-
 ## Basic Usage
 
 ```typescript
@@ -399,6 +377,7 @@ Key optimizations:
 
 - `@esportsplus/reactivity` - Reactive primitives
 - `@esportsplus/queue` - Object pooling
+- `@esportsplus/typescript` - TypeScript compiler utilities
 - `@esportsplus/utilities` - Utility functions
 
 ## License

package/build/compiler/codegen.d.ts

@@ -1,6 +1,6 @@
 import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
-import { ts } from '@esportsplus/typescript';
 import type { TemplateInfo } from './ts-parser.js';
+import { ts } from '@esportsplus/typescript';
 type CodegenResult = {
     prepend: string[];
     replacements: ReplacementIntent[];

package/build/compiler/codegen.js

@@ -1,28 +1,60 @@
-import { ts } from '@esportsplus/typescript';
+import { analyze } from './ts-analyzer.js';
 import { ast, uid } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS } from '../constants.js';
+import { DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS } from '../constants.js';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, NAMESPACE, TYPES } from './constants.js';
 import { extractTemplateParts } from './ts-parser.js';
-import { analyze } from './ts-analyzer.js';
+import { ts } from '@esportsplus/typescript';
 import parser from './parser.js';
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+function collectNestedReplacements(ctx, node, replacements) {
+    if (isNestedHtmlTemplate(node)) {
+        replacements.push({
+            end: node.end,
+            start: node.getStart(ctx.sourceFile),
+            text: generateNestedTemplateCode(ctx, node)
+        });
+        return;
+    }
+    if (isReactiveCall(node)) {
+        let call = node;
+        replacements.push({
+            end: node.end,
+            start: node.getStart(ctx.sourceFile),
+            text: `new ${NAMESPACE}.ArraySlot(${rewriteExpression(ctx, call.arguments[0])}, ${rewriteExpression(ctx, call.arguments[1])})`
+        });
+        return;
+    }
+    ts.forEachChild(node, child => collectNestedReplacements(ctx, child, replacements));
+}
+function discoverTemplatesInExpression(ctx, node) {
+    if (isNestedHtmlTemplate(node)) {
+        let { expressions, literals } = extractTemplateParts(node.template), parsed = parser.parse(literals);
+        getOrCreateTemplateId(ctx, parsed.html);
+        for (let i = 0, n = expressions.length; i < n; i++) {
+            discoverTemplatesInExpression(ctx, expressions[i]);
+        }
+        return;
+    }
+    ts.forEachChild(node, child => discoverTemplatesInExpression(ctx, child));
+}
 function generateAttributeBinding(element, name, expr, staticValue) {
     if (name.startsWith('on') && name.length > 2) {
         let event = name.slice(2).toLowerCase(), key = name.toLowerCase();
         if (LIFECYCLE_EVENTS.has(key)) {
-            return `${COMPILER_NAMESPACE}.${key}(${element}, ${expr});`;
+            return `${NAMESPACE}.${key}(${element}, ${expr});`;
         }
         if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${COMPILER_NAMESPACE}.on(${element}, '${event}', ${expr});`;
+            return `${NAMESPACE}.on(${element}, '${event}', ${expr});`;
         }
-        return `${COMPILER_NAMESPACE}.delegate(${element}, '${event}', ${expr});`;
+        return `${NAMESPACE}.delegate(${element}, '${event}', ${expr});`;
     }
     if (name === 'class') {
-        return `${COMPILER_NAMESPACE}.setClass(${element}, '${staticValue}', ${expr});`;
+        return `${NAMESPACE}.setClass(${element}, '${staticValue}', ${expr});`;
     }
     if (name === 'style') {
-        return `${COMPILER_NAMESPACE}.setStyle(${element}, '${staticValue}', ${expr});`;
+        return `${NAMESPACE}.setStyle(${element}, '${staticValue}', ${expr});`;
     }
-    return `${COMPILER_NAMESPACE}.setProperty(${element}, '${name}', ${expr});`;
+    return `${NAMESPACE}.setProperty(${element}, '${name}', ${expr});`;
 }
 function generateNestedTemplateCode(ctx, node) {
     let { expressions, literals } = extractTemplateParts(node.template), exprTexts = [];
@@ -33,22 +65,22 @@ function generateNestedTemplateCode(ctx, node) {
 }
 function generateNodeBinding(ctx, anchor, exprText, exprNode) {
     if (!exprNode) {
-        return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+        return `${NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
     if (isNestedHtmlTemplate(exprNode)) {
         return `${anchor}.parentNode!.insertBefore(${generateNestedTemplateCode(ctx, exprNode)}, ${anchor});`;
     }
     switch (analyze(exprNode, ctx.checker)) {
-        case COMPILER_TYPES.ArraySlot:
-            return `${anchor}.parentNode!.insertBefore(new ${COMPILER_NAMESPACE}.ArraySlot(${exprText}).fragment, ${anchor});`;
-        case COMPILER_TYPES.DocumentFragment:
+        case TYPES.ArraySlot:
+            return `${anchor}.parentNode!.insertBefore(new ${NAMESPACE}.ArraySlot(${exprText}).fragment, ${anchor});`;
+        case TYPES.DocumentFragment:
             return `${anchor}.parentNode!.insertBefore(${exprText}, ${anchor});`;
-        case COMPILER_TYPES.Effect:
-            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
-        case COMPILER_TYPES.Static:
+        case TYPES.Effect:
+            return `new ${NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
+        case TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
         default:
-            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+            return `${NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
 }
 function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, templateNode) {
@@ -78,22 +110,23 @@ function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, templa
         }
         let name = uid('element'), segments = path.slice(start), value = `${ancestor}.${segments.join('!.')}`;
         if (ancestor === root && segments[0] === 'firstChild') {
-            value = value.replace(`${ancestor}.firstChild!`, `(${ancestor}.firstChild! as ${COMPILER_NAMESPACE}.Element)`);
+            value = value.replace(`${ancestor}.firstChild!`, `(${root}.firstChild! as ${NAMESPACE}.Element)`);
         }
-        declarations.push(`${name} = ${value} as ${COMPILER_NAMESPACE}.Element`);
+        declarations.push(`${name} = ${value} as ${NAMESPACE}.Element`);
         nodes.set(key, name);
     }
-    code.push(isArrowBody ? '{' : `(() => {`, `let ${declarations.join(',\n')};`);
+    code.push(isArrowBody ? '{' : `(() => {`);
+    code.push(`let ${declarations.join(',\n')};`);
     for (let i = 0, n = slots.length; i < n; i++) {
         let element = slots[i].path.length === 0
             ? root
             : (nodes.get(slots[i].path.join('.')) || root), slot = slots[i];
-        if (slot.type === COMPILER_TYPES.Attribute) {
+        if (slot.type === TYPES.Attribute) {
             let names = slot.attributes.names;
             for (let j = 0, m = names.length; j < m; j++) {
                 let name = names[j];
-                if (name === COMPILER_TYPES.Attributes) {
-                    code.push(`${COMPILER_NAMESPACE}.setProperties(${element}, ${exprTexts[index] || 'undefined'});`);
+                if (name === TYPES.Attributes) {
+                    code.push(`${NAMESPACE}.setProperties(${element}, ${exprTexts[index] || 'undefined'});`);
                     index++;
                 }
                 else {
@@ -118,117 +151,37 @@ function getOrCreateTemplateId(ctx, html) {
     }
     return id;
 }
-function isNestedHtmlTemplate(expr) {
-    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT;
-}
 function isArrowExpressionBody(node) {
     return ts.isArrowFunction(node.parent) && node.parent.body === node;
 }
+function isNestedHtmlTemplate(expr) {
+    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === ENTRYPOINT;
+}
 function isReactiveCall(expr) {
     return (ts.isCallExpression(expr) &&
         ts.isPropertyAccessExpression(expr.expression) &&
         ts.isIdentifier(expr.expression.expression) &&
-        expr.expression.expression.text === COMPILER_ENTRYPOINT &&
-        expr.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY);
+        expr.expression.expression.text === ENTRYPOINT &&
+        expr.expression.name.text === ENTRYPOINT_REACTIVITY);
 }
 function rewriteExpression(ctx, expr) {
     if (isNestedHtmlTemplate(expr)) {
         return generateNestedTemplateCode(ctx, expr);
     }
     if (isReactiveCall(expr)) {
-        return `
-            ${printer.printNode(ts.EmitHint.Expression, expr.arguments[0], ctx.sourceFile)},
-            ${rewriteExpression(ctx, expr.arguments[1])}
-        `;
+        return `${rewriteExpression(ctx, expr.arguments[0])}, ${rewriteExpression(ctx, expr.arguments[1])}`;
     }
-    if (!ast.hasMatch(expr, n => isNestedHtmlTemplate(n) || isReactiveCall(n))) {
+    if (!ast.test(expr, n => isNestedHtmlTemplate(n) || isReactiveCall(n))) {
         return printer.printNode(ts.EmitHint.Expression, expr, ctx.sourceFile);
     }
-    return walkExpression(ctx, expr);
-}
-function walkExpression(ctx, node) {
-    if (isNestedHtmlTemplate(node)) {
-        return generateNestedTemplateCode(ctx, node);
-    }
-    if (isReactiveCall(node)) {
-        let call = node;
-        return `new ${COMPILER_NAMESPACE}.ArraySlot(${printer.printNode(ts.EmitHint.Expression, call.arguments[0], ctx.sourceFile)}, ${rewriteExpression(ctx, call.arguments[1])})`;
-    }
-    if (!ast.hasMatch(node, n => isNestedHtmlTemplate(n) || isReactiveCall(n))) {
-        return printer.printNode(ts.EmitHint.Expression, node, ctx.sourceFile);
-    }
-    if (ts.isConditionalExpression(node)) {
-        return `${walkExpression(ctx, node.condition)} ? ${walkExpression(ctx, node.whenTrue)} : ${walkExpression(ctx, node.whenFalse)}`;
-    }
-    if (ts.isBinaryExpression(node)) {
-        return `${walkExpression(ctx, node.left)} ${node.operatorToken.getText(ctx.sourceFile)} ${walkExpression(ctx, node.right)}`;
-    }
-    if (ts.isCallExpression(node)) {
-        let args = [];
-        for (let i = 0, n = node.arguments.length; i < n; i++) {
-            args.push(walkExpression(ctx, node.arguments[i]));
-        }
-        return `${walkExpression(ctx, node.expression)}(${args.join(', ')})`;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-        return `${walkExpression(ctx, node.expression)}.${node.name.text}`;
-    }
-    if (ts.isElementAccessExpression(node)) {
-        return `${walkExpression(ctx, node.expression)}[${walkExpression(ctx, node.argumentExpression)}]`;
-    }
-    if (ts.isParenthesizedExpression(node)) {
-        return `(${walkExpression(ctx, node.expression)})`;
-    }
-    if (ts.isArrowFunction(node)) {
-        return `(${node.parameters.map(p => p.getText(ctx.sourceFile)).join(', ')}) => ${ts.isBlock(node.body) ? node.body.getText(ctx.sourceFile) : walkExpression(ctx, node.body)}`;
-    }
-    if (ts.isArrayLiteralExpression(node)) {
-        let elements = [];
-        for (let i = 0, n = node.elements.length; i < n; i++) {
-            elements.push(walkExpression(ctx, node.elements[i]));
-        }
-        return `[${elements.join(', ')}]`;
-    }
-    if (ts.isObjectLiteralExpression(node)) {
-        let properties = [];
-        for (let i = 0, n = node.properties.length; i < n; i++) {
-            let prop = node.properties[i];
-            if (ts.isPropertyAssignment(prop)) {
-                properties.push(`${prop.name.getText(ctx.sourceFile)}: ${walkExpression(ctx, prop.initializer)}`);
-            }
-            else if (ts.isShorthandPropertyAssignment(prop)) {
-                properties.push(prop.name.text);
-            }
-            else if (ts.isSpreadAssignment(prop)) {
-                properties.push(`...${walkExpression(ctx, prop.expression)}`);
-            }
-            else {
-                properties.push(prop.getText(ctx.sourceFile));
-            }
-        }
-        return `{ ${properties.join(', ')} }`;
-    }
-    if (ts.isPrefixUnaryExpression(node)) {
-        return `${ts.tokenToString(node.operator)}${walkExpression(ctx, node.operand)}`;
-    }
-    if (ts.isPostfixUnaryExpression(node)) {
-        return `${walkExpression(ctx, node.operand)}${ts.tokenToString(node.operator)}`;
+    let exprStart = expr.getStart(ctx.sourceFile), replacements = [], text = expr.getText(ctx.sourceFile);
+    ts.forEachChild(expr, child => collectNestedReplacements(ctx, child, replacements));
+    replacements.sort((a, b) => b.start - a.start);
+    for (let i = 0, n = replacements.length; i < n; i++) {
+        let r = replacements[i];
+        text = text.slice(0, r.start - exprStart) + r.text + text.slice(r.end - exprStart);
     }
-    if (ts.isTemplateExpression(node)) {
-        let parts = [node.head.text];
-        for (let i = 0, n = node.templateSpans.length; i < n; i++) {
-            let span = node.templateSpans[i];
-            parts.push('${' + walkExpression(ctx, span.expression) + '}' + span.literal.text);
-        }
-        return '`' + parts.join('') + '`';
-    }
-    if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
-        return walkExpression(ctx, node.expression);
-    }
-    if (ts.isNonNullExpression(node)) {
-        return `${walkExpression(ctx, node.expression)}!`;
-    }
-    return printer.printNode(ts.EmitHint.Expression, node, ctx.sourceFile);
+    return text;
 }
 const generateCode = (templates, sourceFile, checker) => {
     let result = {
@@ -246,8 +199,8 @@ const generateCode = (templates, sourceFile, checker) => {
             ranges.push({ end: exprs[j].end, start: exprs[j].getStart(sourceFile) });
         }
     }
-    let rootTemplates = templates.filter(t => !ast.inRange(ranges, t.node.getStart(sourceFile), t.node.end));
-    if (rootTemplates.length === 0) {
+    let root = templates.filter(t => !ast.inRange(ranges, t.node.getStart(sourceFile), t.node.end));
+    if (root.length === 0) {
         return result;
     }
     let ctx = {
@@ -255,30 +208,36 @@ const generateCode = (templates, sourceFile, checker) => {
         sourceFile,
         templates: result.templates
     };
-    for (let i = 0, n = rootTemplates.length; i < n; i++) {
-        let template = rootTemplates[i];
-        result.replacements.push({
-            generate: (sf) => {
-                let exprTexts = [], localCtx = {
-                    checker,
-                    sourceFile: sf,
-                    templates: ctx.templates
-                }, parsed = parser.parse(template.literals);
-                for (let j = 0, m = template.expressions.length; j < m; j++) {
-                    exprTexts.push(rewriteExpression(localCtx, template.expressions[j]));
-                }
-                if (isArrowExpressionBody(template.node) &&
-                    template.node.parent.parameters.length === 0 &&
-                    (!parsed.slots || parsed.slots.length === 0)) {
-                    return getOrCreateTemplateId(localCtx, parsed.html);
-                }
-                return generateTemplateCode(localCtx, parsed, exprTexts, template.expressions, template.node);
-            },
-            node: template.node
-        });
+    for (let i = 0, n = root.length; i < n; i++) {
+        let exprTexts = [], parsed = parser.parse(root[i].literals), template = root[i];
+        for (let j = 0, m = template.expressions.length; j < m; j++) {
+            exprTexts.push(rewriteExpression(ctx, template.expressions[j]));
+        }
+        if (isArrowExpressionBody(template.node) &&
+            template.node.parent.parameters.length === 0 &&
+            (!parsed.slots || parsed.slots.length === 0)) {
+            let code = getOrCreateTemplateId(ctx, parsed.html);
+            result.replacements.push({
+                generate: () => code,
+                node: template.node
+            });
+        }
+        else {
+            let code = generateTemplateCode(ctx, parsed, exprTexts, template.expressions, template.node);
+            result.replacements.push({
+                generate: () => code,
+                node: template.node
+            });
+        }
+    }
+    for (let i = 0, n = templates.length; i < n; i++) {
+        getOrCreateTemplateId(ctx, parser.parse(templates[i].literals).html);
+        for (let j = 0, m = templates[i].expressions.length; j < m; j++) {
+            discoverTemplatesInExpression(ctx, templates[i].expressions[j]);
+        }
     }
     for (let [html, id] of ctx.templates) {
-        result.prepend.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
+        result.prepend.push(`const ${id} = ${NAMESPACE}.template(\`${html}\`);`);
     }
     return result;
 };

package/build/compiler/constants.d.ts

@@ -0,0 +1,16 @@
+declare const ENTRYPOINT = "html";
+declare const ENTRYPOINT_REACTIVITY = "reactive";
+declare const NAMESPACE: string;
+declare const PACKAGE = "@esportsplus/template";
+declare const enum TYPES {
+    ArraySlot = "array-slot",
+    Attributes = "attributes",
+    Attribute = "attribute",
+    DocumentFragment = "document-fragment",
+    Effect = "effect",
+    Node = "node",
+    Primitive = "primitive",
+    Static = "static",
+    Unknown = "unknown"
+}
+export { ENTRYPOINT, ENTRYPOINT_REACTIVITY, NAMESPACE, PACKAGE, TYPES };

package/build/compiler/constants.js

@@ -0,0 +1,19 @@
+import { uid } from '@esportsplus/typescript/compiler';
+const ENTRYPOINT = 'html';
+const ENTRYPOINT_REACTIVITY = 'reactive';
+const NAMESPACE = uid('template');
+const PACKAGE = '@esportsplus/template';
+var TYPES;
+(function (TYPES) {
+    TYPES["ArraySlot"] = "array-slot";
+    TYPES["Attributes"] = "attributes";
+    TYPES["Attribute"] = "attribute";
+    TYPES["DocumentFragment"] = "document-fragment";
+    TYPES["Effect"] = "effect";
+    TYPES["Node"] = "node";
+    TYPES["Primitive"] = "primitive";
+    TYPES["Static"] = "static";
+    TYPES["Unknown"] = "unknown";
+})(TYPES || (TYPES = {}));
+;
+export { ENTRYPOINT, ENTRYPOINT_REACTIVITY, NAMESPACE, PACKAGE, TYPES };

package/build/compiler/index.d.ts

@@ -1,3 +1,6 @@
-import type { Plugin } from '@esportsplus/typescript/compiler';
-declare const plugin: Plugin;
-export default plugin;
+import type { TransformContext } from '@esportsplus/typescript/compiler';
+declare const _default: {
+    patterns: string[];
+    transform: (ctx: TransformContext) => {};
+};
+export default _default;

package/build/compiler/index.js

@@ -1,29 +1,33 @@
 import { ts } from '@esportsplus/typescript';
 import { ast } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, NAMESPACE, PACKAGE } from './constants.js';
 import { generateCode, printer } from './codegen.js';
 import { findHtmlTemplates, findReactiveCalls } from './ts-parser.js';
-const plugin = {
+export default {
     patterns: [
-        `${COMPILER_ENTRYPOINT}\``,
-        `${COMPILER_ENTRYPOINT}.${COMPILER_ENTRYPOINT_REACTIVITY}`
+        `${ENTRYPOINT}\``,
+        `${ENTRYPOINT}.${ENTRYPOINT_REACTIVITY}`
     ],
     transform: (ctx) => {
-        let importsIntent = [], prepend = [], ranges = [], replacements = [], removeImports = [], templates = findHtmlTemplates(ctx.sourceFile, ctx.checker);
+        let intents = {
+            imports: [],
+            prepend: [],
+            replacements: []
+        }, ranges = [], remove = [], templates = findHtmlTemplates(ctx.sourceFile, ctx.checker);
         for (let i = 0, n = templates.length; i < n; i++) {
             ranges.push({
                 end: templates[i].end,
                 start: templates[i].start
             });
         }
-        let reactiveCalls = findReactiveCalls(ctx.sourceFile, ctx.checker);
-        for (let i = 0, n = reactiveCalls.length; i < n; i++) {
-            let call = reactiveCalls[i];
+        let calls = findReactiveCalls(ctx.sourceFile, ctx.checker);
+        for (let i = 0, n = calls.length; i < n; i++) {
+            let call = calls[i];
             if (ast.inRange(ranges, call.start, call.end)) {
                 continue;
             }
-            replacements.push({
-                generate: (sourceFile) => `new ${COMPILER_NAMESPACE}.ArraySlot(
+            intents.replacements.push({
+                generate: (sourceFile) => `new ${NAMESPACE}.ArraySlot(
                     ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                     ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
                 )`,
@@ -32,23 +36,18 @@ const plugin = {
         }
         if (templates.length > 0) {
             let result = generateCode(templates, ctx.sourceFile, ctx.checker);
-            prepend.push(...result.prepend);
-            replacements.push(...result.replacements);
-            removeImports.push(COMPILER_ENTRYPOINT);
+            intents.prepend.push(...result.prepend);
+            intents.replacements.push(...result.replacements);
+            remove.push(ENTRYPOINT);
         }
-        if (replacements.length === 0 && prepend.length === 0) {
+        if (intents.replacements.length === 0 && intents.prepend.length === 0) {
             return {};
         }
-        importsIntent.push({
-            namespace: COMPILER_NAMESPACE,
+        intents.imports.push({
+            namespace: NAMESPACE,
             package: PACKAGE,
-            remove: removeImports
+            remove: remove
         });
-        return {
-            imports: importsIntent,
-            prepend,
-            replacements
-        };
+        return intents;
     }
 };
-export default plugin;

package/build/compiler/parser.d.ts

@@ -1,18 +1,18 @@
-import { COMPILER_TYPES } from '../constants.js';
+import { TYPES } from './constants.js';
 type NodePath = ('firstChild' | 'firstElementChild' | 'nextElementSibling' | 'nextSibling')[];
 declare const _default: {
     parse: (literals: string[]) => {
         html: string;
         slots: ({
             path: NodePath;
-            type: COMPILER_TYPES.Node;
+            type: TYPES.Node;
         } | {
             attributes: {
                 names: string[];
                 statics: Record<string, string>;
             };
             path: NodePath;
-            type: COMPILER_TYPES.Attribute;
+            type: TYPES.Attribute;
         })[] | null;
     };
 };

package/build/compiler/parser.js

@@ -1,4 +1,5 @@
-import { COMPILER_TYPES, PACKAGE, SLOT_HTML } from '../constants.js';
+import { SLOT_HTML } from '../constants.js';
+import { PACKAGE, TYPES } from './constants.js';
 const ATTRIBUTE_DELIMITERS = {
     class: ' ',
     style: ';'
@@ -102,7 +103,7 @@ const parse = (literals) => {
                             }
                         }
                         else {
-                            names.push(COMPILER_TYPES.Attributes);
+                            names.push(TYPES.Attributes);
                         }
                     }
                 }
@@ -124,7 +125,7 @@ const parse = (literals) => {
                     if (!attrs) {
                         throw new Error(`${PACKAGE}: attribute metadata could not be found for '${attr}'`);
                     }
-                    slots.push({ attributes: attrs, path, type: COMPILER_TYPES.Attribute });
+                    slots.push({ attributes: attrs, path, type: TYPES.Attribute });
                     for (let i = 0, n = attrs.names.length; i < n; i++) {
                         buffer += parsed[slot++];
                     }
@@ -138,7 +139,7 @@ const parse = (literals) => {
                 buffer += parsed[slot++] + SLOT_HTML;
                 slots.push({
                     path: methods(parent.children, parent.path, 'firstChild', 'nextSibling'),
-                    type: COMPILER_TYPES.Node
+                    type: TYPES.Node
                 });
             }
             if (n === slot) {

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

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

package/build/compiler/plugins/tsc.js

@@ -1,2 +1,4 @@
-import plugin from '../index.js';
-export default plugin;
+import { plugin } from '@esportsplus/typescript/compiler';
+import reactivity from '@esportsplus/reactivity/compiler';
+import template from '../index.js';
+export default plugin.tsc([reactivity, template]);

package/build/compiler/plugins/vite.js

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

package/build/compiler/ts-analyzer.d.ts

@@ -1,4 +1,4 @@
-import { COMPILER_TYPES } from '../constants.js';
 import { ts } from '@esportsplus/typescript';
-declare const analyze: (expr: ts.Expression, checker?: ts.TypeChecker) => COMPILER_TYPES;
+import { TYPES } from './constants.js';
+declare const analyze: (expr: ts.Expression, checker?: ts.TypeChecker) => TYPES;
 export { analyze };