@vitarx/plugin-vite 0.0.1-alpha.1 → 0.0.1-beta.1

package/dist/constants/index.d.ts

@@ -12,6 +12,12 @@ export declare const VITARX_APIS: {
     readonly UNREF: "unref";
     readonly IS_REF: "isRef";
 };
+/**
+ * UI 相关的 API 名称列表
+ * 这些 API 用于创建视图，在 HMR 时需要识别
+ */
+export declare const UI_API_NAMES: readonly ["createView", "branch", "dynamic", "access", "withDirectives"];
+export type UIApiName = (typeof UI_API_NAMES)[number];
 /**
  * Ref 相关 API 名称
  * 用于识别 ref 变量

package/dist/constants/index.js

@@ -12,6 +12,11 @@ export const VITARX_APIS = {
     UNREF: 'unref',
     IS_REF: 'isRef'
 };
+/**
+ * UI 相关的 API 名称列表
+ * 这些 API 用于创建视图，在 HMR 时需要识别
+ */
+export const UI_API_NAMES = ['createView', 'branch', 'dynamic', 'access', 'withDirectives'];
 /**
  * Ref 相关 API 名称
  * 用于识别 ref 变量

package/dist/context.d.ts

@@ -6,11 +6,12 @@
 import type { File } from '@babel/types';
 import type { CompileOptions } from './transform.js';
 import type { CompilerWarning } from './error.js';
+import { UI_API_NAMES } from './constants/index.js';
 /**
  * UI 相关的 API 名称列表
  * 这些 API 用于创建视图，在 HMR 时需要识别
  */
-export declare const UI_API_NAMES: readonly ["createView", "branch", "dynamic", "access", "withDirectives"];
+export declare const UI_API_NAMES_CONST: readonly ["createView", "branch", "dynamic", "access", "withDirectives"];
 export type UIApiName = (typeof UI_API_NAMES)[number];
 /**
  * 导入信息

package/dist/context.js

@@ -1,8 +1,9 @@
+import { UI_API_NAMES } from './constants/index.js';
 /**
  * UI 相关的 API 名称列表
  * 这些 API 用于创建视图，在 HMR 时需要识别
  */
-export const UI_API_NAMES = ['createView', 'branch', 'dynamic', 'access', 'withDirectives'];
+export const UI_API_NAMES_CONST = UI_API_NAMES;
 /**
  * 创建转换上下文
  * @param code - 源代码

package/dist/hmr-client/utils.js

@@ -5,11 +5,12 @@
  */
 import { parse } from 'acorn';
 import { simple as walkSimple } from 'acorn-walk';
+import { UI_API_NAMES } from '../constants/index.js';
 /**
  * UI 相关的运行时 API 名称
  * 这些 API 调用代表 UI 描述代码
  */
-const UI_APIS = new Set(['createView', 'branch', 'dynamic', 'access', 'withDirectives', 'jsxDEV']);
+const UI_APIS = new Set([...UI_API_NAMES, 'jsxDEV']);
 /**
  * 判断标识符名称是否为 UI API
  * 支持原始名称和带后缀的名称（如 jsxDEV$1）

package/dist/index.js

@@ -43,13 +43,12 @@ export default function vitarx(_options) {
         },
         configResolved(config) {
             viteConfig = config;
-            const sourcemap = config.build.sourcemap;
             compileOptions = {
                 dev: isDEV,
                 ssr: isSSR,
                 hmr: isDEV && !isSSR,
                 runtimeModule: 'vitarx',
-                sourceMap: sourcemap === 'inline' ? 'inline' : sourcemap === true ? 'both' : false
+                sourceMap: false
             };
         },
         async transform(code, id) {
@@ -57,9 +56,9 @@ export default function vitarx(_options) {
             if (result) {
                 return await transformWithOxc(result.code, id, {
                     jsx: 'preserve'
-                }, result.map, viteConfig);
+                }, this.getCombinedSourcemap(), viteConfig);
             }
-            return result;
+            return null;
         }
     };
 }

package/dist/passes/components/ifBlock.js

@@ -1,6 +1,6 @@
 import { isJSXElement } from '@babel/types';
 import { createError } from '../../error.js';
-import { collectVIfChainInfo, createArrowFunction, createBranch, filterWhitespaceChildren, hasDirective, removeVDirectives, validateVIfChain } from '../../utils/index.js';
+import { collectVIfChainInfo, createArrowFunction, createBranch, filterWhitespaceChildren, getDevLocInfo, hasDirective, removeVIfChainDirectives, validateVIfChain } from '../../utils/index.js';
 /**
  * 处理 IfBlock 组件
  */
@@ -13,9 +13,11 @@ export function processIfBlock(path, ctx) {
     const jsxChildren = children;
     validateVIfChain(jsxChildren);
     const { nodes, conditions } = collectVIfChainInfo(jsxChildren);
-    nodes.forEach(node => removeVDirectives(node));
+    nodes.forEach(node => removeVIfChainDirectives(node));
     const branches = nodes.map(node => createArrowFunction(node));
-    const branchCall = createBranch({ conditions, branches }, ctx);
+    // 获取位置信息（仅开发环境）
+    const locInfo = getDevLocInfo(ctx, path.node);
+    const branchCall = createBranch({ conditions, branches, locInfo }, ctx);
     if (path.node.loc) {
         branchCall.loc = path.node.loc;
     }

package/dist/passes/components/switch.js

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { isJSXElement, isJSXText } from '@babel/types';
 import { createError } from '../../error.js';
-import { createArrowFunction, createBranch, getJSXAttributeByName, getJSXElementName } from '../../utils/index.js';
+import { createArrowFunction, createBranch, getDevLocInfo, getJSXAttributeByName, getJSXElementName } from '../../utils/index.js';
 /**
  * 处理 Switch 组件
  * @param path - JSX 元素路径
@@ -20,9 +20,11 @@ export function processSwitch(path, ctx) {
         conditions.push(t.booleanLiteral(true));
         branches.push(createArrowFunction(fallbackValue));
     }
+    // 获取位置信息（仅开发环境）
+    const locInfo = getDevLocInfo(ctx, path.node);
     // 生成 branch 调用
     // Switch 的 when 条件如果是标识符，需要 unref
-    const branchCall = createBranch({ conditions, branches, useRef: true }, ctx);
+    const branchCall = createBranch({ conditions, branches, locInfo }, ctx);
     if (path.node.loc) {
         branchCall.loc = path.node.loc;
     }

package/dist/passes/directives/processDirectives.d.ts

@@ -5,6 +5,7 @@
  */
 import * as t from '@babel/types';
 import { TransformContext } from '../../context.js';
+import type { DirectiveInfo } from '../../passes/props/types.js';
 /**
  * 处理指令
  * 将指令转换为 withDirectives 调用
@@ -13,4 +14,4 @@ import { TransformContext } from '../../context.js';
  * @param ctx - 转换上下文
  * @returns 处理后的调用表达式
  */
-export declare function processDirectives(viewCall: t.CallExpression, directives: Map<string, t.Expression>, ctx: TransformContext): t.CallExpression;
+export declare function processDirectives(viewCall: t.CallExpression, directives: Map<string, DirectiveInfo>, ctx: TransformContext): t.CallExpression;

package/dist/passes/directives/processDirectives.js

@@ -20,9 +20,9 @@ export function processDirectives(viewCall, directives, ctx) {
         return viewCall;
     }
     const directiveArray = [];
-    for (const [name, value] of directives) {
+    for (const [name, info] of directives) {
         const directiveName = name.slice(2); // 移除 'v-' 前缀
-        const directiveValue = buildDirectiveValue(value, ctx);
+        const directiveValue = buildDirectiveValue(info.value, info.arg, ctx);
         directiveArray.push([directiveName, directiveValue]);
     }
     markImport(ctx, 'withDirectives');
@@ -32,15 +32,20 @@ export function processDirectives(viewCall, directives, ctx) {
 /**
  * 构建指令值对象
  */
-function buildDirectiveValue(value, ctx) {
+function buildDirectiveValue(value, arg, ctx) {
+    const properties = [];
+    // 添加 value 属性
     if (isIdentifier(value)) {
         markImport(ctx, 'unref');
         const unrefAlias = getAlias(ctx.vitarxAliases, 'unref');
-        return t.objectExpression([
-            t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))]))
-        ]);
+        properties.push(t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))])));
     }
-    return t.objectExpression([
-        t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(value)]))
-    ]);
+    else {
+        properties.push(t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(value)])));
+    }
+    // 添加 arg 属性
+    if (arg) {
+        properties.push(t.objectProperty(t.identifier('arg'), t.stringLiteral(arg)));
+    }
+    return t.objectExpression(properties);
 }

package/dist/passes/directives/vIf.js

@@ -1,6 +1,6 @@
 import * as t from '@babel/types';
 import { isJSXElement, isJSXText } from '@babel/types';
-import { collectFragmentVIfChains, createArrowFunction, createBranch, isWhitespaceJSXText, removeVDirectives } from '../../utils/index.js';
+import { collectFragmentVIfChains, createArrowFunction, createBranch, getDevLocInfo, isWhitespaceJSXText, removeVIfChainDirectives } from '../../utils/index.js';
 /**
  * 处理 Fragment 中的 v-if 链
  * @param path - JSX Fragment 路径
@@ -36,14 +36,17 @@ function processVIfChainItem(chain, children, ctx, transformJSXElement) {
     // 移除指令并转换节点
     const branches = [];
     for (const node of nodes) {
-        removeVDirectives(node);
+        removeVIfChainDirectives(node);
         const transformedNode = transformJSXElement(node, ctx, false);
         if (transformedNode) {
             branches.push(createArrowFunction(transformedNode));
         }
     }
+    // 获取第一个节点的位置信息（仅开发环境）
+    const firstNode = nodes[0];
+    const locInfo = getDevLocInfo(ctx, firstNode);
     // 生成 branch 调用
-    const branchCall = createBranch({ conditions, branches }, ctx);
+    const branchCall = createBranch({ conditions, branches, locInfo }, ctx);
     // 替换链的第一个节点，其他节点标记为 null
     if (start >= 0) {
         children[start] = branchCall;

package/dist/passes/jsx/processChildren.js

@@ -6,7 +6,24 @@
 import * as t from '@babel/types';
 import { isBooleanLiteral, isConditionalExpression, isIdentifier, isJSXElement, isJSXExpressionContainer, isJSXFragment, isJSXText, isLogicalExpression, isMemberExpression, isNumericLiteral, isStringLiteral } from '@babel/types';
 import { markImport } from '../../context.js';
-import { addPureComment, createAccessCall, createBinaryBranch, createDynamicCall, getAlias } from '../../utils/index.js';
+import { addPureComment, createAccessCall, createBinaryBranch, createDynamicCall, getAlias, getDevLocInfo } from '../../utils/index.js';
+/**
+ * 处理成员表达式
+ */
+function handleMemberExpression(expr, ctx) {
+    markImport(ctx, 'access');
+    const accessAlias = getAlias(ctx.vitarxAliases, 'access');
+    return createAccessCall(expr.object, expr.property, accessAlias);
+}
+/**
+ * 处理逻辑表达式
+ */
+function handleLogicalExpression(expr, ctx, loc) {
+    markImport(ctx, 'dynamic');
+    const dynamicAlias = getAlias(ctx.vitarxAliases, 'dynamic');
+    const locInfo = loc ? getDevLocInfo(ctx, { loc }) : null;
+    return addPureComment(createDynamicCall(expr, dynamicAlias, locInfo));
+}
 /**
  * 处理子节点数组
  * @param children - 子节点数组
@@ -38,11 +55,11 @@ function processChildNode(node, ctx) {
     if (isJSXExpressionContainer(node)) {
         if (node.expression.type === 'JSXEmptyExpression')
             return null;
-        return processChildExpression(node.expression, ctx);
+        return processChildExpression(node.expression, ctx, node.loc);
     }
     // JSX 展开子元素
     if (node.type === 'JSXSpreadChild') {
-        return processChildExpression(node.expression, ctx);
+        return processChildExpression(node.expression, ctx, node.loc);
     }
     // JSX 元素或片段
     if (isJSXElement(node) || isJSXFragment(node)) {
@@ -58,9 +75,7 @@ function processChildNode(node, ctx) {
     }
     // 成员表达式
     if (isMemberExpression(node)) {
-        markImport(ctx, 'access');
-        const accessAlias = getAlias(ctx.vitarxAliases, 'access');
-        return createAccessCall(node.object, node.property, accessAlias);
+        return handleMemberExpression(node, ctx);
     }
     // 条件表达式
     if (isConditionalExpression(node)) {
@@ -68,9 +83,7 @@ function processChildNode(node, ctx) {
     }
     // 逻辑表达式
     if (isLogicalExpression(node)) {
-        markImport(ctx, 'dynamic');
-        const dynamicAlias = getAlias(ctx.vitarxAliases, 'dynamic');
-        return addPureComment(createDynamicCall(node, dynamicAlias));
+        return handleLogicalExpression(node, ctx);
     }
     // 调用表达式
     if (node.type === 'CallExpression') {
@@ -81,22 +94,18 @@ function processChildNode(node, ctx) {
 /**
  * 处理子表达式
  */
-function processChildExpression(expr, ctx) {
+function processChildExpression(expr, ctx, loc) {
     if (isIdentifier(expr)) {
         return expr;
     }
     if (isMemberExpression(expr)) {
-        markImport(ctx, 'access');
-        const accessAlias = getAlias(ctx.vitarxAliases, 'access');
-        return createAccessCall(expr.object, expr.property, accessAlias);
+        return handleMemberExpression(expr, ctx);
     }
     if (isConditionalExpression(expr)) {
         return processConditionalExpression(expr, ctx);
     }
     if (isLogicalExpression(expr)) {
-        markImport(ctx, 'dynamic');
-        const dynamicAlias = getAlias(ctx.vitarxAliases, 'dynamic');
-        return addPureComment(createDynamicCall(expr, dynamicAlias));
+        return handleLogicalExpression(expr, ctx, loc);
     }
     return expr;
 }
@@ -109,6 +118,8 @@ function processConditionalExpression(node, ctx) {
     // 处理分支
     const processedConsequent = processChildNode(consequent, ctx) || t.nullLiteral();
     const processedAlternate = processChildNode(alternate, ctx) || t.nullLiteral();
+    // 获取位置信息（仅开发环境）
+    const locInfo = getDevLocInfo(ctx, node);
     // 使用公共的 createBinaryBranch
-    return createBinaryBranch(test, processedConsequent, processedAlternate, ctx);
+    return createBinaryBranch(test, processedConsequent, processedAlternate, ctx, locInfo);
 }

package/dist/passes/jsx/processJSXElement.js

@@ -1,8 +1,8 @@
 import * as t from '@babel/types';
-import { isJSXElement, isJSXExpressionContainer, isJSXText } 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, createLocationObject, getAlias, getDirectiveValue, getJSXAttributeByName, getJSXElementName, isNativeElement, isVElse, isVIf, isVIfChain, removeVDirectives } from '../../utils/index.js';
+import { addPureComment, createArrowFunction, createBranch, createCreateViewCall, getAlias, getDevLocInfo, getDirectiveValue, getJSXAttributeByName, getJSXElementName, hasEffectiveChildren, filterEffectiveChildren, isNativeElement, isVElse, isVIf, isVIfChain, removeVIfChainDirectives } from '../../utils/index.js';
 import { processDirectives } from '../directives/index.js';
 import { processProps } from '../props/index.js';
 import { processChildren } from './processChildren.js';
@@ -72,15 +72,7 @@ export function transformJSXElement(node, ctx, handleVIf = false) {
     // 确定元素类型
     const type = isNativeElement(name) ? t.stringLiteral(name) : t.identifier(name);
     // 检测是否有有效子元素
-    const hasChildren = node.children.some(child => {
-        if (isJSXText(child)) {
-            return child.value.trim().length > 0;
-        }
-        if (isJSXExpressionContainer(child)) {
-            return child.expression.type !== 'JSXEmptyExpression';
-        }
-        return true;
-    });
+    const hasChildren = hasEffectiveChildren(node);
     // 处理属性（有子元素时跳过 children 属性）
     const { props, directives } = processProps(node, ctx, hasChildren);
     // 处理子元素
@@ -88,7 +80,7 @@ export function transformJSXElement(node, ctx, handleVIf = false) {
     // 生成 createView 调用
     markImport(ctx, 'createView');
     const createViewAlias = getAlias(ctx.vitarxAliases, 'createView');
-    const locInfo = ctx.options.dev && node.loc ? createLocationObject(ctx.filename, node.loc) : null;
+    const locInfo = getDevLocInfo(ctx, node);
     let viewCall = createCreateViewCall(type, finalProps, locInfo, createViewAlias);
     // 处理指令
     if (directives.size > 0) {
@@ -108,15 +100,7 @@ export function transformJSXElement(node, ctx, handleVIf = false) {
  */
 function processElementChildren(node, props, ctx) {
     // 过滤有效子元素
-    const children = node.children.filter(child => {
-        if (isJSXText(child)) {
-            return child.value.trim().length > 0;
-        }
-        if (isJSXExpressionContainer(child)) {
-            return child.expression.type !== 'JSXEmptyExpression';
-        }
-        return true;
-    });
+    const children = filterEffectiveChildren(node);
     if (children.length === 0) {
         return props;
     }
@@ -158,14 +142,14 @@ function transformSingleVIf(node, ctx) {
     const condition = getDirectiveValue(node, 'v-if');
     if (!condition)
         return null;
-    // 移除 v- 指令
-    removeVDirectives(node);
-    // 转换元素
+    removeVIfChainDirectives(node);
     const transformedNode = transformJSXElement(node, ctx, false);
     if (!transformedNode)
         return null;
+    // 获取位置信息（仅开发环境）
+    const locInfo = getDevLocInfo(ctx, node);
     // 生成 branch 调用
-    const branchCall = createBranch({ conditions: [condition], branches: [createArrowFunction(transformedNode)] }, ctx);
+    const branchCall = createBranch({ conditions: [condition], branches: [createArrowFunction(transformedNode)], locInfo }, ctx);
     if (node.loc) {
         branchCall.loc = node.loc;
     }

package/dist/passes/jsx/processJSXFragment.js

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { addPureComment, createCreateViewCall, createLocationObject, filterWhitespaceChildren, getAlias, validateMatchInSwitch } from '../../utils/index.js';
+import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, validateMatchInSwitch } from '../../utils/index.js';
 import { processChildren } from './processChildren.js';
 /**
  * 处理 JSX Fragment
@@ -17,7 +17,7 @@ export function processJSXFragment(path, ctx) {
     ctx.imports.createView = true;
     const fragmentAlias = getAlias(ctx.vitarxAliases, 'Fragment');
     const createViewAlias = getAlias(ctx.vitarxAliases, 'createView');
-    const locInfo = ctx.options.dev && node.loc ? createLocationObject(ctx.filename, node.loc) : null;
+    const locInfo = getDevLocInfo(ctx, node);
     // 无子元素
     if (children.length === 0) {
         const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), null, locInfo, createViewAlias));

package/dist/passes/props/attribute.js

@@ -71,7 +71,7 @@ export function processAttribute(attr, existingPropNames, ctx) {
 }
 /**
  * 处理命名空间属性
- * 支持 v:xxx 格式的指令语法
+ *
  * @param attr - JSX 属性节点
  * @param attrName - 命名空间名称
  * @param existingPropNames - 已存在的属性名集合
@@ -82,22 +82,24 @@ function processNamespacedAttribute(attr, attrName, existingPropNames, ctx) {
     const namespace = attrName.namespace.name;
     const name = attrName.name.name;
     const fullName = `${namespace}:${name}`;
-    // v:xxx 指令
-    if (namespace === 'v') {
-        const directiveName = `v-${name}`;
-        const value = getAttributeValue(attr.value);
-        // v:bind 等同于 v-bind
-        if (directiveName === 'v-bind') {
-            return { type: 'directive', name: 'v-bind', value, isVBind: true, isVModel: false };
-        }
-        // 其他指令（排除 v-if 系列和 v-model）
-        if (!['v-if', 'v-else-if', 'v-else', 'v-model'].includes(directiveName)) {
-            return { type: 'directive', name: directiveName, value, isVBind: false, isVModel: false };
+    const value = getAttributeValue(attr.value);
+    // v-xxx:arg 格式的带参数指令 (如 v-test:t)
+    if (namespace.startsWith('v-')) {
+        const directiveName = namespace;
+        // 排除 v-if 系列和 v-model
+        if (!['v-if', 'v-else-if', 'v-else', 'v-model', 'v-bind'].includes(directiveName)) {
+            return {
+                type: 'directive',
+                name: directiveName,
+                value,
+                isVBind: false,
+                isVModel: false,
+                arg: name
+            };
         }
     }
     // 其他命名空间属性作为普通属性处理
     existingPropNames.add(fullName);
-    const value = getAttributeValue(attr.value);
     const property = createProperty(fullName, value, ctx);
     return { type: 'property', property };
 }
@@ -140,26 +142,20 @@ function getAttributeValue(value) {
  * @returns 对象属性或方法节点
  */
 function createProperty(key, value, ctx) {
-    // 静态值：直接赋值
+    const keyNode = t.stringLiteral(key);
     if (isStringLiteral(value) || isNumericLiteral(value) || isBooleanLiteral(value)) {
-        return t.objectProperty(t.identifier(key), value);
+        return t.objectProperty(keyNode, value);
     }
-    // Identifier: 检查是否为已知的 ref 变量
     if (isIdentifier(value)) {
-        // 已知 ref 变量：直接访问 .value
         if (ctx.refVariables.has(value.name)) {
-            return t.objectMethod('get', t.identifier(key), [], t.blockStatement([t.returnStatement(t.memberExpression(value, t.identifier('value')))]));
+            return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(t.memberExpression(value, t.identifier('value')))]));
         }
-        // children 属性：直接引用，不使用 unref
-        // 原因：children 中的 ref 是合法的可变渲染源
         if (key === 'children') {
-            return t.objectProperty(t.identifier(key), value);
+            return t.objectProperty(keyNode, value);
         }
-        // 其他未知变量：使用 unref 进行解包
         markImport(ctx, 'unref');
         const unrefAlias = getAlias(ctx.vitarxAliases, 'unref');
-        return t.objectMethod('get', t.identifier(key), [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))]));
+        return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))]));
     }
-    // 其他表达式：直接返回（保持响应性）
-    return t.objectMethod('get', t.identifier(key), [], t.blockStatement([t.returnStatement(value)]));
+    return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(value)]));
 }

package/dist/passes/props/index.js

@@ -75,7 +75,7 @@ export function processProps(node, ctx, hasChildren = false) {
                 }
                 // 其他指令：添加到指令映射
                 else {
-                    directives.set(result.name, result.value);
+                    directives.set(result.name, { value: result.value, arg: result.arg });
                 }
             }
             else if (result.type === 'property') {

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

@@ -3,14 +3,23 @@
  * @module passes/props/types
  */
 import * as t from '@babel/types';
+/**
+ * 指令信息
+ */
+export interface DirectiveInfo {
+    /** 指令值表达式 */
+    value: t.Expression;
+    /** 指令参数 (如 v-test:t 中的 t) */
+    arg?: string;
+}
 /**
  * Props 处理结果
  */
 export interface PropsResult {
     /** 处理后的 props 对象表达式，无属性时为 null */
     props: t.ObjectExpression | null;
-    /** 指令映射表，key 为指令名，value 为指令值表达式 */
-    directives: Map<string, t.Expression>;
+    /** 指令映射表，key 为指令名，value 为指令信息 */
+    directives: Map<string, DirectiveInfo>;
     /** 是否包含 v-bind 展开属性 */
     hasVBind: boolean;
 }
@@ -36,6 +45,7 @@ export type AttributeResult = {
     value: t.Expression;
     isVBind: boolean;
     isVModel: boolean;
+    arg?: string;
 } | {
     type: 'property';
     property: t.ObjectProperty | t.ObjectMethod;

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

@@ -1,5 +1,10 @@
+/**
+ * AST 节点构建函数
+ * @module utils/ast-builders
+ */
+import * as t from '@babel/types';
 import { type ArrowFunctionExpression, type CallExpression, type Expression, type ObjectExpression, type SourceLocation } from '@babel/types';
-import type { VitarxImportAliases } from '../context.js';
+import type { TransformContext, VitarxImportAliases } from '../context.js';
 /**
  * 创建 unref 调用
  * @param argument - 参数表达式
@@ -19,17 +24,19 @@ export declare function createAccessCall(object: Expression, key: Expression, al
  * 创建 dynamic 调用
  * @param argument - 参数表达式
  * @param alias - dynamic 别名
+ * @param locInfo - 位置信息对象
  * @returns CallExpression
  */
-export declare function createDynamicCall(argument: Expression, alias?: string): CallExpression;
+export declare function createDynamicCall(argument: Expression, alias?: string, locInfo?: ObjectExpression | null): CallExpression;
 /**
  * 创建 branch 调用
  * @param condition - 条件函数
  * @param branches - 分支函数数组
  * @param alias - branch 别名
+ * @param locInfo - 位置信息对象
  * @returns CallExpression
  */
-export declare function createBranchCall(condition: ArrowFunctionExpression, branches: ArrowFunctionExpression[], alias?: string): CallExpression;
+export declare function createBranchCall(condition: ArrowFunctionExpression, branches: ArrowFunctionExpression[], alias?: string, locInfo?: ObjectExpression | null): CallExpression;
 /**
  * 创建 createView 调用
  * @param type - 元素类型
@@ -73,3 +80,13 @@ export declare function addPureComment<T extends CallExpression>(node: T): T;
  * @returns 别名或原名
  */
 export declare function getAlias(aliases: VitarxImportAliases, name: keyof VitarxImportAliases): string;
+/**
+ * 获取开发环境下的位置信息对象
+ * 仅在开发环境下返回位置信息，生产环境返回 null
+ * @param ctx - 转换上下文
+ * @param node - AST 节点或位置信息
+ * @returns 位置信息对象或 null
+ */
+export declare function getDevLocInfo(ctx: TransformContext, node: t.Node | {
+    loc: t.SourceLocation | null;
+}): ObjectExpression | null;

package/dist/utils/ast-builders.js

@@ -40,22 +40,30 @@ export function createAccessCall(object, key, alias) {
  * 创建 dynamic 调用
  * @param argument - 参数表达式
  * @param alias - dynamic 别名
+ * @param locInfo - 位置信息对象
  * @returns CallExpression
  */
-export function createDynamicCall(argument, alias) {
-    return t.callExpression(t.identifier(alias || 'dynamic'), [
-        t.arrowFunctionExpression([], argument)
-    ]);
+export function createDynamicCall(argument, alias, locInfo) {
+    const args = [t.arrowFunctionExpression([], argument)];
+    if (locInfo) {
+        args.push(locInfo);
+    }
+    return t.callExpression(t.identifier(alias || 'dynamic'), args);
 }
 /**
  * 创建 branch 调用
  * @param condition - 条件函数
  * @param branches - 分支函数数组
  * @param alias - branch 别名
+ * @param locInfo - 位置信息对象
  * @returns CallExpression
  */
-export function createBranchCall(condition, branches, alias) {
-    return t.callExpression(t.identifier(alias || 'branch'), [condition, t.arrayExpression(branches)]);
+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);
 }
 /**
  * 创建 createView 调用
@@ -140,3 +148,13 @@ export function addPureComment(node) {
 export function getAlias(aliases, name) {
     return aliases[name] || name;
 }
+/**
+ * 获取开发环境下的位置信息对象
+ * 仅在开发环境下返回位置信息，生产环境返回 null
+ * @param ctx - 转换上下文
+ * @param node - AST 节点或位置信息
+ * @returns 位置信息对象或 null
+ */
+export function getDevLocInfo(ctx, node) {
+    return ctx.options.dev && node.loc ? createLocationObject(ctx.filename, node.loc) : null;
+}

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

@@ -15,6 +15,8 @@ export interface BranchConfig {
     branches: t.ArrowFunctionExpression[];
     /** 是否使用 unref 包装标识符条件 */
     useRef?: boolean;
+    /** 位置信息对象 */
+    locInfo?: t.ObjectExpression | null;
 }
 /**
  * 创建 branch 调用
@@ -28,20 +30,13 @@ export declare function createBranch(config: BranchConfig, ctx: TransformContext
  * 从后向前构建三元表达式链
  */
 export declare function buildNestedCondition(conditions: t.Expression[], ctx: TransformContext, useRef?: boolean): t.Expression;
-/**
- * 从条件数组和分支节点创建完整的 branch 调用
- * @param conditions - 条件表达式数组
- * @param branchNodes - 分支节点数组（会被包装为箭头函数）
- * @param ctx - 转换上下文
- * @returns branch 调用表达式
- */
-export declare function createBranchFromNodes(conditions: t.Expression[], branchNodes: t.Expression[], ctx: TransformContext): t.CallExpression;
 /**
  * 创建简单的二元条件 branch（用于三元表达式）
  * @param condition - 条件表达式
  * @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): t.CallExpression;
+export declare function createBinaryBranch(condition: t.Expression, consequent: t.Expression, alternate: t.Expression, ctx: TransformContext, locInfo?: t.ObjectExpression | null): t.CallExpression;

package/dist/utils/branch-factory.js

@@ -14,7 +14,7 @@ import { addPureComment, createArrowFunction, createBranchCall, createUnrefCall,
  * @returns branch 调用表达式
  */
 export function createBranch(config, ctx) {
-    const { conditions, branches, useRef = true } = config;
+    const { conditions, branches, useRef = true, locInfo } = config;
     markImport(ctx, 'branch');
     // 只有在需要 unref 且条件中有标识符时才标记导入
     if (useRef && conditions.some(c => isIdentifier(c))) {
@@ -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));
+    return addPureComment(createBranchCall(createArrowFunction(conditionExpr), branches, branchAlias, locInfo));
 }
 /**
  * 判断表达式是否需要括号包裹
@@ -79,29 +79,19 @@ export function buildNestedCondition(conditions, ctx, useRef = true) {
     }
     return result || t.nullLiteral();
 }
-/**
- * 从条件数组和分支节点创建完整的 branch 调用
- * @param conditions - 条件表达式数组
- * @param branchNodes - 分支节点数组（会被包装为箭头函数）
- * @param ctx - 转换上下文
- * @returns branch 调用表达式
- */
-export function createBranchFromNodes(conditions, branchNodes, ctx) {
-    const branches = branchNodes.map(node => createArrowFunction(node));
-    return createBranch({ conditions, branches, useRef: true }, ctx);
-}
 /**
  * 创建简单的二元条件 branch（用于三元表达式）
  * @param condition - 条件表达式
  * @param consequent - 真值分支
  * @param alternate - 假值分支
  * @param ctx - 转换上下文
+ * @param locInfo - 位置信息对象
  * @returns branch 调用表达式
  */
-export function createBinaryBranch(condition, consequent, alternate, ctx) {
+export function createBinaryBranch(condition, consequent, alternate, ctx, locInfo) {
     const conditions = [condition, t.booleanLiteral(true)];
     const branches = [createArrowFunction(consequent), createArrowFunction(alternate)];
     // 只有条件是 Identifier 时才需要 unref
     const useRef = isIdentifier(condition);
-    return createBranch({ conditions, branches, useRef }, ctx);
+    return createBranch({ conditions, branches, useRef, locInfo }, ctx);
 }

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, removeAttribute, filterWhitespaceChildren, validateMatchInSwitch } from './jsx-helpers.js';
-export { createUnrefCall, createAccessCall, createDynamicCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias } from './ast-builders.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 { 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, removeAttribute, filterWhitespaceChildren, validateMatchInSwitch } from './jsx-helpers.js';
+export { getJSXElementName, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateMatchInSwitch } from './jsx-helpers.js';
 // AST 构建函数
-export { createUnrefCall, createAccessCall, createDynamicCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias } from './ast-builders.js';
+export { createUnrefCall, createAccessCall, createDynamicCall, 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

@@ -52,6 +52,10 @@ export declare function isVElse(node: JSXElement): boolean;
  * 移除元素上所有 v- 开头的指令属性
  */
 export declare function removeVDirectives(node: JSXElement): void;
+/**
+ * 移除元素上的 v-if 链指令（v-if、v-else-if、v-else）
+ */
+export declare function removeVIfChainDirectives(node: JSXElement): void;
 /**
  * 移除元素上指定名称的属性
  */
@@ -60,6 +64,18 @@ export declare function removeAttribute(node: JSXElement, attrName: string): voi
  * 过滤掉空白文本子节点
  */
 export declare function filterWhitespaceChildren(children: t.Node[]): t.Node[];
+/**
+ * 检查 JSX 元素是否有有效的子元素
+ * @param node - JSX 元素节点
+ * @returns 是否有有效子元素
+ */
+export declare function hasEffectiveChildren(node: JSXElement): boolean;
+/**
+ * 过滤并返回有效的子元素
+ * @param node - JSX 元素节点
+ * @returns 有效子元素数组
+ */
+export declare function filterEffectiveChildren(node: JSXElement): t.Node[];
 /**
  * 校验 Match 组件必须在 Switch 内使用
  * @param children - 子节点数组

package/dist/utils/jsx-helpers.js

@@ -127,6 +127,26 @@ export function removeVDirectives(node) {
         return true;
     });
 }
+/**
+ * 移除元素上的 v-if 链指令（v-if、v-else-if、v-else）
+ */
+export function removeVIfChainDirectives(node) {
+    const vIfChainDirectives = ['v-if', 'v-else-if', 'v-else'];
+    node.openingElement.attributes = node.openingElement.attributes.filter(attr => {
+        if (attr.type === 'JSXAttribute') {
+            const attrName = attr.name;
+            if (attrName.type === 'JSXNamespacedName') {
+                if (attrName.namespace.name === 'v') {
+                    return !vIfChainDirectives.includes(`v-${attrName.name.name}`);
+                }
+            }
+            else if (attrName.type === 'JSXIdentifier') {
+                return !vIfChainDirectives.includes(attrName.name);
+            }
+        }
+        return true;
+    });
+}
 /**
  * 移除元素上指定名称的属性
  */
@@ -152,6 +172,38 @@ export function removeAttribute(node, attrName) {
 export function filterWhitespaceChildren(children) {
     return children.filter(child => !isJSXText(child) || !isWhitespaceJSXText(child));
 }
+/**
+ * 检查 JSX 元素是否有有效的子元素
+ * @param node - JSX 元素节点
+ * @returns 是否有有效子元素
+ */
+export function hasEffectiveChildren(node) {
+    return node.children.some(child => {
+        if (isJSXText(child)) {
+            return child.value.trim().length > 0;
+        }
+        if (child.type === 'JSXExpressionContainer') {
+            return child.expression.type !== 'JSXEmptyExpression';
+        }
+        return true;
+    });
+}
+/**
+ * 过滤并返回有效的子元素
+ * @param node - JSX 元素节点
+ * @returns 有效子元素数组
+ */
+export function filterEffectiveChildren(node) {
+    return node.children.filter(child => {
+        if (isJSXText(child)) {
+            return child.value.trim().length > 0;
+        }
+        if (child.type === 'JSXExpressionContainer') {
+            return child.expression.type !== 'JSXEmptyExpression';
+        }
+        return true;
+    });
+}
 /**
  * 校验 Match 组件必须在 Switch 内使用
  * @param children - 子节点数组

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitarx/plugin-vite",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-beta.1",
   "description": "The official plugin for Vitarx support in Vite.",
   "author": "ZhuChongLin <8210856@qq.com>",
   "license": "MIT",