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

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);
             }
         }
@@ -119,20 +113,25 @@ function transformAST(ast, ctx) {
  */
 function generateCode(ast, code, id, sourceMap) {
     const babelGenerate = typeof generate === 'object' ? generate.default : generate;
-    const output = babelGenerate(ast, { sourceMaps: !!sourceMap, filename: id }, code);
-    return { code: output.code, map: output.map || undefined };
+    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,13 +1,12 @@
 /**
- * AST 收集模块
- * 负责收集导入、导出、组件等信息的收集
- * @module passes/transform/collect
+ * 组件收集模块
+ * 负责从 AST 中收集组件函数信息
+ * @module utils/component-collect
  */
 import * as t from '@babel/types';
-import { DEFAULT_EXPORT_BASE_NAME, PURE_COMPILE_COMPONENTS } from '../constants/index.js';
+import { DEFAULT_EXPORT_BASE_NAME } from '../constants/index.js';
 import { generateUniqueAlias } from './generate.js';
-/** 纯编译组件名称集合 */
-const PURE_COMPILE_COMPONENT_SET = new Set(PURE_COMPILE_COMPONENTS);
+import { collectExportedNames, collectAllBindingNames, collectBuilderWrappedNames, isBuilderCall } from './collect-names.js';
 /**
  * 生成唯一的默认导出组件名称
  * 避免与已存在的名称冲突
@@ -25,104 +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);
-    }
-    // 匿名函数不在此处预留名称，而是在处理时动态生成唯一名称
-}
-/**
- * 检查函数是否为组件函数
- * 通过遍历 AST 检查是否包含 JSX 元素
- */
-function isComponentFunction(node) {
-    let result = false;
-    const check = (n) => {
-        if (result)
-            return;
-        // 直接包含 JSX 元素
-        if (n.type === 'JSXElement' || n.type === 'JSXFragment') {
-            result = true;
-            return;
-        }
-        // 检查 return 语句中的纯编译组件
-        if (n.type === 'ReturnStatement' && n.argument?.type === 'JSXElement') {
-            const opening = n.argument.openingElement;
-            if (opening.name.type === 'JSXIdentifier' &&
-                PURE_COMPILE_COMPONENT_SET.has(opening.name.name)) {
-                result = true;
-                return;
-            }
-        }
-        // 递归遍历子节点
-        for (const key of Object.keys(n)) {
-            const child = n[key];
-            if (child && typeof child === 'object') {
-                if (Array.isArray(child)) {
-                    for (const c of child) {
-                        if (c && typeof child === 'object')
-                            check(c);
-                    }
-                }
-                else {
-                    check(child);
-                }
-            }
-        }
-    };
-    check(node);
-    return result;
-}
-/**
- * 尝试添加组件到列表
- * 检查名称有效性、是否导出、是否为组件函数
- */
-function tryAddComponent(name, node, exportedNames, components) {
-    if (isValidComponentName(name) && exportedNames.has(name) && isComponentFunction(node)) {
-        components.push({ name, node });
+function tryAddComponent(name, node, exportedNames, components, builderWrappedNames = new Set()) {
+    if (isValidComponentName(name) && exportedNames.has(name)) {
+        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);
         }
     }
 }
@@ -141,91 +58,107 @@ 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) {
-        if (!isComponentFunction(decl))
-            return;
         name = generateUniqueDefaultName(exportedNames);
         decl.id = t.identifier(name);
         funcNode = decl;
     }
-    // 函数表达式
     else if (decl.type === 'FunctionExpression') {
-        if (!isComponentFunction(decl))
-            return;
         name = generateUniqueDefaultName(exportedNames);
         funcNode = convertToNamedFunctionDeclaration(decl, name);
         node.declaration = funcNode;
     }
-    // 箭头函数
     else if (decl.type === 'ArrowFunctionExpression') {
-        if (!isComponentFunction(decl))
-            return;
         name = generateUniqueDefaultName(exportedNames);
         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;