@vitarx/plugin-vite 1.0.4 → 1.0.6

package/dist/utils/forward-export.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 导入转发默认导出检测
+ *
+ * 识别「纯转发组件默认导出」的模块——典型场景是文件路由的 _layout 布局
+ * 转发文件（`export default AdminLayout` / `export { AdminLayout as default }`，
+ * AdminLayout 为 import 绑定）。此类模块本身不含组件函数定义，组件收集
+ * 结果为空，此前不会注入任何 HMR 代码，编辑该文件时 Vite 找不到自接受
+ * 边界而回落整页刷新。
+ *
+ * 注意只匹配组件形态（大写开头）的导入绑定：转发普通值（工具函数、常量）
+ * 的模块不具备组件热更新能力，保持整页刷新的默认行为。
+ * @module utils/forward-export
+ */
+import * as t from '@babel/types';
+/**
+ * 检测模块是否存在「导入转发形式的组件默认导出」
+ *
+ * 覆盖两种转发形态（转发目标均为本地 import 绑定且大写开头）：
+ * 1. `export default AdminLayout`（含 `as T` 断言包装）
+ * 2. `export { AdminLayout as default }`
+ *
+ * 带 source 的 re-export（`export { X as default } from './x'`）没有本地
+ * 绑定，不在导入绑定集合中，天然被排除。
+ *
+ * @param program - AST Program 节点
+ * @returns 是否存在转发形式的组件默认导出
+ */
+export declare function hasForwardedComponentDefaultExport(program: t.Program): boolean;

package/dist/utils/forward-export.js

@@ -0,0 +1,76 @@
+import { isValidComponentName } from './component-collect.js';
+/**
+ * 收集模块内所有本地 import 绑定名称
+ * @param program - AST Program 节点
+ * @returns 导入绑定名称集合
+ */
+function collectImportedBindingNames(program) {
+    const importedBindings = new Set();
+    for (const node of program.body) {
+        if (node.type !== 'ImportDeclaration')
+            continue;
+        for (const spec of node.specifiers) {
+            importedBindings.add(spec.local.name);
+        }
+    }
+    return importedBindings;
+}
+/**
+ * 解包 TS 类型包装表达式
+ *
+ * `export default X as T` 在 babel TS 插件下解析为 TSAsExpression
+ * （还有 satisfies / 非空断言变体），解包到真实表达式后再判定。
+ * @param node - 默认导出声明表达式
+ * @returns 解包后的表达式
+ */
+function unwrapTsWrappers(node) {
+    while (node.type === 'TSAsExpression' ||
+        node.type === 'TSSatisfiesExpression' ||
+        node.type === 'TSNonNullExpression') {
+        node = node.expression;
+    }
+    return node;
+}
+/**
+ * 检测模块是否存在「导入转发形式的组件默认导出」
+ *
+ * 覆盖两种转发形态（转发目标均为本地 import 绑定且大写开头）：
+ * 1. `export default AdminLayout`（含 `as T` 断言包装）
+ * 2. `export { AdminLayout as default }`
+ *
+ * 带 source 的 re-export（`export { X as default } from './x'`）没有本地
+ * 绑定，不在导入绑定集合中，天然被排除。
+ *
+ * @param program - AST Program 节点
+ * @returns 是否存在转发形式的组件默认导出
+ */
+export function hasForwardedComponentDefaultExport(program) {
+    const importedBindings = collectImportedBindingNames(program);
+    if (importedBindings.size === 0)
+        return false;
+    for (const node of program.body) {
+        // 形态1：export default X
+        if (node.type === 'ExportDefaultDeclaration') {
+            const decl = unwrapTsWrappers(node.declaration);
+            if (decl.type === 'Identifier') {
+                const name = decl.name;
+                if (importedBindings.has(name) && isValidComponentName(name))
+                    return true;
+            }
+        }
+        // 形态2：export { X as default }
+        if (node.type === 'ExportNamedDeclaration') {
+            for (const spec of node.specifiers) {
+                if (spec.type === 'ExportSpecifier' &&
+                    spec.exported.type === 'Identifier' &&
+                    spec.exported.name === 'default' &&
+                    spec.local.type === 'Identifier' &&
+                    importedBindings.has(spec.local.name) &&
+                    isValidComponentName(spec.local.name)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}

package/dist/utils/function-extract.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 函数提取模块
+ * 从调用表达式中提取匿名函数，转换为命名函数声明
+ * @module utils/function-extract
+ */
+import * as t from '@babel/types';
+/**
+ * 将函数表达式或箭头函数转换为命名函数声明
+ * 用于将匿名函数转换为可追踪的命名函数
+ * @param func - 函数表达式或箭头函数节点
+ * @param name - 生成的函数名称
+ * @returns 命名函数声明节点
+ */
+export declare function convertToNamedFunctionDeclaration(func: t.FunctionExpression | t.ArrowFunctionExpression, name: string): t.FunctionDeclaration;
+/**
+ * 从调用表达式中提取函数参数
+ * 将 export default builder(()=><div/>) 转换为：
+ * const _defaultExport = ()=><div/>
+ * export default builder(_defaultExport)
+ * @param callExpr - 调用表达式
+ * @param exportedNames - 已存在的名称集合
+ * @param builderAlias - builder 的本地别名
+ * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
+ */
+export declare function extractFunctionFromCallExpression(callExpr: t.CallExpression, exportedNames: Set<string>, builderAlias: string | null): {
+    name: string;
+    funcNode: t.FunctionDeclaration;
+    isBuilderWrapped: boolean;
+} | null;
+/**
+ * 从变量声明的调用表达式中提取函数
+ * 将 const App = builder(() => <div/>) 转换为：
+ * function App$1() { return <div/> }
+ * const App = builder(App$1)
+ * @param callExpr - 调用表达式
+ * @param variableName - 变量名（作为内部函数名的基础）
+ * @param allBindingNames - 所有绑定名称集合（用于避免命名冲突）
+ * @param builderAlias - builder 的本地别名
+ * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
+ */
+export declare function extractFunctionFromVariableInit(callExpr: t.CallExpression, variableName: string, allBindingNames: Set<string>, builderAlias: string | null): {
+    name: string;
+    funcNode: t.FunctionDeclaration;
+    isBuilderWrapped: boolean;
+} | null;

package/dist/utils/function-extract.js

@@ -0,0 +1,98 @@
+/**
+ * 函数提取模块
+ * 从调用表达式中提取匿名函数，转换为命名函数声明
+ * @module utils/function-extract
+ */
+import * as t from '@babel/types';
+import { isBuilderCall } from './collect-names.js';
+import { generateUniqueAlias, generateUniqueDefaultName } from './generate.js';
+/**
+ * 将函数表达式或箭头函数转换为命名函数声明
+ * 用于将匿名函数转换为可追踪的命名函数
+ * @param func - 函数表达式或箭头函数节点
+ * @param name - 生成的函数名称
+ * @returns 命名函数声明节点
+ */
+export function convertToNamedFunctionDeclaration(func, name) {
+    let body;
+    // 处理箭头函数的隐式返回：将表达式体包装为显式 return 语句
+    if (func.type === 'ArrowFunctionExpression' && func.body.type !== 'BlockStatement') {
+        body = t.blockStatement([t.returnStatement(func.body)]);
+    }
+    else {
+        body = func.body;
+    }
+    // 创建函数声明节点
+    const funcDecl = t.functionDeclaration(t.identifier(name), // 函数名称
+    func.params, // 参数列表
+    body, // 函数体
+    func.type === 'FunctionExpression' ? func.generator : false, // 是否为生成器
+    func.async // 是否为异步函数
+    );
+    // 保留原始位置信息用于源码映射
+    funcDecl.loc = func.loc;
+    return funcDecl;
+}
+/**
+ * 从调用表达式中提取函数参数
+ * 将 export default builder(()=><div/>) 转换为：
+ * const _defaultExport = ()=><div/>
+ * export default builder(_defaultExport)
+ * @param callExpr - 调用表达式
+ * @param exportedNames - 已存在的名称集合
+ * @param builderAlias - builder 的本地别名
+ * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
+ */
+export function extractFunctionFromCallExpression(callExpr, exportedNames, builderAlias) {
+    // 判断是否为 builder 函数调用
+    const isBuilder = isBuilderCall(callExpr, builderAlias);
+    // 遍历调用表达式的所有参数
+    for (let i = 0; i < callExpr.arguments.length; i++) {
+        const arg = callExpr.arguments[i];
+        // 找到作为参数传入的匿名函数
+        if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
+            // 生成唯一名称
+            const name = generateUniqueDefaultName(exportedNames);
+            // 转换为命名函数声明
+            const funcNode = convertToNamedFunctionDeclaration(arg, name);
+            // 将原参数替换为标识符引用
+            callExpr.arguments[i] = t.identifier(name);
+            return { name, funcNode, isBuilderWrapped: isBuilder };
+        }
+    }
+    // 未找到可提取的函数参数
+    return null;
+}
+/**
+ * 从变量声明的调用表达式中提取函数
+ * 将 const App = builder(() => <div/>) 转换为：
+ * function App$1() { return <div/> }
+ * const App = builder(App$1)
+ * @param callExpr - 调用表达式
+ * @param variableName - 变量名（作为内部函数名的基础）
+ * @param allBindingNames - 所有绑定名称集合（用于避免命名冲突）
+ * @param builderAlias - builder 的本地别名
+ * @returns 提取结果，包含名称、函数声明节点和是否是 builder 包装
+ */
+export function extractFunctionFromVariableInit(callExpr, variableName, allBindingNames, builderAlias) {
+    // 判断是否为 builder 函数调用
+    const isBuilder = isBuilderCall(callExpr, builderAlias);
+    // 遍历调用表达式的所有参数
+    for (let i = 0; i < callExpr.arguments.length; i++) {
+        const arg = callExpr.arguments[i];
+        // 找到作为参数传入的匿名函数
+        if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
+            // 以变量名为基础生成唯一别名，避免与已有名称冲突
+            const name = generateUniqueAlias(variableName, allBindingNames);
+            // 将新名称加入集合，防止后续生成重复名称
+            allBindingNames.add(name);
+            // 转换为命名函数声明
+            const funcNode = convertToNamedFunctionDeclaration(arg, name);
+            // 将原参数替换为标识符引用
+            callExpr.arguments[i] = t.identifier(name);
+            return { name, funcNode, isBuilderWrapped: isBuilder };
+        }
+    }
+    // 未找到可提取的函数参数
+    return null;
+}

package/dist/utils/generate.d.ts

@@ -6,3 +6,10 @@
  * @returns 唯一的别名
  */
 export declare function generateUniqueAlias(baseName: string, existingNames: Set<string>): string;
+/**
+ * 生成唯一的默认导出组件名称
+ * 优先使用基础名称，若冲突则生成唯一别名
+ * @param existingNames - 已存在的名称集合
+ * @returns 唯一的默认导出名称
+ */
+export declare function generateUniqueDefaultName(existingNames: Set<string>): string;

package/dist/utils/generate.js

@@ -1,3 +1,9 @@
+/**
+ * 名称生成工具模块
+ * 提供唯一别名和默认导出名称的生成功能
+ * @module utils/generate
+ */
+import { DEFAULT_EXPORT_BASE_NAME } from '../constants/index.js';
 /**
  * 生成唯一的别名
  * 从 $1 开始递增，直到找到不冲突的名称
@@ -13,3 +19,17 @@ export function generateUniqueAlias(baseName, existingNames) {
     }
     return `${baseName}$${index}`;
 }
+/**
+ * 生成唯一的默认导出组件名称
+ * 优先使用基础名称，若冲突则生成唯一别名
+ * @param existingNames - 已存在的名称集合
+ * @returns 唯一的默认导出名称
+ */
+export function generateUniqueDefaultName(existingNames) {
+    // 如果默认名称未被占用，直接返回
+    if (!existingNames.has(DEFAULT_EXPORT_BASE_NAME)) {
+        return DEFAULT_EXPORT_BASE_NAME;
+    }
+    // 否则生成唯一别名
+    return generateUniqueAlias(DEFAULT_EXPORT_BASE_NAME, existingNames);
+}

package/dist/utils/index.d.ts

@@ -1,8 +1,9 @@
 export { isWhitespaceJSXText, isJSXComment } from './ast-guards.js';
-export { getJSXElementName, resolveJSXElementType, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateNoDirectMatchChild } from './jsx-helpers.js';
+export { getJSXElementName, resolveJSXElementType, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren } from './jsx-helpers.js';
 export { createUnrefCall, createAccessorCall, createExprCall, 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';
 export { collectComponentFunctions, type ComponentInfo } from './component-collect.js';
-export { generateUniqueAlias } from './generate.js';
+export { hasForwardedComponentDefaultExport } from './forward-export.js';
+export { generateUniqueAlias, generateUniqueDefaultName } from './generate.js';

package/dist/utils/index.js

@@ -1,7 +1,7 @@
 // 类型守卫
 export { isWhitespaceJSXText, isJSXComment } from './ast-guards.js';
 // JSX 辅助函数
-export { getJSXElementName, resolveJSXElementType, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren, validateNoDirectMatchChild } from './jsx-helpers.js';
+export { getJSXElementName, resolveJSXElementType, isPureCompileComponent, isComponent, isNativeElement, getJSXAttributeByName, hasDirective, getDirectiveValue, isVIfChain, isVIf, isVElseIf, isVElse, removeVDirectives, removeVIfChainDirectives, removeAttribute, filterWhitespaceChildren, hasEffectiveChildren, filterEffectiveChildren } from './jsx-helpers.js';
 // AST 构建函数
 export { createUnrefCall, createAccessorCall, createExprCall, createBranchCall, createCreateViewCall, createWithDirectivesCall, createArrowFunction, createLocationObject, addPureComment, getAlias, getDevLocInfo } from './ast-builders.js';
 // 模式处理辅助函数
@@ -12,5 +12,7 @@ export { createBranch, createBinaryBranch, buildNestedCondition } from './branch
 export { validateVIfChain, collectVIfChainInfo, collectFragmentVIfChains } from './vif-helpers.js';
 // 组件收集
 export { collectComponentFunctions } from './component-collect.js';
+// 导入转发默认导出检测
+export { hasForwardedComponentDefaultExport } from './forward-export.js';
 // 生成器
-export { generateUniqueAlias } from './generate.js';
+export { generateUniqueAlias, generateUniqueDefaultName } from './generate.js';

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

@@ -101,8 +101,5 @@ export declare function hasEffectiveChildren(node: JSXElement): boolean;
  */
 export declare function filterEffectiveChildren(node: JSXElement): t.Node[];
 /**
- * 校验子节点中不能直接包含 Match 组件
- * Match 必须在 Switch 内使用，非 Switch 元素的子节点中不允许出现 Match
- * @param children - 子节点数组
+ * 过滤掉空白文本子节点
  */
-export declare function validateNoDirectMatchChild(children: t.Node[]): void;

package/dist/utils/jsx-helpers.js

@@ -4,9 +4,8 @@
  * @module utils/jsx-helpers
  */
 import * as t from '@babel/types';
-import { isJSXElement, isJSXText } from '@babel/types';
+import { isJSXText } from '@babel/types';
 import { DIRECTIVE_PREFIX, PURE_COMPILE_COMPONENTS, V_IF_CHAIN_DIRECTIVES } from '../constants/index.js';
-import { createError } from '../error.js';
 import { isWhitespaceJSXText } from './ast-guards.js';
 /**
  * 获取 JSX 元素的名称
@@ -253,17 +252,5 @@ export function filterEffectiveChildren(node) {
     return node.children.filter(isEffectiveChild);
 }
 /**
- * 校验子节点中不能直接包含 Match 组件
- * Match 必须在 Switch 内使用，非 Switch 元素的子节点中不允许出现 Match
- * @param children - 子节点数组
+ * 过滤掉空白文本子节点
  */
-export function validateNoDirectMatchChild(children) {
-    for (const child of children) {
-        if (isJSXElement(child)) {
-            const childName = getJSXElementName(child);
-            if (childName === 'Match') {
-                throw createError('E012', child);
-            }
-        }
-    }
-}

package/dist/utils/vif-helpers.js

@@ -125,7 +125,9 @@ export function collectFragmentVIfChains(children) {
  */
 function collectSingleChainFromFragment(children, startIndex) {
     const nodes = [children[startIndex]];
-    const conditions = [getDirectiveValue(nodes[0], 'v-if')];
+    // v-if 指令值已由 validateVIfChain 保证存在，fallback 为 true（无表达式时）
+    const vIfValue = getDirectiveValue(nodes[0], 'v-if') ?? t.booleanLiteral(true);
+    const conditions = [vIfValue];
     let j = startIndex + 1;
     // 继续收集后续的 v-else-if 和 v-else
     while (j < children.length) {
@@ -147,9 +149,10 @@ function collectSingleChainFromFragment(children, startIndex) {
         if (!isVIfChain(nextChild))
             break;
         if (isVElseIf(nextChild)) {
-            // 收集 v-else-if
+            // 收集 v-else-if，值已由 validateVIfChain 保证存在
             nodes.push(nextChild);
-            conditions.push(getDirectiveValue(nextChild, 'v-else-if'));
+            const vElseIfValue = getDirectiveValue(nextChild, 'v-else-if') ?? t.booleanLiteral(true);
+            conditions.push(vElseIfValue);
             j++;
         }
         else if (isVElse(nextChild)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitarx/plugin-vite",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "The official plugin for Vitarx support in Vite.",
   "author": "ZhuChongLin <8210856@qq.com>",
   "license": "MIT",
@@ -47,7 +47,6 @@
     "acorn-walk": "^8.3.5"
   },
   "devDependencies": {
-    "typescript": "^6.0.3",
     "@commitlint/cli": "^20.4.2",
     "@commitlint/config-conventional": "^20.4.2",
     "@commitlint/types": "^20.4.0",
@@ -55,13 +54,15 @@
     "@types/babel__generator": "^7.27.0",
     "@types/babel__traverse": "^7.28.0",
     "@types/node": "^25.3.2",
+    "happy-dom": "^20.14.5",
     "husky": "^9.1.7",
     "node": "^25.7.0",
     "prettier": "^3.8.1",
     "rimraf": "^6.1.3",
-    "vitest": "^4.0.18",
+    "typescript": "^6.0.3",
+    "vitarx": "^4.0.6",
     "vite": "^8.0.5",
-    "vitarx": "^4.0.0"
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "vitest run && rimraf dist && tsc -p tsconfig.build.json",

package/dist/hmr-client/utils.d.ts

@@ -1,23 +0,0 @@
-/**
- * 代码变更类型
- */
-export interface ChangeCode {
-    /** UI 描述代码是否变化（需要重新构建视图） */
-    build: boolean;
-    /** 非 UI 代码是否变化（需要完全重新挂载） */
-    logic: boolean;
-}
-/**
- * 判断两个函数组件的代码差异
- *
- * 分析策略：
- * 1. 解析函数代码，提取所有 createView/branch/expr 等 UI API 调用
- * 2. 将这些调用识别为 UI 描述代码
- * 3. 其余代码识别为非 UI 代码（逻辑代码）
- * 4. 分别比较 UI 代码和非 UI 代码是否变化
- *
- * @param newCode 新函数代码
- * @param oldCode 旧函数代码
- * @returns {ChangeCode} 变更检测结果
- */
-export declare function diffComponentChange(newCode: string, oldCode: string): ChangeCode;

package/dist/hmr-client/utils.js

@@ -1,137 +0,0 @@
-/**
- * HMR 代码变更检测工具
- * 用于判断组件代码中 UI 描述部分和非 UI 部分的变更
- * @module hmr-client/utils
- */
-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([...UI_API_NAMES, 'jsxDEV', 'h']);
-/**
- * 判断标识符名称是否为 UI API
- * 支持原始名称和带后缀的名称（如 jsxDEV$1、branch$2、expr$1）
- */
-function isUIApi(name) {
-    if (UI_APIS.has(name))
-        return true;
-    for (const api of UI_APIS) {
-        if (name.startsWith(api + '$'))
-            return true;
-    }
-    return false;
-}
-/**
- * 从函数代码中分离 UI 代码和非 UI 代码
- * @param functionCode 完整函数代码
- * @returns 包含逻辑代码和渲染代码的对象
- */
-function separateLogicAndRender(functionCode) {
-    const uiNodes = [];
-    // 包装代码以便解析
-    const wrappedCode = `(${functionCode})`;
-    try {
-        const ast = parse(wrappedCode, {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            allowReturnOutsideFunction: true,
-            allowAwaitOutsideFunction: true,
-            allowImportExportEverywhere: true,
-            allowHashBang: true,
-            allowReserved: true
-        });
-        // 遍历 AST 收集所有 UI API 调用节点
-        walkSimple(ast, {
-            CallExpression(node) {
-                const callee = node.callee;
-                // 直接调用：createView(...)
-                if (callee.type === 'Identifier' && isUIApi(callee.name)) {
-                    uiNodes.push({ start: node.start, end: node.end });
-                    return;
-                }
-                // 成员调用：exports.createView(...)
-                if (callee.type === 'MemberExpression' &&
-                    callee.property.type === 'Identifier' &&
-                    isUIApi(callee.property.name)) {
-                    uiNodes.push({ start: node.start, end: node.end });
-                }
-            }
-        });
-    }
-    catch {
-        // 解析失败时，返回原始代码作为逻辑代码
-        return {
-            logicCode: functionCode.trim(),
-            renderCode: ''
-        };
-    }
-    // 按位置排序，从后向前替换以保持索引正确
-    uiNodes.sort((a, b) => a.start - b.start);
-    const filteredNodes = [];
-    for (const node of uiNodes) {
-        const isContained = filteredNodes.some(parent => node.start >= parent.start && node.end <= parent.end);
-        if (!isContained) {
-            filteredNodes.push(node);
-        }
-    }
-    filteredNodes.sort((a, b) => b.start - a.start);
-    // 提取 UI 代码
-    const renderCode = filteredNodes
-        .map(n => wrappedCode.slice(n.start, n.end))
-        .reverse()
-        .join('\n');
-    // 移除 UI 代码后的逻辑代码
-    let logicCode = wrappedCode;
-    for (const node of filteredNodes) {
-        logicCode = logicCode.slice(0, node.start) + logicCode.slice(node.end);
-    }
-    return {
-        logicCode: logicCode.trim(),
-        renderCode
-    };
-}
-/**
- * 规范化代码字符串
- * 移除多余空白、注释等，用于比较
- */
-function normalizeCode(code) {
-    // 移除多行注释
-    let result = code.replace(/\/\*[\s\S]*?\*\//g, '');
-    // 移除单行注释
-    result = result.replace(/\/\/.*$/gm, '');
-    // 移除多余空白
-    result = result.replace(/\s+/g, ' ');
-    // 移除首尾空白
-    return result.trim();
-}
-/**
- * 判断两个函数组件的代码差异
- *
- * 分析策略：
- * 1. 解析函数代码，提取所有 createView/branch/expr 等 UI API 调用
- * 2. 将这些调用识别为 UI 描述代码
- * 3. 其余代码识别为非 UI 代码（逻辑代码）
- * 4. 分别比较 UI 代码和非 UI 代码是否变化
- *
- * @param newCode 新函数代码
- * @param oldCode 旧函数代码
- * @returns {ChangeCode} 变更检测结果
- */
-export function diffComponentChange(newCode, oldCode) {
-    const { renderCode: newRenderCode, logicCode: newLogicCode } = separateLogicAndRender(newCode);
-    const { renderCode: oldRenderCode, logicCode: oldLogicCode } = separateLogicAndRender(oldCode);
-    // 规范化后比较，避免格式差异导致误判
-    const normalizedNewLogic = normalizeCode(newLogicCode);
-    const normalizedOldLogic = normalizeCode(oldLogicCode);
-    const normalizedNewRender = normalizeCode(newRenderCode);
-    const normalizedOldRender = normalizeCode(oldRenderCode);
-    return {
-        // UI 代码变化：需要重新构建视图
-        build: normalizedNewRender !== normalizedOldRender,
-        // 非 UI 代码变化：需要完全重新挂载组件
-        logic: normalizedNewLogic !== normalizedOldLogic
-    };
-}