@esportsplus/template 0.37.0 → 0.38.1

package/build/compiler/codegen.d.ts

@@ -1,10 +1,11 @@
+import type { ReplacementIntent } from '@esportsplus/typescript/compiler';
 import { ts } from '@esportsplus/typescript';
-import type { ReactiveCallInfo, TemplateInfo } from './ts-parser.js';
+import type { TemplateInfo } from './ts-parser.js';
 type CodegenResult = {
-    changed: boolean;
-    code: string;
+    prepend: string[];
+    replacements: ReplacementIntent[];
+    templates: Map<string, string>;
 };
-declare const generateCode: (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker, existingAliases?: Map<string, string>) => CodegenResult;
-declare const generateReactiveInlining: (calls: ReactiveCallInfo[], code: string, sourceFile: ts.SourceFile, arraySlotAlias: string) => string;
-export { generateCode, generateReactiveInlining };
+declare const generateCode: (templates: TemplateInfo[], sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => CodegenResult;
+export { generateCode };
 export type { CodegenResult };

package/build/compiler/codegen.js

@@ -1,48 +1,47 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c, imports, uid } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE } from '../constants.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 parser from './parser.js';
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-function addImport(ctx, name) {
-    let alias = ctx.imports.get(name);
-    if (!alias) {
-        alias = uid(name);
-        ctx.imports.set(name, alias);
+function collectNestedReplacements(ctx, node, exprStart, replacements) {
+    if (isNestedHtmlTemplate(node)) {
+        replacements.push({
+            end: node.end - exprStart,
+            newText: generateNestedTemplateCode(ctx, node),
+            start: node.getStart(ctx.sourceFile) - exprStart
+        });
+    }
+    else if (isReactiveCall(node)) {
+        replacements.push({
+            end: node.end - exprStart,
+            newText: rewriteReactiveCall(ctx, node),
+            start: node.getStart(ctx.sourceFile) - exprStart
+        });
+    }
+    else {
+        ts.forEachChild(node, child => collectNestedReplacements(ctx, child, exprStart, replacements));
     }
-    return alias;
 }
-function generateAttributeBinding(ctx, element, name, expr, staticValue) {
+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 `${addImport(ctx, key)}(${element}, ${expr});`;
+            return `${COMPILER_NAMESPACE}.${key}(${element}, ${expr});`;
         }
         if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${addImport(ctx, 'on')}(${element}, '${event}', ${expr});`;
+            return `${COMPILER_NAMESPACE}.on(${element}, '${event}', ${expr});`;
         }
-        return `${addImport(ctx, 'delegate')}(${element}, '${event}', ${expr});`;
+        return `${COMPILER_NAMESPACE}.delegate(${element}, '${event}', ${expr});`;
     }
     if (name === 'class') {
-        return `${addImport(ctx, 'setClass')}(${element}, '${staticValue}', ${expr});`;
+        return `${COMPILER_NAMESPACE}.setClass(${element}, '${staticValue}', ${expr});`;
     }
     if (name === 'style') {
-        return `${addImport(ctx, 'setStyle')}(${element}, '${staticValue}', ${expr});`;
-    }
-    return `${addImport(ctx, 'setProperty')}(${element}, '${name}', ${expr});`;
-}
-function collectNestedTemplateReplacements(ctx, node, exprStart, replacements) {
-    if (isNestedHtmlTemplate(node)) {
-        replacements.push({
-            end: node.end - exprStart,
-            newText: generateNestedTemplateCode(ctx, node),
-            start: node.getStart() - exprStart
-        });
-    }
-    else {
-        ts.forEachChild(node, child => collectNestedTemplateReplacements(ctx, child, exprStart, replacements));
+        return `${COMPILER_NAMESPACE}.setStyle(${element}, '${staticValue}', ${expr});`;
     }
+    return `${COMPILER_NAMESPACE}.setProperty(${element}, '${name}', ${expr});`;
 }
 function generateNestedTemplateCode(ctx, node) {
     let expressions = [], exprTexts = [], literals = [], template = node.template;
@@ -62,23 +61,23 @@ function generateNestedTemplateCode(ctx, node) {
 }
 function generateNodeBinding(ctx, anchor, exprText, exprNode) {
     if (!exprNode) {
-        return `${addImport(ctx, 'slot')}(${anchor}, ${exprText});`;
+        return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
     if (isNestedHtmlTemplate(exprNode)) {
-        return `${anchor}.parentNode.insertBefore(${generateNestedTemplateCode(ctx, exprNode)}, ${anchor});`;
+        return `${anchor}.parentNode!.insertBefore(${generateNestedTemplateCode(ctx, exprNode)}, ${anchor});`;
     }
     let slotType = analyze(exprNode, ctx.checker);
     switch (slotType) {
-        case COMPILER_TYPES.Effect:
-            return `new ${addImport(ctx, 'EffectSlot')}(${anchor}, ${exprText});`;
         case COMPILER_TYPES.ArraySlot:
-            return `new ${addImport(ctx, 'ArraySlot')}(${anchor}, ${exprText});`;
+            return `${anchor}.parentNode!.insertBefore(new ${COMPILER_NAMESPACE}.ArraySlot(${exprText}).fragment, ${anchor});`;
+        case COMPILER_TYPES.DocumentFragment:
+            return `${anchor}.parentNode!.insertBefore(${exprText}, ${anchor});`;
+        case COMPILER_TYPES.Effect:
+            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
         case COMPILER_TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
-        case COMPILER_TYPES.DocumentFragment:
-            return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
         default:
-            return `${addImport(ctx, 'slot')}(${anchor}, ${exprText});`;
+            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
 }
 function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArrowBody) {
@@ -106,11 +105,11 @@ function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArro
                 break;
             }
         }
-        let alias = addImport(ctx, 'Element'), name = uid('element'), segments = path.slice(start), value = `${ancestor}.${segments.join('!.')}`;
+        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 ${alias})`);
+            value = value.replace(`${ancestor}.firstChild!`, `(${ancestor}.firstChild! as ${COMPILER_NAMESPACE}.Element)`);
         }
-        declarations.push(`${name} = ${value} as ${alias}`);
+        declarations.push(`${name} = ${value} as ${COMPILER_NAMESPACE}.Element`);
         nodes.set(key, name);
     }
     code.push(isArrowBody ? '{' : `(() => {`, `let ${declarations.join(',\n')};`);
@@ -123,11 +122,11 @@ function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArro
             for (let j = 0, m = names.length; j < m; j++) {
                 let name = names[j];
                 if (name === COMPILER_TYPES.Attributes) {
-                    code.push(`${addImport(ctx, 'setProperties')}(${element}, ${exprTexts[index] || 'undefined'});`);
+                    code.push(`${COMPILER_NAMESPACE}.setProperties(${element}, ${exprTexts[index] || 'undefined'});`);
                     index++;
                 }
                 else {
-                    code.push(generateAttributeBinding(ctx, element, name, exprTexts[index++] || 'undefined', slot.attributes.statics[name] || ''));
+                    code.push(generateAttributeBinding(element, name, exprTexts[index++] || 'undefined', slot.attributes.statics[name] || ''));
                 }
             }
         }
@@ -151,95 +150,131 @@ function getOrCreateTemplateId(ctx, html) {
 function isNestedHtmlTemplate(expr) {
     return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_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;
+}
 function rewriteExpression(ctx, expr) {
     if (isNestedHtmlTemplate(expr)) {
         return generateNestedTemplateCode(ctx, expr);
     }
-    if (!ast.hasMatch(expr, n => isNestedHtmlTemplate(n))) {
+    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 = [];
-    collectNestedTemplateReplacements(ctx, expr, expr.getStart(), replacements);
-    return c.replaceReverse(expr.getText(ctx.sourceFile), 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}`;
 }
-const generateCode = (templates, originalCode, sourceFile, checker, existingAliases) => {
+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]);
+        }
+    }
+    else {
+        ts.forEachChild(node, child => discoverTemplatesInExpression(ctx, child));
+    }
+}
+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]);
+        }
+    }
+}
+const generateCode = (templates, sourceFile, checker) => {
+    let result = {
+        prepend: [],
+        replacements: [],
+        templates: new Map()
+    };
     if (templates.length === 0) {
-        return { changed: false, code: originalCode };
+        return result;
     }
     let ranges = [];
     for (let i = 0, n = templates.length; i < n; i++) {
         let exprs = templates[i].expressions;
         for (let j = 0, m = exprs.length; j < m; j++) {
-            ranges.push({ end: exprs[j].end, start: exprs[j].getStart() });
+            ranges.push({ end: exprs[j].end, start: exprs[j].getStart(sourceFile) });
         }
     }
-    let rootTemplates = templates.filter(t => !ast.inRange(ranges, t.start, t.end));
+    let rootTemplates = templates.filter(t => !ast.inRange(ranges, t.node.getStart(sourceFile), t.node.end));
     if (rootTemplates.length === 0) {
-        return { changed: false, code: originalCode };
+        return result;
     }
     let ctx = {
         checker,
-        imports: existingAliases ?? new Map(),
         printer,
         sourceFile,
-        templates: new Map(),
-    }, replacements = [], templateAlias = addImport(ctx, 'template');
+        templates: result.templates
+    };
     for (let i = 0, n = rootTemplates.length; i < n; i++) {
-        let exprTexts = [], template = rootTemplates[i];
-        for (let j = 0, m = template.expressions.length; j < m; j++) {
-            exprTexts.push(rewriteExpression(ctx, template.expressions[j]));
-        }
-        let codeBefore = originalCode.slice(0, template.start), isArrowBody = codeBefore.trimEnd().endsWith('=>'), parsed = parser.parse(template.literals);
-        if (isArrowBody && (!parsed.slots || parsed.slots.length === 0)) {
-            let arrowMatch = codeBefore.match(ARROW_EMPTY_PARAMS);
-            if (arrowMatch) {
-                replacements.push({
-                    end: template.end,
-                    newText: getOrCreateTemplateId(ctx, parsed.html),
-                    start: template.start - arrowMatch[0].length
-                });
-                continue;
-            }
-        }
-        replacements.push({
-            end: template.end,
-            newText: generateTemplateCode(ctx, parsed, exprTexts, template.expressions, isArrowBody),
-            start: template.start
-        });
-    }
-    let changed = replacements.length > 0, code = c.replaceReverse(originalCode, replacements);
-    if (changed && ctx.templates.size > 0) {
-        let aliasedImports = [], factories = [], updatedSourceFile = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
-        for (let [name, alias] of ctx.imports) {
-            aliasedImports.push(`${name} as ${alias}`);
-        }
-        for (let [html, id] of ctx.templates) {
-            factories.push(`const ${id} = ${templateAlias}(\`${html}\`);`);
-        }
-        code = imports.modify(code, updatedSourceFile, PACKAGE, {
-            add: new Set(aliasedImports),
-            remove: [COMPILER_ENTRYPOINT]
+        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
         });
-        code = factories.join('\n') + '\n\n' + code;
-    }
-    return { changed, code };
-};
-const generateReactiveInlining = (calls, code, sourceFile, arraySlotAlias) => {
-    if (calls.length === 0) {
-        return code;
     }
-    let replacements = [];
-    for (let i = 0, n = calls.length; i < n; i++) {
-        let call = calls[i];
-        replacements.push({
-            end: call.end,
-            newText: `new ${arraySlotAlias}(
-                ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
-                ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
-            )`,
-            start: call.start
-        });
+    discoverAllTemplates(ctx, templates);
+    for (let [html, id] of ctx.templates) {
+        result.prepend.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
     }
-    return c.replaceReverse(code, replacements);
+    return result;
 };
-export { generateCode, generateReactiveInlining };
+export { generateCode };

package/build/compiler/index.d.ts

@@ -1,10 +1,3 @@
-import type { PluginContext } from '@esportsplus/typescript/compiler';
-import { ts } from '@esportsplus/typescript';
-type TransformResult = {
-    changed: boolean;
-    code: string;
-    sourceFile: ts.SourceFile;
-};
-declare const analyze: (sourceFile: ts.SourceFile, program: ts.Program, context: PluginContext) => void;
-declare const transform: (sourceFile: ts.SourceFile, program: ts.Program, context?: PluginContext) => TransformResult;
-export { analyze, transform };
+import type { Plugin } from '@esportsplus/typescript/compiler';
+declare const plugin: Plugin;
+export default plugin;

package/build/compiler/index.js

@@ -1,82 +1,63 @@
 import { ts } from '@esportsplus/typescript';
-import { code as c, imports, uid } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '../constants.js';
-import { generateCode, generateReactiveInlining } from './codegen.js';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, PACKAGE } from '../constants.js';
+import { generateCode } from './codegen.js';
 import { findHtmlTemplates, findReactiveCalls } from './ts-parser.js';
-const CONTEXT_KEY = 'template:analyzed';
-const PATTERNS = [`${COMPILER_ENTRYPOINT}\``, `${COMPILER_ENTRYPOINT}.${COMPILER_ENTRYPOINT_REACTIVITY}`];
-const REGEX_BACKSLASH = /\\/g;
-const REGEX_FORWARD_SLASH = /\//g;
-function getAnalyzedFile(context, filename) {
-    return context?.get(CONTEXT_KEY)?.get(filename);
-}
-const analyze = (sourceFile, program, context) => {
-    let code = sourceFile.getFullText();
-    if (!c.contains(code, { patterns: PATTERNS })) {
-        return;
-    }
-    let checker = program.getTypeChecker(), filename = sourceFile.fileName, files = context.get(CONTEXT_KEY), programSourceFile = program.getSourceFile(filename)
-        || program.getSourceFile(filename.replace(REGEX_BACKSLASH, '/'))
-        || program.getSourceFile(filename.replace(REGEX_FORWARD_SLASH, '\\'));
-    if (programSourceFile) {
-        sourceFile = programSourceFile;
-    }
-    if (!files) {
-        files = new Map();
-        context.set(CONTEXT_KEY, files);
+const PATTERNS = [
+    `${COMPILER_ENTRYPOINT}\``,
+    `${COMPILER_ENTRYPOINT}.${COMPILER_ENTRYPOINT_REACTIVITY}`
+];
+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;
+        }
     }
-    files.set(filename, {
-        reactiveCalls: findReactiveCalls(sourceFile, checker),
-        templates: findHtmlTemplates(sourceFile, checker)
-    });
-};
-const transform = (sourceFile, program, context) => {
-    let code = sourceFile.getFullText(), filename = sourceFile.fileName;
-    let analyzed = getAnalyzedFile(context, filename);
-    if (!analyzed) {
-        if (!c.contains(code, { patterns: PATTERNS })) {
-            return { changed: false, code, sourceFile };
+    return false;
+}
+let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+const plugin = {
+    patterns: PATTERNS,
+    transform: (ctx) => {
+        let importsIntent = [], prepend = [], replacements = [], removeImports = [];
+        let templates = findHtmlTemplates(ctx.sourceFile, ctx.checker);
+        let templateRanges = [];
+        for (let i = 0, n = templates.length; i < n; i++) {
+            templateRanges.push({
+                end: templates[i].end,
+                start: templates[i].start
+            });
         }
-        let checker = program.getTypeChecker(), programSourceFile = program.getSourceFile(filename)
-            || program.getSourceFile(filename.replace(REGEX_BACKSLASH, '/'))
-            || program.getSourceFile(filename.replace(REGEX_FORWARD_SLASH, '\\'));
-        if (programSourceFile) {
-            sourceFile = programSourceFile;
+        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)) {
+                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)})`,
+                node: call.node
+            });
         }
-        analyzed = {
-            reactiveCalls: findReactiveCalls(sourceFile, checker),
-            templates: findHtmlTemplates(sourceFile, checker)
-        };
-    }
-    let changed = false, codegenChanged = false, existingAliases = new Map(), result = code;
-    if (analyzed.reactiveCalls.length > 0) {
-        changed = true;
-        existingAliases.set('ArraySlot', uid('ArraySlot'));
-        result = generateReactiveInlining(analyzed.reactiveCalls, result, sourceFile, existingAliases.get('ArraySlot'));
-        sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-        analyzed = {
-            reactiveCalls: [],
-            templates: findHtmlTemplates(sourceFile, program.getTypeChecker())
-        };
-    }
-    if (analyzed.templates.length > 0) {
-        let codegenResult = generateCode(analyzed.templates, result, sourceFile, program.getTypeChecker(), existingAliases);
-        if (codegenResult.changed) {
-            changed = true;
-            codegenChanged = true;
-            result = codegenResult.code;
+        if (templates.length > 0) {
+            let result = generateCode(templates, ctx.sourceFile, ctx.checker);
+            prepend.push(...result.prepend);
+            replacements.push(...result.replacements);
+            removeImports.push(COMPILER_ENTRYPOINT);
         }
-    }
-    if (existingAliases.size > 0 && !codegenChanged) {
-        let aliasedImports = [];
-        for (let [name, alias] of existingAliases) {
-            aliasedImports.push(`${name} as ${alias}`);
+        if (replacements.length === 0 && prepend.length === 0) {
+            return {};
         }
-        result = imports.modify(result, sourceFile, PACKAGE, { add: aliasedImports });
-    }
-    if (changed) {
-        sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
+        importsIntent.push({
+            namespace: COMPILER_NAMESPACE,
+            package: PACKAGE,
+            remove: removeImports
+        });
+        return {
+            imports: importsIntent,
+            prepend,
+            replacements
+        };
     }
-    return { changed, code: result, sourceFile };
 };
-export { analyze, transform };
+export default plugin;

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 { plugin } from '@esportsplus/typescript/compiler';
 import { PACKAGE } from '../../constants.js';
-import { analyze, transform } from '../index.js';
+import templatePlugin from '../index.js';
 export default plugin.vite({
-    analyze,
     name: PACKAGE,
-    transform
+    plugins: [templatePlugin]
 });

package/build/constants.d.ts

@@ -2,6 +2,7 @@ declare const ARRAY_SLOT: unique symbol;
 declare const CLEANUP: unique symbol;
 declare const COMPILER_ENTRYPOINT = "html";
 declare const COMPILER_ENTRYPOINT_REACTIVITY = "reactive";
+declare const COMPILER_NAMESPACE: string;
 declare const enum COMPILER_TYPES {
     ArraySlot = "array-slot",
     Attributes = "attributes",
@@ -21,4 +22,4 @@ declare const STATE_HYDRATING = 0;
 declare const STATE_NONE = 1;
 declare const STATE_WAITING = 2;
 declare const STORE: unique symbol;
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/build/constants.js

@@ -1,7 +1,9 @@
+import { uid } from '@esportsplus/typescript/compiler';
 const ARRAY_SLOT = Symbol('template.array.slot');
 const CLEANUP = Symbol('template.cleanup');
 const COMPILER_ENTRYPOINT = 'html';
 const COMPILER_ENTRYPOINT_REACTIVITY = 'reactive';
+const COMPILER_NAMESPACE = uid('template');
 var COMPILER_TYPES;
 (function (COMPILER_TYPES) {
     COMPILER_TYPES["ArraySlot"] = "array-slot";
@@ -33,4 +35,4 @@ const STATE_HYDRATING = 0;
 const STATE_NONE = 1;
 const STATE_WAITING = 2;
 const STORE = Symbol('template.store');
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/package.json

@@ -2,8 +2,8 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/queue": "^0.2.0",
-    "@esportsplus/reactivity": "^0.27.3",
-    "@esportsplus/typescript": "^0.24.2",
+    "@esportsplus/reactivity": "^0.28.1",
+    "@esportsplus/typescript": "^0.25.0",
     "@esportsplus/utilities": "^0.27.2",
     "serve": "^14.2.5"
   },
@@ -35,7 +35,7 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.37.0",
+  "version": "0.38.1",
   "scripts": {
     "build": "tsc",
     "build:test": "vite build --config test/vite.config.ts",