@vitarx/plugin-vite 0.0.1-beta.7 → 1.0.0-beta.0

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 - 参数表达式
@@ -17,13 +15,13 @@ export function createUnrefCall(argument, alias) {
     return t.callExpression(t.identifier(alias || 'unref'), [argument]);
 }
 /**
- * 创建 access 调用
+ * 创建 accessor 调用
  * @param object - 对象表达式
  * @param key - 键表达式
- * @param alias - access 别名
+ * @param alias - accessor 别名
  * @returns CallExpression
  */
-export function createAccessCall(object, key, alias) {
+export function createAccessorCall(object, key, alias) {
     let keyArg;
     if (isIdentifier(key)) {
         keyArg = t.stringLiteral(key.name);
@@ -34,36 +32,26 @@ export function createAccessCall(object, key, alias) {
     else {
         keyArg = key;
     }
-    return t.callExpression(t.identifier(alias || 'access'), [object, keyArg]);
+    return t.callExpression(t.identifier(alias || 'accessor'), [object, keyArg]);
 }
 /**
- * 创建 dynamic 调用
+ * 创建 expr 调用
  * @param argument - 参数表达式
- * @param alias - dynamic 别名
- * @param locInfo - 位置信息对象
+ * @param alias - expr 别名
  * @returns CallExpression
  */
-export function createDynamicCall(argument, alias, locInfo) {
-    const args = [t.arrowFunctionExpression([], argument)];
-    if (locInfo) {
-        args.push(locInfo);
-    }
-    return t.callExpression(t.identifier(alias || 'dynamic'), args);
+export function createExprCall(argument, alias) {
+    return t.callExpression(t.identifier(alias || 'expr'), [t.arrowFunctionExpression([], argument)]);
 }
 /**
  * 创建 branch 调用
  * @param condition - 条件函数
  * @param branches - 分支函数数组
  * @param alias - branch 别名
- * @param locInfo - 位置信息对象
  * @returns CallExpression
  */
-export function createBranchCall(condition, branches, alias, locInfo) {
-    const args = [condition, t.arrayExpression(branches)];
-    if (locInfo) {
-        args.push(locInfo);
-    }
-    return t.callExpression(t.identifier(alias || 'branch'), args);
+export function createBranchCall(condition, branches, alias) {
+    return t.callExpression(t.identifier(alias || 'branch'), [condition, t.arrayExpression(branches)]);
 }
 /**
  * 创建 createView 调用
@@ -75,15 +63,12 @@ export function createBranchCall(condition, branches, alias, locInfo) {
  */
 export function createCreateViewCall(type, props, locInfo, alias) {
     const args = [type];
-    // props 参数
     if (props) {
         args.push(props);
     }
     else if (locInfo) {
-        // 如果有 locInfo 但没有 props，需要传 null
         args.push(t.nullLiteral());
     }
-    // locInfo 参数
     if (locInfo) {
         args.push(locInfo);
     }
@@ -113,29 +98,17 @@ export function createWithDirectivesCall(view, directives, alias) {
 export function createArrowFunction(body) {
     return t.arrowFunctionExpression([], body);
 }
-/**
- * 创建位置信息对象
- * @param filename - 文件名
- * @param loc - 源码位置
- * @returns ObjectExpression
- */
-export function createLocationObject(filename, loc) {
-    return t.objectExpression([
-        t.objectProperty(t.identifier('fileName'), t.stringLiteral(filename)),
-        t.objectProperty(t.identifier('lineNumber'), t.numericLiteral(loc.start.line)),
-        t.objectProperty(t.identifier('columnNumber'), t.numericLiteral(loc.start.column + 1))
-    ]);
-}
 /**
  * 为调用表达式添加 @__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;
 }
@@ -148,6 +121,19 @@ export function addPureComment(node) {
 export function getAlias(aliases, name) {
     return aliases[name] || name;
 }
+/**
+ * 创建位置信息对象
+ * @param filename - 文件名
+ * @param loc - 源码位置
+ * @returns ObjectExpression
+ */
+export function createLocationObject(filename, loc) {
+    return t.objectExpression([
+        t.objectProperty(t.identifier('fileName'), t.stringLiteral(filename)),
+        t.objectProperty(t.identifier('lineNumber'), t.numericLiteral(loc.start.line)),
+        t.objectProperty(t.identifier('columnNumber'), t.numericLiteral(loc.start.column + 1))
+    ]);
+}
 /**
  * 获取开发环境下的位置信息对象
  * 仅在开发环境下返回位置信息，生产环境返回 null

package/dist/utils/branch-factory.d.ts

@@ -15,8 +15,6 @@ export interface BranchConfig {
     branches: t.ArrowFunctionExpression[];
     /** 是否使用 unref 包装标识符条件 */
     useRef?: boolean;
-    /** 位置信息对象 */
-    locInfo?: t.ObjectExpression | null;
 }
 /**
  * 创建 branch 调用
@@ -36,7 +34,6 @@ export declare function buildNestedCondition(conditions: t.Expression[], ctx: Tr
  * @param consequent - 真值分支
  * @param alternate - 假值分支
  * @param ctx - 转换上下文
- * @param locInfo - 位置信息对象
  * @returns branch 调用表达式
  */
-export declare function createBinaryBranch(condition: t.Expression, consequent: t.Expression, alternate: t.Expression, ctx: TransformContext, locInfo?: t.ObjectExpression | null): t.CallExpression;
+export declare function createBinaryBranch(condition: t.Expression, consequent: t.Expression, alternate: t.Expression, ctx: TransformContext): t.CallExpression;

package/dist/utils/branch-factory.js

@@ -14,15 +14,14 @@ import { addPureComment, createArrowFunction, createBranchCall, createUnrefCall,
  * @returns branch 调用表达式
  */
 export function createBranch(config, ctx) {
-    const { conditions, branches, useRef = true, locInfo } = config;
+    const { conditions, branches, useRef = true } = config;
     markImport(ctx, 'branch');
-    // 只有在需要 unref 且条件中有标识符时才标记导入
     if (useRef && conditions.some(c => isIdentifier(c))) {
         markImport(ctx, 'unref');
     }
     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), ctx);
 }
 /**
  * 判断表达式是否需要括号包裹
@@ -85,13 +84,11 @@ export function buildNestedCondition(conditions, ctx, useRef = true) {
  * @param consequent - 真值分支
  * @param alternate - 假值分支
  * @param ctx - 转换上下文
- * @param locInfo - 位置信息对象
  * @returns branch 调用表达式
  */
-export function createBinaryBranch(condition, consequent, alternate, ctx, locInfo) {
+export function createBinaryBranch(condition, consequent, alternate, ctx) {
     const conditions = [condition, t.booleanLiteral(true)];
     const branches = [createArrowFunction(consequent), createArrowFunction(alternate)];
-    // 只有条件是 Identifier 时才需要 unref
     const useRef = isIdentifier(condition);
-    return createBranch({ conditions, branches, useRef, locInfo }, ctx);
+    return createBranch({ conditions, branches, useRef }, 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,6 +1,6 @@
 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 { createUnrefCall, createAccessCall, createDynamicCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias, getDevLocInfo } from './ast-builders.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, createAccessorCall, createExprCall, 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';
 export { validateVIfChain, collectVIfChainInfo, collectFragmentVIfChains, type VIfChainInfo } from './vif-helpers.js';

package/dist/utils/index.js

@@ -1,9 +1,9 @@
 // 类型守卫
 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';
+export { createUnrefCall, createAccessorCall, createExprCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias, getDevLocInfo } from './ast-builders.js';
 // 模式处理辅助函数
 export { collectPatternBindings, collectObjectPatternBindings } from './pattern-helpers.js';
 // Branch 工厂

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);