@vitarx/plugin-vite 0.0.1-beta.7 → 0.0.1-beta.8

package/dist/context.d.ts

@@ -3,9 +3,9 @@
  * 定义编译转换过程中的上下文数据结构
  * @module context
  */
-import type { File } from '@babel/types';
+import type { CallExpression, File } from '@babel/types';
 import type { CompilerWarning } from './error.js';
-import type { CompileOptions } from './transform.js';
+import type { CompileOptions } from './types.js';
 /**
  * 导入信息
  * 追踪需要注入的运行时 API
@@ -80,6 +80,12 @@ export interface TransformContext {
     refVariables: Set<string>;
     /** UI API 别名集合（用于 HMR 代码分离识别） */
     uiApiAliases: Set<string>;
+    /** builder 函数的本地别名（用于识别纯构建组件） */
+    builderAlias: string | null;
+    /** 已处理的 AST 节点追踪集合 */
+    processedNodes: WeakSet<any>;
+    /** 已添加 PURE 注释的节点追踪集合 */
+    pureCommentedNodes: WeakSet<CallExpression>;
     /** 编译警告列表 */
     warnings: CompilerWarning[];
 }

package/dist/context.js

@@ -44,6 +44,9 @@ export function createContext(code, id, options, ast) {
         },
         refVariables: new Set(),
         uiApiAliases: new Set(),
+        builderAlias: null,
+        processedNodes: new WeakSet(),
+        pureCommentedNodes: new WeakSet(),
         warnings: []
     };
 }

package/dist/hmr-client/index.d.ts

@@ -45,8 +45,9 @@ export default class HMRManager {
      * 注册节点
      *
      * @param view - 组件视图节点
+     * @param component - 组件构造函数
      */
-    register(view: ComponentView): void;
+    register(view: ComponentView, component?: Component): void;
     /**
      * 获取模块id
      *

package/dist/hmr-client/index.js

@@ -80,11 +80,12 @@ class HMRManager {
      * 注册节点
      *
      * @param view - 组件视图节点
+     * @param component - 组件构造函数
      */
-    register(view) {
+    register(view, component) {
         if (!view)
             return;
-        const component = view.component;
+        component ?? (component = view.component);
         const id = this.getId(component);
         if (__classPrivateFieldGet(this, _HMRManager_idMapToView, "f").has(id)) {
             __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id).add(view);

package/dist/index.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { version } from 'vite';
-import { transform } from './transform.js';
+import { shouldTransform, transform } from './transform.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const IS_V8 = version.startsWith('8');
 let viteTransform;
@@ -63,6 +63,8 @@ export default function vitarx(options) {
             };
         },
         async transform(code, id) {
+            if (!shouldTransform(id))
+                return null;
             const result = await transform(code, id, compileOptions);
             if (!result)
                 return null;

package/dist/passes/directives/processDirectives.js

@@ -27,7 +27,7 @@ export function processDirectives(viewCall, directives, ctx) {
     }
     markImport(ctx, 'withDirectives');
     const withDirectivesAlias = getAlias(ctx.vitarxAliases, 'withDirectives');
-    return addPureComment(createWithDirectivesCall(viewCall, directiveArray, withDirectivesAlias));
+    return addPureComment(createWithDirectivesCall(viewCall, directiveArray, withDirectivesAlias), ctx);
 }
 /**
  * 构建指令值对象

package/dist/passes/hmr/inject-imports.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HMR 导入注入模块
+ * 负责注入 HMR 所需的导入语句
+ * @module passes/hmr/inject-imports
+ */
+import * as t from '@babel/types';
+/** getComponentView 的内部别名，避免与用户代码冲突 */
+export declare const GET_COMPONENT_VIEW_ALIAS = "__$VITARX_GET_COMPONENT_VIEW$__";
+/**
+ * 注入 HMR 客户端导入
+ * @param program - AST Program 节点
+ */
+export declare function injectHMRImport(program: t.Program): void;
+/**
+ * 注入 getComponentView 导入
+ * 使用唯一的别名避免与用户代码冲突
+ * @param program - AST Program 节点
+ */
+export declare function injectGetComponentViewImport(program: t.Program): void;

package/dist/passes/hmr/inject-imports.js

@@ -0,0 +1,26 @@
+/**
+ * HMR 导入注入模块
+ * 负责注入 HMR 所需的导入语句
+ * @module passes/hmr/inject-imports
+ */
+import * as t from '@babel/types';
+import { HMR } from '../../constants/index.js';
+/** getComponentView 的内部别名，避免与用户代码冲突 */
+export const GET_COMPONENT_VIEW_ALIAS = '__$VITARX_GET_COMPONENT_VIEW$__';
+/**
+ * 注入 HMR 客户端导入
+ * @param program - AST Program 节点
+ */
+export function injectHMRImport(program) {
+    const importDecl = t.importDeclaration([t.importDefaultSpecifier(t.identifier(HMR.manager))], t.stringLiteral('@vitarx/vite-plugin/hmr-client'));
+    program.body.unshift(importDecl);
+}
+/**
+ * 注入 getComponentView 导入
+ * 使用唯一的别名避免与用户代码冲突
+ * @param program - AST Program 节点
+ */
+export function injectGetComponentViewImport(program) {
+    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(GET_COMPONENT_VIEW_ALIAS), t.identifier('getComponentView'))], t.stringLiteral('vitarx'));
+    program.body.unshift(importDecl);
+}

package/dist/passes/hmr/inject-state.d.ts

@@ -0,0 +1,29 @@
+/**
+ * HMR 状态恢复模块
+ * 负责为组件函数注入状态保存和恢复代码
+ * @module passes/hmr/inject-state
+ */
+import * as t from '@babel/types';
+/**
+ * 创建组件函数体内的 HMR 注册代码
+ * @param variableNames - 需要追踪的变量名列表
+ * @returns HMR 注册语句数组
+ */
+export declare function createHMRRegistrationStatements(variableNames: string[]): t.Statement[];
+/**
+ * 创建包装组件的 HMR 注册代码
+ * 只注册节点，不保存状态，传入组件函数自身作为第二个参数
+ * @param componentName - 组件函数名称
+ * @returns HMR 注册语句数组
+ */
+export declare function createWrappedComponentHMRStatements(componentName: string): t.Statement[];
+/**
+ * 从函数体中收集局部变量名
+ * @param functionBody - 函数体语句块
+ * @returns 变量名数组
+ */
+export declare function collectLocalVariableNames(functionBody: t.BlockStatement): string[];
+/**
+ * 为函数体内的变量声明注入状态恢复代码
+ */
+export declare function injectStatePreservation(functionBody: t.BlockStatement): void;

package/dist/passes/hmr/inject-state.js

@@ -0,0 +1,101 @@
+/**
+ * HMR 状态恢复模块
+ * 负责为组件函数注入状态保存和恢复代码
+ * @module passes/hmr/inject-state
+ */
+import * as t from '@babel/types';
+import { HMR } from '../../constants/index.js';
+import { collectPatternBindings } from '../../utils/index.js';
+import { GET_COMPONENT_VIEW_ALIAS } from './inject-imports.js';
+/**
+ * 创建组件函数体内的 HMR 注册代码
+ * @param variableNames - 需要追踪的变量名列表
+ * @returns HMR 注册语句数组
+ */
+export function createHMRRegistrationStatements(variableNames) {
+    const statements = [];
+    statements.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(HMR.view), t.callExpression(t.identifier(GET_COMPONENT_VIEW_ALIAS), []))
+    ]));
+    statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view)])));
+    const stateProperties = variableNames.map(name => t.objectMethod('get', t.identifier(name), [], t.blockStatement([t.returnStatement(t.identifier(name))])));
+    statements.push(t.expressionStatement(t.logicalExpression('&&', t.identifier(HMR.view), t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('resolve')), []), t.identifier('then')), [
+        t.arrowFunctionExpression([], t.blockStatement([
+            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(HMR.view), t.identifier(HMR.state)), t.objectExpression(stateProperties)))
+        ]))
+    ]))));
+    return statements;
+}
+/**
+ * 创建包装组件的 HMR 注册代码
+ * 只注册节点，不保存状态，传入组件函数自身作为第二个参数
+ * @param componentName - 组件函数名称
+ * @returns HMR 注册语句数组
+ */
+export function createWrappedComponentHMRStatements(componentName) {
+    const statements = [];
+    statements.push(t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(HMR.view), t.callExpression(t.identifier(GET_COMPONENT_VIEW_ALIAS), []))
+    ]));
+    statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view), t.identifier(componentName)])));
+    return statements;
+}
+/**
+ * 从函数体中收集局部变量名
+ * @param functionBody - 函数体语句块
+ * @returns 变量名数组
+ */
+export function collectLocalVariableNames(functionBody) {
+    const variableNames = new Set();
+    for (const stmt of functionBody.body) {
+        if (stmt.type === 'VariableDeclaration') {
+            for (const decl of stmt.declarations) {
+                if (decl.id.type !== 'VoidPattern') {
+                    collectPatternBindings(decl.id, variableNames);
+                }
+            }
+        }
+    }
+    return Array.from(variableNames);
+}
+/**
+ * 判断表达式是否为函数类型
+ */
+function isFunctionExpression(expr) {
+    if (!expr)
+        return false;
+    return (expr.type === 'ArrowFunctionExpression' ||
+        expr.type === 'FunctionExpression' ||
+        expr.type === 'ClassExpression');
+}
+/**
+ * 创建状态恢复表达式
+ * 格式：__$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, '变量名') ?? 原始初始值
+ */
+function createMemoExpression(variableName, originalInit) {
+    return t.logicalExpression('??', t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('memo')), [t.identifier(HMR.view), t.stringLiteral(variableName)]), originalInit);
+}
+/**
+ * 为单个变量声明注入状态恢复代码
+ */
+function injectStatePreservationForDeclaration(decl) {
+    if (decl.id.type !== 'Identifier')
+        return;
+    if (!decl.init)
+        return;
+    if (isFunctionExpression(decl.init))
+        return;
+    decl.init = createMemoExpression(decl.id.name, decl.init);
+}
+/**
+ * 为函数体内的变量声明注入状态恢复代码
+ */
+export function injectStatePreservation(functionBody) {
+    for (const stmt of functionBody.body) {
+        if (stmt.type === 'VariableDeclaration') {
+            for (const decl of stmt.declarations) {
+                injectStatePreservationForDeclaration(decl);
+            }
+        }
+    }
+}

package/dist/passes/hmr/inject.d.ts

@@ -4,7 +4,7 @@
  * @module passes/hmr
  */
 import * as t from '@babel/types';
-import { type ComponentInfo } from '../../utils/index.js';
+import type { ComponentInfo } from '../../utils/index.js';
 /**
  * 注入 HMR 支持
  * 主入口函数，为所有组件注入完整的 HMR 支持

package/dist/passes/hmr/inject.js

@@ -5,133 +5,28 @@
  */
 import * as t from '@babel/types';
 import { HMR } from '../../constants/index.js';
-import { collectPatternBindings } from '../../utils/index.js';
-/** getComponentView 的内部别名，避免与用户代码冲突 */
-const GET_COMPONENT_VIEW_ALIAS = '__$VITARX_GET_COMPONENT_VIEW$__';
-/**
- * 注入 HMR 客户端导入
- * @param program - AST Program 节点
- */
-function injectHMRImport(program) {
-    const importDecl = t.importDeclaration([t.importDefaultSpecifier(t.identifier(HMR.manager))], t.stringLiteral('@vitarx/vite-plugin/hmr-client'));
-    program.body.unshift(importDecl);
-}
-/**
- * 注入 getComponentView 导入
- * 使用唯一的别名避免与用户代码冲突
- * @param program - AST Program 节点
- */
-function injectGetComponentViewImport(program) {
-    // 创建独立的 import 语句，使用不会冲突的别名
-    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(GET_COMPONENT_VIEW_ALIAS), t.identifier('getComponentView'))], t.stringLiteral('vitarx'));
-    program.body.unshift(importDecl);
-}
-/**
- * 创建组件函数体内的 HMR 注册代码
- * @param variableNames - 需要追踪的变量名列表
- * @returns HMR 注册语句数组
- */
-function createHMRRegistrationStatements(variableNames) {
-    const statements = [];
-    // 声明并获取当前视图实例
-    statements.push(t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier(HMR.view), t.callExpression(t.identifier(GET_COMPONENT_VIEW_ALIAS), []))
-    ]));
-    // 注册到 HMR 管理器
-    statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view)])));
-    // 创建状态追踪对象
-    const stateProperties = variableNames.map(name => t.objectMethod('get', t.identifier(name), [], t.blockStatement([t.returnStatement(t.identifier(name))])));
-    // 异步设置状态
-    statements.push(t.expressionStatement(t.logicalExpression('&&', t.identifier(HMR.view), t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('resolve')), []), t.identifier('then')), [
-        t.arrowFunctionExpression([], t.blockStatement([
-            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(HMR.view), t.identifier(HMR.state)), t.objectExpression(stateProperties)))
-        ]))
-    ]))));
-    return statements;
-}
-/**
- * 从函数体中收集局部变量名
- * @param functionBody - 函数体语句块
- * @returns 变量名数组
- */
-function collectLocalVariableNames(functionBody) {
-    const variableNames = new Set();
-    for (const stmt of functionBody.body) {
-        if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-                if (decl.id.type !== 'VoidPattern') {
-                    collectPatternBindings(decl.id, variableNames);
-                }
-            }
-        }
-    }
-    return Array.from(variableNames);
-}
-/**
- * 判断表达式是否为函数类型
- * 包括：箭头函数、函数表达式、类表达式
- */
-function isFunctionExpression(expr) {
-    if (!expr)
-        return false;
-    return (expr.type === 'ArrowFunctionExpression' ||
-        expr.type === 'FunctionExpression' ||
-        expr.type === 'ClassExpression');
-}
-/**
- * 创建状态恢复表达式
- * 格式：__$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, '变量名') ?? 原始初始值
- */
-function createMemoExpression(variableName, originalInit) {
-    return t.logicalExpression('??', t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('memo')), [t.identifier(HMR.view), t.stringLiteral(variableName)]), originalInit);
-}
-/**
- * 为单个变量声明注入状态恢复代码
- * 仅处理标识符类型的变量声明，且初始值不是函数
- */
-function injectStatePreservationForDeclaration(decl) {
-    // 只处理标识符类型的变量声明
-    if (decl.id.type !== 'Identifier')
-        return;
-    // 没有初始值，不需要处理
-    if (!decl.init)
-        return;
-    // 初始值是函数，不需要状态恢复
-    if (isFunctionExpression(decl.init))
-        return;
-    // 注入状态恢复代码
-    decl.init = createMemoExpression(decl.id.name, decl.init);
-}
-/**
- * 为函数体内的变量声明注入状态恢复代码
- */
-function injectStatePreservation(functionBody) {
-    for (const stmt of functionBody.body) {
-        if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-                injectStatePreservationForDeclaration(decl);
-            }
-        }
-    }
-}
+import { injectHMRImport, injectGetComponentViewImport } from './inject-imports.js';
+import { createHMRRegistrationStatements, createWrappedComponentHMRStatements, collectLocalVariableNames, injectStatePreservation } from './inject-state.js';
 /**
  * 为组件函数注入 HMR 注册代码
  * @param func - 函数声明/表达式/箭头函数
  * @param variableNames - 需要追踪的变量名列表
+ * @param isWrapped - 是否为包装组件
+ * @param componentName - 组件名称（包装组件需要）
  */
-function injectHMRIntoFunction(func, variableNames) {
-    // 处理箭头函数没有函数体的情况（表达式体）
+function injectHMRIntoFunction(func, variableNames, isWrapped = false, componentName) {
     if (func.type === 'ArrowFunctionExpression' && func.body.type !== 'BlockStatement') {
-        // 将表达式体转换为块语句
         const returnStmt = t.returnStatement(func.body);
         func.body = t.blockStatement([returnStmt]);
     }
     if (!func.body || func.body.type !== 'BlockStatement')
         return;
-    // 注入状态恢复代码
-    injectStatePreservation(func.body);
-    // 注入 HMR 注册代码
-    const statements = createHMRRegistrationStatements(variableNames);
+    if (!isWrapped) {
+        injectStatePreservation(func.body);
+    }
+    const statements = isWrapped
+        ? createWrappedComponentHMRStatements(componentName)
+        : createHMRRegistrationStatements(variableNames);
     func.body.body.unshift(...statements);
 }
 /**
@@ -171,19 +66,14 @@ function generateComponentId(filename, componentName) {
 export function injectHMRSupport(program, components, filename) {
     if (components.length === 0)
         return;
-    // 注入必要的导入
     injectHMRImport(program);
     injectGetComponentViewImport(program);
-    // 为每个组件函数注入 HMR 代码
-    for (const { node } of components) {
-        // 收集局部变量名（如果有函数体）
+    for (const { node, isWrapped, name } of components) {
         const variableNames = node.body?.type === 'BlockStatement' ? collectLocalVariableNames(node.body) : [];
-        injectHMRIntoFunction(node, variableNames);
+        injectHMRIntoFunction(node, variableNames, isWrapped, name);
     }
-    // 为每个组件绑定 ID
     for (const { name } of components) {
         program.body.push(createBindIdStatement(name, generateComponentId(filename, name)));
     }
-    // 注入 import.meta.hot.accept
     program.body.push(createHotAcceptStatement());
 }

package/dist/passes/jsx/processChildren.js

@@ -22,7 +22,7 @@ function handleLogicalExpression(expr, ctx, loc) {
     markImport(ctx, 'dynamic');
     const dynamicAlias = getAlias(ctx.vitarxAliases, 'dynamic');
     const locInfo = loc ? getDevLocInfo(ctx, { loc }) : null;
-    return addPureComment(createDynamicCall(expr, dynamicAlias, locInfo));
+    return addPureComment(createDynamicCall(expr, dynamicAlias, locInfo), ctx);
 }
 /**
  * 处理子节点数组

package/dist/passes/jsx/processJSXElement.js

@@ -87,7 +87,7 @@ export function transformJSXElement(node, ctx, handleVIf = false) {
         viewCall = processDirectives(viewCall, directives, ctx);
     }
     else {
-        viewCall = addPureComment(viewCall);
+        viewCall = addPureComment(viewCall, ctx);
     }
     if (node.loc) {
         viewCall.loc = node.loc;

package/dist/passes/jsx/processJSXFragment.js

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, validateMatchInSwitch } from '../../utils/index.js';
+import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, validateNoDirectMatchChild } from '../../utils/index.js';
 import { processChildren } from './processChildren.js';
 /**
  * 处理 JSX Fragment
@@ -11,7 +11,7 @@ export function processJSXFragment(path, ctx) {
     // 过滤空白子节点
     const children = filterWhitespaceChildren(node.children);
     // 校验 Match 组件
-    validateMatchInSwitch(children);
+    validateNoDirectMatchChild(children);
     // 标记需要的导入
     ctx.imports.Fragment = true;
     ctx.imports.createView = true;
@@ -20,7 +20,7 @@ export function processJSXFragment(path, ctx) {
     const locInfo = getDevLocInfo(ctx, node);
     // 无子元素
     if (children.length === 0) {
-        const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), null, locInfo, createViewAlias));
+        const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), null, locInfo, createViewAlias), ctx);
         if (node.loc)
             viewCall.loc = node.loc;
         path.replaceWith(viewCall);
@@ -30,7 +30,7 @@ export function processJSXFragment(path, ctx) {
     const processedChildren = processChildren(children, ctx);
     const childrenValue = processedChildren.length === 1 ? processedChildren[0] : t.arrayExpression(processedChildren);
     const props = t.objectExpression([t.objectProperty(t.identifier('children'), childrenValue)]);
-    const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), props, locInfo, createViewAlias));
+    const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), props, locInfo, createViewAlias), ctx);
     if (node.loc)
         viewCall.loc = node.loc;
     path.replaceWith(viewCall);

package/dist/passes/props/index.js

@@ -5,16 +5,9 @@
  */
 import * as t from '@babel/types';
 import { createError } from '../../error.js';
-import { isNativeElement } from '../../utils/index.js';
+import { getJSXElementName, isNativeElement } from '../../utils/index.js';
 import { createProperty, getAttributeValue, processAttribute, processSpreadAttribute } from './attribute.js';
 import { createVModelProps, extractVModelState } from './vmodel.js';
-/**
- * 获取 JSX 元素的名称
- */
-function getJSXElementName(node) {
-    const nameNode = node.openingElement.name;
-    return nameNode.type === 'JSXIdentifier' ? nameNode.name : null;
-}
 /**
  * 校验 class 和 className 不能同时存在
  */

package/dist/transform.d.ts

@@ -4,16 +4,13 @@
  * @module transform
  */
 import { type GeneratorResult } from '@babel/generator';
+import type { CompileOptions } from './types.js';
 export interface TransformResult extends GeneratorResult {
 }
-export interface CompileOptions {
-    hmr: boolean;
-    dev: boolean;
-    ssr: boolean;
-    runtimeModule: string;
-    sourceMap: boolean | 'inline' | 'both';
-    transformClassNameToClass: boolean;
-}
+/**
+ * 检查文件是否需要转换
+ */
+export declare function shouldTransform(id: string): boolean;
 /**
  * 转换 JSX/TSX 代码
  */

package/dist/transform.js

@@ -9,15 +9,6 @@ import traverse from '@babel/traverse';
 import { createContext } from './context.js';
 import { collectExistingImports, collectLocalBindings, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
 import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, isPureCompileComponent } from './utils/index.js';
-/** 用于追踪已处理的节点 */
-const processedNodes = new WeakSet();
-/**
- * 检查文件是否需要转换
- */
-function shouldTransform(id) {
-    const ext = id.split('?')[0].split('.').pop()?.toLowerCase();
-    return ext === 'jsx' || ext === 'tsx';
-}
 /**
  * 创建解析器选项
  */
@@ -66,6 +57,9 @@ function setupAliases(ctx, program) {
     if (ctx.options.hmr) {
         ctx.vitarxAliases.createView = generateUniqueAlias('jsxDEV', allNames);
     }
+    if (vitarxImports.has('builder')) {
+        ctx.builderAlias = vitarxImports.get('builder');
+    }
 }
 /**
  * 收集 ref 相关信息
@@ -83,21 +77,21 @@ function transformAST(ast, ctx) {
     babelTraverse(ast, {
         JSXElement: {
             enter(path) {
-                if (processedNodes.has(path.node))
+                if (ctx.processedNodes.has(path.node))
                     return;
                 const name = getJSXElementName(path.node);
                 if (name && isPureCompileComponent(name)) {
-                    processedNodes.add(path.node);
+                    ctx.processedNodes.add(path.node);
                     processPureCompileComponent(path, ctx);
                 }
             },
             exit(path) {
-                if (processedNodes.has(path.node))
+                if (ctx.processedNodes.has(path.node))
                     return;
                 const name = getJSXElementName(path.node);
                 if (name && isPureCompileComponent(name))
                     return;
-                processedNodes.add(path.node);
+                ctx.processedNodes.add(path.node);
                 processJSXElement(path, ctx);
             }
         },
@@ -106,9 +100,9 @@ function transformAST(ast, ctx) {
                 processVIfChain(path, ctx, transformJSXElement);
             },
             exit(path) {
-                if (processedNodes.has(path.node))
+                if (ctx.processedNodes.has(path.node))
                     return;
-                processedNodes.add(path.node);
+                ctx.processedNodes.add(path.node);
                 processJSXFragment(path, ctx);
             }
         }
@@ -122,17 +116,22 @@ function generateCode(ast, code, id, sourceMap) {
     const output = babelGenerate(ast, { sourceMaps: !!sourceMap, filename: id, sourceFileName: id }, code);
     return { code: output.code, map: output.map };
 }
+/**
+ * 检查文件是否需要转换
+ */
+export function shouldTransform(id) {
+    const ext = id.split('?')[0].split('.').pop()?.toLowerCase();
+    return ext === 'jsx' || ext === 'tsx';
+}
 /**
  * 转换 JSX/TSX 代码
  */
 export async function transform(code, id, options) {
-    if (!shouldTransform(id))
-        return null;
     const ast = parse(code, createParserOptions());
     const ctx = createContext(code, id, options, ast);
     setupAliases(ctx, ast.program);
     collectRefInfo(ctx, ast.program);
-    const components = collectComponentFunctions(ast.program);
+    const components = collectComponentFunctions(ast.program, ctx.builderAlias);
     transformAST(ast, ctx);
     injectImports(ast.program, ctx);
     if (options.hmr && components.length > 0) {

package/dist/types.d.ts

@@ -1,4 +1,15 @@
 import type { RenderUnit, View } from 'vitarx';
+/**
+ * 编译选项
+ */
+export interface CompileOptions {
+    hmr: boolean;
+    dev: boolean;
+    ssr: boolean;
+    runtimeModule: string;
+    sourceMap: boolean | 'inline' | 'both';
+    transformClassNameToClass: boolean;
+}
 export interface IfBlockProps {
     /**
      * 子元素列表

package/dist/utils/ast-builders.d.ts

@@ -70,9 +70,10 @@ export declare function createLocationObject(filename: string, loc: SourceLocati
 /**
  * 为调用表达式添加 @__PURE__ 注释
  * @param node - 调用表达式节点
+ * @param ctx - 转换上下文
  * @returns 添加注释后的节点
  */
-export declare function addPureComment<T extends CallExpression>(node: T): T;
+export declare function addPureComment<T extends CallExpression>(node: T, ctx: TransformContext): T;
 /**
  * 获取 API 别名
  * @param aliases - 别名映射

package/dist/utils/ast-builders.js

@@ -5,8 +5,6 @@
 import * as t from '@babel/types';
 import { isIdentifier, isStringLiteral } from '@babel/types';
 import { PURE_COMMENT } from '../constants/index.js';
-/** 用于追踪已添加 PURE 注释的节点 */
-const pureCommentedNodes = new WeakSet();
 /**
  * 创建 unref 调用
  * @param argument - 参数表达式
@@ -129,13 +127,14 @@ export function createLocationObject(filename, loc) {
 /**
  * 为调用表达式添加 @__PURE__ 注释
  * @param node - 调用表达式节点
+ * @param ctx - 转换上下文
  * @returns 添加注释后的节点
  */
-export function addPureComment(node) {
-    if (pureCommentedNodes.has(node)) {
+export function addPureComment(node, ctx) {
+    if (ctx.pureCommentedNodes.has(node)) {
         return node;
     }
-    pureCommentedNodes.add(node);
+    ctx.pureCommentedNodes.add(node);
     t.addComment(node, 'leading', ` ${PURE_COMMENT} `, false);
     return node;
 }

package/dist/utils/branch-factory.js

@@ -22,7 +22,7 @@ export function createBranch(config, ctx) {
     }
     const conditionExpr = buildNestedCondition(conditions, ctx, useRef);
     const branchAlias = getAlias(ctx.vitarxAliases, 'branch');
-    return addPureComment(createBranchCall(createArrowFunction(conditionExpr), branches, branchAlias, locInfo));
+    return addPureComment(createBranchCall(createArrowFunction(conditionExpr), branches, branchAlias, locInfo), ctx);
 }
 /**
  * 判断表达式是否需要括号包裹

package/dist/utils/collect-names.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 名称收集模块
+ * 负责从 AST 中收集导出名称、绑定名称和 builder 包装名称
+ * @module utils/collect-names
+ */
+import type * as t from '@babel/types';
+/**
+ * 从命名导出中收集名称
+ */
+export declare function collectFromNamedExport(node: t.ExportNamedDeclaration, names: Set<string>): void;
+/**
+ * 从默认导出中收集名称
+ */
+export declare function collectFromDefaultExport(node: t.ExportDefaultDeclaration, names: Set<string>): void;
+/**
+ * 收集所有导出的标识符名称
+ */
+export declare function collectExportedNames(program: t.Program): Set<string>;
+/**
+ * 收集模块中所有绑定的名称（用于避免命名冲突）
+ */
+export declare function collectAllBindingNames(program: t.Program): Set<string>;
+/**
+ * 判断调用表达式是否是 builder 调用
+ * @param callExpr - 调用表达式
+ * @param builderAlias - builder 的本地别名
+ * @returns 是否是 builder 调用
+ */
+export declare function isBuilderCall(callExpr: t.CallExpression, builderAlias: string | null): boolean;
+/**
+ * 收集被 builder 调用的组件名称
+ * 检测 builder(Comp) 或 builder(Comp, options) 形式的调用
+ * @param program - AST Program 节点
+ * @param builderAlias - builder 的本地别名
+ * @returns 被 builder 调用的组件名称集合
+ */
+export declare function collectBuilderWrappedNames(program: t.Program, builderAlias: string | null): Set<string>;

package/dist/utils/collect-names.js

@@ -0,0 +1,129 @@
+/**
+ * 从命名导出中收集名称
+ */
+export function collectFromNamedExport(node, names) {
+    if (node.declaration) {
+        if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
+            names.add(node.declaration.id.name);
+        }
+        else if (node.declaration.type === 'VariableDeclaration') {
+            for (const decl of node.declaration.declarations) {
+                if (decl.id.type === 'Identifier') {
+                    names.add(decl.id.name);
+                }
+            }
+        }
+    }
+    if (node.specifiers) {
+        for (const spec of node.specifiers) {
+            if (spec.type === 'ExportSpecifier') {
+                names.add(spec.local.name);
+            }
+        }
+    }
+}
+/**
+ * 从默认导出中收集名称
+ */
+export function collectFromDefaultExport(node, names) {
+    const decl = node.declaration;
+    if (decl.type === 'FunctionDeclaration' && decl.id) {
+        names.add(decl.id.name);
+    }
+    else if (decl.type === 'Identifier') {
+        names.add(decl.name);
+    }
+}
+/**
+ * 从变量声明中收集变量名
+ */
+function collectFromVariableDeclaration(node, names) {
+    for (const decl of node.declarations) {
+        if (decl.id.type === 'Identifier') {
+            names.add(decl.id.name);
+        }
+    }
+}
+/**
+ * 从导入声明中收集绑定的名称
+ */
+function collectFromImportDeclaration(node, names) {
+    for (const spec of node.specifiers) {
+        names.add(spec.local.name);
+    }
+}
+/**
+ * 收集所有导出的标识符名称
+ */
+export function collectExportedNames(program) {
+    const names = new Set();
+    for (const node of program.body) {
+        if (node.type === 'ExportNamedDeclaration') {
+            collectFromNamedExport(node, names);
+        }
+        else if (node.type === 'ExportDefaultDeclaration') {
+            collectFromDefaultExport(node, names);
+        }
+    }
+    return names;
+}
+/**
+ * 收集模块中所有绑定的名称（用于避免命名冲突）
+ */
+export function collectAllBindingNames(program) {
+    const names = new Set();
+    for (const node of program.body) {
+        if (node.type === 'FunctionDeclaration' && node.id) {
+            names.add(node.id.name);
+        }
+        else if (node.type === 'VariableDeclaration') {
+            collectFromVariableDeclaration(node, names);
+        }
+        else if (node.type === 'ImportDeclaration') {
+            collectFromImportDeclaration(node, names);
+        }
+        else if (node.type === 'ExportNamedDeclaration') {
+            collectFromNamedExport(node, names);
+        }
+        else if (node.type === 'ExportDefaultDeclaration') {
+            collectFromDefaultExport(node, names);
+        }
+    }
+    return names;
+}
+/**
+ * 判断调用表达式是否是 builder 调用
+ * @param callExpr - 调用表达式
+ * @param builderAlias - builder 的本地别名
+ * @returns 是否是 builder 调用
+ */
+export function isBuilderCall(callExpr, builderAlias) {
+    if (!builderAlias)
+        return false;
+    const callee = callExpr.callee;
+    return callee.type === 'Identifier' && callee.name === builderAlias;
+}
+/**
+ * 收集被 builder 调用的组件名称
+ * 检测 builder(Comp) 或 builder(Comp, options) 形式的调用
+ * @param program - AST Program 节点
+ * @param builderAlias - builder 的本地别名
+ * @returns 被 builder 调用的组件名称集合
+ */
+export function collectBuilderWrappedNames(program, builderAlias) {
+    const wrappedNames = new Set();
+    if (!builderAlias)
+        return wrappedNames;
+    for (const node of program.body) {
+        if (node.type === 'ExpressionStatement' && node.expression.type === 'CallExpression') {
+            const callExpr = node.expression;
+            if (isBuilderCall(callExpr, builderAlias)) {
+                const arg = callExpr.arguments[0];
+                if (arg?.type === 'Identifier') {
+                    wrappedNames.add(arg.name);
+                }
+            }
+        }
+    }
+    return wrappedNames;
+}

package/dist/utils/component-collect.d.ts

@@ -1,7 +1,7 @@
 /**
- * AST 收集模块
- * 负责收集导入、导出、组件等信息的收集
- * @module passes/transform/collect
+ * 组件收集模块
+ * 负责从 AST 中收集组件函数信息
+ * @module utils/component-collect
  */
 import * as t from '@babel/types';
 /**
@@ -10,8 +10,13 @@ import * as t from '@babel/types';
 export interface ComponentInfo {
     name: string;
     node: t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression;
+    /** 是否为包装组件（传递给 builder/defineComponent 等函数） */
+    isWrapped?: boolean;
 }
 /**
  * 收集模块中的组件函数
+ * @param program - AST Program 节点
+ * @param builderAlias - builder 函数的本地别名（用于识别纯构建组件）
+ * @returns 组件信息数组
  */
-export declare function collectComponentFunctions(program: t.Program): ComponentInfo[];
+export declare function collectComponentFunctions(program: t.Program, builderAlias?: string | null): ComponentInfo[];

package/dist/utils/component-collect.js

@@ -1,11 +1,12 @@
 /**
- * AST 收集模块
- * 负责收集导入、导出、组件等信息的收集
- * @module passes/transform/collect
+ * 组件收集模块
+ * 负责从 AST 中收集组件函数信息
+ * @module utils/component-collect
  */
 import * as t from '@babel/types';
 import { DEFAULT_EXPORT_BASE_NAME } from '../constants/index.js';
 import { generateUniqueAlias } from './generate.js';
+import { collectExportedNames, collectAllBindingNames, collectBuilderWrappedNames, isBuilderCall } from './collect-names.js';
 /**
  * 生成唯一的默认导出组件名称
  * 避免与已存在的名称冲突
@@ -23,58 +24,22 @@ function generateUniqueDefaultName(exportedNames) {
 function isValidComponentName(name) {
     return /^[A-Z]/.test(name);
 }
-/**
- * 从命名导出中收集名称
- */
-function collectFromNamedExport(node, names) {
-    if (node.declaration) {
-        if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
-            names.add(node.declaration.id.name);
-        }
-        else if (node.declaration.type === 'VariableDeclaration') {
-            for (const decl of node.declaration.declarations) {
-                if (decl.id.type === 'Identifier') {
-                    names.add(decl.id.name);
-                }
-            }
-        }
-    }
-    if (node.specifiers) {
-        for (const spec of node.specifiers) {
-            if (spec.type === 'ExportSpecifier') {
-                names.add(spec.local.name);
-            }
-        }
-    }
-}
-/**
- * 从默认导出中收集名称
- */
-function collectFromDefaultExport(node, names) {
-    const decl = node.declaration;
-    if (decl.type === 'FunctionDeclaration' && decl.id) {
-        names.add(decl.id.name);
-    }
-    else if (decl.type === 'Identifier') {
-        names.add(decl.name);
-    }
-    // 匿名函数不在此处预留名称，而是在处理时动态生成唯一名称
-}
-function tryAddComponent(name, node, exportedNames, components) {
+function tryAddComponent(name, node, exportedNames, components, builderWrappedNames = new Set()) {
     if (isValidComponentName(name) && exportedNames.has(name)) {
-        components.push({ name, node });
+        const isWrapped = builderWrappedNames.has(name);
+        components.push({ name, node, isWrapped });
     }
 }
 /**
  * 处理变量声明中的组件
  */
-function processVariableDeclaration(declaration, exportedNames, components) {
+function processVariableDeclaration(declaration, exportedNames, components, builderWrappedNames = new Set()) {
     for (const decl of declaration.declarations) {
         if (decl.id.type !== 'Identifier')
             continue;
         const init = decl.init;
         if (init?.type === 'ArrowFunctionExpression' || init?.type === 'FunctionExpression') {
-            tryAddComponent(decl.id.name, init, exportedNames, components);
+            tryAddComponent(decl.id.name, init, exportedNames, components, builderWrappedNames);
         }
     }
 }
@@ -93,14 +58,43 @@ function convertToNamedFunctionDeclaration(func, name) {
     funcDecl.loc = func.loc;
     return funcDecl;
 }
+/**
+ * 从调用表达式中提取函数参数
+ * 将 export default builder(()=><div/>) 转换为：
+ * const _defaultExport = ()=><div/>
+ * export default builder(_defaultExport)
+ * @param callExpr - 调用表达式
+ * @param exportedNames - 已存在的名称集合
+ * @param builderAlias - builder 的本地别名
+ * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
+ */
+function extractFunctionFromCallExpression(callExpr, exportedNames, builderAlias) {
+    const isBuilder = isBuilderCall(callExpr, builderAlias);
+    for (let i = 0; i < callExpr.arguments.length; i++) {
+        const arg = callExpr.arguments[i];
+        if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
+            const name = generateUniqueDefaultName(exportedNames);
+            const funcNode = convertToNamedFunctionDeclaration(arg, name);
+            callExpr.arguments[i] = t.identifier(name);
+            return { name, funcNode, isBuilderWrapped: isBuilder };
+        }
+    }
+    return null;
+}
 /**
  * 处理默认导出的匿名函数
  * 为匿名函数生成唯一名称并转换为命名函数声明
+ * @param node - 默认导出节点
+ * @param program - AST Program 节点，用于插入提取的函数声明
+ * @param exportedNames - 已存在的名称集合
+ * @param components - 组件信息数组
+ * @param builderAlias - builder 的本地别名
  */
-function processAnonymousDefaultExport(node, exportedNames, components) {
+function processAnonymousDefaultExport(node, program, exportedNames, components, builderAlias) {
     const decl = node.declaration;
     let funcNode = null;
     let name;
+    let isWrapped = false;
     if (decl.type === 'FunctionDeclaration' && !decl.id) {
         name = generateUniqueDefaultName(exportedNames);
         decl.id = t.identifier(name);
@@ -116,59 +110,55 @@ function processAnonymousDefaultExport(node, exportedNames, components) {
         funcNode = convertToNamedFunctionDeclaration(decl, name);
         node.declaration = funcNode;
     }
-    if (funcNode) {
-        components.push({ name: name, node: funcNode });
-    }
-}
-/**
- * 收集所有导出的标识符名称
- */
-function collectExportedNames(program) {
-    const names = new Set();
-    for (const node of program.body) {
-        if (node.type === 'ExportNamedDeclaration') {
-            collectFromNamedExport(node, names);
-        }
-        else if (node.type === 'ExportDefaultDeclaration') {
-            collectFromDefaultExport(node, names);
+    else if (decl.type === 'CallExpression') {
+        const result = extractFunctionFromCallExpression(decl, exportedNames, builderAlias);
+        if (result) {
+            name = result.name;
+            funcNode = result.funcNode;
+            isWrapped = result.isBuilderWrapped;
+            const exportIndex = program.body.indexOf(node);
+            if (exportIndex !== -1) {
+                program.body.splice(exportIndex, 0, funcNode);
+            }
         }
     }
-    return names;
+    if (funcNode) {
+        components.push({ name: name, node: funcNode, isWrapped });
+    }
 }
 /**
  * 收集模块中的组件函数
+ * @param program - AST Program 节点
+ * @param builderAlias - builder 函数的本地别名（用于识别纯构建组件）
+ * @returns 组件信息数组
  */
-export function collectComponentFunctions(program) {
+export function collectComponentFunctions(program, builderAlias = null) {
     const exportedNames = collectExportedNames(program);
+    const allBindingNames = collectAllBindingNames(program);
+    const builderWrappedNames = collectBuilderWrappedNames(program, builderAlias);
     const components = [];
     for (const node of program.body) {
-        // 普通函数声明
         if (node.type === 'FunctionDeclaration' && node.id) {
-            tryAddComponent(node.id.name, node, exportedNames, components);
+            tryAddComponent(node.id.name, node, exportedNames, components, builderWrappedNames);
         }
-        // 普通变量声明
         else if (node.type === 'VariableDeclaration') {
-            processVariableDeclaration(node, exportedNames, components);
+            processVariableDeclaration(node, exportedNames, components, builderWrappedNames);
         }
-        // 命名导出
         else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
             if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
-                tryAddComponent(node.declaration.id.name, node.declaration, exportedNames, components);
+                tryAddComponent(node.declaration.id.name, node.declaration, exportedNames, components, builderWrappedNames);
             }
             else if (node.declaration.type === 'VariableDeclaration') {
-                processVariableDeclaration(node.declaration, exportedNames, components);
+                processVariableDeclaration(node.declaration, exportedNames, components, builderWrappedNames);
             }
         }
-        // 默认导出
         else if (node.type === 'ExportDefaultDeclaration') {
             const decl = node.declaration;
-            // 命名函数声明
             if (decl.type === 'FunctionDeclaration' && decl.id) {
-                tryAddComponent(decl.id.name, decl, exportedNames, components);
+                tryAddComponent(decl.id.name, decl, exportedNames, components, builderWrappedNames);
             }
-            // 匿名函数（函数声明、函数表达式、箭头函数）
             else {
-                processAnonymousDefaultExport(node, exportedNames, components);
+                processAnonymousDefaultExport(node, program, allBindingNames, components, builderAlias);
             }
         }
     }

package/dist/utils/index.d.ts

@@ -1,5 +1,5 @@
 export { isWhitespaceJSXText } from './ast-guards.js';
-export { getJSXElementName, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateMatchInSwitch } from './jsx-helpers.js';
+export { getJSXElementName, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateNoDirectMatchChild } from './jsx-helpers.js';
 export { createUnrefCall, createAccessCall, createDynamicCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias, getDevLocInfo } from './ast-builders.js';
 export { collectPatternBindings, collectObjectPatternBindings } from './pattern-helpers.js';
 export { createBranch, createBinaryBranch, buildNestedCondition, type BranchConfig } from './branch-factory.js';

package/dist/utils/index.js

@@ -1,7 +1,7 @@
 // 类型守卫
 export { isWhitespaceJSXText } from './ast-guards.js';
 // JSX 辅助函数
-export { getJSXElementName, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateMatchInSwitch } from './jsx-helpers.js';
+export { getJSXElementName, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateNoDirectMatchChild } from './jsx-helpers.js';
 // AST 构建函数
 export { createUnrefCall, createAccessCall, createDynamicCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias, getDevLocInfo } from './ast-builders.js';
 // 模式处理辅助函数

package/dist/utils/jsx-helpers.d.ts

@@ -77,7 +77,8 @@ export declare function hasEffectiveChildren(node: JSXElement): boolean;
  */
 export declare function filterEffectiveChildren(node: JSXElement): t.Node[];
 /**
- * 校验 Match 组件必须在 Switch 内使用
+ * 校验子节点中不能直接包含 Match 组件
+ * Match 必须在 Switch 内使用，非 Switch 元素的子节点中不允许出现 Match
  * @param children - 子节点数组
  */
-export declare function validateMatchInSwitch(children: t.Node[]): void;
+export declare function validateNoDirectMatchChild(children: t.Node[]): void;

package/dist/utils/jsx-helpers.js

@@ -205,10 +205,11 @@ export function filterEffectiveChildren(node) {
     });
 }
 /**
- * 校验 Match 组件必须在 Switch 内使用
+ * 校验子节点中不能直接包含 Match 组件
+ * Match 必须在 Switch 内使用，非 Switch 元素的子节点中不允许出现 Match
  * @param children - 子节点数组
  */
-export function validateMatchInSwitch(children) {
+export function validateNoDirectMatchChild(children) {
     for (const child of children) {
         if (isJSXElement(child)) {
             const childName = getJSXElementName(child);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitarx/plugin-vite",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.1-beta.8",
   "description": "The official plugin for Vitarx support in Vite.",
   "author": "ZhuChongLin <8210856@qq.com>",
   "license": "MIT",
@@ -26,6 +26,12 @@
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
       }
+    },
+    "./transform": {
+      "import": {
+        "types": "./dist/transform.d.ts",
+        "default": "./dist/transform.js"
+      }
     }
   },
   "peerDependencies": {
@@ -53,12 +59,13 @@
     "prettier": "^3.8.1",
     "rimraf": "^6.1.3",
     "vitest": "^4.0.18",
-    "vite": "^8.0.2",
+    "vite": "^8.0.5",
     "vitarx": "^4.0.0-beta.8"
   },
   "scripts": {
-    "build": "rimraf dist && tsc",
+    "build": "vitest run && rimraf dist && tsc -p tsconfig.build.json",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit",
     "release": "release-cli"
   }
 }