@vitarx/plugin-vite 0.0.1-beta.7 → 1.0.0-beta.0

package/dist/passes/hmr/inject.js

@@ -5,133 +5,28 @@
  */
 import * as t from '@babel/types';
 import { HMR } from '../../constants/index.js';
-import { collectPatternBindings } from '../../utils/index.js';
-/** getComponentView 的内部别名，避免与用户代码冲突 */
-const GET_COMPONENT_VIEW_ALIAS = '__$VITARX_GET_COMPONENT_VIEW$__';
-/**
- * 注入 HMR 客户端导入
- * @param program - AST Program 节点
- */
-function injectHMRImport(program) {
-    const importDecl = t.importDeclaration([t.importDefaultSpecifier(t.identifier(HMR.manager))], t.stringLiteral('@vitarx/vite-plugin/hmr-client'));
-    program.body.unshift(importDecl);
-}
-/**
- * 注入 getComponentView 导入
- * 使用唯一的别名避免与用户代码冲突
- * @param program - AST Program 节点
- */
-function injectGetComponentViewImport(program) {
-    // 创建独立的 import 语句，使用不会冲突的别名
-    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(GET_COMPONENT_VIEW_ALIAS), t.identifier('getComponentView'))], t.stringLiteral('vitarx'));
-    program.body.unshift(importDecl);
-}
-/**
- * 创建组件函数体内的 HMR 注册代码
- * @param variableNames - 需要追踪的变量名列表
- * @returns HMR 注册语句数组
- */
-function createHMRRegistrationStatements(variableNames) {
-    const statements = [];
-    // 声明并获取当前视图实例
-    statements.push(t.variableDeclaration('const', [
-        t.variableDeclarator(t.identifier(HMR.view), t.callExpression(t.identifier(GET_COMPONENT_VIEW_ALIAS), []))
-    ]));
-    // 注册到 HMR 管理器
-    statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view)])));
-    // 创建状态追踪对象
-    const stateProperties = variableNames.map(name => t.objectMethod('get', t.identifier(name), [], t.blockStatement([t.returnStatement(t.identifier(name))])));
-    // 异步设置状态
-    statements.push(t.expressionStatement(t.logicalExpression('&&', t.identifier(HMR.view), t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('resolve')), []), t.identifier('then')), [
-        t.arrowFunctionExpression([], t.blockStatement([
-            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(HMR.view), t.identifier(HMR.state)), t.objectExpression(stateProperties)))
-        ]))
-    ]))));
-    return statements;
-}
-/**
- * 从函数体中收集局部变量名
- * @param functionBody - 函数体语句块
- * @returns 变量名数组
- */
-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);
-                }
-            }
-        }
-    }
-    return Array.from(variableNames);
-}
-/**
- * 判断表达式是否为函数类型
- * 包括：箭头函数、函数表达式、类表达式
- */
-function isFunctionExpression(expr) {
-    if (!expr)
-        return false;
-    return (expr.type === 'ArrowFunctionExpression' ||
-        expr.type === 'FunctionExpression' ||
-        expr.type === 'ClassExpression');
-}
-/**
- * 创建状态恢复表达式
- * 格式：__$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, '变量名') ?? 原始初始值
- */
-function createMemoExpression(variableName, originalInit) {
-    return t.logicalExpression('??', t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('memo')), [t.identifier(HMR.view), t.stringLiteral(variableName)]), originalInit);
-}
-/**
- * 为单个变量声明注入状态恢复代码
- * 仅处理标识符类型的变量声明，且初始值不是函数
- */
-function injectStatePreservationForDeclaration(decl) {
-    // 只处理标识符类型的变量声明
-    if (decl.id.type !== 'Identifier')
-        return;
-    // 没有初始值，不需要处理
-    if (!decl.init)
-        return;
-    // 初始值是函数，不需要状态恢复
-    if (isFunctionExpression(decl.init))
-        return;
-    // 注入状态恢复代码
-    decl.init = createMemoExpression(decl.id.name, decl.init);
-}
-/**
- * 为函数体内的变量声明注入状态恢复代码
- */
-function injectStatePreservation(functionBody) {
-    for (const stmt of functionBody.body) {
-        if (stmt.type === 'VariableDeclaration') {
-            for (const decl of stmt.declarations) {
-                injectStatePreservationForDeclaration(decl);
-            }
-        }
-    }
-}
+import { injectHMRImport, injectGetComponentViewImport } from './inject-imports.js';
+import { createHMRRegistrationStatements, createWrappedComponentHMRStatements, collectLocalVariableNames, injectStatePreservation } from './inject-state.js';
 /**
  * 为组件函数注入 HMR 注册代码
  * @param func - 函数声明/表达式/箭头函数
  * @param variableNames - 需要追踪的变量名列表
+ * @param isWrapped - 是否为包装组件
+ * @param componentName - 组件名称（包装组件需要）
  */
-function injectHMRIntoFunction(func, variableNames) {
-    // 处理箭头函数没有函数体的情况（表达式体）
+function injectHMRIntoFunction(func, variableNames, isWrapped = false, componentName) {
     if (func.type === 'ArrowFunctionExpression' && func.body.type !== 'BlockStatement') {
-        // 将表达式体转换为块语句
         const returnStmt = t.returnStatement(func.body);
         func.body = t.blockStatement([returnStmt]);
     }
     if (!func.body || func.body.type !== 'BlockStatement')
         return;
-    // 注入状态恢复代码
-    injectStatePreservation(func.body);
-    // 注入 HMR 注册代码
-    const statements = createHMRRegistrationStatements(variableNames);
+    if (!isWrapped) {
+        injectStatePreservation(func.body);
+    }
+    const statements = isWrapped
+        ? createWrappedComponentHMRStatements(componentName)
+        : createHMRRegistrationStatements(variableNames);
     func.body.body.unshift(...statements);
 }
 /**
@@ -171,19 +66,14 @@ function generateComponentId(filename, componentName) {
 export function injectHMRSupport(program, components, filename) {
     if (components.length === 0)
         return;
-    // 注入必要的导入
     injectHMRImport(program);
     injectGetComponentViewImport(program);
-    // 为每个组件函数注入 HMR 代码
-    for (const { node } of components) {
-        // 收集局部变量名（如果有函数体）
+    for (const { node, isWrapped, name } of components) {
         const variableNames = node.body?.type === 'BlockStatement' ? collectLocalVariableNames(node.body) : [];
-        injectHMRIntoFunction(node, variableNames);
+        injectHMRIntoFunction(node, variableNames, isWrapped, name);
     }
-    // 为每个组件绑定 ID
     for (const { name } of components) {
         program.body.push(createBindIdStatement(name, generateComponentId(filename, name)));
     }
-    // 注入 import.meta.hot.accept
     program.body.push(createHotAcceptStatement());
 }

package/dist/passes/imports/injectImports.js

@@ -13,8 +13,8 @@ const API_IMPORT_CONFIG = [
     { name: 'createView', importKey: 'createView' },
     { name: 'Fragment', importKey: 'Fragment' },
     { name: 'branch', importKey: 'branch' },
-    { name: 'dynamic', importKey: 'dynamic' },
-    { name: 'access', importKey: 'access' },
+    { name: 'expr', importKey: 'expr' },
+    { name: 'accessor', importKey: 'accessor' },
     { name: 'withDirectives', importKey: 'withDirectives' },
     { name: 'unref', importKey: 'unref' },
     { name: 'isRef', importKey: 'isRef' }

package/dist/passes/jsx/processChildren.js

@@ -4,25 +4,28 @@
  * @module passes/jsx/processChildren
  */
 import * as t from '@babel/types';
-import { isBooleanLiteral, isConditionalExpression, isIdentifier, isJSXElement, isJSXExpressionContainer, isJSXFragment, isJSXText, isLogicalExpression, isMemberExpression, isNumericLiteral, isStringLiteral } from '@babel/types';
+import { isBinaryExpression, isConditionalExpression, isIdentifier, isJSXElement, isJSXExpressionContainer, isJSXFragment, isJSXText, isLogicalExpression, isMemberExpression } from '@babel/types';
 import { markImport } from '../../context.js';
-import { addPureComment, createAccessCall, createBinaryBranch, createDynamicCall, getAlias, getDevLocInfo } from '../../utils/index.js';
+import { addPureComment, createAccessorCall, createBinaryBranch, createExprCall, getAlias } from '../../utils/index.js';
 /**
- * 处理成员表达式
+ * 处理成员表达式，生成 accessor 调用
  */
 function handleMemberExpression(expr, ctx) {
-    markImport(ctx, 'access');
-    const accessAlias = getAlias(ctx.vitarxAliases, 'access');
-    return createAccessCall(expr.object, expr.property, accessAlias);
+    markImport(ctx, 'accessor');
+    const accessorAlias = getAlias(ctx.vitarxAliases, 'accessor');
+    return createAccessorCall(expr.object, expr.property, accessorAlias);
 }
 /**
- * 处理逻辑表达式
+ * 使用 expr 包装表达式
+ * 用于逻辑表达式、二元表达式和调用表达式的统一包装
+ * 运行时根据返回值类型决定是否跟踪响应式：
+ * - 数组返回值：原样返回（仅渲染一次）
+ * - 其他返回值：创建 DynamicView 追踪
  */
-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));
+function wrapWithExpr(expr, ctx) {
+    markImport(ctx, 'expr');
+    const exprAlias = getAlias(ctx.vitarxAliases, 'expr');
+    return addPureComment(createExprCall(expr, exprAlias), ctx);
 }
 /**
  * 处理子节点数组
@@ -42,59 +45,40 @@ export function processChildren(children, ctx) {
 }
 /**
  * 处理单个子节点
+ * JSX 容器节点在此拆包后委托给 processChildExpression 处理
+ * 已转换的 API 调用（createView/branch 等 CallExpression）直接透传
  */
 function processChildNode(node, ctx) {
-    // JSX 文本
     if (isJSXText(node)) {
         const trimmed = node.value.trim();
         if (!trimmed)
             return null;
         return t.stringLiteral(trimmed);
     }
-    // JSX 表达式容器
     if (isJSXExpressionContainer(node)) {
         if (node.expression.type === 'JSXEmptyExpression')
             return null;
-        return processChildExpression(node.expression, ctx, node.loc);
+        return processChildExpression(node.expression, ctx);
     }
-    // JSX 展开子元素
     if (node.type === 'JSXSpreadChild') {
-        return processChildExpression(node.expression, ctx, node.loc);
+        return processChildExpression(node.expression, ctx);
     }
-    // JSX 元素或片段
     if (isJSXElement(node) || isJSXFragment(node)) {
         return node;
     }
-    // 字面量
-    if (isStringLiteral(node) || isNumericLiteral(node) || isBooleanLiteral(node)) {
-        return node;
-    }
-    // 标识符
-    if (isIdentifier(node)) {
-        return node;
-    }
-    // 成员表达式
-    if (isMemberExpression(node)) {
-        return handleMemberExpression(node, ctx);
-    }
-    // 条件表达式
-    if (isConditionalExpression(node)) {
-        return processConditionalExpression(node, ctx);
-    }
-    // 逻辑表达式
-    if (isLogicalExpression(node)) {
-        return handleLogicalExpression(node, ctx);
-    }
-    // 调用表达式
+    // 已转换的 API 调用（createView/branch 等）直接透传，不包装 expr
     if (node.type === 'CallExpression') {
         return node;
     }
-    return node;
+    // 其他表达式类型委托给 processChildExpression
+    return processChildExpression(node, ctx);
 }
 /**
- * 处理子表达式
+ * 处理子表达式（来自 JSX 表达式容器或条件分支）
+ * 根据表达式类型生成对应的运行时 API 调用
+ * CallExpression 在此用 expr 包装（用户函数调用需要响应式追踪）
  */
-function processChildExpression(expr, ctx, loc) {
+function processChildExpression(expr, ctx) {
     if (isIdentifier(expr)) {
         return expr;
     }
@@ -104,22 +88,17 @@ function processChildExpression(expr, ctx, loc) {
     if (isConditionalExpression(expr)) {
         return processConditionalExpression(expr, ctx);
     }
-    if (isLogicalExpression(expr)) {
-        return handleLogicalExpression(expr, ctx, loc);
+    if (isLogicalExpression(expr) || isBinaryExpression(expr) || expr.type === 'CallExpression') {
+        return wrapWithExpr(expr, ctx);
     }
     return expr;
 }
 /**
- * 处理条件表达式
- * 转换为 branch 调用
+ * 处理条件表达式，转换为 branch 调用
  */
 function processConditionalExpression(node, ctx) {
     const { test, consequent, alternate } = node;
-    // 处理分支
     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, locInfo);
+    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, getAlias, getDevLocInfo, getDirectiveValue, getJSXAttributeByName, getJSXElementName, hasEffectiveChildren, filterEffectiveChildren, isNativeElement, isVElse, isVIf, isVIfChain, removeVIfChainDirectives } from '../../utils/index.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 { processProps } from '../props/index.js';
 import { processChildren } from './processChildren.js';
@@ -87,7 +87,7 @@ export function transformJSXElement(node, ctx, handleVIf = false) {
         viewCall = processDirectives(viewCall, directives, ctx);
     }
     else {
-        viewCall = addPureComment(viewCall);
+        viewCall = addPureComment(viewCall, ctx);
     }
     if (node.loc) {
         viewCall.loc = node.loc;
@@ -146,10 +146,7 @@ function transformSingleVIf(node, ctx) {
     const transformedNode = transformJSXElement(node, ctx, false);
     if (!transformedNode)
         return null;
-    // 获取位置信息（仅开发环境）
-    const locInfo = getDevLocInfo(ctx, node);
-    // 生成 branch 调用
-    const branchCall = createBranch({ conditions: [condition], branches: [createArrowFunction(transformedNode)], locInfo }, ctx);
+    const branchCall = createBranch({ conditions: [condition], branches: [createArrowFunction(transformedNode)] }, 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, filterWhitespaceChildren, getAlias, getDevLocInfo, validateMatchInSwitch } from '../../utils/index.js';
+import { addPureComment, createCreateViewCall, filterWhitespaceChildren, getAlias, getDevLocInfo, validateNoDirectMatchChild } from '../../utils/index.js';
 import { processChildren } from './processChildren.js';
 /**
  * 处理 JSX Fragment
@@ -11,7 +11,7 @@ export function processJSXFragment(path, ctx) {
     // 过滤空白子节点
     const children = filterWhitespaceChildren(node.children);
     // 校验 Match 组件
-    validateMatchInSwitch(children);
+    validateNoDirectMatchChild(children);
     // 标记需要的导入
     ctx.imports.Fragment = true;
     ctx.imports.createView = true;
@@ -20,7 +20,7 @@ export function processJSXFragment(path, ctx) {
     const locInfo = getDevLocInfo(ctx, node);
     // 无子元素
     if (children.length === 0) {
-        const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), null, locInfo, createViewAlias));
+        const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), null, locInfo, createViewAlias), ctx);
         if (node.loc)
             viewCall.loc = node.loc;
         path.replaceWith(viewCall);
@@ -30,7 +30,7 @@ export function processJSXFragment(path, ctx) {
     const processedChildren = processChildren(children, ctx);
     const childrenValue = processedChildren.length === 1 ? processedChildren[0] : t.arrayExpression(processedChildren);
     const props = t.objectExpression([t.objectProperty(t.identifier('children'), childrenValue)]);
-    const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), props, locInfo, createViewAlias));
+    const viewCall = addPureComment(createCreateViewCall(t.identifier(fragmentAlias), props, locInfo, createViewAlias), ctx);
     if (node.loc)
         viewCall.loc = node.loc;
     path.replaceWith(viewCall);

package/dist/passes/props/index.js

@@ -5,16 +5,9 @@
  */
 import * as t from '@babel/types';
 import { createError } from '../../error.js';
-import { isNativeElement } from '../../utils/index.js';
+import { getJSXElementName, isNativeElement } from '../../utils/index.js';
 import { createProperty, getAttributeValue, processAttribute, processSpreadAttribute } from './attribute.js';
 import { createVModelProps, extractVModelState } from './vmodel.js';
-/**
- * 获取 JSX 元素的名称
- */
-function getJSXElementName(node) {
-    const nameNode = node.openingElement.name;
-    return nameNode.type === 'JSXIdentifier' ? nameNode.name : null;
-}
 /**
  * 校验 class 和 className 不能同时存在
  */

package/dist/transform.d.ts

@@ -4,16 +4,13 @@
  * @module transform
  */
 import { type GeneratorResult } from '@babel/generator';
+import type { CompileOptions } from './types.js';
 export interface TransformResult extends GeneratorResult {
 }
-export interface CompileOptions {
-    hmr: boolean;
-    dev: boolean;
-    ssr: boolean;
-    runtimeModule: string;
-    sourceMap: boolean | 'inline' | 'both';
-    transformClassNameToClass: boolean;
-}
+/**
+ * 检查文件是否需要转换
+ */
+export declare function shouldTransform(id: string): boolean;
 /**
  * 转换 JSX/TSX 代码
  */

package/dist/transform.js

@@ -9,15 +9,6 @@ import traverse from '@babel/traverse';
 import { createContext } from './context.js';
 import { collectExistingImports, collectLocalBindings, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
 import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, isPureCompileComponent } from './utils/index.js';
-/** 用于追踪已处理的节点 */
-const processedNodes = new WeakSet();
-/**
- * 检查文件是否需要转换
- */
-function shouldTransform(id) {
-    const ext = id.split('?')[0].split('.').pop()?.toLowerCase();
-    return ext === 'jsx' || ext === 'tsx';
-}
 /**
  * 创建解析器选项
  */
@@ -49,8 +40,8 @@ function setupAliases(ctx, program) {
         'createView',
         'Fragment',
         'branch',
-        'dynamic',
-        'access',
+        'expr',
+        'accessor',
         'withDirectives',
         'unref',
         'isRef'
@@ -66,6 +57,9 @@ function setupAliases(ctx, program) {
     if (ctx.options.hmr) {
         ctx.vitarxAliases.createView = generateUniqueAlias('jsxDEV', allNames);
     }
+    if (vitarxImports.has('builder')) {
+        ctx.builderAlias = vitarxImports.get('builder');
+    }
 }
 /**
  * 收集 ref 相关信息
@@ -83,21 +77,21 @@ function transformAST(ast, ctx) {
     babelTraverse(ast, {
         JSXElement: {
             enter(path) {
-                if (processedNodes.has(path.node))
+                if (ctx.processedNodes.has(path.node))
                     return;
                 const name = getJSXElementName(path.node);
                 if (name && isPureCompileComponent(name)) {
-                    processedNodes.add(path.node);
+                    ctx.processedNodes.add(path.node);
                     processPureCompileComponent(path, ctx);
                 }
             },
             exit(path) {
-                if (processedNodes.has(path.node))
+                if (ctx.processedNodes.has(path.node))
                     return;
                 const name = getJSXElementName(path.node);
                 if (name && isPureCompileComponent(name))
                     return;
-                processedNodes.add(path.node);
+                ctx.processedNodes.add(path.node);
                 processJSXElement(path, ctx);
             }
         },
@@ -106,9 +100,9 @@ function transformAST(ast, ctx) {
                 processVIfChain(path, ctx, transformJSXElement);
             },
             exit(path) {
-                if (processedNodes.has(path.node))
+                if (ctx.processedNodes.has(path.node))
                     return;
-                processedNodes.add(path.node);
+                ctx.processedNodes.add(path.node);
                 processJSXFragment(path, ctx);
             }
         }
@@ -122,17 +116,22 @@ function generateCode(ast, code, id, sourceMap) {
     const output = babelGenerate(ast, { sourceMaps: !!sourceMap, filename: id, sourceFileName: id }, code);
     return { code: output.code, map: output.map };
 }
+/**
+ * 检查文件是否需要转换
+ */
+export function shouldTransform(id) {
+    const ext = id.split('?')[0].split('.').pop()?.toLowerCase();
+    return ext === 'jsx' || ext === 'tsx';
+}
 /**
  * 转换 JSX/TSX 代码
  */
 export async function transform(code, id, options) {
-    if (!shouldTransform(id))
-        return null;
     const ast = parse(code, createParserOptions());
     const ctx = createContext(code, id, options, ast);
     setupAliases(ctx, ast.program);
     collectRefInfo(ctx, ast.program);
-    const components = collectComponentFunctions(ast.program);
+    const components = collectComponentFunctions(ast.program, ctx.builderAlias);
     transformAST(ast, ctx);
     injectImports(ast.program, ctx);
     if (options.hmr && components.length > 0) {

package/dist/types.d.ts

@@ -1,4 +1,15 @@
 import type { RenderUnit, View } from 'vitarx';
+/**
+ * 编译选项
+ */
+export interface CompileOptions {
+    hmr: boolean;
+    dev: boolean;
+    ssr: boolean;
+    runtimeModule: string;
+    sourceMap: boolean | 'inline' | 'both';
+    transformClassNameToClass: boolean;
+}
 export interface IfBlockProps {
     /**
      * 子元素列表

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

@@ -3,7 +3,8 @@
  * @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 ArrowFunctionExpression, type CallExpression, type Expression, type ObjectExpression } from '@babel/types';
+import type { SourceLocation } from 'acorn';
 import type { TransformContext, VitarxImportAliases } from '../context.js';
 /**
  * 创建 unref 调用
@@ -13,30 +14,28 @@ import type { TransformContext, VitarxImportAliases } from '../context.js';
  */
 export declare function createUnrefCall(argument: Expression, alias?: string): CallExpression;
 /**
- * 创建 access 调用
+ * 创建 accessor 调用
  * @param object - 对象表达式
  * @param key - 键表达式
- * @param alias - access 别名
+ * @param alias - accessor 别名
  * @returns CallExpression
  */
-export declare function createAccessCall(object: Expression, key: Expression, alias?: string): CallExpression;
+export declare function createAccessorCall(object: Expression, key: Expression, alias?: string): CallExpression;
 /**
- * 创建 dynamic 调用
+ * 创建 expr 调用
  * @param argument - 参数表达式
- * @param alias - dynamic 别名
- * @param locInfo - 位置信息对象
+ * @param alias - expr 别名
  * @returns CallExpression
  */
-export declare function createDynamicCall(argument: Expression, alias?: string, locInfo?: ObjectExpression | null): CallExpression;
+export declare function createExprCall(argument: Expression, alias?: string): CallExpression;
 /**
  * 创建 branch 调用
  * @param condition - 条件函数
  * @param branches - 分支函数数组
  * @param alias - branch 别名
- * @param locInfo - 位置信息对象
  * @returns CallExpression
  */
-export declare function createBranchCall(condition: ArrowFunctionExpression, branches: ArrowFunctionExpression[], alias?: string, locInfo?: ObjectExpression | null): CallExpression;
+export declare function createBranchCall(condition: ArrowFunctionExpression, branches: ArrowFunctionExpression[], alias?: string): CallExpression;
 /**
  * 创建 createView 调用
  * @param type - 元素类型
@@ -60,19 +59,13 @@ export declare function createWithDirectivesCall(view: Expression, directives: A
  * @returns ArrowFunctionExpression
  */
 export declare function createArrowFunction(body: Expression): ArrowFunctionExpression;
-/**
- * 创建位置信息对象
- * @param filename - 文件名
- * @param loc - 源码位置
- * @returns ObjectExpression
- */
-export declare function createLocationObject(filename: string, loc: SourceLocation): ObjectExpression;
 /**
  * 为调用表达式添加 @__PURE__ 注释
  * @param node - 调用表达式节点
+ * @param ctx - 转换上下文
  * @returns 添加注释后的节点
  */
-export declare function addPureComment<T extends CallExpression>(node: T): T;
+export declare function addPureComment<T extends CallExpression>(node: T, ctx: TransformContext): T;
 /**
  * 获取 API 别名
  * @param aliases - 别名映射
@@ -80,6 +73,13 @@ export declare function addPureComment<T extends CallExpression>(node: T): T;
  * @returns 别名或原名
  */
 export declare function getAlias(aliases: VitarxImportAliases, name: keyof VitarxImportAliases): string;
+/**
+ * 创建位置信息对象
+ * @param filename - 文件名
+ * @param loc - 源码位置
+ * @returns ObjectExpression
+ */
+export declare function createLocationObject(filename: string, loc: SourceLocation): ObjectExpression;
 /**
  * 获取开发环境下的位置信息对象
  * 仅在开发环境下返回位置信息，生产环境返回 null