@vitarx/plugin-vite 1.0.4 → 1.0.6

package/dist/passes/props/attribute.js

@@ -87,6 +87,9 @@ export function getAttributeValue(value) {
  *
  * 特殊处理：
  * - children 属性不使用 unref，因为 ref 作为 children 是合法的可变渲染源
+ * - ref 属性不使用 unref/.value，因为 ref 绑定需要 ref 对象本身
+ *   运行时 resolveProps() 通过 isRef() 判定 ref 属性值，若此处解包，
+ *   popProperty 取到的是解包后的值（如 null），isRef 判定失败导致绑定失效
  * - 其他标识符属性使用 unref 解包
  *
  * @param key - 属性名
@@ -107,15 +110,22 @@ ctx // 转换上下文，包含转换过程中的相关信息
     }
     // 如果是标识符（变量名）
     if (t.isIdentifier(value)) {
-        // 特殊处理 children 属性或不在 refVariables 中的变量
-        if (key === 'children' || ctx.nonRefVariables.has(value.name)) {
+        // 特殊处理 children 和 ref 属性：
+        // - children: ref 作为 children 是合法的可变渲染源，需保持引用本身
+        // - ref: ref 绑定需要 ref 对象本身，运行时通过 isRef() 判定后赋值 .value
+        //   若此处 unref/.value 解包，popProperty 取到解包值（如 null），isRef 失败
+        if (key === 'children' || key === 'ref') {
+            return t.objectProperty(keyNode, value);
+        }
+        // 已知非 ref 变量（函数声明、箭头函数等）：静态分析确定非 ref，直接赋值无需 unref
+        if (ctx.nonRefVariables.has(value.name)) {
             return t.objectProperty(keyNode, value);
         }
         // 如果是 ref 变量，创建 getter 方法返回 ref 的 value
         if (ctx.refVariables.has(value.name)) {
             return createGetter(keyNode, t.returnStatement(t.memberExpression(value, t.identifier('value'))));
         }
-        // 其他标识符属性创建 unref getter
+        // 未知标识符：创建 unref getter（非 ref 原样返回，安全）
         return createUnrefGetter(keyNode, value, ctx);
     }
     // 如果是成员表达式（如 obj.property）

package/dist/transform.js

@@ -7,8 +7,8 @@ import generate from '@babel/generator';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import { createContext } from './context.js';
-import { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
-import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, isPureCompileComponent } from './utils/index.js';
+import { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectHMRAcceptOnly, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
+import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, hasForwardedComponentDefaultExport, isPureCompileComponent } from './utils/index.js';
 const entryPatterns = [/\/src\/main\.(tsx|jsx)$/, /\\src\\main\.(tsx|jsx)$/];
 /**
  * 创建解析器选项
@@ -64,12 +64,13 @@ function setupAliases(ctx, program) {
 }
 /**
  * 收集 ref 相关信息
+ * 注意：nonRefVariables 在 collectComponentFunctions 之后单独收集，
+ * 因为匿名默认导出需要先被转换为命名函数才能被识别
  */
 function collectRefInfo(ctx, program) {
     const refApiAliases = collectRefApiAliases(program);
     ctx.refApiAliases = refApiAliases;
     ctx.refVariables = collectRefVariables(program, refApiAliases);
-    ctx.nonRefVariables = collectNonRefVariables(program);
 }
 /**
  * 转换 AST
@@ -146,10 +147,20 @@ export async function transform(code, id, options) {
     setupAliases(ctx, ast.program);
     collectRefInfo(ctx, ast.program);
     const components = collectComponentFunctions(ast.program, ctx.builderAlias);
+    // 在组件函数收集之后收集非 ref 变量
+    // 此时匿名默认导出已被转换为命名函数，可被正确识别为非 ref
+    ctx.nonRefVariables = collectNonRefVariables(ast.program);
     transformAST(ast, ctx);
     injectImports(ast.program, ctx);
-    if (options.hmr && components.length > 0 && !isEntryFile(id)) {
-        injectHMRSupport(ast.program, components, id);
+    if (options.hmr && !isEntryFile(id)) {
+        if (components.length > 0) {
+            injectHMRSupport(ast.program, components, id);
+        }
+        else if (hasForwardedComponentDefaultExport(ast.program)) {
+            // 导入转发组件默认导出的模块（如 _layout 转发文件）：无本地组件定义，
+            // 注入 accept-only 自接受，避免编辑时回落整页刷新
+            injectHMRAcceptOnly(ast.program);
+        }
     }
     return generateCode(ast, code, id, options.sourceMap);
 }

package/dist/types.d.ts

@@ -53,7 +53,7 @@ declare global {
              *
              * ```tsx
              * const show = ref(true)
-             * // v-if指令不支持 ref 自动解包，必须使用.value
+             * // v-if 指令支持 ref 自动解包，ref.value 是可选的
              * <div v-if={show.value}></div>
              * ```
              */

package/dist/utils/branch-factory.js

@@ -16,9 +16,7 @@ import { addPureComment, createArrowFunction, createBranchCall, createUnrefCall,
 export function createBranch(config, ctx) {
     const { conditions, branches, useRef = true } = config;
     markImport(ctx, 'branch');
-    if (useRef && conditions.some(c => isIdentifier(c) && ctx.refVariables.has(c.name))) {
-        markImport(ctx, 'unref');
-    }
+    // unref 导入标记由 buildNestedCondition 内部统一管理
     const conditionExpr = buildNestedCondition(conditions, ctx, useRef);
     const branchAlias = getAlias(ctx.vitarxAliases, 'branch');
     return addPureComment(createBranchCall(createArrowFunction(conditionExpr), branches, branchAlias), ctx);
@@ -63,8 +61,28 @@ export function buildNestedCondition(conditions, ctx, useRef = true) {
             result = t.numericLiteral(i);
             continue;
         }
-        // 构建条件表达式
-        const conditionExpr = useRef && isIdentifier(condition) ? createUnrefCall(condition, unrefAlias) : condition;
+        // 构建条件表达式：对标识符进行三态解包
+        // 已知 ref → .value（高效），已知非 ref → 原样（静态分析确定），未知 → unref()（安全）
+        let conditionExpr;
+        if (useRef && isIdentifier(condition)) {
+            if (ctx.refVariables.has(condition.name)) {
+                // 已知 ref：直接使用 .value
+                conditionExpr = t.memberExpression(condition, t.identifier('value'));
+            }
+            else if (ctx.nonRefVariables.has(condition.name)) {
+                // 已知非 ref（函数等）：原样使用，无需解包
+                conditionExpr = condition;
+            }
+            else {
+                // 未知标识符：使用 unref() 解包（非 ref 原样返回）
+                markImport(ctx, 'unref');
+                conditionExpr = createUnrefCall(condition, unrefAlias);
+            }
+        }
+        else {
+            // 复杂表达式：原样不解包，用户手动写 .value
+            conditionExpr = condition;
+        }
         // 对复杂条件表达式添加括号
         const wrappedCondition = wrapExpression(conditionExpr);
         if (result === null) {
@@ -89,6 +107,8 @@ export function buildNestedCondition(conditions, ctx, useRef = true) {
 export function createBinaryBranch(condition, consequent, alternate, ctx) {
     const conditions = [condition, t.booleanLiteral(true)];
     const branches = [createArrowFunction(consequent), createArrowFunction(alternate)];
-    const useRef = isIdentifier(condition);
+    // 三元表达式不解包 ref，用户需手动写 .value
+    // 这样 TypeScript 类型推导能正确检查 Ref<T> 参与运算的类型错误
+    const useRef = false;
     return createBranch({ conditions, branches, useRef }, ctx);
 }

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

@@ -14,6 +14,13 @@ export interface ComponentInfo {
     /** 是否为包装组件（传递给 builder 函数） */
     isWrapped?: boolean;
 }
+/**
+ * 检查名称是否为有效的组件名称
+ * 必须以大写字母开头（符合 React/Vue 组件命名规范）
+ * @param name - 待检查的名称
+ * @returns 是否为有效组件名称
+ */
+export declare function isValidComponentName(name: string): boolean;
 /**
  * 收集模块中的组件函数
  * 遍历 AST 程序节点，提取所有导出的组件函数

package/dist/utils/component-collect.js

@@ -1,48 +1,28 @@
-/**
- * 组件收集模块
- * 负责从 AST 中收集组件函数信息
- * @module utils/component-collect
- */
-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';
-/**
- * 生成唯一的默认导出组件名称
- * 避免与已存在的名称冲突
- */
-function generateUniqueDefaultName(exportedNames) {
-    // 如果默认名称未被占用，直接返回
-    if (!exportedNames.has(DEFAULT_EXPORT_BASE_NAME)) {
-        return DEFAULT_EXPORT_BASE_NAME;
-    }
-    // 否则生成唯一别名
-    return generateUniqueAlias(DEFAULT_EXPORT_BASE_NAME, exportedNames);
-}
+import { collectAllBindingNames, collectBuilderWrappedNames, collectExportedNames } from './collect-names.js';
+import { extractFunctionFromVariableInit } from './function-extract.js';
+import { processAnonymousDefaultExport, processIdentifierDefaultExport } from './default-export.js';
 /**
  * 检查名称是否为有效的组件名称
  * 必须以大写字母开头（符合 React/Vue 组件命名规范）
+ * @param name - 待检查的名称
+ * @returns 是否为有效组件名称
  */
-function isValidComponentName(name) {
-    // 使用正则表达式检查首字母是否为大写
+export function isValidComponentName(name) {
     return /^[A-Z]/.test(name);
 }
 /**
  * 尝试添加组件信息到组件列表中
- *
- * @param name 组件名称
- * @param node 函数声明节点，可以是函数声明、箭头函数表达式或函数表达式
- * @param exportedNames 已导出的名称集合
- * @param components 组件信息数组，用于存储符合条件的组件信息
- * @param builderWrappedNames 已被包装器包装的函数名称集合，默认为空集合
+ * @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 });
     }
 }
@@ -58,14 +38,12 @@ function tryAddComponent(name, node, exportedNames, components, builderWrappedNa
  * @param allBindingNames - 所有绑定名称集合（用于生成唯一名称时避免冲突）
  */
 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' &&
@@ -73,7 +51,6 @@ function processVariableDeclaration(declaration, exportedNames, components, buil
             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);
@@ -82,14 +59,11 @@ function processVariableDeclaration(declaration, exportedNames, components, buil
                 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,
@@ -99,173 +73,6 @@ function processVariableDeclaration(declaration, exportedNames, components, buil
         }
     }
 }
-/**
- * 将函数表达式或箭头函数转换为命名函数声明
- * 用于将匿名函数转换为可追踪的命名函数
- */
-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 // 是否为异步函数
-    );
-    // 保留原始位置信息用于源码映射
-    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) {
-    // 判断是否为 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;
-}
-/**
- * 处理默认导出的匿名函数
- * 为匿名函数生成唯一名称并转换为命名函数声明
- * @param node - 默认导出节点
- * @param program - AST Program 节点，用于插入提取的函数声明
- * @param exportedNames - 已存在的名称集合
- * @param components - 组件信息数组
- * @param builderAlias - builder 的本地别名
- */
-function processAnonymousDefaultExport(node, program, exportedNames, components, builderAlias) {
-    const decl = node.declaration;
-    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 程序节点，提取所有导出的组件函数
@@ -274,65 +81,34 @@ function findVariableDeclaration(program, name) {
  * @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') {
-            // 处理变量声明 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') {
-                // 处理变量声明 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
-                            });
-                        }
-                    }
-                }
+                processIdentifierDefaultExport(decl, program, allBindingNames, components, builderAlias);
             }
             else {
-                // 处理匿名默认导出
                 processAnonymousDefaultExport(node, program, allBindingNames, components, builderAlias);
             }
         }

package/dist/utils/default-export.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 默认导出处理模块
+ * 处理 export default 的各种形式，提取组件函数
+ * @module utils/default-export
+ */
+import * as t from '@babel/types';
+import type { ComponentInfo } from './component-collect.js';
+/**
+ * 在 program.body 中查找指定名称的变量声明
+ * 用于处理 export default X 场景，追溯标识符对应的变量声明
+ * @param program - AST Program 节点
+ * @param name - 要查找的变量名
+ * @returns 包含变量声明和所在语句的对象，未找到返回 null
+ */
+export declare function findVariableDeclaration(program: t.Program, name: string): {
+    decl: t.VariableDeclarator;
+    statement: t.Statement;
+} | null;
+/**
+ * 处理默认导出的匿名函数
+ * 为匿名函数生成唯一名称并转换为命名函数声明
+ * @param node - 默认导出节点
+ * @param program - AST Program 节点，用于插入提取的函数声明
+ * @param allBindingNames - 所有绑定名称集合（用于生成唯一名称时避免冲突）
+ * @param components - 组件信息数组
+ * @param builderAlias - builder 的本地别名
+ */
+export declare function processAnonymousDefaultExport(node: t.ExportDefaultDeclaration, program: t.Program, allBindingNames: Set<string>, components: ComponentInfo[], builderAlias: string | null): void;
+/**
+ * 处理标识符默认导出的 builder 包装追溯
+ * 处理 export default X 场景，追溯 X 是否为 builder 包装的组件
+ * @param decl - 标识符声明节点
+ * @param program - AST Program 节点
+ * @param allBindingNames - 所有绑定名称集合
+ * @param components - 组件信息数组
+ * @param builderAlias - builder 的本地别名
+ */
+export declare function processIdentifierDefaultExport(decl: t.Identifier, program: t.Program, allBindingNames: Set<string>, components: ComponentInfo[], builderAlias: string | null): void;

package/dist/utils/default-export.js

@@ -0,0 +1,119 @@
+/**
+ * 默认导出处理模块
+ * 处理 export default 的各种形式，提取组件函数
+ * @module utils/default-export
+ */
+import * as t from '@babel/types';
+import { generateUniqueDefaultName } from './generate.js';
+import { convertToNamedFunctionDeclaration, extractFunctionFromCallExpression, extractFunctionFromVariableInit } from './function-extract.js';
+import { isValidComponentName } from './component-collect.js';
+/**
+ * 在 program.body 中查找指定名称的变量声明
+ * 用于处理 export default X 场景，追溯标识符对应的变量声明
+ * @param program - AST Program 节点
+ * @param name - 要查找的变量名
+ * @returns 包含变量声明和所在语句的对象，未找到返回 null
+ */
+export 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;
+}
+/**
+ * 处理默认导出的匿名函数
+ * 为匿名函数生成唯一名称并转换为命名函数声明
+ * @param node - 默认导出节点
+ * @param program - AST Program 节点，用于插入提取的函数声明
+ * @param allBindingNames - 所有绑定名称集合（用于生成唯一名称时避免冲突）
+ * @param components - 组件信息数组
+ * @param builderAlias - builder 的本地别名
+ */
+export function processAnonymousDefaultExport(node, program, allBindingNames, components, builderAlias) {
+    const decl = node.declaration;
+    let funcNode = null;
+    let name;
+    let isWrapped = false;
+    // 处理无名称的函数声明 export default function() {}
+    if (decl.type === 'FunctionDeclaration' && !decl.id) {
+        name = generateUniqueDefaultName(allBindingNames);
+        decl.id = t.identifier(name);
+        funcNode = decl;
+    }
+    else if (decl.type === 'FunctionExpression') {
+        // 处理函数表达式 export default function() {}
+        name = generateUniqueDefaultName(allBindingNames);
+        funcNode = convertToNamedFunctionDeclaration(decl, name);
+        node.declaration = funcNode;
+    }
+    else if (decl.type === 'ArrowFunctionExpression') {
+        // 处理箭头函数 export default () => {}
+        name = generateUniqueDefaultName(allBindingNames);
+        funcNode = convertToNamedFunctionDeclaration(decl, name);
+        node.declaration = funcNode;
+    }
+    else if (decl.type === 'CallExpression') {
+        // 处理包装调用 export default builder(() => {})
+        const result = extractFunctionFromCallExpression(decl, allBindingNames, 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 });
+    }
+}
+/**
+ * 处理标识符默认导出的 builder 包装追溯
+ * 处理 export default X 场景，追溯 X 是否为 builder 包装的组件
+ * @param decl - 标识符声明节点
+ * @param program - AST Program 节点
+ * @param allBindingNames - 所有绑定名称集合
+ * @param components - 组件信息数组
+ * @param builderAlias - builder 的本地别名
+ */
+export function processIdentifierDefaultExport(decl, program, allBindingNames, components, builderAlias) {
+    // 追溯标识符对应的变量声明，判断是否为 builder 包装组件
+    if (!isValidComponentName(decl.name))
+        return;
+    const varDecl = findVariableDeclaration(program, decl.name);
+    if (varDecl?.decl.init?.type !== 'CallExpression')
+        return;
+    const result = extractFunctionFromVariableInit(varDecl.decl.init, decl.name, allBindingNames, builderAlias);
+    if (!result)
+        return;
+    // 将提取的函数声明插入到变量声明所在语句之前
+    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
+    });
+}