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

package/dist/context.d.ts

@@ -78,6 +78,8 @@ export interface TransformContext {
     refApiAliases: RefApiAliases;
     /** ref 变量名集合 */
     refVariables: Set<string>;
+    /** 确定非 ref 的变量名集合（函数声明、箭头函数/函数表达式变量） */
+    nonRefVariables: Set<string>;
     /** builder 函数的本地别名（用于识别纯构建组件） */
     builderAlias: string | null;
     /** 已处理的 AST 节点追踪集合 */

package/dist/context.js

@@ -43,6 +43,7 @@ export function createContext(code, id, options, ast) {
             computed: null
         },
         refVariables: new Set(),
+        nonRefVariables: new Set(),
         builderAlias: null,
         processedNodes: new WeakSet(),
         pureCommentedNodes: new WeakSet(),

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

@@ -85,6 +85,53 @@ function collectRefVariablesFromNode(node, refVariables, refApiLocalNames, toRef
         }
     }
 }
+/**
+ * 收集确定不是 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/props/attribute.d.ts

@@ -39,8 +39,8 @@ export declare function getAttributeValue(value: t.JSXAttribute['value']): t.Exp
  * @param ctx - 转换上下文
  * @returns 对象属性或方法节点
  */
-export declare function createProperty(key: string, // 属性名称字符串
-value: t.Expression, // 属性值的表达式，可以是各种类型的表达式
+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,10 +4,9 @@
  * @module passes/props/attribute
  */
 import * as t from '@babel/types';
-import { isBooleanLiteral, isIdentifier, isJSXExpressionContainer, isMemberExpression, isNumericLiteral, isStringLiteral } from '@babel/types';
 import { markImport } from '../../context.js';
 import { createError } from '../../error.js';
-import { createAccessorCall, getAlias } from '../../utils/index.js';
+import { getAlias } from '../../utils/index.js';
 /**
  * 处理展开属性 {...props}
  * 将展开属性转换为 v-bind 特殊属性格式
@@ -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,46 +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)) {
-        // 检查标识符是否是 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') {
+    // 如果是标识符（变量名）
+    if (t.isIdentifier(value)) {
+        // 特殊处理 children 属性或不在 refVariables 中的变量
+        if (key === 'children' || ctx.nonRefVariables.has(value.name)) {
             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]))]));
+        // 如果是 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);
     }
-    // 如果值是成员表达式，创建 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));
+    // 如果是成员表达式（如 obj.property）
+    if (t.isMemberExpression(value)) {
+        return createUnrefGetter(keyNode, value, ctx);
+    }
+    // 如果是调用表达式（如 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 方法直接返回值
-    return t.objectMethod('get', keyNode, [], t.blockStatement([t.returnStatement(value)]));
+}
+/**
+ * 创建一个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 属性

package/dist/transform.js

@@ -7,7 +7,7 @@ import generate from '@babel/generator';
 import { parse } from '@babel/parser';
 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 { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
 import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, isPureCompileComponent } from './utils/index.js';
 /**
  * 创建解析器选项
@@ -68,6 +68,7 @@ function collectRefInfo(ctx, program) {
     const refApiAliases = collectRefApiAliases(program);
     ctx.refApiAliases = refApiAliases;
     ctx.refVariables = collectRefVariables(program, refApiAliases);
+    ctx.nonRefVariables = collectNonRefVariables(program);
 }
 /**
  * 转换 AST

package/package.json

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