@vitarx/plugin-vite 1.0.4 → 1.0.6

package/dist/constants/index.d.ts

@@ -1,12 +1,3 @@
-/**
- * Vitarx 运行时 API 名称
- * 这些 API 需要从 vitarx 包导入
- */
-/**
- * UI 相关的 API 名称列表
- * 这些 API 用于创建视图，在 HMR 时需要识别
- */
-export declare const UI_API_NAMES: readonly ["createView", "branch", "dynamic", "expr", "accessor", "withDirectives"];
 /**
  * Ref 相关 API 名称
  * 用于识别 ref 变量

package/dist/constants/index.js

@@ -1,12 +1,3 @@
-/**
- * Vitarx 运行时 API 名称
- * 这些 API 需要从 vitarx 包导入
- */
-/**
- * UI 相关的 API 名称列表
- * 这些 API 用于创建视图，在 HMR 时需要识别
- */
-export const UI_API_NAMES = ['createView', 'branch', 'dynamic', 'expr', 'accessor', 'withDirectives'];
 /**
  * Ref 相关 API 名称
  * 用于识别 ref 变量

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

@@ -46,6 +46,17 @@ export default class HMRManager {
      * const state = __$VITARX_HMR$__.instance.memo(__$VITARX_HMR_VIEW_NODE$__, 'state') ?? ref(0)
      */
     memo(view: ComponentView, name: string): any;
+    /**
+     * 无条件恢复状态（不做 Ref/reactive 门禁）
+     *
+     * 供解构声明的隐藏变量使用：composable 返回的控制器是普通对象
+     * （内含 Ref 与函数），memo 的响应式门禁会将其拒收导致恢复永远
+     * 落空。仅限转换器为解构声明生成的代码调用。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {string} name - 变量名称
+     */
+    memoRaw(view: ComponentView, name: string): any;
     /**
      * 注册节点
      *
@@ -59,10 +70,25 @@ export default class HMRManager {
      * @param component - 组件构造函数
      */
     getId(component: Component): string;
+    /**
+     * 登记视图状态 getter
+     *
+     * 由转换器注入的代码在组件函数每次执行时调用，登记当前作用域的
+     * 惰性状态读取器（同一视图重复登记覆盖旧的）。读取动作延迟到
+     * 热更新快照时发生，正常挂载/重挂载不会产生任何状态残留。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {Record<string, () => any>} getters - 变量名到读取器的映射
+     */
+    trackState(view: ComponentView, getters: Record<string, () => any>): void;
     /**
      * 模块更新
      *
      * @param newModule - 新模块对象
+     * @returns 模块导出中是否包含至少一个已绑定 HMR id 的组件。
+     *          供导入转发模块的 accept 回调判断兜底：转发目标若不含
+     *          可识别组件（如换成未转换模块的组件），调用方应
+     *          invalidate 触发整页刷新，避免界面静默 stale。
      */
-    update(newModule: ModuleNamespace): void;
+    update(newModule: ModuleNamespace): boolean;
 }

package/dist/hmr-client/index.js

@@ -3,10 +3,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _HMRManager_idMapToView, _HMRManager_idMapToComponent;
+var _HMRManager_instances, _HMRManager_idMapToView, _HMRManager_idMapToComponent, _HMRManager_viewStateGetters, _HMRManager_snapshotState;
 import { isComponent, isReactive, isRef } from 'vitarx';
 import { HMR } from '../constants/index.js';
 import { processUpdate } from './update.js';
+import { collectLiveViews, registerViewRef } from './weak-refs.js';
 /**
  * HMR管理器
  *
@@ -14,10 +15,18 @@ import { processUpdate } from './update.js';
  */
 class HMRManager {
     constructor() {
+        _HMRManager_instances.add(this);
         /**
          * id模块映射到组件虚拟节点集合
          *
-         * 模块id -> 组件虚拟节点
+         * 模块id -> 组件虚拟节点（WeakRef 弱引用）
+         *
+         * 为什么用 WeakRef：register 在组件每次执行时都会调用，若用强引用，
+         * 已销毁的视图（弹窗关闭、路由切换）会被本 Map 永久钉住造成内存泄漏。
+         * WeakRef 借助 GC 可达性天然区分「Freeze 停用」与「真销毁」——
+         * Freeze 缓存持有视图强引用，停用中的视图不会被回收，热更新照常处理；
+         * 真销毁的视图无引用可回收，deref() 返回空，遍历时剪枝。
+         * 剪枝时机为 register/update 遍历（dev 下高频），泄漏上限极小。
          */
         _HMRManager_idMapToView.set(this, new Map()
         /**
@@ -28,6 +37,20 @@ class HMRManager {
          * id映射到组件构造函数
          */
         _HMRManager_idMapToComponent.set(this, new Map()
+        /**
+         * 视图状态 getter 登记表
+         *
+         * 组件函数每次执行时通过 trackState 登记当前作用域状态的惰性读取器，
+         * 热更新时读取一次生成快照；视图销毁/重挂载不会保留，避免旧状态泄漏。
+         */
+        );
+        /**
+         * 视图状态 getter 登记表
+         *
+         * 组件函数每次执行时通过 trackState 登记当前作用域状态的惰性读取器，
+         * 热更新时读取一次生成快照；视图销毁/重挂载不会保留，避免旧状态泄漏。
+         */
+        _HMRManager_viewStateGetters.set(this, new WeakMap()
         /**
          * 获取单实例
          */
@@ -81,6 +104,21 @@ class HMRManager {
             return undefined;
         return state;
     }
+    /**
+     * 无条件恢复状态（不做 Ref/reactive 门禁）
+     *
+     * 供解构声明的隐藏变量使用：composable 返回的控制器是普通对象
+     * （内含 Ref 与函数），memo 的响应式门禁会将其拒收导致恢复永远
+     * 落空。仅限转换器为解构声明生成的代码调用。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {string} name - 变量名称
+     */
+    memoRaw(view, name) {
+        if (!view)
+            return undefined;
+        return view[HMR.state]?.[name];
+    }
     /**
      * 注册节点
      *
@@ -92,11 +130,12 @@ class HMRManager {
             return;
         component ?? (component = view.component);
         const id = this.getId(component);
-        if (__classPrivateFieldGet(this, _HMRManager_idMapToView, "f").has(id)) {
-            __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id).add(view);
+        const refs = __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id);
+        if (refs) {
+            registerViewRef(refs, view);
         }
         else {
-            __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").set(id, new Set([view]));
+            __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").set(id, new Set([new WeakRef(view)]));
         }
     }
     /**
@@ -107,14 +146,33 @@ class HMRManager {
     getId(component) {
         return Reflect.get(component, HMR.id);
     }
+    /**
+     * 登记视图状态 getter
+     *
+     * 由转换器注入的代码在组件函数每次执行时调用，登记当前作用域的
+     * 惰性状态读取器（同一视图重复登记覆盖旧的）。读取动作延迟到
+     * 热更新快照时发生，正常挂载/重挂载不会产生任何状态残留。
+     *
+     * @param {ComponentView} view - 组件视图
+     * @param {Record<string, () => any>} getters - 变量名到读取器的映射
+     */
+    trackState(view, getters) {
+        if (!view)
+            return;
+        __classPrivateFieldGet(this, _HMRManager_viewStateGetters, "f").set(view, getters);
+    }
     /**
      * 模块更新
      *
      * @param newModule - 新模块对象
+     * @returns 模块导出中是否包含至少一个已绑定 HMR id 的组件。
+     *          供导入转发模块的 accept 回调判断兜底：转发目标若不含
+     *          可识别组件（如换成未转换模块的组件），调用方应
+     *          invalidate 触发整页刷新，避免界面静默 stale。
      */
     update(newModule) {
         if (!newModule)
-            return;
+            return false;
         try {
             const components = [];
             const updatedView = new Set();
@@ -135,23 +193,39 @@ class HMRManager {
             for (const component of components) {
                 const id = this.getId(component);
                 // 模块活跃的虚拟节点集合
-                const views = __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id);
-                if (!views)
+                const refs = __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").get(id);
+                if (!refs)
+                    continue;
+                // 收集存活视图（死引用已剪枝），遍历使其更新
+                const views = collectLiveViews(refs);
+                // 集合清空则移除 Map 条目，避免空壳残留长期积累
+                if (refs.size === 0) {
+                    __classPrivateFieldGet(this, _HMRManager_idMapToView, "f").delete(id);
                     continue;
-                // 遍历关联的所有视图，使其更新
+                }
                 for (const view of views) {
                     // 跳过已更新过的视图，避免同一次更新中同一个视图被更新多次
                     if (updatedView.has(view))
                         continue;
                     // 仅在视图是活跃状态，且已挂载时才更新
                     if (view.isActive && view.isMounted) {
-                        // 处理视图更新
-                        processUpdate(view, this.resolveComponent(view.component));
+                        // 重执行前快照当前状态，使组件函数重执行时 memo 命中、保留状态
+                        __classPrivateFieldGet(this, _HMRManager_instances, "m", _HMRManager_snapshotState).call(this, view);
+                        try {
+                            // 处理视图更新
+                            processUpdate(view, this.resolveComponent(view.component));
+                        }
+                        finally {
+                            // 快照仅服务于本次热更新，用完即清——
+                            // 保证后续正常的「卸载→重挂载」拿到全新状态，与生产行为一致
+                            delete view[HMR.state];
+                        }
                         // 标记视图已更新
                         updatedView.add(view);
                     }
                 }
             }
+            return components.length > 0;
         }
         catch (e) {
             if (import.meta.hot) {
@@ -161,7 +235,29 @@ class HMRManager {
                 throw e;
             }
         }
+        return false;
     }
 }
-_HMRManager_idMapToView = new WeakMap(), _HMRManager_idMapToComponent = new WeakMap();
+_HMRManager_idMapToView = new WeakMap(), _HMRManager_idMapToComponent = new WeakMap(), _HMRManager_viewStateGetters = new WeakMap(), _HMRManager_instances = new WeakSet(), _HMRManager_snapshotState = function _HMRManager_snapshotState(view) {
+    const getters = __classPrivateFieldGet(this, _HMRManager_viewStateGetters, "f").get(view);
+    if (!getters)
+        return;
+    const snapshot = {};
+    for (const name in getters) {
+        try {
+            // 注意：getters 是 getter 属性对象——读取属性即执行 getter 并返回值，
+            // 不能再加调用括号（否则会把返回值当函数调用，全部抛 TypeError）
+            const value = getters[name];
+            // 防御：函数值（旧编译产物仍可能登记函数变量）不进入快照，
+            // 绝不调用组件内的业务函数
+            if (typeof value === 'function')
+                continue;
+            snapshot[name] = value;
+        }
+        catch {
+            // 单个变量读取失败（如暂时性死区）不影响其余状态恢复
+        }
+    }
+    view[HMR.state] = snapshot;
+};
 export default HMRManager;

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

@@ -1,7 +1,16 @@
+/**
+ * HMR 组件更新：统一「卸载 → 重建 → 挂载」语义
+ *
+ * 任何代码变更（含纯 UI/注释）都走完整重挂载：dispose 触发旧实例的
+ * onDispose/onScopeDispose 清理副作用，init 重执行组件函数（状态经
+ * memo/快照协议保留），mount 触发 onMounted——dev 与生产的生命周期
+ * 语义完全一致，不区分 logic/非 logic 分叉，不存在钩子滞留或孤儿监听。
+ * @module hmr-client/update
+ */
 import { Component, ComponentView } from 'vitarx';
 /**
- * 处理组件更新函数
+ * 处理组件更新：卸载旧实例 → 重建（重执行组件函数，状态经快照恢复）→ 挂载
  * @param view - 组件视图对象，包含当前组件的实例和节点信息
- * @param newComponent - 新的组件定义，用于替换现有组件
+ * @param newComponent - 新的组件定义
  */
 export declare function processUpdate(view: ComponentView, newComponent: Component): void;

package/dist/hmr-client/update.js

@@ -1,72 +1,38 @@
-import { createCommentView, EffectScope, getRenderer, runComponent } from 'vitarx';
-import { diffComponentChange } from './utils.js';
 /**
- * 处理组件更新函数
+ * HMR 组件更新：统一「卸载 → 重建 → 挂载」语义
+ *
+ * 任何代码变更（含纯 UI/注释）都走完整重挂载：dispose 触发旧实例的
+ * onDispose/onScopeDispose 清理副作用，init 重执行组件函数（状态经
+ * memo/快照协议保留），mount 触发 onMounted——dev 与生产的生命周期
+ * 语义完全一致，不区分 logic/非 logic 分叉，不存在钩子滞留或孤儿监听。
+ * @module hmr-client/update
+ */
+import { getRenderer } from 'vitarx';
+/**
+ * 处理组件更新：卸载旧实例 → 重建（重执行组件函数，状态经快照恢复）→ 挂载
  * @param view - 组件视图对象，包含当前组件的实例和节点信息
- * @param newComponent - 新的组件定义，用于替换现有组件
+ * @param newComponent - 新的组件定义
  */
 export function processUpdate(view, newComponent) {
-    // 获取渲染器实例
+    // 获取渲染器实例，创建占位注释节点并插入到旧元素位置，
+    // 作为新旧子树替换的锚点
     const renderer = getRenderer();
-    // 创建一个占位符注释节点
     const placeholder = renderer.createComment('');
-    // 获取旧组件的DOM元素
-    const oldElement = view.node;
-    // 将占位符插入到旧元素的位置
-    renderer.insert(placeholder, oldElement);
-    // 获取组件实例
-    const instance = view.instance;
-    // 比较新旧组件的差异，检查逻辑是否有变化
-    const { logic } = diffComponentChange(view.component.toString(), newComponent.toString());
-    // 更新视图中的组件引用
+    renderer.insert(placeholder, view.node);
+    // 更新视图中的组件引用为最新模块导出
     Object.defineProperty(view, 'component', {
         value: newComponent,
         writable: true,
         enumerable: true,
         configurable: true
     });
-    // 如果逻辑有变化，则完全重新挂载组件
-    if (logic) {
-        const ctx = view.ctx;
-        view.dispose();
-        view.init(ctx);
-        view.mount(placeholder, 'replace');
-        return;
-    }
-    // 销毁旧作用域
-    instance.scope.dispose();
-    // 重新创建新的作用域
-    const scope = new EffectScope({
-        name: view.name,
-        errorHandler: (error, source) => {
-            instance.reportError(error, `effect:${source}`);
-        }
-    });
-    Object.defineProperty(instance, 'scope', {
-        value: scope,
-        writable: true,
-        enumerable: true,
-        configurable: true
-    });
-    // 销毁旧的子树
-    instance.subView.dispose();
-    // 创建新的子树
-    let subView;
-    try {
-        subView = runComponent(instance, () => newComponent(view.props));
-    }
-    catch (e) {
-        instance.reportError(e, 'component:run');
-        subView = createCommentView(`Component<${view.name}>:failed`);
-    }
-    Object.defineProperty(instance, 'subView', {
-        value: instance['normalizeView'](subView),
-        writable: true,
-        enumerable: true,
-        configurable: true
-    });
-    // 初始化新的子树
-    instance.subView.init(instance.subViewContext);
-    // 挂载新的子树
-    instance.subView.mount(placeholder, 'replace');
+    // 完整重挂载：dispose（清理旧副作用，触发 onDispose/onScopeDispose）
+    // → init（重执行组件函数，memo 命中快照保留状态）
+    // → mount（触发 onMounted，重新注册副作用）
+    // 注意：ctx 必须在 dispose 之前捕获——dispose 会拆除 provide 链，
+    // 之后读取 ctx 会导致重执行时 inject（如 useRouter）解析失败
+    const ctx = view.ctx;
+    view.dispose();
+    view.init(ctx);
+    view.mount(placeholder, 'replace');
 }

package/dist/hmr-client/weak-refs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * HMR 视图弱引用集合工具
+ *
+ * #idMapToView 借助 WeakRef 让已销毁视图可被 GC 回收，避免被管理器
+ * 永久强引用造成内存泄漏。GC 可达性天然区分「Freeze 停用」与
+ * 「真销毁」——Freeze 缓存持有视图强引用，停用中的视图不会被回收，
+ * 热更新照常处理；真销毁的视图无引用可回收，deref() 返回空，遍历时剪枝。
+ *
+ * 剪枝/去重逻辑抽为纯函数并接受 WeakRefLike 结构类型，便于以伪引用
+ * 做确定性单元测试（真实 WeakRef 的 deref 时点依赖 GC，无法确定性断言）。
+ * @module hmr-client/weak-refs
+ */
+import type { ComponentView } from 'vitarx';
+/**
+ * WeakRef 结构类型
+ *
+ * 真实 WeakRef 天然满足此结构；测试可注入自定义伪引用。
+ */
+export interface WeakRefLike<T extends object> {
+    deref(): T | undefined;
+}
+/**
+ * 向引用集合登记视图：剪枝死引用 + 按 deref 比对去重
+ *
+ * WeakRef 身份 ≠ 视图身份，同一视图多次登记（组件每次执行都会
+ * register）必须按解引用结果比对，否则集合会被同视图的多个
+ * WeakRef 无限撑大。
+ * @param refs - 视图弱引用集合（原地修改）
+ * @param view - 待登记的视图
+ */
+export declare function registerViewRef(refs: Set<WeakRefLike<ComponentView>>, view: ComponentView): void;
+/**
+ * 收集集合中仍存活（未被 GC）的视图，并原地剪枝死引用
+ * @param refs - 视图弱引用集合（原地修改）
+ * @returns 存活视图数组
+ */
+export declare function collectLiveViews(refs: Set<WeakRefLike<ComponentView>>): ComponentView[];

package/dist/hmr-client/weak-refs.js

@@ -0,0 +1,41 @@
+/**
+ * 向引用集合登记视图：剪枝死引用 + 按 deref 比对去重
+ *
+ * WeakRef 身份 ≠ 视图身份，同一视图多次登记（组件每次执行都会
+ * register）必须按解引用结果比对，否则集合会被同视图的多个
+ * WeakRef 无限撑大。
+ * @param refs - 视图弱引用集合（原地修改）
+ * @param view - 待登记的视图
+ */
+export function registerViewRef(refs, view) {
+    let exists = false;
+    for (const ref of refs) {
+        const cached = ref.deref();
+        if (!cached) {
+            refs.delete(ref);
+        }
+        else if (cached === view) {
+            exists = true;
+        }
+    }
+    if (!exists)
+        refs.add(new WeakRef(view));
+}
+/**
+ * 收集集合中仍存活（未被 GC）的视图，并原地剪枝死引用
+ * @param refs - 视图弱引用集合（原地修改）
+ * @returns 存活视图数组
+ */
+export function collectLiveViews(refs) {
+    const live = [];
+    for (const ref of refs) {
+        const view = ref.deref();
+        if (view) {
+            live.push(view);
+        }
+        else {
+            refs.delete(ref);
+        }
+    }
+    return live;
+}

package/dist/passes/directives/processDirectives.d.ts

@@ -5,7 +5,7 @@
  */
 import * as t from '@babel/types';
 import { TransformContext } from '../../context.js';
-import type { DirectiveInfo } from '../../passes/props/types.js';
+import type { DirectiveInfo } from '../props/types.js';
 /**
  * 处理指令
  * 将指令转换为 withDirectives 调用

package/dist/passes/directives/processDirectives.js

@@ -52,16 +52,21 @@ ctx // 转换上下文，包含别名、导入等信息
     const properties = []; // 定义对象属性数组，可以是属性或方法
     // 添加 value 属性
     if (isIdentifier(value)) {
-        // 如果值是一个标识符
-        markImport(ctx, 'unref'); // 标记需要导入unref函数
-        const unrefAlias = getAlias(ctx.vitarxAliases, 'unref'); // 获取unref函数的别名
-        properties.push(
-        // 添加一个getter方法作为属性
-        t.objectMethod('get', // 方法类型为getter
-        t.identifier('value'), // 属性名为value
-        [], // 无参数
-        t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))]) // 返回unref(value)
-        ));
+        // 三态决策：已知 ref → .value，已知非 ref → 原样，未知 → unref()
+        if (ctx.refVariables.has(value.name)) {
+            // 已知 ref：直接使用 .value
+            properties.push(t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(t.memberExpression(value, t.identifier('value')))])));
+        }
+        else if (ctx.nonRefVariables.has(value.name)) {
+            // 已知非 ref（函数等）：原样返回，无需 unref
+            properties.push(t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(value)])));
+        }
+        else {
+            // 未知标识符：使用 unref() 解包（非 ref 原样返回）
+            markImport(ctx, 'unref');
+            const unrefAlias = getAlias(ctx.vitarxAliases, 'unref');
+            properties.push(t.objectMethod('get', t.identifier('value'), [], t.blockStatement([t.returnStatement(t.callExpression(t.identifier(unrefAlias), [value]))])));
+        }
     }
     else {
         // 如果值不是标识符

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

@@ -2,4 +2,4 @@
  * HMR 注入模块入口
  * @module passes/hmr
  */
-export { injectHMRSupport } from './inject.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './inject.js';

package/dist/passes/hmr/index.js

@@ -2,4 +2,4 @@
  * HMR 注入模块入口
  * @module passes/hmr
  */
-export { injectHMRSupport } from './inject.js';
+export { injectHMRSupport, injectHMRAcceptOnly } from './inject.js';

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

@@ -20,15 +20,21 @@ export declare function createHMRRegistrationStatements(variableNames: string[])
  */
 export declare function createWrappedComponentHMRStatements(componentName: string): t.Statement[];
 /**
- * 从函数体中收集局部变量名
- * 递归遍历函数体中的所有变量声明，用于状态恢复
+ * 为函数体注入状态恢复代码并收集需要登记（trackState）的变量名
+ *
+ * 处理规则：
+ * - 标识符声明（非函数初始值）：初始值包装为 memo(view, '变量名') ?? 原始初始值
+ * - useModel 调用：豁免（桥接状态每次重建，见 isUseModelCall）
+ * - 解构声明（如 `const { a } = useFoo()`）：拆分为隐藏变量整包 memo +
+ *   原声明解构隐藏变量——composable 返回的状态对象得以跨重执行保留，
+ *   其内部创建的响应式状态与已挂载的副作用保持一致
+ * - 函数类型初始值 / 无初始值：不注入
+ * - for 循环头部声明：循环局部绑定，不注入（仅递归循环体）
+ *
+ * 单趟完成注入与收集，返回按执行顺序排列的登记名列表（标识符名 +
+ * 隐藏变量名），供 trackState 生成 getter。隐藏变量采用用户标识符不可能
+ * 命中的 `__$VITARX_D<N>$__` 命名，按组件函数内确定性计数。
  * @param functionBody - 函数体语句块
- * @returns 变量名数组
+ * @returns 需要状态登记的变量名数组
  */
-export declare function collectLocalVariableNames(functionBody: t.BlockStatement): string[];
-/**
- * 为函数体内的变量声明注入状态恢复代码
- * 遍历函数体中的所有变量声明语句
- * @param functionBody - 函数体语句块
- */
-export declare function injectStatePreservation(functionBody: t.BlockStatement): void;
+export declare function injectStatePreservation(functionBody: t.BlockStatement): string[];