@vitarx/plugin-vite 1.0.1 → 1.0.2-alpha.0

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

@@ -1,11 +1,12 @@
 /**
  * AST 类型守卫函数
- * 用于判断节点类型
+ * 用于判断节点类型和属性
  * @module utils/ast-guards
  */
 import { type Node } from '@babel/types';
 /**
  * 判断 JSXText 是否为纯空白文本
+ * 空白文本在渲染时通常需要被过滤掉
  * @param node - AST 节点
  * @returns 是否为纯空白文本
  */

package/dist/utils/ast-guards.js

@@ -1,16 +1,19 @@
 /**
  * AST 类型守卫函数
- * 用于判断节点类型
+ * 用于判断节点类型和属性
  * @module utils/ast-guards
  */
 import { isJSXText } from '@babel/types';
 /**
  * 判断 JSXText 是否为纯空白文本
+ * 空白文本在渲染时通常需要被过滤掉
  * @param node - AST 节点
  * @returns 是否为纯空白文本
  */
 export function isWhitespaceJSXText(node) {
+    // 先判断是否为 JSXText 类型
     if (!isJSXText(node))
         return false;
+    // 使用正则表达式判断是否只包含空白字符
     return /^\s*$/.test(node.value);
 }

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

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

package/dist/utils/collect-names.js

@@ -1,7 +1,10 @@
 /**
- * 从命名导出中收集名称
+ * 从命名导出声明中收集名称
+ * @param node - 命名导出声明节点
+ * @param names - 存储名称的集合
  */
 export function collectFromNamedExport(node, names) {
+    // 处理内联声明（export function/const）
     if (node.declaration) {
         if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
             names.add(node.declaration.id.name);
@@ -14,6 +17,7 @@ export function collectFromNamedExport(node, names) {
             }
         }
     }
+    // 处理导出说明符（export { a, b }）
     if (node.specifiers) {
         for (const spec of node.specifiers) {
             if (spec.type === 'ExportSpecifier') {
@@ -23,22 +27,29 @@ export function collectFromNamedExport(node, names) {
     }
 }
 /**
- * 从默认导出中收集名称
+ * 从默认导出声明中收集名称
+ * @param node - 默认导出声明节点
+ * @param names - 存储名称的集合
  */
 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') {
+        // 处理标识符引用（export default Component）
         names.add(decl.name);
     }
 }
 /**
  * 从变量声明中收集变量名
+ * @param node - 变量声明节点
+ * @param names - 存储名称的集合
  */
 function collectFromVariableDeclaration(node, names) {
     for (const decl of node.declarations) {
+        // 只处理简单标识符（不处理解构）
         if (decl.id.type === 'Identifier') {
             names.add(decl.id.name);
         }
@@ -46,17 +57,23 @@ function collectFromVariableDeclaration(node, names) {
 }
 /**
  * 从导入声明中收集绑定的名称
+ * @param node - 导入声明节点
+ * @param names - 存储名称的集合
  */
 function collectFromImportDeclaration(node, names) {
     for (const spec of node.specifiers) {
+        // 收集本地绑定名称
         names.add(spec.local.name);
     }
 }
 /**
  * 收集所有导出的标识符名称
+ * @param program - AST Program 节点
+ * @returns 导出名称集合
  */
 export function collectExportedNames(program) {
     const names = new Set();
+    // 遍历程序体中的所有节点
     for (const node of program.body) {
         if (node.type === 'ExportNamedDeclaration') {
             collectFromNamedExport(node, names);
@@ -69,23 +86,32 @@ export function collectExportedNames(program) {
 }
 /**
  * 收集模块中所有绑定的名称（用于避免命名冲突）
+ * 包括函数声明、变量声明、导入声明和导出声明
+ * @param program - AST Program 节点
+ * @returns 所有绑定名称集合
  */
 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);
         }
     }
@@ -93,14 +119,16 @@ export function collectAllBindingNames(program) {
 }
 /**
  * 判断调用表达式是否是 builder 调用
- * @param callExpr - 调用表达式
+ * @param callExpr - 调用表达式节点
  * @param builderAlias - builder 的本地别名
  * @returns 是否是 builder 调用
  */
 export function isBuilderCall(callExpr, builderAlias) {
+    // 如果没有配置 builder 别名，直接返回 false
     if (!builderAlias)
         return false;
     const callee = callExpr.callee;
+    // 检查调用者是否为标识符且名称匹配
     return callee.type === 'Identifier' && callee.name === builderAlias;
 }
 /**
@@ -108,13 +136,16 @@ export function isBuilderCall(callExpr, builderAlias) {
  * 检测 builder(Comp) 或 builder(Comp, options) 形式的调用
  * @param program - AST Program 节点
  * @param builderAlias - builder 的本地别名
- * @returns 被 builder 调用的组件名称集合
+ * @returns 被 builder 包装的组件名称集合
  */
 export function collectBuilderWrappedNames(program, builderAlias) {
     const wrappedNames = new Set();
+    // 如果没有配置 builder 别名，直接返回空集合
     if (!builderAlias)
         return wrappedNames;
+    // 遍历程序体中的所有节点
     for (const node of program.body) {
+        // 处理独立调用语句：builder(Comp)
         if (node.type === 'ExpressionStatement' && node.expression.type === 'CallExpression') {
             const callExpr = node.expression;
             if (isBuilderCall(callExpr, builderAlias)) {
@@ -125,6 +156,7 @@ export function collectBuilderWrappedNames(program, builderAlias) {
             }
         }
         else if (node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'CallExpression') {
+            // 处理默认导出：export default builder(Comp)
             const callExpr = node.declaration;
             if (isBuilderCall(callExpr, builderAlias)) {
                 const arg = callExpr.arguments[0];
@@ -134,6 +166,7 @@ export function collectBuilderWrappedNames(program, builderAlias) {
             }
         }
         else if (node.type === 'VariableDeclaration') {
+            // 处理变量声明：const Comp = builder(CompImpl)
             for (const decl of node.declarations) {
                 if (decl.init?.type === 'CallExpression' && isBuilderCall(decl.init, builderAlias)) {
                     const arg = decl.init.arguments[0];
@@ -144,6 +177,7 @@ export function collectBuilderWrappedNames(program, builderAlias) {
             }
         }
         else if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+            // 处理命名导出：export const Comp = builder(CompImpl)
             for (const decl of node.declaration.declarations) {
                 if (decl.init?.type === 'CallExpression' && isBuilderCall(decl.init, builderAlias)) {
                     const arg = decl.init.arguments[0];

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

@@ -5,16 +5,18 @@
  */
 import * as t from '@babel/types';
 /**
- * 组件信息
+ * 组件信息接口
+ * 描述从 AST 中提取的组件函数信息
  */
 export interface ComponentInfo {
     name: string;
     node: t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression;
-    /** 是否为包装组件（传递给 builder/defineComponent 等函数） */
+    /** 是否为包装组件（传递给 builder 函数） */
     isWrapped?: boolean;
 }
 /**
  * 收集模块中的组件函数
+ * 遍历 AST 程序节点，提取所有导出的组件函数
  * @param program - AST Program 节点
  * @param builderAlias - builder 函数的本地别名（用于识别纯构建组件）
  * @returns 组件信息数组

package/dist/utils/component-collect.js

@@ -5,56 +5,121 @@
  */
 import * as t from '@babel/types';
 import { DEFAULT_EXPORT_BASE_NAME } from '../constants/index.js';
+// 导入名称收集相关工具函数
+import { collectAllBindingNames, collectBuilderWrappedNames, collectExportedNames, isBuilderCall } from './collect-names.js';
 import { generateUniqueAlias } from './generate.js';
-import { collectExportedNames, collectAllBindingNames, collectBuilderWrappedNames, isBuilderCall } from './collect-names.js';
 /**
  * 生成唯一的默认导出组件名称
  * 避免与已存在的名称冲突
  */
 function generateUniqueDefaultName(exportedNames) {
+    // 如果默认名称未被占用，直接返回
     if (!exportedNames.has(DEFAULT_EXPORT_BASE_NAME)) {
         return DEFAULT_EXPORT_BASE_NAME;
     }
+    // 否则生成唯一别名
     return generateUniqueAlias(DEFAULT_EXPORT_BASE_NAME, exportedNames);
 }
 /**
  * 检查名称是否为有效的组件名称
- * 必须以大写字母开头
+ * 必须以大写字母开头（符合 React/Vue 组件命名规范）
  */
 function isValidComponentName(name) {
+    // 使用正则表达式检查首字母是否为大写
     return /^[A-Z]/.test(name);
 }
+/**
+ * 尝试添加组件信息到组件列表中
+ *
+ * @param name 组件名称
+ * @param node 函数声明节点，可以是函数声明、箭头函数表达式或函数表达式
+ * @param exportedNames 已导出的名称集合
+ * @param components 组件信息数组，用于存储符合条件的组件信息
+ * @param builderWrappedNames 已被包装器包装的函数名称集合，默认为空集合
+ */
 function tryAddComponent(name, node, exportedNames, components, builderWrappedNames = new Set()) {
+    // 检查组件名称是否有效（大写开头）且是否已导出
     if (isValidComponentName(name) && exportedNames.has(name)) {
+        // 判断组件是否已被 builder/defineComponent 等包装器包装
         const isWrapped = builderWrappedNames.has(name);
+        // 将组件信息添加到组件数组中
         components.push({ name, node, isWrapped });
     }
 }
 /**
  * 处理变量声明中的组件
+ * 提取变量赋值中的箭头函数、函数表达式或 builder 包装调用作为组件
+ * @param declaration - 变量声明节点
+ * @param exportedNames - 已导出的名称集合
+ * @param components - 组件信息数组
+ * @param builderWrappedNames - 已被包装器包装的函数名称集合
+ * @param program - AST Program 节点，用于插入提取的函数声明
+ * @param builderAlias - builder 的本地别名
+ * @param allBindingNames - 所有绑定名称集合（用于生成唯一名称时避免冲突）
  */
-function processVariableDeclaration(declaration, exportedNames, components, builderWrappedNames = new Set()) {
+function processVariableDeclaration(declaration, exportedNames, components, builderWrappedNames = new Set(), program, builderAlias, allBindingNames) {
+    // 遍历变量声明中的每个声明
     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, builderWrappedNames);
         }
+        else if (init?.type === 'CallExpression' &&
+            program &&
+            builderAlias != null &&
+            allBindingNames) {
+            // 处理 builder 包装的变量声明：const App = builder(() => <div/>)
+            // 仅处理已导出且名称合法的变量
+            if (!isValidComponentName(decl.id.name) || !exportedNames.has(decl.id.name))
+                continue;
+            const result = extractFunctionFromVariableInit(init, decl.id.name, allBindingNames, builderAlias);
+            if (result) {
+                // 找到包含该变量声明的语句在 program.body 中的位置
+                const stmtIndex = program.body.findIndex(stmt => {
+                    if (stmt === declaration)
+                        return true;
+                    // 变量声明可能在 ExportNamedDeclaration 内部
+                    return stmt.type === 'ExportNamedDeclaration' && stmt.declaration === declaration;
+                });
+                // 将提取的函数声明插入到变量声明之前
+                if (stmtIndex !== -1) {
+                    program.body.splice(stmtIndex, 0, result.funcNode);
+                }
+                // 直接添加为包装组件（不经过 tryAddComponent，因为内部函数名不在 exportedNames 中）
+                components.push({
+                    name: result.name,
+                    node: result.funcNode,
+                    isWrapped: result.isBuilderWrapped
+                });
+            }
+        }
     }
 }
 /**
  * 将函数表达式或箭头函数转换为命名函数声明
+ * 用于将匿名函数转换为可追踪的命名函数
  */
 function convertToNamedFunctionDeclaration(func, name) {
     let body;
+    // 处理箭头函数的隐式返回：将表达式体包装为显式 return 语句
     if (func.type === 'ArrowFunctionExpression' && func.body.type !== 'BlockStatement') {
         body = t.blockStatement([t.returnStatement(func.body)]);
     }
     else {
         body = func.body;
     }
-    const funcDecl = t.functionDeclaration(t.identifier(name), func.params, body, func.type === 'FunctionExpression' ? func.generator : false, func.async);
+    // 创建函数声明节点
+    const funcDecl = t.functionDeclaration(t.identifier(name), // 函数名称
+    func.params, // 参数列表
+    body, // 函数体
+    func.type === 'FunctionExpression' ? func.generator : false, // 是否为生成器
+    func.async // 是否为异步函数
+    );
+    // 保留原始位置信息用于源码映射
     funcDecl.loc = func.loc;
     return funcDecl;
 }
@@ -69,16 +134,56 @@ function convertToNamedFunctionDeclaration(func, name) {
  * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
  */
 function extractFunctionFromCallExpression(callExpr, exportedNames, builderAlias) {
+    // 判断是否为 builder 函数调用
     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;
+}
+/**
+ * 从变量声明的调用表达式中提取函数
+ * 将 const App = builder(() => <div/>) 转换为：
+ * function App$1() { return <div/> }
+ * const App = builder(App$1)
+ * @param callExpr - 调用表达式
+ * @param variableName - 变量名（作为内部函数名的基础）
+ * @param allBindingNames - 所有绑定名称集合（用于避免命名冲突）
+ * @param builderAlias - builder 的本地别名
+ * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
+ */
+function extractFunctionFromVariableInit(callExpr, variableName, allBindingNames, builderAlias) {
+    // 判断是否为 builder 函数调用
+    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 = generateUniqueAlias(variableName, allBindingNames);
+            // 将新名称加入集合，防止后续生成重复名称
+            allBindingNames.add(name);
+            // 转换为命名函数声明
             const funcNode = convertToNamedFunctionDeclaration(arg, name);
+            // 将原参数替换为标识符引用
             callExpr.arguments[i] = t.identifier(name);
             return { name, funcNode, isBuilderWrapped: isBuilder };
         }
     }
+    // 未找到可提取的函数参数
     return null;
 }
 /**
@@ -95,69 +200,139 @@ function processAnonymousDefaultExport(node, program, exportedNames, components,
     let funcNode = null;
     let name;
     let isWrapped = false;
+    // 处理无名称的函数声明 export default function() {}
     if (decl.type === 'FunctionDeclaration' && !decl.id) {
         name = generateUniqueDefaultName(exportedNames);
         decl.id = t.identifier(name);
         funcNode = decl;
     }
     else if (decl.type === 'FunctionExpression') {
+        // 处理函数表达式 export default function() {}
         name = generateUniqueDefaultName(exportedNames);
         funcNode = convertToNamedFunctionDeclaration(decl, name);
         node.declaration = funcNode;
     }
     else if (decl.type === 'ArrowFunctionExpression') {
+        // 处理箭头函数 export default () => {}
         name = generateUniqueDefaultName(exportedNames);
         funcNode = convertToNamedFunctionDeclaration(decl, name);
         node.declaration = funcNode;
     }
     else if (decl.type === 'CallExpression') {
+        // 处理包装调用 export default builder(() => {})
         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);
             }
         }
     }
+    // 如果成功提取到函数节点，添加到组件列表
     if (funcNode) {
         components.push({ name: name, node: funcNode, isWrapped });
     }
 }
+/**
+ * 在 program.body 中查找指定名称的变量声明
+ * 用于处理 export default X 场景，追溯标识符对应的变量声明
+ * @param program - AST Program 节点
+ * @param name - 要查找的变量名
+ * @returns 包含变量声明和所在语句的对象，未找到返回 null
+ */
+function findVariableDeclaration(program, name) {
+    for (const stmt of program.body) {
+        // 查找普通变量声明
+        if (stmt.type === 'VariableDeclaration') {
+            for (const decl of stmt.declarations) {
+                if (decl.id.type === 'Identifier' && decl.id.name === name) {
+                    return { decl, statement: stmt };
+                }
+            }
+        }
+        // 查找命名导出中的变量声明
+        if (stmt.type === 'ExportNamedDeclaration' &&
+            stmt.declaration?.type === 'VariableDeclaration') {
+            for (const decl of stmt.declaration.declarations) {
+                if (decl.id.type === 'Identifier' && decl.id.name === name) {
+                    return { decl, statement: stmt };
+                }
+            }
+        }
+    }
+    return null;
+}
 /**
  * 收集模块中的组件函数
+ * 遍历 AST 程序节点，提取所有导出的组件函数
  * @param program - AST Program 节点
  * @param builderAlias - builder 函数的本地别名（用于识别纯构建组件）
  * @returns 组件信息数组
  */
 export function collectComponentFunctions(program, builderAlias = null) {
+    // 收集所有已导出的名称
     const exportedNames = collectExportedNames(program);
+    // 收集所有绑定名称（用于生成唯一名称时避免冲突）
     const allBindingNames = collectAllBindingNames(program);
+    // 收集被 builder 包装的函数名称
     const builderWrappedNames = collectBuilderWrappedNames(program, builderAlias);
+    // 存储收集到的组件信息
     const components = [];
+    // 遍历程序体中的所有节点
     for (const node of program.body) {
+        // 处理普通函数声明 function Component() {}
         if (node.type === 'FunctionDeclaration' && node.id) {
             tryAddComponent(node.id.name, node, exportedNames, components, builderWrappedNames);
         }
         else if (node.type === 'VariableDeclaration') {
-            processVariableDeclaration(node, exportedNames, components, builderWrappedNames);
+            // 处理变量声明 const Component = () => {} 或 const App = builder(() => {})
+            processVariableDeclaration(node, exportedNames, components, builderWrappedNames, program, builderAlias, allBindingNames);
         }
         else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+            // 处理命名导出 export function Component() {} 或 export const Component = () => {}
             if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
                 tryAddComponent(node.declaration.id.name, node.declaration, exportedNames, components, builderWrappedNames);
             }
             else if (node.declaration.type === 'VariableDeclaration') {
-                processVariableDeclaration(node.declaration, exportedNames, components, builderWrappedNames);
+                // 处理变量声明 const Component = () => {} 或 const App = builder(() => {})
+                processVariableDeclaration(node.declaration, exportedNames, components, builderWrappedNames, program, builderAlias, allBindingNames);
             }
         }
         else if (node.type === 'ExportDefaultDeclaration') {
+            // 处理默认导出 export default Component 或 export default () => {}
             const decl = node.declaration;
             if (decl.type === 'FunctionDeclaration' && decl.id) {
+                // 处理具名函数默认导出 export default function Component() {}
                 tryAddComponent(decl.id.name, decl, exportedNames, components, builderWrappedNames);
             }
+            else if (decl.type === 'Identifier') {
+                // 处理标识符默认导出 export default X
+                // 追溯标识符对应的变量声明，判断是否为 builder 包装组件
+                if (isValidComponentName(decl.name) && exportedNames.has(decl.name)) {
+                    const varDecl = findVariableDeclaration(program, decl.name);
+                    if (varDecl?.decl.init?.type === 'CallExpression') {
+                        const result = extractFunctionFromVariableInit(varDecl.decl.init, decl.name, allBindingNames, builderAlias);
+                        if (result) {
+                            // 将提取的函数声明插入到变量声明所在语句之前
+                            const stmtIndex = program.body.indexOf(varDecl.statement);
+                            if (stmtIndex !== -1) {
+                                program.body.splice(stmtIndex, 0, result.funcNode);
+                            }
+                            components.push({
+                                name: result.name,
+                                node: result.funcNode,
+                                isWrapped: result.isBuilderWrapped
+                            });
+                        }
+                    }
+                }
+            }
             else {
+                // 处理匿名默认导出
                 processAnonymousDefaultExport(node, program, allBindingNames, components, builderAlias);
             }
         }

package/dist/utils/generate.d.ts

@@ -1,5 +1,8 @@
 /**
  * 生成唯一的别名
  * 从 $1 开始递增，直到找到不冲突的名称
+ * @param baseName - 基础名称
+ * @param existingNames - 已存在的名称集合（用于冲突检测）
+ * @returns 唯一的别名
  */
 export declare function generateUniqueAlias(baseName: string, existingNames: Set<string>): string;

package/dist/utils/generate.js

@@ -1,9 +1,13 @@
 /**
  * 生成唯一的别名
  * 从 $1 开始递增，直到找到不冲突的名称
+ * @param baseName - 基础名称
+ * @param existingNames - 已存在的名称集合（用于冲突检测）
+ * @returns 唯一的别名
  */
 export function generateUniqueAlias(baseName, existingNames) {
     let index = 1;
+    // 循环查找不冲突的名称
     while (existingNames.has(`${baseName}$${index}`)) {
         index++;
     }

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

@@ -1,29 +1,43 @@
 /**
  * JSX 相关工具函数
+ * 提供 JSX 元素的各种操作和判断方法
  * @module utils/jsx-helpers
  */
 import * as t from '@babel/types';
 import { type Expression, type JSXAttribute, type JSXElement } from '@babel/types';
 /**
  * 获取 JSX 元素的名称
+ * @param node - JSX 元素节点
+ * @returns 元素名称（Identifier）或 null（MemberExpression）
  */
 export declare function getJSXElementName(node: JSXElement): string | null;
 /**
  * 将 JSX 元素名称节点转换为 createView 的类型表达式
  * JSXIdentifier → Identifier（组件）或 StringLiteral（原生元素）
  * JSXMemberExpression → MemberExpression（如 Obj.Key → Obj.Key）
+ * @param node - JSX 元素节点
+ * @returns 类型表达式或 null
  */
 export declare function resolveJSXElementType(node: JSXElement): t.Expression | null;
 /**
  * 判断名称是否为纯编译组件
+ * 纯编译组件在编译时完全展开，不会生成运行时调用
+ * @param name - 元素名称
+ * @returns 是否为纯编译组件
  */
 export declare function isPureCompileComponent(name: string): boolean;
 /**
  * 判断名称是否为组件（首字母大写）
+ * 遵循 React/Vue 的组件命名约定
+ * @param name - 元素名称
+ * @returns 是否为组件
  */
 export declare function isComponent(name: string): boolean;
 /**
  * 判断名称是否为原生元素
+ * 原生元素使用小写字母开头
+ * @param name - 元素名称
+ * @returns 是否为原生元素
  */
 export declare function isNativeElement(name: string): boolean;
 /**