@vitarx/plugin-vite 1.0.0-beta.0 → 1.0.0-beta.2

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

@@ -47,16 +47,73 @@ export function createWrappedComponentHMRStatements(componentName) {
  */
 export function collectLocalVariableNames(functionBody) {
     const variableNames = new Set();
-    for (const stmt of functionBody.body) {
-        if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-                if (decl.id.type !== 'VoidPattern') {
-                    collectPatternBindings(decl.id, variableNames);
-                }
+    collectFromBlock(functionBody, variableNames);
+    return Array.from(variableNames);
+}
+function collectFromBlock(block, variableNames) {
+    for (const stmt of block.body) {
+        collectFromStatement(stmt, variableNames);
+    }
+}
+function collectFromStatement(stmt, variableNames) {
+    if (stmt.type === 'VariableDeclaration') {
+        for (const decl of stmt.declarations) {
+            if (decl.id.type !== 'VoidPattern') {
+                collectPatternBindings(decl.id, variableNames);
             }
         }
     }
-    return Array.from(variableNames);
+    else if (stmt.type === 'IfStatement') {
+        if (stmt.consequent.type === 'BlockStatement') {
+            collectFromBlock(stmt.consequent, variableNames);
+        }
+        else {
+            collectFromStatement(stmt.consequent, variableNames);
+        }
+        if (stmt.alternate) {
+            if (stmt.alternate.type === 'BlockStatement') {
+                collectFromBlock(stmt.alternate, variableNames);
+            }
+            else {
+                collectFromStatement(stmt.alternate, variableNames);
+            }
+        }
+    }
+    else if (stmt.type === 'ForStatement' || stmt.type === 'WhileStatement' || stmt.type === 'DoWhileStatement') {
+        if (stmt.body.type === 'BlockStatement') {
+            collectFromBlock(stmt.body, variableNames);
+        }
+        else {
+            collectFromStatement(stmt.body, variableNames);
+        }
+    }
+    else if (stmt.type === 'ForInStatement' || stmt.type === 'ForOfStatement') {
+        if (stmt.body.type === 'BlockStatement') {
+            collectFromBlock(stmt.body, variableNames);
+        }
+        else {
+            collectFromStatement(stmt.body, variableNames);
+        }
+    }
+    else if (stmt.type === 'BlockStatement') {
+        collectFromBlock(stmt, variableNames);
+    }
+    else if (stmt.type === 'SwitchStatement') {
+        for (const c of stmt.cases) {
+            for (const s of c.consequent) {
+                collectFromStatement(s, variableNames);
+            }
+        }
+    }
+    else if (stmt.type === 'TryStatement') {
+        collectFromBlock(stmt.block, variableNames);
+        if (stmt.handler) {
+            collectFromBlock(stmt.handler.body, variableNames);
+        }
+        if (stmt.finalizer) {
+            collectFromBlock(stmt.finalizer, variableNames);
+        }
+    }
 }
 /**
  * 判断表达式是否为函数类型

package/dist/passes/hmr/inject.js

@@ -50,11 +50,12 @@ function createHotAcceptStatement() {
  */
 function generateComponentId(filename, componentName) {
     const combined = `${filename}:${componentName}`;
-    let hash = 0;
+    let hash = 2166136261;
     for (let i = 0; i < combined.length; i++) {
-        hash = ((hash << 5) - hash + combined.charCodeAt(i)) | 0;
+        hash ^= combined.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
     }
-    return Math.abs(hash).toString(16);
+    return (hash >>> 0).toString(16);
 }
 /**
  * 注入 HMR 支持

package/dist/passes/imports/collectImports.d.ts

@@ -10,10 +10,7 @@ import * as t from '@babel/types';
  * @param program - AST Program 节点
  * @returns 本地变量名集合和 vitarx 导入映射
  */
-export declare function collectExistingImports(program: t.Program): {
-    localNames: Set<string>;
-    vitarxImports: Map<string, string>;
-};
+export declare function collectExistingImports(program: t.Program): Map<string, string>;
 /**
  * 收集本地变量绑定
  * 包括导入绑定、变量声明、函数声明、类声明

package/dist/passes/imports/collectImports.js

@@ -7,18 +7,17 @@ import { collectPatternBindings } from '../../utils/index.js';
  * @returns 本地变量名集合和 vitarx 导入映射
  */
 export function collectExistingImports(program) {
-    const localNames = new Set();
     const vitarxImports = new Map();
     for (const node of program.body) {
         if (node.type !== 'ImportDeclaration')
             continue;
-        // 跳过 import type 和 import typeof 语句
         if (node.importKind === 'type' || node.importKind === 'typeof')
             continue;
         const source = node.source.value;
+        if (source !== VITARX_MODULE)
+            continue;
         for (const specifier of node.specifiers) {
-            localNames.add(specifier.local.name);
-            if (source === VITARX_MODULE && specifier.type === 'ImportSpecifier') {
+            if (specifier.type === 'ImportSpecifier') {
                 const importedName = specifier.imported.type === 'Identifier'
                     ? specifier.imported.name
                     : specifier.imported.value;
@@ -26,7 +25,7 @@ export function collectExistingImports(program) {
             }
         }
     }
-    return { localNames, vitarxImports };
+    return vitarxImports;
 }
 /**
  * 收集本地变量绑定

package/dist/passes/imports/collectRefVariables.js

@@ -44,8 +44,12 @@ export function collectRefVariables(program, refApiAliases) {
     const refVariables = new Set();
     const { refApiLocalNames, toRefsLocalNames } = buildApiNameSets(refApiAliases);
     for (const node of program.body) {
-        if (node.type !== 'VariableDeclaration')
-            continue;
+        collectRefVariablesFromNode(node, refVariables, refApiLocalNames, toRefsLocalNames);
+    }
+    return refVariables;
+}
+function collectRefVariablesFromNode(node, refVariables, refApiLocalNames, toRefsLocalNames) {
+    if (node.type === 'VariableDeclaration') {
         for (const decl of node.declarations) {
             if (!decl.init)
                 continue;
@@ -64,7 +68,22 @@ export function collectRefVariables(program, refApiAliases) {
             }
         }
     }
-    return refVariables;
+    else if (node.type === 'FunctionDeclaration' && node.body) {
+        for (const stmt of node.body.body) {
+            collectRefVariablesFromNode(stmt, refVariables, refApiLocalNames, toRefsLocalNames);
+        }
+    }
+    else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+        collectRefVariablesFromNode(node.declaration, refVariables, refApiLocalNames, toRefsLocalNames);
+    }
+    else if (node.type === 'ExportDefaultDeclaration') {
+        const decl = node.declaration;
+        if (decl.type === 'FunctionDeclaration' && decl.body) {
+            for (const stmt of decl.body.body) {
+                collectRefVariablesFromNode(stmt, refVariables, refApiLocalNames, toRefsLocalNames);
+            }
+        }
+    }
 }
 /**
  * 构建 API 名称集合

package/dist/passes/jsx/processChildren.js

@@ -34,13 +34,18 @@ function wrapWithExpr(expr, ctx) {
  * @returns 处理后的表达式数组
  */
 export function processChildren(children, ctx) {
+    // 初始化结果数组，用于存储处理后的表达式
     const result = [];
+    // 遍历每个子节点
     for (const child of children) {
+        // 处理单个子节点，将其转换为表达式
         const processed = processChildNode(child, ctx);
+        // 如果处理结果不为null，则添加到结果数组中
         if (processed !== null) {
             result.push(processed);
         }
     }
+    // 返回处理后的表达式数组
     return result;
 }
 /**
@@ -63,6 +68,7 @@ function processChildNode(node, ctx) {
     if (node.type === 'JSXSpreadChild') {
         return processChildExpression(node.expression, ctx);
     }
+    // JSXElement/JSXFragment 由 Babel 遍历的 exit 阶段处理，此处直接透传
     if (isJSXElement(node) || isJSXFragment(node)) {
         return node;
     }
@@ -78,27 +84,50 @@ function processChildNode(node, ctx) {
  * 根据表达式类型生成对应的运行时 API 调用
  * CallExpression 在此用 expr 包装（用户函数调用需要响应式追踪）
  */
+/**
+ * 处理子表达式函数
+ * @param {t.Expression} expr - 要处理的表达式节点
+ * @param {TransformContext} ctx - 转换上下文，包含转换所需的环境信息
+ * @returns {t.Expression} 处理后的表达式节点
+ */
 function processChildExpression(expr, ctx) {
+    // 如果是简单标识符，直接返回
     if (isIdentifier(expr)) {
         return expr;
     }
+    // 如果是成员表达式（如 obj.property），调用专门的处理函数
     if (isMemberExpression(expr)) {
         return handleMemberExpression(expr, ctx);
     }
+    // 如果是条件表达式（如 ternary operator），递归处理条件表达式
     if (isConditionalExpression(expr)) {
         return processConditionalExpression(expr, ctx);
     }
+    // 如果是逻辑表达式、二元表达式或函数调用表达式，用 expr 包装
+    // 这些表达式需要响应式追踪，所以需要特殊处理
     if (isLogicalExpression(expr) || isBinaryExpression(expr) || expr.type === 'CallExpression') {
         return wrapWithExpr(expr, ctx);
     }
+    // 其他类型的表达式直接返回，无需特殊处理
     return expr;
 }
 /**
  * 处理条件表达式，转换为 branch 调用
+ * 该函数接收一个条件表达式节点和转换上下文，将其转换为二元分支调用
+ * @param node - 条件表达式节点，包含测试条件、 consequent 和 alternate 分支
+ * @param ctx - 转换上下文，包含转换过程中需要的辅助信息和工具函数
+ * @returns 返回一个调用表达式，表示转换后的分支逻辑
  */
-function processConditionalExpression(node, ctx) {
+function processConditionalExpression(node, // 条件表达式节点，包含 test、consequent 和 alternate 属性
+ctx // 转换上下文，提供转换过程中需要的辅助方法和状态
+) {
+    // 返回一个调用表达式，表示分支逻辑
+    // 解构条件表达式节点的三个主要部分：测试条件、真分支和假分支
     const { test, consequent, alternate } = node;
+    // 处理真分支，如果处理结果为空则使用 null 字面量作为默认值
     const processedConsequent = processChildNode(consequent, ctx) || t.nullLiteral();
+    // 处理假分支，如果处理结果为空则使用 null 字面量作为默认值
     const processedAlternate = processChildNode(alternate, ctx) || t.nullLiteral();
+    // 创建并返回一个二元分支调用，传入测试条件、处理后的真分支和假分支
     return createBinaryBranch(test, processedConsequent, processedAlternate, ctx);
 }

package/dist/passes/jsx/processJSXElement.js

@@ -2,8 +2,8 @@ import * as t from '@babel/types';
 import { isJSXElement } from '@babel/types';
 import { addWarning, markImport } from '../../context.js';
 import { createError, createWarning } from '../../error.js';
-import { addPureComment, createArrowFunction, createBranch, createCreateViewCall, filterEffectiveChildren, getAlias, getDevLocInfo, getDirectiveValue, getJSXAttributeByName, getJSXElementName, hasEffectiveChildren, isNativeElement, isVElse, isVIf, isVIfChain, removeVIfChainDirectives } from '../../utils/index.js';
-import { processDirectives } from '../directives/index.js';
+import { addPureComment, createArrowFunction, createBranch, createCreateViewCall, filterEffectiveChildren, getAlias, getDevLocInfo, getDirectiveValue, getJSXAttributeByName, getJSXElementName, hasEffectiveChildren, isVElse, isVIf, isVIfChain, removeVIfChainDirectives, resolveJSXElementType } from '../../utils/index.js';
+import { processDirectives, transformChildrenVIfChains } from '../directives/index.js';
 import { processProps } from '../props/index.js';
 import { processChildren } from './processChildren.js';
 /**
@@ -26,26 +26,14 @@ export function processJSXElement(path, ctx) {
  * 校验 Match 组件必须在 Switch 内使用
  */
 function validateMatchInSwitch(path) {
-    const parent = path.parentPath;
-    if (!parent) {
-        throw createError('E012', path.node);
-    }
-    // 检查父元素是否是 Switch
-    if (parent.node.type === 'JSXElement') {
-        const parentName = getJSXElementName(parent.node);
-        if (parentName === 'Switch') {
-            return;
-        }
-    }
-    // 检查是否在 Fragment 内且 Fragment 的父元素是 Switch
-    if (parent.node.type === 'JSXFragment' || parent.node.type === 'JSXElement') {
-        const grandParent = parent.parentPath;
-        if (grandParent?.node.type === 'JSXElement') {
-            const grandParentName = getJSXElementName(grandParent.node);
-            if (grandParentName === 'Switch') {
+    let current = path.parentPath;
+    while (current) {
+        if (current.node.type === 'JSXElement') {
+            const name = getJSXElementName(current.node);
+            if (name === 'Switch')
                 return;
-            }
         }
+        current = current.parentPath;
     }
     throw createError('E012', path.node);
 }
@@ -57,9 +45,6 @@ function validateMatchInSwitch(path) {
  * @returns 转换后的表达式
  */
 export function transformJSXElement(node, ctx, handleVIf = false) {
-    const name = getJSXElementName(node);
-    if (!name)
-        return null;
     // 处理 v-if 链
     if (handleVIf && isVIfChain(node)) {
         if (isVIf(node)) {
@@ -69,8 +54,10 @@ export function transformJSXElement(node, ctx, handleVIf = false) {
             throw createError(isVElse(node) ? 'E003' : 'E004', node);
         }
     }
-    // 确定元素类型
-    const type = isNativeElement(name) ? t.stringLiteral(name) : t.identifier(name);
+    // 解析 JSX 元素类型
+    const type = resolveJSXElementType(node);
+    if (!type)
+        return null;
     // 检测是否有有效子元素
     const hasChildren = hasEffectiveChildren(node);
     // 处理属性（有子元素时跳过 children 属性）
@@ -123,8 +110,10 @@ function processElementChildren(node, props, ctx) {
             }
         }
     }
+    // 处理子元素中的 v-if 链（确保嵌套链在 transformJSXElement 递归调用时被正确处理）
+    const chainProcessed = transformChildrenVIfChains(children, ctx, transformJSXElement);
     // 处理子元素
-    const processedChildren = processChildren(children, ctx);
+    const processedChildren = processChildren(chainProcessed, ctx);
     const childrenValue = processedChildren.length === 1 ? processedChildren[0] : t.arrayExpression(processedChildren);
     // 添加 children 属性
     if (props) {
@@ -135,20 +124,35 @@ function processElementChildren(node, props, ctx) {
 }
 /**
  * 转换单个 v-if 元素
+ * 该函数处理带有 v-if 指令的 JSX 元素，将其转换为条件渲染的函数调用
+ * @param node - 要转换的 JSX 元素节点
+ * @param ctx - 转换上下文，包含转换所需的环境信息
+ * @returns 返回转换后的条件渲染函数调用表达式，如果转换失败则返回 null
  */
 function transformSingleVIf(node, ctx) {
+    // 首先检查节点是否是有效的 v-if 元素
     if (!isVIf(node))
         return null;
+    // 获取 v-if 指令的值（条件表达式）
     const condition = getDirectiveValue(node, 'v-if');
+    // 如果没有找到条件表达式，则返回 null
     if (!condition)
         return null;
+    // 移除节点上的 v-if 相关指令链
     removeVIfChainDirectives(node);
+    // 转换 JSX 元素，不保留原始属性
     const transformedNode = transformJSXElement(node, ctx, false);
+    // 如果转换失败，返回 null
     if (!transformedNode)
         return null;
-    const branchCall = createBranch({ conditions: [condition], branches: [createArrowFunction(transformedNode)] }, ctx);
+    // 创建条件分支的函数调用
+    const branchCall = createBranch(
+    // 包含条件数组和对应的分支函数
+    { conditions: [condition], branches: [createArrowFunction(transformedNode)] }, ctx);
+    // 保留原始节点的位置信息
     if (node.loc) {
         branchCall.loc = node.loc;
     }
+    // 返回转换后的分支函数调用
     return branchCall;
 }

package/dist/passes/jsx/processJSXFragment.d.ts

@@ -5,7 +5,7 @@
  */
 import type { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
-import { TransformContext } from '../../context.js';
+import { type TransformContext } from '../../context.js';
 /**
  * 处理 JSX Fragment
  * @param path - JSX Fragment 路径

package/dist/passes/jsx/processJSXFragment.js

@@ -1,4 +1,5 @@
 import * as t from '@babel/types';
+import { markImport } from '../../context.js';
 import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, validateNoDirectMatchChild } from '../../utils/index.js';
 import { processChildren } from './processChildren.js';
 /**
@@ -13,8 +14,8 @@ export function processJSXFragment(path, ctx) {
     // 校验 Match 组件
     validateNoDirectMatchChild(children);
     // 标记需要的导入
-    ctx.imports.Fragment = true;
-    ctx.imports.createView = true;
+    markImport(ctx, 'Fragment');
+    markImport(ctx, 'createView');
     const fragmentAlias = getAlias(ctx.vitarxAliases, 'Fragment');
     const createViewAlias = getAlias(ctx.vitarxAliases, 'createView');
     const locInfo = getDevLocInfo(ctx, node);

package/dist/passes/props/attribute.d.ts

@@ -39,7 +39,9 @@ export declare function getAttributeValue(value: t.JSXAttribute['value']): t.Exp
  * @param ctx - 转换上下文
  * @returns 对象属性或方法节点
  */
-export declare function createProperty(key: string, value: t.Expression, ctx: TransformContext): t.ObjectProperty | t.ObjectMethod;
+export declare function createProperty(key: string, // 属性名称字符串
+value: t.Expression, // 属性值的表达式，可以是各种类型的表达式
+ctx: TransformContext): t.ObjectProperty | t.ObjectMethod;
 /**
  * 处理单个 JSX 属性
  * 根据属性名类型分发到不同的处理逻辑

package/dist/passes/props/attribute.js

@@ -4,10 +4,10 @@
  * @module passes/props/attribute
  */
 import * as t from '@babel/types';
-import { isBooleanLiteral, isIdentifier, isJSXExpressionContainer, isNumericLiteral, isStringLiteral } from '@babel/types';
+import { isBooleanLiteral, isIdentifier, isJSXExpressionContainer, isMemberExpression, isNumericLiteral, isStringLiteral } from '@babel/types';
 import { markImport } from '../../context.js';
 import { createError } from '../../error.js';
-import { getAlias } from '../../utils/index.js';
+import { createAccessorCall, getAlias } from '../../utils/index.js';
 /**
  * 处理展开属性 {...props}
  * 将展开属性转换为 v-bind 特殊属性格式
@@ -95,22 +95,45 @@ export function getAttributeValue(value) {
  * @param ctx - 转换上下文
  * @returns 对象属性或方法节点
  */
-export function createProperty(key, value, ctx) {
+export function createProperty(key, // 属性名称字符串
+value, // 属性值的表达式，可以是各种类型的表达式
+ctx // 转换上下文对象，包含转换所需的各种信息和工具函数
+) {
+    // 返回类型，可以是对象属性或对象方法
+    // 创建属性名的字符串字面量节点
     const keyNode = t.stringLiteral(key);
+    // 如果值是字符串、数字或布尔字面量，直接创建对象属性
     if (isStringLiteral(value) || isNumericLiteral(value) || isBooleanLiteral(value)) {
         return t.objectProperty(keyNode, value);
     }
+    // 如果值是标识符
     if (isIdentifier(value)) {
+        // 检查标识符是否是 ref 变量
         if (ctx.refVariables.has(value.name)) {
+            // 如果是 ref 变量，创建一个 getter 方法来访问其 value 属性
             return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(t.memberExpression(value, t.identifier('value')))]));
         }
+        // 特殊处理 children 属性，不使用 unref
         if (key === 'children') {
             return t.objectProperty(keyNode, value);
         }
+        // 标记需要导入 unref 函数
         markImport(ctx, 'unref');
+        // 获取 unref 函数的别名
         const unrefAlias = getAlias(ctx.vitarxAliases, 'unref');
+        // 创建 getter 方法，使用 unref 解包属性值
         return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))]));
     }
+    // 如果值是成员表达式，创建 accessor 调用
+    if (isMemberExpression(value)) {
+        // 标记需要导入 accessor 函数
+        markImport(ctx, 'accessor');
+        // 获取 accessor 函数的别名
+        const accessorAlias = getAlias(ctx.vitarxAliases, 'accessor');
+        // 创建属性节点，使用 accessor 处理成员表达式
+        return t.objectProperty(keyNode, createAccessorCall(value.object, value.property, accessorAlias));
+    }
+    // 默认情况下创建 getter 方法直接返回值
     return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(value)]));
 }
 /**
@@ -152,6 +175,5 @@ export function processAttribute(attr, existingPropNames, ctx) {
         return { type: 'property', property };
     }
     // 未知属性类型，作为普通属性处理
-    const value = getAttributeValue(attr.value);
-    return { type: 'property', property: t.objectProperty(t.identifier('unknown'), value) };
+    throw createError('E002', attr, 'Unsupported attribute name type');
 }

package/dist/transform.js

@@ -33,7 +33,7 @@ function createParserOptions() {
  * 设置 API 别名
  */
 function setupAliases(ctx, program) {
-    const { vitarxImports } = collectExistingImports(program);
+    const vitarxImports = collectExistingImports(program);
     const localBindings = collectLocalBindings(program);
     const allNames = new Set([...localBindings]);
     const apiNames = [
@@ -84,6 +84,9 @@ function transformAST(ast, ctx) {
                     ctx.processedNodes.add(path.node);
                     processPureCompileComponent(path, ctx);
                 }
+                else {
+                    processVIfChain(path, ctx, transformJSXElement);
+                }
             },
             exit(path) {
                 if (ctx.processedNodes.has(path.node))

package/dist/utils/ast-builders.js

@@ -3,7 +3,7 @@
  * @module utils/ast-builders
  */
 import * as t from '@babel/types';
-import { isIdentifier, isStringLiteral } from '@babel/types';
+import { isIdentifier } from '@babel/types';
 import { PURE_COMMENT } from '../constants/index.js';
 /**
  * 创建 unref 调用
@@ -22,16 +22,7 @@ export function createUnrefCall(argument, alias) {
  * @returns CallExpression
  */
 export function createAccessorCall(object, key, alias) {
-    let keyArg;
-    if (isIdentifier(key)) {
-        keyArg = t.stringLiteral(key.name);
-    }
-    else if (isStringLiteral(key)) {
-        keyArg = key;
-    }
-    else {
-        keyArg = key;
-    }
+    const keyArg = isIdentifier(key) ? t.stringLiteral(key.name) : key;
     return t.callExpression(t.identifier(alias || 'accessor'), [object, keyArg]);
 }
 /**

package/dist/utils/branch-factory.js

@@ -16,7 +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))) {
+    if (useRef && conditions.some(c => isIdentifier(c) && ctx.refVariables.has(c.name))) {
         markImport(ctx, 'unref');
     }
     const conditionExpr = buildNestedCondition(conditions, ctx, useRef);

package/dist/utils/collect-names.js

@@ -124,6 +124,35 @@ export function collectBuilderWrappedNames(program, builderAlias) {
                 }
             }
         }
+        else if (node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'CallExpression') {
+            const callExpr = node.declaration;
+            if (isBuilderCall(callExpr, builderAlias)) {
+                const arg = callExpr.arguments[0];
+                if (arg?.type === 'Identifier') {
+                    wrappedNames.add(arg.name);
+                }
+            }
+        }
+        else if (node.type === 'VariableDeclaration') {
+            for (const decl of node.declarations) {
+                if (decl.init?.type === 'CallExpression' && isBuilderCall(decl.init, builderAlias)) {
+                    const arg = decl.init.arguments[0];
+                    if (arg?.type === 'Identifier') {
+                        wrappedNames.add(arg.name);
+                    }
+                }
+            }
+        }
+        else if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+            for (const decl of node.declaration.declarations) {
+                if (decl.init?.type === 'CallExpression' && isBuilderCall(decl.init, builderAlias)) {
+                    const arg = decl.init.arguments[0];
+                    if (arg?.type === 'Identifier') {
+                        wrappedNames.add(arg.name);
+                    }
+                }
+            }
+        }
     }
     return wrappedNames;
 }

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, validateNoDirectMatchChild } from './jsx-helpers.js';
+export { getJSXElementName, resolveJSXElementType, 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';

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, validateNoDirectMatchChild } from './jsx-helpers.js';
+export { getJSXElementName, resolveJSXElementType, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateNoDirectMatchChild } from './jsx-helpers.js';
 // AST 构建函数
 export { createUnrefCall, createAccessorCall, createExprCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias, getDevLocInfo } from './ast-builders.js';
 // 模式处理辅助函数

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

@@ -8,6 +8,12 @@ import { type Expression, type JSXAttribute, type JSXElement } from '@babel/type
  * 获取 JSX 元素的名称
  */
 export declare function getJSXElementName(node: JSXElement): string | null;
+/**
+ * 将 JSX 元素名称节点转换为 createView 的类型表达式
+ * JSXIdentifier → Identifier（组件）或 StringLiteral（原生元素）
+ * JSXMemberExpression → MemberExpression（如 Obj.Key → Obj.Key）
+ */
+export declare function resolveJSXElementType(node: JSXElement): t.Expression | null;
 /**
  * 判断名称是否为纯编译组件
  */
@@ -26,10 +32,13 @@ export declare function isNativeElement(name: string): boolean;
 export declare function getJSXAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
 /**
  * 检查元素是否具有指定指令
+ * v-if/v-else-if/v-else 仅支持 JSXIdentifier 格式（v-if），不支持命名空间格式（v:if）
+ * 其他指令（如 v-show）支持 v-xxx:arg 命名空间格式
  */
 export declare function hasDirective(node: JSXElement, directiveName: string): boolean;
 /**
  * 获取指令的值
+ * v-if/v-else-if/v-else 仅支持 JSXIdentifier 格式（v-if），不支持命名空间格式（v:if）
  */
 export declare function getDirectiveValue(node: JSXElement, directiveName: string): Expression | null;
 /**
@@ -54,6 +63,7 @@ export declare function isVElse(node: JSXElement): boolean;
 export declare function removeVDirectives(node: JSXElement): void;
 /**
  * 移除元素上的 v-if 链指令（v-if、v-else-if、v-else）
+ * 仅处理 JSXIdentifier 格式，不支持命名空间格式（v:if）
  */
 export declare function removeVIfChainDirectives(node: JSXElement): void;
 /**