@esportsplus/template 0.28.3 → 0.29.2

package/build/transformer/codegen.js

@@ -0,0 +1,316 @@
+import { addImport, applyReplacementsReverse, uid } from '@esportsplus/typescript/transformer';
+import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer.js';
+import ts from 'typescript';
+import parser from './parser.js';
+const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
+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({
+            end: node.end - exprStart,
+            newText: generateNestedTemplateCode(node, sourceFile),
+            start: node.getStart() - exprStart
+        });
+    }
+    else {
+        ts.forEachChild(node, child => collectNestedTemplateReplacements(child, exprStart, sourceFile, replacements));
+    }
+}
+function generateImports() {
+    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;
+    if (ts.isNoSubstitutionTemplateLiteral(template)) {
+        literals.push(template.text);
+    }
+    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(expr, sourceFile));
+        }
+    }
+    return generateTemplateCode(parser.parse(literals), exprTexts, expressions, sourceFile, false);
+}
+function generateNodeBinding(anchor, exprText, exprNode, sourceFile) {
+    if (!exprNode) {
+        needsSlot = true;
+        return `${nameSlot}(${anchor}, ${exprText});`;
+    }
+    if (isNestedHtmlTemplate(exprNode)) {
+        return `${anchor}.parentNode.insertBefore(${generateNestedTemplateCode(exprNode, sourceFile)}, ${anchor});`;
+    }
+    let slotType = analyzeExpression(exprNode, currentChecker);
+    switch (slotType) {
+        case 'effect':
+            needsEffectSlot = true;
+            return `new ${nameEffectSlot}(${anchor}, ${exprText});`;
+        case 'array-slot':
+            needsArraySlot = true;
+            return `new ${nameArraySlot}(${anchor}, ${exprText});`;
+        case 'static':
+            return `${anchor}.textContent = ${exprText};`;
+        case 'document-fragment':
+            return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
+        default:
+            needsSlot = true;
+            return `${nameSlot}(${anchor}, ${exprText});`;
+    }
+}
+function generateTemplateCode({ html, slots }, exprTexts, exprNodes, sourceFile, isArrowBody) {
+    if (!slots || slots.length === 0) {
+        return `${getOrCreateTemplateId(html)}()`;
+    }
+    let code = [], declarations = [], index = 0, nodes = new Map(), root = uid('root');
+    declarations.push(`${root} = ${getOrCreateTemplateId(html)}()`);
+    nodes.set('', root);
+    for (let i = 0, n = slots.length; i < n; i++) {
+        let path = slots[i].path;
+        if (path.length === 0) {
+            continue;
+        }
+        let key = path.join('.');
+        if (nodes.has(key)) {
+            continue;
+        }
+        let ancestorVar = root, startIdx = 0;
+        for (let j = path.length - 1; j >= 0; j--) {
+            let prefix = path.slice(0, j).join('.');
+            if (nodes.has(prefix)) {
+                ancestorVar = nodes.get(prefix);
+                startIdx = j;
+                break;
+            }
+        }
+        let name = uid('element'), suffix = path.slice(startIdx).join('.');
+        declarations.push(`${name} = ${ancestorVar}.${suffix}`);
+        nodes.set(key, name);
+    }
+    code.push(isArrowBody ? '{' : `(() => {`, `let ${declarations.join(',\n')};`);
+    for (let i = 0, n = slots.length; i < n; i++) {
+        let elementVar = slots[i].path.length === 0
+            ? root
+            : (nodes.get(slots[i].path.join('.')) || root), slot = slots[i];
+        if (slot.type === 'attributes') {
+            for (let j = 0, m = slot.attributes.names.length; j < m; j++) {
+                let name = slot.attributes.names[j];
+                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);
+                }
+            }
+        }
+        else {
+            code.push(generateNodeBinding(elementVar, exprTexts[index] || 'undefined', exprNodes[index], sourceFile));
+            index++;
+        }
+    }
+    code.push(`return ${root};`);
+    code.push(isArrowBody ? `}` : `})()`);
+    return code.join('\n');
+}
+function getOrCreateTemplateId(html) {
+    let id = htmlToTemplateId.get(html);
+    if (!id) {
+        id = uid('tmpl');
+        hoistedFactories.set(id, html);
+        htmlToTemplateId.set(html, id);
+    }
+    return id;
+}
+function hasArraySlotImport(sourceFile) {
+    for (let i = 0, n = sourceFile.statements.length; i < n; i++) {
+        let stmt = sourceFile.statements[i];
+        if (!ts.isImportDeclaration(stmt) || !stmt.importClause?.namedBindings) {
+            continue;
+        }
+        let bindings = stmt.importClause.namedBindings;
+        if (!ts.isNamedImports(bindings)) {
+            continue;
+        }
+        for (let j = 0, m = bindings.elements.length; j < m; j++) {
+            if (bindings.elements[j].name.text === 'ArraySlot') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function hasArraySlotUsage(node) {
+    if (ts.isNewExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'ArraySlot') {
+        return true;
+    }
+    let found = false;
+    ts.forEachChild(node, child => {
+        if (!found && hasArraySlotUsage(child)) {
+            found = true;
+        }
+    });
+    return found;
+}
+function hasNestedTemplates(node) {
+    if (isNestedHtmlTemplate(node)) {
+        return true;
+    }
+    let found = false;
+    ts.forEachChild(node, child => {
+        if (!found && hasNestedTemplates(child)) {
+            found = true;
+        }
+    });
+    return found;
+}
+function isNestedHtmlTemplate(expr) {
+    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === 'html';
+}
+function isNestedTemplate(template, allTemplates) {
+    for (let i = 0, n = allTemplates.length; i < n; i++) {
+        let other = allTemplates[i];
+        if (other === template) {
+            continue;
+        }
+        for (let j = 0, m = other.expressions.length; j < m; j++) {
+            let expr = other.expressions[j];
+            if (template.start >= expr.getStart() && template.end <= expr.end) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function rewriteExpression(expr, sourceFile) {
+    if (isNestedHtmlTemplate(expr)) {
+        return generateNestedTemplateCode(expr, sourceFile);
+    }
+    if (!hasNestedTemplates(expr)) {
+        return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printNode(ts.EmitHint.Expression, expr, sourceFile);
+    }
+    let exprStart = expr.getStart(), replacements = [];
+    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 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 };
+    }
+    let replacements = [];
+    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(template.expressions[j], sourceFile));
+        }
+        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(parsed.html),
+                    start: template.start - arrowMatch[0].length
+                });
+                continue;
+            }
+        }
+        replacements.push({
+            end: template.end,
+            newText: generateTemplateCode(parsed, exprTexts, template.expressions, sourceFile, isArrowBody),
+            start: template.start
+        });
+    }
+    let changed = replacements.length > 0, code = applyReplacementsReverse(originalCode, replacements);
+    if (changed && hoistedFactories.size > 0) {
+        let factories = [];
+        for (let [id, html] of hoistedFactories) {
+            factories.push(`const ${id} = ${nameTemplate}(\`${html}\`);`);
+        }
+        code = generateImports() + '\n\n' + factories.join('\n') + '\n\n' + code;
+    }
+    return { changed, code };
+};
+const generateReactiveInlining = (calls, code, sourceFile) => {
+    if (calls.length === 0) {
+        return code;
+    }
+    let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }), result = code;
+    for (let i = calls.length - 1; i >= 0; i--) {
+        let call = calls[i];
+        result = result.slice(0, call.start);
+        result += `new ${nameArraySlot}(
+                ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
+                ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
+            )`;
+        result += result.slice(call.end);
+    }
+    return result;
+};
+const getNames = () => ({
+    attr: nameAttr,
+    event: nameEvent,
+    slot: nameSlot
+});
+const needsArraySlotImport = (sourceFile) => {
+    return hasArraySlotUsage(sourceFile) && !hasArraySlotImport(sourceFile);
+};
+const setTypeChecker = (checker) => {
+    currentChecker = checker;
+};
+export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, needsArraySlotImport, setTypeChecker };

package/build/transformer/index.d.ts

@@ -0,0 +1,12 @@
+import { mightNeedTransform } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+type TransformResult = {
+    changed: boolean;
+    code: string;
+    sourceFile: ts.SourceFile;
+};
+declare const PATTERNS: string[];
+declare function createTransformer(program: ts.Program): ts.TransformerFactory<ts.SourceFile>;
+declare const transform: (sourceFile: ts.SourceFile, program: ts.Program) => TransformResult;
+export type { TransformResult };
+export { createTransformer, mightNeedTransform, PATTERNS, transform };

package/build/transformer/index.js

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

package/build/transformer/parser.d.ts

@@ -0,0 +1,18 @@
+type NodePath = ('firstChild' | 'firstElementChild' | 'nextElementSibling' | 'nextSibling')[];
+declare const _default: {
+    parse: (literals: string[]) => {
+        html: string;
+        slots: ({
+            path: NodePath;
+            type: "slot";
+        } | {
+            attributes: {
+                names: string[];
+                statics: Record<string, string>;
+            };
+            path: NodePath;
+            type: "attributes";
+        })[] | null;
+    };
+};
+export default _default;

package/build/transformer/parser.js

@@ -0,0 +1,166 @@
+const SLOT_HTML = '<!--$-->';
+const ATTRIBUTE_DELIMITERS = {
+    class: ' ',
+    style: ';'
+};
+const NODE_CLOSING = 1;
+const NODE_COMMENT = 2;
+const NODE_ELEMENT = 3;
+const NODE_SLOT = 4;
+const NODE_VOID = 5;
+const NODE_WHITELIST = {
+    '!': NODE_COMMENT,
+    '/': NODE_CLOSING,
+    'area': NODE_VOID,
+    'base': NODE_VOID,
+    'br': NODE_VOID,
+    'col': NODE_VOID,
+    'embed': NODE_VOID,
+    'hr': NODE_VOID,
+    'img': NODE_VOID,
+    'input': NODE_VOID,
+    'keygen': NODE_VOID,
+    'link': NODE_VOID,
+    'menuitem': NODE_VOID,
+    'meta': NODE_VOID,
+    'param': NODE_VOID,
+    'source': NODE_VOID,
+    'track': NODE_VOID,
+    'wbr': NODE_VOID
+};
+const REGEX_EMPTY_ATTRIBUTES = /\s+[\w:-]+\s*=\s*["']\s*["']|\s+(?=>)/g;
+const REGEX_EMPTY_TEXT_NODES = /(>|}|\s)\s+(<|{|\s)/g;
+const REGEX_EVENTS = /(?:\s*on[\w-:]+\s*=(?:\s*["'][^"']*["'])*)/g;
+const REGEX_SLOT_ATTRIBUTES = /<[\w-]+([^><]*{{\$}}[^><]*)>/g;
+const REGEX_SLOT_NODES = /<([\w-]+|[\/!])(?:([^><]*{{\$}}[^><]*)|(?:[^><]*))?>|{{\$}}/g;
+const SLOT_MARKER = '{{$}}';
+function methods(children, copy, first, next) {
+    let length = copy.length, result = new Array(length + 1 + children);
+    for (let i = 0, n = length; i < n; i++) {
+        result[i] = copy[i];
+    }
+    result[length] = first;
+    for (let i = 0, n = children; i < n; i++) {
+        result[length + 1 + i] = next;
+    }
+    return result;
+}
+const parse = (literals) => {
+    let html = literals
+        .join(SLOT_MARKER)
+        .replace(REGEX_EMPTY_TEXT_NODES, '$1$2')
+        .trim(), n = literals.length - 1;
+    if (n === 0) {
+        return { html, slots: null };
+    }
+    let attributes = {}, buffer = '', events = false, index = 0, level = 0, levels = [{ children: 0, elements: 0, path: [] }], parsed = html.split(SLOT_MARKER), slot = 0, slots = [];
+    {
+        let attribute = '', buffer = '', char = '', quote = '';
+        for (let match of html.matchAll(REGEX_SLOT_ATTRIBUTES)) {
+            let found = match[1];
+            if (attributes[found]) {
+                continue;
+            }
+            let { names, statics } = attributes[found] = { names: [], statics: {} };
+            for (let i = 0, n = found.length; i < n; i++) {
+                char = found[i];
+                if (char === ' ') {
+                    buffer = '';
+                }
+                else if (char === '=') {
+                    attribute = buffer;
+                    buffer = '';
+                }
+                else if (char === '"' || char === "'") {
+                    if (!attribute) {
+                        continue;
+                    }
+                    else if (!quote) {
+                        quote = char;
+                    }
+                    else if (quote === char) {
+                        if (attribute) {
+                            statics[attribute] ??= '';
+                            statics[attribute] += `${ATTRIBUTE_DELIMITERS[attribute] || ''}${buffer}`;
+                        }
+                        attribute = '';
+                        buffer = '';
+                        quote = '';
+                    }
+                }
+                else if (char === '{' && char !== buffer) {
+                    buffer = char;
+                }
+                else {
+                    buffer += char;
+                    if (buffer === SLOT_MARKER) {
+                        buffer = '';
+                        if (attribute) {
+                            names.push(attribute);
+                            if (!quote) {
+                                attribute = '';
+                            }
+                        }
+                        else {
+                            names.push('spread');
+                        }
+                    }
+                    else if (buffer === 'on') {
+                        events = true;
+                    }
+                }
+            }
+        }
+    }
+    {
+        for (let match of html.matchAll(REGEX_SLOT_NODES)) {
+            let parent = levels[level], type = match[1] === undefined ? NODE_SLOT : (NODE_WHITELIST[match[1].toLowerCase()] || NODE_ELEMENT);
+            if ((match.index || 1) - 1 > index) {
+                parent.children++;
+            }
+            if (type === NODE_ELEMENT || type === NODE_VOID) {
+                let attr = match[2], path = parent.path.length
+                    ? methods(parent.elements, parent.path, 'firstElementChild', 'nextElementSibling')
+                    : methods(parent.children, [], 'firstChild', 'nextSibling');
+                if (attr) {
+                    let attrs = attributes[attr];
+                    if (!attrs) {
+                        throw new Error(`@esportsplus/template: attribute metadata could not be found for '${attr}'`);
+                    }
+                    slots.push({ attributes: attrs, path, type: 'attributes' });
+                    for (let i = 0, n = attrs.names.length; i < n; i++) {
+                        buffer += parsed[slot++];
+                    }
+                }
+                if (type === NODE_ELEMENT) {
+                    levels[++level] = { children: 0, elements: 0, path };
+                }
+                parent.elements++;
+            }
+            else if (type === NODE_SLOT) {
+                buffer += parsed[slot++] + SLOT_HTML;
+                slots.push({ path: methods(parent.children, parent.path, 'firstChild', 'nextSibling'), type: 'slot' });
+            }
+            if (n === slot) {
+                buffer += parsed[slot];
+                break;
+            }
+            if (type === NODE_CLOSING) {
+                level--;
+            }
+            else {
+                parent.children++;
+            }
+            index = (match.index || 0) + match[0].length;
+        }
+    }
+    if (events) {
+        buffer = buffer.replace(REGEX_EVENTS, '');
+    }
+    buffer = buffer.replace(REGEX_EMPTY_ATTRIBUTES, '');
+    return {
+        html: buffer,
+        slots: slots.length ? slots : null
+    };
+};
+export default { parse };

package/build/transformer/plugins/esbuild.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'esbuild';
+declare const _default: (options?: {
+    root?: string;
+}) => Plugin;
+export default _default;

package/build/transformer/plugins/esbuild.js

@@ -0,0 +1,35 @@
+import { mightNeedTransform, PATTERNS, transform } from '../index.js';
+import { program, TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
+import fs from 'fs';
+import ts from 'typescript';
+export default (options) => {
+    let root = options?.root ?? process.cwd();
+    return {
+        name: '@esportsplus/template/plugin-esbuild',
+        setup(build) {
+            build.onLoad({ filter: TRANSFORM_PATTERN }, async (args) => {
+                let code = await fs.promises.readFile(args.path, 'utf8');
+                if (!mightNeedTransform(code, { patterns: PATTERNS })) {
+                    return null;
+                }
+                try {
+                    let sourceFile = ts.createSourceFile(args.path, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile, program.get(root));
+                    if (!result.changed) {
+                        return null;
+                    }
+                    return {
+                        contents: result.code,
+                        loader: args.path.endsWith('x') ? 'tsx' : 'ts'
+                    };
+                }
+                catch (error) {
+                    console.error(`@esportsplus/template: Error transforming ${args.path}:`, error);
+                    return null;
+                }
+            });
+            build.onEnd(() => {
+                program.delete(root);
+            });
+        }
+    };
+};

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

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (program: ts.Program) => ts.TransformerFactory<ts.SourceFile>;
+export default _default;

package/build/transformer/plugins/tsc.js

@@ -0,0 +1,4 @@
+import { createTransformer } from '../index.js';
+export default (program) => {
+    return createTransformer(program);
+};

package/build/transformer/plugins/vite.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+declare const _default: (options?: {
+    root?: string;
+}) => Plugin;
+export default _default;

package/build/transformer/plugins/vite.js

@@ -0,0 +1,37 @@
+import { mightNeedTransform, PATTERNS, transform } from '../index.js';
+import { program, TRANSFORM_PATTERN } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+export default (options) => {
+    let root;
+    return {
+        enforce: 'pre',
+        name: '@esportsplus/template/plugin-vite',
+        configResolved(config) {
+            root = options?.root ?? config.root;
+        },
+        transform(code, id) {
+            if (!TRANSFORM_PATTERN.test(id) || id.includes('node_modules')) {
+                return null;
+            }
+            if (!mightNeedTransform(code, { patterns: PATTERNS })) {
+                return null;
+            }
+            try {
+                let sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile, program.get(root));
+                if (!result.changed) {
+                    return null;
+                }
+                return { code: result.code, map: null };
+            }
+            catch (error) {
+                console.error(`@esportsplus/template: Error transforming ${id}:`, error);
+                return null;
+            }
+        },
+        watchChange(id) {
+            if (TRANSFORM_PATTERN.test(id)) {
+                program.delete(root);
+            }
+        }
+    };
+};