@esportsplus/template 0.38.2 → 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,11 +1,12 @@
 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[];
     templates: Map<string, string>;
 };
+declare let printer: ts.Printer;
 declare const generateCode: (templates: TemplateInfo[], sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => CodegenResult;
-export { generateCode };
+export { generateCode, printer };
 export type { CodegenResult };

package/build/compiler/codegen.js

@@ -1,90 +1,93 @@
-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 { analyze } from './analyzer.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 { ts } from '@esportsplus/typescript';
 import parser from './parser.js';
-const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-function collectNestedReplacements(ctx, node, exprStart, replacements) {
+function collectNestedReplacements(ctx, node, replacements) {
     if (isNestedHtmlTemplate(node)) {
         replacements.push({
-            end: node.end - exprStart,
-            newText: generateNestedTemplateCode(ctx, node),
-            start: node.getStart(ctx.sourceFile) - exprStart
+            end: node.end,
+            start: node.getStart(ctx.sourceFile),
+            text: generateNestedTemplateCode(ctx, node)
         });
+        return;
     }
-    else if (isReactiveCall(node)) {
+    if (isReactiveCall(node)) {
+        let call = node;
         replacements.push({
-            end: node.end - exprStart,
-            newText: rewriteNestedReactiveCall(ctx, node),
-            start: node.getStart(ctx.sourceFile) - exprStart
+            end: node.end,
+            start: node.getStart(ctx.sourceFile),
+            text: `new ${NAMESPACE}.ArraySlot(${rewriteExpression(ctx, call.arguments[0])}, ${rewriteExpression(ctx, call.arguments[1])})`
         });
+        return;
     }
-    else {
-        ts.forEachChild(node, child => collectNestedReplacements(ctx, child, exprStart, replacements));
+    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 = [], exprTexts = [], literals = [], template = node.template;
-    if (ts.isNoSubstitutionTemplateLiteral(template)) {
-        literals.push(template.text);
+    let { expressions, literals } = extractTemplateParts(node.template), exprTexts = [];
+    for (let i = 0, n = expressions.length; i < n; i++) {
+        exprTexts.push(rewriteExpression(ctx, expressions[i]));
     }
-    else if (ts.isTemplateExpression(template)) {
-        literals.push(template.head.text);
-        for (let i = 0, n = template.templateSpans.length; i < n; i++) {
-            let expr = template.templateSpans[i].expression;
-            expressions.push(expr);
-            literals.push(template.templateSpans[i].literal.text);
-            exprTexts.push(rewriteExpression(ctx, expr));
-        }
-    }
-    return generateTemplateCode(ctx, parser.parse(literals), exprTexts, expressions, false);
+    return generateTemplateCode(ctx, parser.parse(literals), exprTexts, expressions, 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});`;
     }
-    let slotType = analyze(exprNode, ctx.checker);
-    switch (slotType) {
-        case COMPILER_TYPES.ArraySlot:
-            return `${anchor}.parentNode!.insertBefore(new ${COMPILER_NAMESPACE}.ArraySlot(${exprText}).fragment, ${anchor});`;
-        case COMPILER_TYPES.DocumentFragment:
+    switch (analyze(exprNode, ctx.checker)) {
+        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, isArrowBody) {
+function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, templateNode) {
     if (!slots || slots.length === 0) {
         return `${getOrCreateTemplateId(ctx, html)}()`;
     }
-    let code = [], declarations = [], index = 0, nodes = new Map(), root = uid('root');
+    let code = [], declarations = [], index = 0, isArrowBody = isArrowExpressionBody(templateNode), nodes = new Map(), root = uid('root');
     declarations.push(`${root} = ${getOrCreateTemplateId(ctx, html)}()`);
     nodes.set('', root);
     for (let i = 0, n = slots.length; i < n; i++) {
@@ -107,22 +110,23 @@ function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArro
         }
         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 {
@@ -147,83 +151,37 @@ function getOrCreateTemplateId(ctx, html) {
     }
     return id;
 }
+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 === COMPILER_ENTRYPOINT;
+    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);
-}
-function replaceReverse(text, replacements) {
-    let sorted = replacements.slice().sort((a, b) => b.start - a.start);
-    for (let i = 0, n = sorted.length; i < n; i++) {
-        let r = sorted[i];
-        text = text.slice(0, r.start) + r.newText + text.slice(r.end);
-    }
-    return text;
+        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 rewriteReactiveCall(ctx, expr);
-    }
-    if (!ast.hasMatch(expr, n => isNestedHtmlTemplate(n) || isReactiveCall(n))) {
-        return ctx.printer.printNode(ts.EmitHint.Expression, expr, ctx.sourceFile);
-    }
-    let replacements = [];
-    collectNestedReplacements(ctx, expr, expr.getStart(ctx.sourceFile), replacements);
-    return replaceReverse(expr.getText(ctx.sourceFile), replacements);
-}
-function rewriteReactiveCall(ctx, node) {
-    let arrayArg = node.arguments[0], arrayText = ctx.printer.printNode(ts.EmitHint.Expression, arrayArg, ctx.sourceFile), callbackArg = node.arguments[1], callbackText = rewriteExpression(ctx, callbackArg);
-    return `${arrayText}, ${callbackText}`;
-}
-function rewriteNestedReactiveCall(ctx, node) {
-    let arrayArg = node.arguments[0], arrayText = ctx.printer.printNode(ts.EmitHint.Expression, arrayArg, ctx.sourceFile), callbackArg = node.arguments[1], callbackText = rewriteExpression(ctx, callbackArg);
-    return `new ${COMPILER_NAMESPACE}.ArraySlot(${arrayText}, ${callbackText})`;
-}
-function discoverTemplatesInExpression(ctx, node) {
-    if (isNestedHtmlTemplate(node)) {
-        let template = node, expressions = [], literals = [], tpl = template.template;
-        if (ts.isNoSubstitutionTemplateLiteral(tpl)) {
-            literals.push(tpl.text);
-        }
-        else if (ts.isTemplateExpression(tpl)) {
-            literals.push(tpl.head.text);
-            for (let i = 0, n = tpl.templateSpans.length; i < n; i++) {
-                expressions.push(tpl.templateSpans[i].expression);
-                literals.push(tpl.templateSpans[i].literal.text);
-            }
-        }
-        let parsed = parser.parse(literals);
-        getOrCreateTemplateId(ctx, parsed.html);
-        for (let i = 0, n = expressions.length; i < n; i++) {
-            discoverTemplatesInExpression(ctx, expressions[i]);
-        }
-    }
-    else if (isReactiveCall(node)) {
-        let call = node;
-        if (call.arguments.length >= 2) {
-            discoverTemplatesInExpression(ctx, call.arguments[1]);
-        }
+        return `${rewriteExpression(ctx, expr.arguments[0])}, ${rewriteExpression(ctx, expr.arguments[1])}`;
     }
-    else {
-        ts.forEachChild(node, child => discoverTemplatesInExpression(ctx, child));
+    if (!ast.test(expr, n => isNestedHtmlTemplate(n) || isReactiveCall(n))) {
+        return printer.printNode(ts.EmitHint.Expression, expr, ctx.sourceFile);
     }
-}
-function discoverAllTemplates(ctx, templates) {
-    for (let i = 0, n = templates.length; i < n; i++) {
-        let parsed = parser.parse(templates[i].literals);
-        getOrCreateTemplateId(ctx, parsed.html);
-        for (let j = 0, m = templates[i].expressions.length; j < m; j++) {
-            discoverTemplatesInExpression(ctx, templates[i].expressions[j]);
-        }
+    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);
     }
+    return text;
 }
 const generateCode = (templates, sourceFile, checker) => {
     let result = {
@@ -241,44 +199,46 @@ 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 = {
         checker,
-        printer,
         sourceFile,
         templates: result.templates
     };
-    for (let i = 0, n = rootTemplates.length; i < n; i++) {
-        let template = rootTemplates[i];
-        result.replacements.push({
-            generate: (sf) => {
-                let codeBefore = sf.getFullText().slice(0, template.node.getStart(sf)), exprTexts = [], isArrowBody = codeBefore.trimEnd().endsWith('=>'), localCtx = {
-                    checker,
-                    printer,
-                    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 (isArrowBody && (!parsed.slots || parsed.slots.length === 0)) {
-                    let arrowMatch = codeBefore.match(ARROW_EMPTY_PARAMS);
-                    if (arrowMatch) {
-                        return getOrCreateTemplateId(localCtx, parsed.html);
-                    }
-                }
-                return generateTemplateCode(localCtx, parsed, exprTexts, template.expressions, isArrowBody);
-            },
-            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]);
+        }
     }
-    discoverAllTemplates(ctx, templates);
     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;
 };
-export { generateCode };
+export { generateCode, printer };

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,62 +1,53 @@
 import { ts } from '@esportsplus/typescript';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
-import { generateCode } from './codegen.js';
+import { ast } from '@esportsplus/typescript/compiler';
+import { ENTRYPOINT, ENTRYPOINT_REACTIVITY, NAMESPACE, PACKAGE } from './constants.js';
+import { generateCode, printer } from './codegen.js';
 import { findHtmlTemplates, findReactiveCalls } from './ts-parser.js';
-function isInRange(ranges, start, end) {
-    for (let i = 0, n = ranges.length; i < n; i++) {
-        let range = ranges[i];
-        if (start >= range.start && end <= range.end) {
-            return true;
-        }
-    }
-    return false;
-}
-let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-const plugin = {
+export default {
     patterns: [
-        `${COMPILER_ENTRYPOINT}\``,
-        `${COMPILER_ENTRYPOINT}.${COMPILER_ENTRYPOINT_REACTIVITY}`
+        `${ENTRYPOINT}\``,
+        `${ENTRYPOINT}.${ENTRYPOINT_REACTIVITY}`
     ],
     transform: (ctx) => {
-        let importsIntent = [], prepend = [], replacements = [], removeImports = [];
-        let templates = findHtmlTemplates(ctx.sourceFile, ctx.checker);
-        let templateRanges = [];
+        let intents = {
+            imports: [],
+            prepend: [],
+            replacements: []
+        }, ranges = [], remove = [], templates = findHtmlTemplates(ctx.sourceFile, ctx.checker);
         for (let i = 0, n = templates.length; i < n; i++) {
-            templateRanges.push({
+            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];
-            if (isInRange(templateRanges, call.start, call.end)) {
+        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(${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)}, ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)})`,
+            intents.replacements.push({
+                generate: (sourceFile) => `new ${NAMESPACE}.ArraySlot(
+                    ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
+                    ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
+                )`,
                 node: call.node
             });
         }
         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]
 });