@vitarx/plugin-vite 1.0.0-beta.1 → 1.0.0-beta.3

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.d.ts

@@ -20,3 +20,10 @@ export declare function collectRefApiAliases(program: t.Program): RefApiAliases;
  * @returns ref 变量名集合
  */
 export declare function collectRefVariables(program: t.Program, refApiAliases: RefApiAliases): Set<string>;
+/**
+ * 收集确定不是 ref 的变量
+ * 包括函数声明、箭头函数和函数表达式变量
+ * @param program - AST Program 节点
+ * @returns 非 ref 变量名集合
+ */
+export declare function collectNonRefVariables(program: t.Program): Set<string>;

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,69 @@ 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);
+            }
+        }
+    }
+}
+/**
+ * 收集确定不是 ref 的变量
+ * 包括函数声明、箭头函数和函数表达式变量
+ * @param program - AST Program 节点
+ * @returns 非 ref 变量名集合
+ */
+export function collectNonRefVariables(program) {
+    const nonRefVariables = new Set();
+    for (const node of program.body) {
+        collectNonRefFromNode(node, nonRefVariables);
+    }
+    return nonRefVariables;
+}
+function collectNonRefFromNode(node, nonRefVariables) {
+    if (node.type === 'FunctionDeclaration' && node.id) {
+        nonRefVariables.add(node.id.name);
+        if (node.body) {
+            for (const stmt of node.body.body) {
+                collectNonRefFromNode(stmt, nonRefVariables);
+            }
+        }
+    }
+    else if (node.type === 'VariableDeclaration') {
+        for (const decl of node.declarations) {
+            if (!decl.init)
+                continue;
+            if (decl.id.type !== 'Identifier')
+                continue;
+            const init = decl.init;
+            if (init.type === 'ArrowFunctionExpression' ||
+                init.type === 'FunctionExpression') {
+                nonRefVariables.add(decl.id.name);
+            }
+        }
+    }
+    else if (node.type === 'ExportNamedDeclaration') {
+        if (node.declaration) {
+            collectNonRefFromNode(node.declaration, nonRefVariables);
+        }
+    }
+    else if (node.type === 'ExportDefaultDeclaration') {
+        const decl = node.declaration;
+        if (decl.type === 'FunctionDeclaration' && decl.id) {
+            nonRefVariables.add(decl.id.name);
+        }
+    }
 }
 /**
  * 构建 API 名称集合

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

@@ -3,5 +3,5 @@
  * @module passes/imports
  */
 export { collectExistingImports, collectLocalBindings } from './collectImports.js';
-export { collectRefApiAliases, collectRefVariables } from './collectRefVariables.js';
+export { collectRefApiAliases, collectNonRefVariables, collectRefVariables } from './collectRefVariables.js';
 export { injectImports } from './injectImports.js';

package/dist/passes/imports/index.js

@@ -3,5 +3,5 @@
  * @module passes/imports
  */
 export { collectExistingImports, collectLocalBindings } from './collectImports.js';
-export { collectRefApiAliases, collectRefVariables } from './collectRefVariables.js';
+export { collectRefApiAliases, collectNonRefVariables, collectRefVariables } from './collectRefVariables.js';
 export { injectImports } from './injectImports.js';

package/dist/passes/index.d.ts

@@ -2,7 +2,7 @@
  * 编译转换处理模块
  * @module passes
  */
-export { collectExistingImports, collectLocalBindings, collectRefApiAliases, collectRefVariables, injectImports } from './imports/index.js';
+export { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectImports } from './imports/index.js';
 export { processPureCompileComponent, processSwitch, processIfBlock } from './components/index.js';
 export { processVIfChain, processDirectives } from './directives/index.js';
 export { processChildren, processJSXElement, transformJSXElement, processJSXFragment } from './jsx/index.js';

package/dist/passes/index.js

@@ -3,7 +3,7 @@
  * @module passes
  */
 // 导入处理
-export { collectExistingImports, collectLocalBindings, collectRefApiAliases, collectRefVariables, injectImports } from './imports/index.js';
+export { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectImports } from './imports/index.js';
 // 编译宏组件
 export { processPureCompileComponent, processSwitch, processIfBlock } from './components/index.js';
 // 指令处理

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,7 +2,7 @@ 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 { 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 属性）
@@ -137,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, // 属性值表达式，使用 t.Expression 类型表示
+ctx: TransformContext): t.ObjectProperty | t.ObjectMethod;
 /**
  * 处理单个 JSX 属性
  * 根据属性名类型分发到不同的处理逻辑

package/dist/passes/props/attribute.js

@@ -4,7 +4,6 @@
  * @module passes/props/attribute
  */
 import * as t from '@babel/types';
-import { isBooleanLiteral, isIdentifier, isJSXExpressionContainer, isNumericLiteral, isStringLiteral } from '@babel/types';
 import { markImport } from '../../context.js';
 import { createError } from '../../error.js';
 import { getAlias } from '../../utils/index.js';
@@ -71,10 +70,10 @@ export function getAttributeValue(value) {
     if (!value) {
         return t.booleanLiteral(true);
     }
-    if (isStringLiteral(value)) {
+    if (t.isStringLiteral(value)) {
         return value;
     }
-    if (isJSXExpressionContainer(value)) {
+    if (t.isJSXExpressionContainer(value)) {
         if (value.expression.type === 'JSXEmptyExpression') {
             return t.booleanLiteral(true);
         }
@@ -95,23 +94,101 @@ export function getAttributeValue(value) {
  * @param ctx - 转换上下文
  * @returns 对象属性或方法节点
  */
-export function createProperty(key, value, ctx) {
+export function createProperty(key, // 属性名称，字符串类型
+value, // 属性值表达式，使用 t.Expression 类型表示
+ctx // 转换上下文，包含转换过程中的相关信息
+) {
+    // 返回类型为对象属性或对象方法
+    // 创建属性名的字面量节点
     const keyNode = t.stringLiteral(key);
-    if (isStringLiteral(value) || isNumericLiteral(value) || isBooleanLiteral(value)) {
+    // 如果是静态值，直接创建对象属性
+    if (isStaticValue(value)) {
         return t.objectProperty(keyNode, value);
     }
-    if (isIdentifier(value)) {
-        if (ctx.refVariables.has(value.name)) {
-            return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(t.memberExpression(value, t.identifier('value')))]));
-        }
-        if (key === 'children') {
+    // 如果是标识符（变量名）
+    if (t.isIdentifier(value)) {
+        // 特殊处理 children 属性或不在 refVariables 中的变量
+        if (key === 'children' || ctx.nonRefVariables.has(value.name)) {
             return t.objectProperty(keyNode, value);
         }
-        markImport(ctx, 'unref');
-        const unrefAlias = getAlias(ctx.vitarxAliases, 'unref');
-        return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))]));
+        // 如果是 ref 变量，创建 getter 方法返回 ref 的 value
+        if (ctx.refVariables.has(value.name)) {
+            return createGetter(keyNode, t.returnStatement(t.memberExpression(value, t.identifier('value'))));
+        }
+        // 其他标识符属性创建 unref getter
+        return createUnrefGetter(keyNode, value, ctx);
+    }
+    // 如果是成员表达式（如 obj.property）
+    if (t.isMemberExpression(value)) {
+        return createUnrefGetter(keyNode, value, ctx);
     }
-    return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(value)]));
+    // 如果是调用表达式（如 function()）
+    if (t.isCallExpression(value)) {
+        return createUnrefGetter(keyNode, value, ctx);
+    }
+    // 默认情况，创建 getter 方法返回值
+    return createGetter(keyNode, t.returnStatement(value));
+}
+/**
+ * 判断给定的表达式是否为静态值
+ * 静态值指的是那些可以在编译时确定值，不会在运行时改变的表达式
+ * @param value - 要检查的AST表达式节点
+ * @returns 如果是静态值返回true，否则返回false
+ */
+function isStaticValue(value) {
+    // 使用switch语句检查表达式的类型
+    switch (value.type) {
+        // 字符串字面量是静态值
+        case 'StringLiteral':
+        // 数字字面量是静态值
+        case 'NumericLiteral':
+        // 布尔字面量是静态值
+        case 'BooleanLiteral':
+        // null字面量是静态值
+        case 'NullLiteral':
+        // 箭头函数表达式是静态值
+        case 'ArrowFunctionExpression':
+        // 函数表达式是静态值
+        case 'FunctionExpression':
+        // 对象表达式是静态值
+        case 'ObjectExpression':
+        // 数组表达式是静态值
+        case 'ArrayExpression':
+            return true;
+        // 其他类型的表达式都不是静态值
+        default:
+            return false;
+    }
+}
+/**
+ * 创建一个getter方法
+ * @param keyNode - 属性键的字符串字面量节点
+ * @param statement - getter方法体中的语句
+ * @returns 返回一个ObjectMethod类型的AST节点，表示一个getter方法
+ */
+function createGetter(keyNode, statement) {
+    // 使用objectMethod方法创建一个getter方法
+    // 参数分别为: 方法类型('get')、属性键、参数数组(空数组)、方法体(包含传入的语句)
+    return t.objectMethod('get', keyNode, [], t.blockStatement([statement]));
+}
+/**
+ * 创建一个getter方法，该方法会对返回值进行unref处理
+ * @param keyNode - 对象的键节点，是一个字符串字面量
+ * @param value - 需要进行unref处理的值表达式
+ * @param ctx - 转换上下文对象，包含转换所需的各种信息和工具函数
+ * @returns 返回一个ObjectMethod类型的AST节点，表示一个getter方法
+ */
+function createUnrefGetter(keyNode, // 对象的键，使用字符串字面量表示
+value, // 需要进行unref处理的值表达式
+ctx // 转换上下文，包含转换所需的各种信息和工具函数
+) {
+    // 返回一个对象方法类型的AST节点
+    markImport(ctx, 'unref'); // 标记需要导入unref函数
+    const unrefAlias = getAlias(ctx.vitarxAliases, 'unref'); // 获取unref函数的别名
+    return createGetter(
+    // 创建并返回一个getter方法
+    keyNode, t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value])) // 返回对value进行unref处理后的结果
+    );
 }
 /**
  * 处理单个 JSX 属性
@@ -152,6 +229,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');
 }