@vitarx/plugin-vite 0.0.1-alpha.0 → 0.0.1-alpha.2

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

@@ -0,0 +1,22 @@
+/**
+ * 导入收集模块
+ * 负责收集现有导入信息和本地变量绑定
+ * @module passes/imports/collectImports
+ */
+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>;
+};
+/**
+ * 收集本地变量绑定
+ * 包括导入绑定、变量声明、函数声明、类声明
+ * @param program - AST Program 节点
+ * @returns 本地变量名集合
+ */
+export declare function collectLocalBindings(program: t.Program): Set<string>;

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

@@ -0,0 +1,22 @@
+/**
+ * Ref 变量收集模块
+ * 负责识别 ref API 别名和收集 ref 变量
+ * @module passes/imports/collectRefVariables
+ */
+import * as t from '@babel/types';
+import type { RefApiAliases } from '../../context.js';
+/**
+ * 收集 ref API 的别名
+ * 识别从 vitarx 或 @vitarx/responsive 导入的 ref/toRef/toRefs/shallowRef/computed
+ * @param program - AST Program 节点
+ * @returns ref API 别名映射
+ */
+export declare function collectRefApiAliases(program: t.Program): RefApiAliases;
+/**
+ * 收集通过 ref API 定义的变量
+ * 包括直接赋值和 toRefs 解构
+ * @param program - AST Program 节点
+ * @param refApiAliases - ref API 别名映射
+ * @returns ref 变量名集合
+ */
+export declare function collectRefVariables(program: t.Program, refApiAliases: RefApiAliases): Set<string>;

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

@@ -0,0 +1,7 @@
+/**
+ * 导入处理模块
+ * @module passes/imports
+ */
+export { collectExistingImports, collectLocalBindings } from './collectImports.js';
+export { collectRefApiAliases, collectRefVariables } from './collectRefVariables.js';
+export { injectImports } from './injectImports.js';

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

@@ -0,0 +1,14 @@
+/**
+ * 导入注入模块
+ * 负责动态注入 vitarx 导入语句
+ * @module passes/imports/injectImports
+ */
+import * as t from '@babel/types';
+import type { TransformContext } from '../../context.js';
+/**
+ * 注入 vitarx 导入
+ * 根据已使用的 API 动态生成导入语句
+ * @param program - AST Program 节点
+ * @param ctx - 转换上下文
+ */
+export declare function injectImports(program: t.Program, ctx: TransformContext): void;

package/dist/passes/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 编译转换处理模块
+ * @module passes
+ */
+export { collectExistingImports, collectLocalBindings, 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';
+export { processProps, type PropsResult } from './props/index.js';
+export { injectHMRSupport } from './hmr/index.js';

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

@@ -0,0 +1,7 @@
+/**
+ * JSX 处理模块
+ * @module passes/jsx
+ */
+export { processChildren } from './processChildren.js';
+export { processJSXElement, transformJSXElement } from './processJSXElement.js';
+export { processJSXFragment } from './processJSXFragment.js';

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

@@ -0,0 +1,14 @@
+/**
+ * 子元素处理模块
+ * 处理 JSX 元素的子节点
+ * @module passes/jsx/processChildren
+ */
+import * as t from '@babel/types';
+import { TransformContext } from '../../context.js';
+/**
+ * 处理子节点数组
+ * @param children - 子节点数组
+ * @param ctx - 转换上下文
+ * @returns 处理后的表达式数组
+ */
+export declare function processChildren(children: t.Node[], ctx: TransformContext): t.Expression[];

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

@@ -0,0 +1,22 @@
+/**
+ * JSX 元素处理模块
+ * 将 JSX 元素转换为 createView 调用
+ * @module passes/jsx/processJSXElement
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { TransformContext } from '../../context.js';
+/**
+ * 处理 JSX 元素
+ * @param path - JSX 元素路径
+ * @param ctx - 转换上下文
+ */
+export declare function processJSXElement(path: NodePath<t.JSXElement>, ctx: TransformContext): void;
+/**
+ * 转换 JSX 元素为表达式
+ * @param node - JSX 元素节点
+ * @param ctx - 转换上下文
+ * @param handleVIf - 是否处理 v-if 指令
+ * @returns 转换后的表达式
+ */
+export declare function transformJSXElement(node: t.JSXElement, ctx: TransformContext, handleVIf?: boolean): t.Expression | null;

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

@@ -0,0 +1,14 @@
+/**
+ * JSX Fragment 处理模块
+ * 将 JSX Fragment 转换为 createView(Fragment, ...) 调用
+ * @module passes/jsx/processJSXFragment
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { TransformContext } from '../../context.js';
+/**
+ * 处理 JSX Fragment
+ * @param path - JSX Fragment 路径
+ * @param ctx - 转换上下文
+ */
+export declare function processJSXFragment(path: NodePath<t.JSXFragment>, ctx: TransformContext): void;

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

@@ -0,0 +1,30 @@
+/**
+ * 属性处理模块
+ * 负责处理 JSX 元素的各类属性，包括普通属性、展开属性、命名空间属性等
+ * @module passes/props/attribute
+ */
+import * as t from '@babel/types';
+import { TransformContext } from '../../context.js';
+import type { AttributeResult } from './types.js';
+/**
+ * 处理展开属性 {...props}
+ * 将展开属性转换为 v-bind 特殊属性格式
+ * @param attr - JSX 展开属性节点
+ * @param hasVBind - 是否已存在 v-bind
+ * @param node - JSX 元素节点（用于错误定位）
+ * @returns 转换后的属性对象，或 null（如果已存在 v-bind）
+ * @throws {Error} E001 - 当已存在 v-bind 时抛出
+ */
+export declare function processSpreadAttribute(attr: t.JSXSpreadAttribute, hasVBind: boolean, node: t.JSXElement): {
+    property: t.ObjectProperty;
+    hasVBind: boolean;
+} | null;
+/**
+ * 处理单个 JSX 属性
+ * 根据属性名类型分发到不同的处理逻辑
+ * @param attr - JSX 属性节点
+ * @param existingPropNames - 已存在的属性名集合
+ * @param ctx - 转换上下文
+ * @returns 属性处理结果
+ */
+export declare function processAttribute(attr: t.JSXAttribute, existingPropNames: Set<string>, ctx: TransformContext): AttributeResult;

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

@@ -0,0 +1,40 @@
+/**
+ * Props 处理模块入口
+ * 负责处理 JSX 元素的属性，包括 v-model 特殊指令
+ * @module passes/props
+ */
+import * as t from '@babel/types';
+import { TransformContext } from '../../context.js';
+import type { PropsResult } from './types.js';
+export type { PropsResult, VModelState, AttributeResult } from './types.js';
+/**
+ * 处理 JSX 元素的属性
+ * 将 JSX 属性转换为运行时 props 对象，并提取指令
+ *
+ * 处理流程：
+ * 1. 遍历所有属性，分类处理
+ * 2. 展开属性转换为 v-bind 格式
+ * 3. 普通属性转换为对象属性或 getter
+ * 4. 指令属性提取到 directives Map
+ * 5. v-model 特殊处理，生成 modelValue 和 onUpdate:modelValue
+ *
+ * @param node - JSX 元素节点
+ * @param ctx - 转换上下文
+ * @param hasChildren - 是否有子元素（有子元素时跳过 children 属性）
+ * @returns 处理结果，包含 props 对象、指令映射和 v-bind 标记
+ *
+ * @example
+ * ```tsx
+ * // 输入
+ * <Input v-model={value} placeholder="text" disabled />
+ *
+ * // 输出 props
+ * {
+ *   modelValue: get() { return value.value },
+ *   'onUpdate:modelValue': v => value.value = v,
+ *   placeholder: "text",
+ *   disabled: true
+ * }
+ * ```
+ */
+export declare function processProps(node: t.JSXElement, ctx: TransformContext, hasChildren?: boolean): PropsResult;

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

@@ -0,0 +1,52 @@
+/**
+ * Props 处理模块 - 类型定义
+ * @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, DirectiveInfo>;
+    /** 是否包含 v-bind 展开属性 */
+    hasVBind: boolean;
+}
+/**
+ * v-model 指令状态
+ */
+export interface VModelState {
+    /** 是否存在 v-model 指令 */
+    hasVModel: boolean;
+    /** v-model 绑定的值表达式 */
+    value: t.Expression | null;
+    /** v-model 属性节点，用于错误定位 */
+    node: t.JSXAttribute | null;
+}
+/**
+ * 属性处理结果联合类型
+ * - directive: 指令类型属性
+ * - property: 普通属性
+ */
+export type AttributeResult = {
+    type: 'directive';
+    name: string;
+    value: t.Expression;
+    isVBind: boolean;
+    isVModel: boolean;
+    arg?: string;
+} | {
+    type: 'property';
+    property: t.ObjectProperty | t.ObjectMethod;
+};

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

@@ -0,0 +1,27 @@
+/**
+ * v-model 指令处理模块
+ * 负责处理 JSX 元素的 v-model 双向绑定指令
+ * @module passes/props/vmodel
+ */
+import * as t from '@babel/types';
+import { TransformContext } from '../../context.js';
+import type { VModelState } from './types.js';
+/**
+ * 从属性列表中提取 v-model 状态
+ * @param attributes - JSX 元素属性列表
+ * @returns v-model 状态对象
+ */
+export declare function extractVModelState(attributes: (t.JSXAttribute | t.JSXSpreadAttribute)[]): VModelState;
+/**
+ * 创建 v-model 相关的 props
+ * 生成 modelValue getter 和 onUpdate:modelValue 回调
+ * @param value - v-model 绑定的值表达式
+ * @param attrNode - v-model 属性节点（用于错误定位）
+ * @param existingPropNames - 已存在的属性名集合（用于冲突检测）
+ * @param node - JSX 元素节点
+ * @param ctx - 转换上下文
+ * @returns 包含 modelValue 和 onUpdate:modelValue 的属性数组
+ * @throws {Error} E009 - 当 modelValue 或 onUpdate:modelValue 已存在时
+ * @throws {Error} E010 - 当 v-model 绑定值不是 Identifier 或 MemberExpression 时
+ */
+export declare function createVModelProps(value: t.Expression, attrNode: t.JSXAttribute | null, existingPropNames: Set<string>, node: t.JSXElement, ctx: TransformContext): (t.ObjectMethod | t.ObjectProperty)[];

package/dist/transform.d.ts

@@ -0,0 +1,15 @@
+export interface TransformResult {
+    code: string;
+    map: any;
+}
+export interface CompileOptions {
+    hmr: boolean;
+    dev: boolean;
+    ssr: boolean;
+    runtimeModule: string;
+    sourceMap: boolean | 'inline' | 'both';
+}
+/**
+ * 转换 JSX/TSX 代码
+ */
+export declare function transform(code: string, id: string, options: CompileOptions): Promise<TransformResult | null>;

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

@@ -0,0 +1,75 @@
+import { type ArrowFunctionExpression, type CallExpression, type Expression, type ObjectExpression, type SourceLocation } from '@babel/types';
+import type { VitarxImportAliases } from '../context.js';
+/**
+ * 创建 unref 调用
+ * @param argument - 参数表达式
+ * @param alias - unref 别名
+ * @returns CallExpression
+ */
+export declare function createUnrefCall(argument: Expression, alias?: string): CallExpression;
+/**
+ * 创建 access 调用
+ * @param object - 对象表达式
+ * @param key - 键表达式
+ * @param alias - access 别名
+ * @returns CallExpression
+ */
+export declare function createAccessCall(object: Expression, key: Expression, alias?: string): CallExpression;
+/**
+ * 创建 dynamic 调用
+ * @param argument - 参数表达式
+ * @param alias - dynamic 别名
+ * @returns CallExpression
+ */
+export declare function createDynamicCall(argument: Expression, alias?: string): CallExpression;
+/**
+ * 创建 branch 调用
+ * @param condition - 条件函数
+ * @param branches - 分支函数数组
+ * @param alias - branch 别名
+ * @returns CallExpression
+ */
+export declare function createBranchCall(condition: ArrowFunctionExpression, branches: ArrowFunctionExpression[], alias?: string): CallExpression;
+/**
+ * 创建 createView 调用
+ * @param type - 元素类型
+ * @param props - props 对象
+ * @param locInfo - 位置信息对象
+ * @param alias - createView 别名
+ * @returns CallExpression
+ */
+export declare function createCreateViewCall(type: Expression, props: ObjectExpression | null, locInfo?: ObjectExpression | null, alias?: string): CallExpression;
+/**
+ * 创建 withDirectives 调用
+ * @param view - 视图节点
+ * @param directives - 指令数组，每项为 [指令名, 指令值]
+ * @param alias - withDirectives 别名
+ * @returns CallExpression
+ */
+export declare function createWithDirectivesCall(view: Expression, directives: Array<[string, Expression]>, alias?: string): CallExpression;
+/**
+ * 创建箭头函数
+ * @param body - 函数体表达式
+ * @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 - 调用表达式节点
+ * @returns 添加注释后的节点
+ */
+export declare function addPureComment<T extends CallExpression>(node: T): T;
+/**
+ * 获取 API 别名
+ * @param aliases - 别名映射
+ * @param name - API 名称
+ * @returns 别名或原名
+ */
+export declare function getAlias(aliases: VitarxImportAliases, name: keyof VitarxImportAliases): string;

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

@@ -0,0 +1,12 @@
+/**
+ * AST 类型守卫函数
+ * 用于判断节点类型
+ * @module utils/ast-guards
+ */
+import { type Node } from '@babel/types';
+/**
+ * 判断 JSXText 是否为纯空白文本
+ * @param node - AST 节点
+ * @returns 是否为纯空白文本
+ */
+export declare function isWhitespaceJSXText(node: Node): boolean;

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

@@ -0,0 +1,47 @@
+/**
+ * Branch 调用工厂模块
+ * 统一处理条件分支的生成
+ * @module utils/branch-factory
+ */
+import * as t from '@babel/types';
+import type { TransformContext } from '../context.js';
+/**
+ * 条件分支配置
+ */
+export interface BranchConfig {
+    /** 条件表达式数组 */
+    conditions: t.Expression[];
+    /** 分支函数数组 */
+    branches: t.ArrowFunctionExpression[];
+    /** 是否使用 unref 包装标识符条件 */
+    useRef?: boolean;
+}
+/**
+ * 创建 branch 调用
+ * @param config - 分支配置
+ * @param ctx - 转换上下文
+ * @returns branch 调用表达式
+ */
+export declare function createBranch(config: BranchConfig, ctx: TransformContext): t.CallExpression;
+/**
+ * 构建嵌套条件表达式
+ * 从后向前构建三元表达式链
+ */
+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 - 转换上下文
+ * @returns branch 调用表达式
+ */
+export declare function createBinaryBranch(condition: t.Expression, consequent: t.Expression, alternate: t.Expression, ctx: TransformContext): t.CallExpression;

package/dist/utils/component-collect.d.ts

@@ -0,0 +1,17 @@
+/**
+ * AST 收集模块
+ * 负责收集导入、导出、组件等信息的收集
+ * @module passes/transform/collect
+ */
+import * as t from '@babel/types';
+/**
+ * 组件信息
+ */
+export interface ComponentInfo {
+    name: string;
+    node: t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression;
+}
+/**
+ * 收集模块中的组件函数
+ */
+export declare function collectComponentFunctions(program: t.Program): ComponentInfo[];

package/dist/utils/generate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 生成唯一的别名
+ * 从 $1 开始递增，直到找到不冲突的名称
+ */
+export declare function generateUniqueAlias(baseName: string, existingNames: Set<string>): string;

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+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 { 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';
+export { collectComponentFunctions, type ComponentInfo } from './component-collect.js';
+export { generateUniqueAlias } from './generate.js';

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

@@ -0,0 +1,67 @@
+/**
+ * JSX 相关工具函数
+ * @module utils/jsx-helpers
+ */
+import * as t from '@babel/types';
+import { type Expression, type JSXAttribute, type JSXElement } from '@babel/types';
+/**
+ * 获取 JSX 元素的名称
+ */
+export declare function getJSXElementName(node: JSXElement): string | null;
+/**
+ * 判断名称是否为纯编译组件
+ */
+export declare function isPureCompileComponent(name: string): boolean;
+/**
+ * 判断名称是否为组件（首字母大写）
+ */
+export declare function isComponent(name: string): boolean;
+/**
+ * 判断名称是否为原生元素
+ */
+export declare function isNativeElement(name: string): boolean;
+/**
+ * 根据名称获取 JSX 属性
+ */
+export declare function getJSXAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
+/**
+ * 检查元素是否具有指定指令
+ */
+export declare function hasDirective(node: JSXElement, directiveName: string): boolean;
+/**
+ * 获取指令的值
+ */
+export declare function getDirectiveValue(node: JSXElement, directiveName: string): Expression | null;
+/**
+ * 检查元素是否为 v-if 链的一部分
+ */
+export declare function isVIfChain(node: JSXElement): boolean;
+/**
+ * 检查元素是否有 v-if 指令
+ */
+export declare function isVIf(node: JSXElement): boolean;
+/**
+ * 检查元素是否有 v-else-if 指令
+ */
+export declare function isVElseIf(node: JSXElement): boolean;
+/**
+ * 检查元素是否有 v-else 指令
+ */
+export declare function isVElse(node: JSXElement): boolean;
+/**
+ * 移除元素上所有 v- 开头的指令属性
+ */
+export declare function removeVDirectives(node: JSXElement): void;
+/**
+ * 移除元素上指定名称的属性
+ */
+export declare function removeAttribute(node: JSXElement, attrName: string): void;
+/**
+ * 过滤掉空白文本子节点
+ */
+export declare function filterWhitespaceChildren(children: t.Node[]): t.Node[];
+/**
+ * 校验 Match 组件必须在 Switch 内使用
+ * @param children - 子节点数组
+ */
+export declare function validateMatchInSwitch(children: t.Node[]): void;

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

@@ -0,0 +1,20 @@
+/**
+ * AST 模式处理辅助函数
+ * 用于处理解构模式、绑定模式等
+ * @module utils/pattern-helpers
+ */
+import type { LVal, ObjectPattern } from '@babel/types';
+/**
+ * 从绑定模式中收集变量名
+ * 支持标识符、对象模式、数组模式
+ * @param pattern - 绑定模式
+ * @param variables - 变量名集合
+ */
+export declare function collectPatternBindings(pattern: LVal, variables: Set<string>): void;
+/**
+ * 从对象解构模式中收集变量名
+ * 专门用于 toRefs 解构场景
+ * @param pattern - 对象模式
+ * @param variables - 变量名集合
+ */
+export declare function collectObjectPatternBindings(pattern: ObjectPattern, variables: Set<string>): void;