@vitarx/plugin-vite 1.0.5 → 1.0.7

package/dist/passes/hmr/inject-state.js

@@ -5,7 +5,6 @@
  */
 import * as t from '@babel/types';
 import { HMR } from '../../constants/index.js';
-import { collectPatternBindings } from '../../utils/index.js';
 import { GET_COMPONENT_VIEW_ALIAS } from './inject-imports.js';
 /**
  * 创建组件函数体内的 HMR 注册代码
@@ -25,15 +24,13 @@ export function createHMRRegistrationStatements(variableNames) {
     statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view)])));
     // 构建状态对象的 getter 属性，延迟求值避免不必要的计算
     const stateProperties = variableNames.map(name => t.objectMethod('get', t.identifier(name), [], t.blockStatement([t.returnStatement(t.identifier(name))])));
-    // 语句3: __$VITARX_HMR_VIEW_NODE$__ && Promise.resolve().then(() => {
-    //   __$VITARX_HMR_VIEW_NODE$__.__$vitarx_hmr_state$__ = { get 变量名() { return 变量名 } }
-    // })
-    // 异步保存状态到视图节点，确保 DOM 更新完成后再保存
-    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)))
-        ]))
-    ]))));
+    // 语句3: __$VITARX_HMR_VIEW_NODE$__ && __$VITARX_HMR$__.instance.trackState(
+    //   __$VITARX_HMR_VIEW_NODE$__,
+    //   { get 变量名() { return 变量名 } }
+    // )
+    // 惰性登记状态 getter：只在热更新时由管理器读取快照写入视图，
+    // 正常「卸载→重挂载」不会写入状态，memo 永远不命中，避免旧状态泄漏
+    statements.push(t.expressionStatement(t.logicalExpression('&&', t.identifier(HMR.view), t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('trackState')), [t.identifier(HMR.view), t.objectExpression(stateProperties)]))));
     return statements;
 }
 /**
@@ -54,90 +51,10 @@ export function createWrappedComponentHMRStatements(componentName) {
     statements.push(t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('register')), [t.identifier(HMR.view), t.identifier(componentName)])));
     return statements;
 }
-/**
- * 从函数体中收集局部变量名
- * 递归遍历函数体中的所有变量声明，用于状态恢复
- * @param functionBody - 函数体语句块
- * @returns 变量名数组
- */
-export function collectLocalVariableNames(functionBody) {
-    const variableNames = new Set();
-    forEachVariableDeclarator(functionBody, decl => {
-        if (decl.id.type !== 'VoidPattern') {
-            collectPatternBindings(decl.id, variableNames);
-        }
-    });
-    return Array.from(variableNames);
-}
-/**
- * 遍历语句块中的所有变量声明，对每个 VariableDeclarator 执行回调
- * 递归处理嵌套的控制流语句（if/for/while/switch/try 等）
- * @param block - 语句块节点
- * @param visitor - 变量声明访问者回调
- */
-function forEachVariableDeclarator(block, visitor) {
-    for (const stmt of block.body) {
-        traverseStatementForDeclarators(stmt, visitor);
-    }
-}
-/**
- * 从单个语句中递归查找变量声明并执行回调
- * 支持多种语句类型：变量声明、条件语句、循环语句、switch、try-catch 等
- * @param stmt - 语句节点
- * @param visitor - 变量声明访问者回调
- */
-function traverseStatementForDeclarators(stmt, visitor) {
-    if (stmt.type === 'VariableDeclaration') {
-        for (const decl of stmt.declarations) {
-            visitor(decl);
-        }
-    }
-    else if (stmt.type === 'IfStatement') {
-        traverseBodyForDeclarators(stmt.consequent, visitor);
-        if (stmt.alternate) {
-            traverseBodyForDeclarators(stmt.alternate, visitor);
-        }
-    }
-    else if (stmt.type === 'ForStatement' || stmt.type === 'WhileStatement' || stmt.type === 'DoWhileStatement') {
-        traverseBodyForDeclarators(stmt.body, visitor);
-    }
-    else if (stmt.type === 'ForInStatement' || stmt.type === 'ForOfStatement') {
-        traverseBodyForDeclarators(stmt.body, visitor);
-    }
-    else if (stmt.type === 'BlockStatement') {
-        forEachVariableDeclarator(stmt, visitor);
-    }
-    else if (stmt.type === 'SwitchStatement') {
-        for (const c of stmt.cases) {
-            for (const s of c.consequent) {
-                traverseStatementForDeclarators(s, visitor);
-            }
-        }
-    }
-    else if (stmt.type === 'TryStatement') {
-        forEachVariableDeclarator(stmt.block, visitor);
-        if (stmt.handler) {
-            forEachVariableDeclarator(stmt.handler.body, visitor);
-        }
-        if (stmt.finalizer) {
-            forEachVariableDeclarator(stmt.finalizer, visitor);
-        }
-    }
-}
-/**
- * 遍历语句体（可能是 BlockStatement 或单条语句）中的变量声明
- */
-function traverseBodyForDeclarators(body, visitor) {
-    if (body.type === 'BlockStatement') {
-        forEachVariableDeclarator(body, visitor);
-    }
-    else {
-        traverseStatementForDeclarators(body, visitor);
-    }
-}
 /**
  * 判断表达式是否为函数类型
- * 函数类型不需要状态恢复（函数定义本身不会改变）
+ * 函数类型不需要状态恢复（函数定义本身不会改变）；且快照读取 getter 会
+ * 拿到函数值，一旦被误调用将执行组件内的业务函数
  * @param expr - 表达式节点
  * @returns 是否为函数类型
  */
@@ -149,44 +66,152 @@ function isFunctionExpression(expr) {
         expr.type === 'ClassExpression' // 类表达式
     );
 }
+/**
+ * 判断是否为 useModel 调用
+ *
+ * useModel 返回的 ModelRef 是父组件状态的双向桥接（派生视图）而非独立
+ * 状态：其内部以 flush:'sync' 的 watch 同步 props→镜像，该 watch 绑定在
+ * 执行时的作用域上。若被 memo 复用，旧 watch 会随旧作用域销毁，表现为
+ * props→镜像同步断裂（v-model 显示残留）。因此每次执行都重建 ModelRef
+ * ——镜像从当前 props 重新初始化，语义正确。
+ * @param expr - 表达式节点
+ * @returns 是否为 useModel 调用
+ */
+function isUseModelCall(expr) {
+    return (!!expr &&
+        expr.type === 'CallExpression' &&
+        expr.callee.type === 'Identifier' &&
+        expr.callee.name === 'useModel');
+}
 /**
  * 创建状态恢复表达式
- * 格式：__$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, '变量名') ?? 原始初始值
- * 如果 memo 方法返回保存的状态则使用，否则使用原始初始值
+ * 格式：__$VITARX_HMR$__.instance.memo(view, '变量名') ?? 原始初始值
  * @param variableName - 变量名
- * @param originalInit - 原始初始化表达式
+ * @param originalInit - 原始初始值表达式
+ * @param raw - 是否绕过响应式门禁（memoRaw）：解构声明的隐藏变量保存的是
+ *   composable 返回的普通对象（内含 Ref 与函数），memo 的门禁会拒收，
+ *   必须走无条件恢复
  * @returns 状态恢复表达式
  */
-function createMemoExpression(variableName, originalInit) {
+function createMemoExpression(variableName, originalInit, raw = false) {
     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 // 原始初始值作为 fallback
+    t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier(raw ? 'memoRaw' : 'memo')), [t.identifier(HMR.view), t.stringLiteral(variableName)]), originalInit // 原始初始值作为 fallback
     );
 }
 /**
- * 为单个变量声明注入状态恢复代码
- * 将 const x = value 转换为 const x = memo(view, 'x') ?? value
- * @param decl - 变量声明节点
- */
-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);
-}
-/**
- * 为函数体内的变量声明注入状态恢复代码
- * 递归遍历所有变量声明（包括 if/for/while/switch/try 嵌套块）
+ * 为函数体注入状态恢复代码并收集需要登记（trackState）的变量名
+ *
+ * 处理规则：
+ * - 标识符声明（非函数初始值）：初始值包装为 memo(view, '变量名') ?? 原始初始值
+ * - useModel 调用：豁免（桥接状态每次重建，见 isUseModelCall）
+ * - 解构声明（如 `const { a } = useFoo()`）：拆分为隐藏变量整包 memo +
+ *   原声明解构隐藏变量——composable 返回的状态对象得以跨重执行保留，
+ *   其内部创建的响应式状态与已挂载的副作用保持一致
+ * - 函数类型初始值 / 无初始值：不注入
+ * - for 循环头部声明：循环局部绑定，不注入（仅递归循环体）
+ *
+ * 单趟完成注入与收集，返回按执行顺序排列的登记名列表（标识符名 +
+ * 隐藏变量名），供 trackState 生成 getter。隐藏变量采用用户标识符不可能
+ * 命中的 `__$VITARX_D<N>$__` 命名，按组件函数内确定性计数。
  * @param functionBody - 函数体语句块
+ * @returns 需要状态登记的变量名数组
  */
 export function injectStatePreservation(functionBody) {
-    forEachVariableDeclarator(functionBody, decl => {
-        injectStatePreservationForDeclaration(decl);
-    });
+    const trackedNames = [];
+    let destructureCounter = 0;
+    processBlock(functionBody);
+    return trackedNames;
+    /** 处理语句块：注入可能把一条声明拆成多条，需重建语句数组 */
+    function processBlock(block) {
+        const newBody = [];
+        for (const stmt of block.body) {
+            newBody.push(...processStatement(stmt));
+        }
+        block.body = newBody;
+    }
+    /** 处理单条语句，返回替换它的语句列表（1~n 条） */
+    function processStatement(stmt) {
+        if (stmt.type === 'VariableDeclaration') {
+            return processVariableDeclaration(stmt);
+        }
+        if (stmt.type === 'IfStatement') {
+            stmt.consequent = wrapBody(stmt.consequent);
+            if (stmt.alternate)
+                stmt.alternate = wrapBody(stmt.alternate);
+        }
+        else if (stmt.type === 'ForStatement' ||
+            stmt.type === 'WhileStatement' ||
+            stmt.type === 'DoWhileStatement') {
+            // for 头部声明是循环局部绑定不注入；仅递归循环体
+            stmt.body = wrapBody(stmt.body);
+        }
+        else if (stmt.type === 'ForInStatement' || stmt.type === 'ForOfStatement') {
+            // 同上：for-of/for-in 的 left 绑定按迭代取值，不做状态保留
+            stmt.body = wrapBody(stmt.body);
+        }
+        else if (stmt.type === 'BlockStatement') {
+            processBlock(stmt);
+        }
+        else if (stmt.type === 'SwitchStatement') {
+            for (const switchCase of stmt.cases) {
+                switchCase.consequent = processStatementList(switchCase.consequent);
+            }
+        }
+        else if (stmt.type === 'TryStatement') {
+            processBlock(stmt.block);
+            if (stmt.handler)
+                processBlock(stmt.handler.body);
+            if (stmt.finalizer)
+                processBlock(stmt.finalizer);
+        }
+        return [stmt];
+    }
+    function processStatementList(list) {
+        const results = [];
+        for (const stmt of list) {
+            results.push(...processStatement(stmt));
+        }
+        return results;
+    }
+    /** 语句体若因注入产生多条语句，需要块化包装保持语法合法 */
+    function wrapBody(body) {
+        if (body.type === 'BlockStatement') {
+            processBlock(body);
+            return body;
+        }
+        const results = processStatement(body);
+        return results.length === 1 ? results[0] : t.blockStatement(results);
+    }
+    /** 逐 declarator 处理变量声明（多 declarator 时拆分为多条声明） */
+    function processVariableDeclaration(stmt) {
+        const results = [];
+        for (const decl of stmt.declarations) {
+            const init = decl.init ?? null;
+            // 无初始值 / VoidPattern / 函数初始值：原样保留
+            if (decl.id.type === 'VoidPattern' || !init || isFunctionExpression(init)) {
+                results.push(t.variableDeclaration(stmt.kind, [decl]));
+                continue;
+            }
+            if (decl.id.type === 'Identifier') {
+                if (isUseModelCall(init)) {
+                    // 桥接状态豁免：不 memo、不登记（见 isUseModelCall 注释）
+                    results.push(t.variableDeclaration(stmt.kind, [decl]));
+                    continue;
+                }
+                trackedNames.push(decl.id.name);
+                decl.init = createMemoExpression(decl.id.name, init);
+                results.push(t.variableDeclaration(stmt.kind, [decl]));
+                continue;
+            }
+            // 解构声明：隐藏变量整包 memo（raw 恢复）+ 原声明解构隐藏变量
+            const hiddenName = `__$VITARX_D${destructureCounter++}$__`;
+            trackedNames.push(hiddenName);
+            results.push(t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier(hiddenName), createMemoExpression(hiddenName, init, true))
+            ]), t.variableDeclaration(stmt.kind, [
+                t.variableDeclarator(decl.id, t.identifier(hiddenName))
+            ]));
+        }
+        return results;
+    }
 }

package/dist/passes/hmr/inject.d.ts

@@ -13,3 +13,13 @@ import type { ComponentInfo } from '../../utils/index.js';
  * @param filename - 文件名（用于生成组件唯一 ID）
  */
 export declare function injectHMRSupport(program: t.Program, components: ComponentInfo[], filename: string): void;
+/**
+ * 为「导入转发组件默认导出」的模块注入 accept-only HMR 支持
+ *
+ * 典型场景：文件路由的 _layout 转发文件（export default AdminLayout）。
+ * 模块本身不含组件函数定义，无需 bindId 与函数体注入（函数体属于
+ * 源模块，其自身已有完整 HMR）；仅需自接受模块更新并把新导出交给
+ * HMRManager.update 按组件 id 热替换。
+ * @param program - AST Program 节点
+ */
+export declare function injectHMRAcceptOnly(program: t.Program): void;

package/dist/passes/hmr/inject.js

@@ -6,15 +6,14 @@
 import * as t from '@babel/types';
 import { HMR } from '../../constants/index.js';
 import { injectHMRImport, injectGetComponentViewImport } from './inject-imports.js';
-import { createHMRRegistrationStatements, createWrappedComponentHMRStatements, collectLocalVariableNames, injectStatePreservation } from './inject-state.js';
+import { createHMRRegistrationStatements, createWrappedComponentHMRStatements, injectStatePreservation } from './inject-state.js';
 /**
  * 为组件函数注入 HMR 注册代码
  * @param func - 函数声明/表达式/箭头函数
- * @param variableNames - 需要追踪的变量名列表
  * @param isWrapped - 是否为包装组件（defineComponent/builder）
  * @param componentName - 组件名称（包装组件需要）
  */
-function injectHMRIntoFunction(func, variableNames, isWrapped = false, componentName) {
+function injectHMRIntoFunction(func, isWrapped = false, componentName) {
     // 如果是箭头函数且函数体不是块语句（单行箭头函数），转换为块语句
     if (func.type === 'ArrowFunctionExpression' && func.body.type !== 'BlockStatement') {
         const returnStmt = t.returnStatement(func.body);
@@ -23,10 +22,8 @@ function injectHMRIntoFunction(func, variableNames, isWrapped = false, component
     // 确保函数体是块语句
     if (!func.body || func.body.type !== 'BlockStatement')
         return;
-    // 非包装组件需要注入状态恢复代码
-    if (!isWrapped) {
-        injectStatePreservation(func.body);
-    }
+    // 非包装组件：注入状态恢复代码并收集登记名（单趟完成）
+    const variableNames = isWrapped ? [] : injectStatePreservation(func.body);
     // 根据组件类型创建对应的 HMR 注册语句
     const statements = isWrapped
         ? createWrappedComponentHMRStatements(componentName)
@@ -58,6 +55,35 @@ function createHotAcceptStatement() {
         ]))
     ]));
 }
+/**
+ * 创建导入转发模块的 hot.accept 语句（带 invalidate 兜底）
+ *
+ * 生成：import.meta.hot.accept(mod => {
+ *   if (!__$VITARX_HMR$__.instance.update(mod)) {
+ *     import.meta.hot.invalidate('[VitarxHMR]: ...')
+ *   }
+ * })
+ *
+ * 转发模块本身不含组件定义，update 的返回值表示新模块导出中是否
+ * 含已绑定 HMR id 的组件——为 false 说明转发目标不可识别（如换成
+ * 未转换模块的组件），必须 invalidate 整页刷新，避免界面静默 stale。
+ *
+ * 已知边界：转发目标在两个均有 HMR id 的组件间切换（export default A
+ * 改为 export default B）时，update 只登记 B 的 id 并返回 true，不会
+ * invalidate，挂在旧 id A 名下的视图不会被更新——文件路由场景由
+ * vitarx-router 虚拟路由模块自身的 hot accept 重建路由树兜底；非路由
+ * 场景需手动刷新。此为接受的降级路径，不做运行时检测。
+ * @returns hot.accept 调用语句
+ */
+function createForwardingHotAcceptStatement() {
+    return t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier('import'), t.identifier('meta')), t.identifier('hot')), t.identifier('accept')), [
+        t.arrowFunctionExpression([t.identifier('mod')], t.blockStatement([
+            t.ifStatement(t.unaryExpression('!', t.callExpression(t.memberExpression(t.memberExpression(t.identifier(HMR.manager), t.identifier('instance')), t.identifier('update')), [t.identifier('mod')])), t.blockStatement([
+                t.expressionStatement(t.callExpression(t.memberExpression(t.memberExpression(t.memberExpression(t.identifier('import'), t.identifier('meta')), t.identifier('hot')), t.identifier('invalidate')), [t.stringLiteral('[VitarxHMR]: 转发的默认导出不是可热更新的组件，回退整页刷新')]))
+            ]))
+        ]))
+    ]));
+}
 /**
  * 生成组件唯一 ID（文件路径 + 组件名称）
  * 使用 FNV-1a 哈希算法生成短哈希值
@@ -92,9 +118,7 @@ export function injectHMRSupport(program, components, filename) {
     injectGetComponentViewImport(program);
     // 步骤2: 为每个组件函数注入 HMR 注册代码和状态恢复
     for (const { node, isWrapped, name } of components) {
-        // 收集函数体内的局部变量名（用于状态保存）
-        const variableNames = node.body?.type === 'BlockStatement' ? collectLocalVariableNames(node.body) : [];
-        injectHMRIntoFunction(node, variableNames, isWrapped, name);
+        injectHMRIntoFunction(node, isWrapped, name);
     }
     // 步骤3: 为每个组件创建 bindId 语句（用于热更新时识别）
     for (const { name } of components) {
@@ -103,3 +127,16 @@ export function injectHMRSupport(program, components, filename) {
     // 步骤4: 创建 import.meta.hot.accept 语句（监听热更新事件）
     program.body.push(createHotAcceptStatement());
 }
+/**
+ * 为「导入转发组件默认导出」的模块注入 accept-only HMR 支持
+ *
+ * 典型场景：文件路由的 _layout 转发文件（export default AdminLayout）。
+ * 模块本身不含组件函数定义，无需 bindId 与函数体注入（函数体属于
+ * 源模块，其自身已有完整 HMR）；仅需自接受模块更新并把新导出交给
+ * HMRManager.update 按组件 id 热替换。
+ * @param program - AST Program 节点
+ */
+export function injectHMRAcceptOnly(program) {
+    injectHMRImport(program);
+    program.body.push(createForwardingHotAcceptStatement());
+}

package/dist/passes/index.d.ts

@@ -7,4 +7,4 @@ export { processPureCompileComponent, processSwitch, processIfBlock } from './co
 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';
+export { injectHMRSupport, injectHMRAcceptOnly } from './hmr/index.js';

package/dist/passes/index.js

@@ -13,4 +13,4 @@ export { processChildren, processJSXElement, transformJSXElement, processJSXFrag
 // Props 处理
 export { processProps } from './props/index.js';
 // HMR 注入
-export { injectHMRSupport } from './hmr/index.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './hmr/index.js';

package/dist/passes/jsx/processChildren.js

@@ -9,11 +9,18 @@ import { markImport } from '../../context.js';
 import { addPureComment, createAccessorCall, createBinaryBranch, createExprCall, getAlias } from '../../utils/index.js';
 /**
  * 处理成员表达式
- * object 为简单标识符时使用 accessor（细粒度追踪）
- * object 为其他表达式（嵌套成员访问等）时降级为 expr（粗粒度追踪）
+ * 静态成员（obj.prop，computed=false）时使用 accessor（细粒度追踪），
+ * property 标识符即属性名，字符串化后作为 key；
+ * 计算成员（obj[keyExpr]，computed=true）时降级为 expr（粗粒度追踪）——
+ * accessor(obj, key) 的 key 在构建期一次求值，无法追踪 key 本身的变化，
+ * 且 key 为标识符时若误字符串化会读成 obj.key 改变语义（读取不存在的属性
+ * 渲染为空），必须保留动态求值语义。
  */
 function handleMemberExpression(expr, ctx) {
-    if (isIdentifier(expr.object)) {
+    // key 静态（obj.prop 或 obj['prop']）才可 accessor：字符串字面量 key 原样
+    // 透传即为正确的静态 key；标识符（非计算成员）即属性名，由 accessor 构建器字符串化
+    const isStaticKey = !expr.computed || t.isStringLiteral(expr.property);
+    if (isStaticKey && isIdentifier(expr.object)) {
         markImport(ctx, 'accessor');
         const accessorAlias = getAlias(ctx.vitarxAliases, 'accessor');
         return createAccessorCall(expr.object, expr.property, accessorAlias);

package/dist/transform.js

@@ -7,8 +7,8 @@ import generate from '@babel/generator';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import { createContext } from './context.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';
+import { collectExistingImports, collectLocalBindings, collectNonRefVariables, collectRefApiAliases, collectRefVariables, injectHMRSupport, injectHMRAcceptOnly, injectImports, processJSXElement, processJSXFragment, processPureCompileComponent, processVIfChain, transformJSXElement } from './passes/index.js';
+import { collectComponentFunctions, generateUniqueAlias, getJSXElementName, hasForwardedComponentDefaultExport, isPureCompileComponent } from './utils/index.js';
 const entryPatterns = [/\/src\/main\.(tsx|jsx)$/, /\\src\\main\.(tsx|jsx)$/];
 /**
  * 创建解析器选项
@@ -152,8 +152,15 @@ export async function transform(code, id, options) {
     ctx.nonRefVariables = collectNonRefVariables(ast.program);
     transformAST(ast, ctx);
     injectImports(ast.program, ctx);
-    if (options.hmr && components.length > 0 && !isEntryFile(id)) {
-        injectHMRSupport(ast.program, components, id);
+    if (options.hmr && !isEntryFile(id)) {
+        if (components.length > 0) {
+            injectHMRSupport(ast.program, components, id);
+        }
+        else if (hasForwardedComponentDefaultExport(ast.program)) {
+            // 导入转发组件默认导出的模块（如 _layout 转发文件）：无本地组件定义，
+            // 注入 accept-only 自接受，避免编辑时回落整页刷新
+            injectHMRAcceptOnly(ast.program);
+        }
     }
     return generateCode(ast, code, id, options.sourceMap);
 }

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

@@ -5,4 +5,5 @@ export { collectPatternBindings, collectObjectPatternBindings } from './pattern-
 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 { hasForwardedComponentDefaultExport } from './forward-export.js';
 export { generateUniqueAlias, generateUniqueDefaultName } from './generate.js';

package/dist/utils/index.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, generateUniqueDefaultName } from './generate.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitarx/plugin-vite",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "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.6"
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "vitest run && rimraf dist && tsc -p tsconfig.build.json",