@vizejs/vite-plugin 0.345.0 → 0.347.7

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as VizeVueVersion, c as VizeInspectorLintPlanRequest, d as LoadConfigOptions, f as ResolvedVizeConfig, i as VizeOptions, l as VizeInspectorOptions, m as VizeConfig, n as MacroArtifact, o as VizeVueFeatures, p as UserConfigExport, r as VizeCompatibilityOptions, s as VizeInspectorLintPlanProvider, t as CompiledModule, u as ConfigEnv } from "./types-T_Fu8G5I.mjs";
+import { a as VizeVueVersion, c as VizeInspectorLintPlanRequest, d as LoadConfigOptions, f as ResolvedVizeConfig, i as VizeOptions, l as VizeInspectorOptions, m as VizeConfig, n as MacroArtifact, o as VizeVueFeatures, p as UserConfigExport, r as VizeCompatibilityOptions, s as VizeInspectorLintPlanProvider, t as CompiledModule, u as ConfigEnv } from "./types-D_BZmgv-.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts

package/dist/index.mjs

@@ -826,6 +826,7 @@ function clearBuildCaches(state) {
 */
 var CompiledModuleCache = class extends Map {
 	#ownersByDependency = /* @__PURE__ */ new Map();
+	#dependenciesByOwner = /* @__PURE__ */ new Map();
 	/**
 	* Deliberately takes no entries: `Map`'s constructor would call the
 	* overridden `set` from inside `super()`, before `#ownersByDependency` exists.
@@ -836,12 +837,15 @@ var CompiledModuleCache = class extends Map {
 	set(file, compiled) {
 		this.#unindex(file);
 		super.set(file, compiled);
+		const dependencies = /* @__PURE__ */ new Set();
 		for (const dependency of compiled.dependencies ?? []) {
 			const key = path.resolve(dependency);
+			dependencies.add(key);
 			const owners = this.#ownersByDependency.get(key);
 			if (owners) owners.add(file);
 			else this.#ownersByDependency.set(key, new Set([file]));
 		}
+		this.#dependenciesByOwner.set(file, dependencies);
 		return this;
 	}
 	delete(file) {
@@ -850,24 +854,40 @@ var CompiledModuleCache = class extends Map {
 	}
 	clear() {
 		this.#ownersByDependency.clear();
+		this.#dependenciesByOwner.clear();
 		super.clear();
 	}
+	/**
+	* Evict a compiled value while retaining the dependency ownership that is
+	* required to route another hot update before Vite reloads the owner module.
+	* The next `set` reconciles that retained snapshot with the new compilation.
+	*/
+	evict(file) {
+		return super.delete(file);
+	}
 	/** The cached SFCs that `src`-import `resolvedDependency`. */
 	ownersOf(resolvedDependency) {
 		const owners = this.#ownersByDependency.get(resolvedDependency);
 		return owners ? [...owners] : [];
 	}
 	#unindex(file) {
-		for (const dependency of super.get(file)?.dependencies ?? []) {
-			const key = path.resolve(dependency);
-			const owners = this.#ownersByDependency.get(key);
+		for (const dependency of this.#dependenciesByOwner.get(file) ?? []) {
+			const owners = this.#ownersByDependency.get(dependency);
 			if (!owners) continue;
 			owners.delete(file);
-			if (owners.size === 0) this.#ownersByDependency.delete(key);
+			if (owners.size === 0) this.#ownersByDependency.delete(dependency);
 		}
+		this.#dependenciesByOwner.delete(file);
 	}
 };
 /**
+* Invalidate a compiled module without dropping its HMR dependency routing.
+* Hand-built plain Maps retain their historical delete behaviour.
+*/
+function evictCompiledModule(cache, file) {
+	return cache instanceof CompiledModuleCache ? cache.evict(file) : cache.delete(file);
+}
+/**
 * Owners of `resolvedDependency` in one cache.
 *
 * Plain `Map`s — the hand-built states in unit tests — keep the original linear
@@ -2843,25 +2863,7 @@ async function transformHook(state, code, id, options) {
 	return null;
 }
 //#endregion
-//#region src/plugin/hmr.ts
-const VIZE_COMPONENTS_CSS_BASENAME = "vize-components.css";
-const VIZE_COMPONENTS_CSS_FILE = `assets/${VIZE_COMPONENTS_CSS_BASENAME}`;
-/**
-* The cached SFCs that pulled `dependencyFile` in through
-* `<script src>` / `<template src>` / `<style src>`.
-*
-* This runs as the first statement of every hot update, before the `.vue` fast
-* path, so editing an ordinary SFC pays for it too. It used to walk both caches
-* end to end with a `path.resolve` per dependency, which made HMR latency grow
-* with the number of components in the project; the caches now carry a reverse
-* index that answers it in constant time. See `compiled-module-cache.ts`.
-*/
-function getVueFilesDependingOn(state, dependencyFile) {
-	const normalizedDependency = path.resolve(dependencyFile);
-	const owners = /* @__PURE__ */ new Set();
-	for (const cache of [state.cache, state.ssrCache]) for (const vueFile of ownersOfDependency(cache, normalizedDependency)) owners.add(vueFile);
-	return [...owners];
-}
+//#region src/plugin/hmr-module-graph.ts
 function unique(values) {
 	return [...new Set(values)];
 }
@@ -2890,16 +2892,15 @@ function getStyleModuleFileCandidates(styleId) {
 }
 async function collectModulesByFile(server, fileIds) {
 	const modules = /* @__PURE__ */ new Set();
-	const graph = server.moduleGraph;
 	for (const fileId of fileIds) {
 		const add = (module) => {
 			if (module) modules.add(module);
 		};
-		add(graph.getModuleById?.(fileId));
+		add(server.moduleGraph.getModuleById?.(fileId));
 		if (!fileId.startsWith("\0")) try {
-			add(await graph.getModuleByUrl?.(fileId));
+			add(await server.moduleGraph.getModuleByUrl?.(fileId));
 		} catch {}
-		for (const module of graph.getModulesByFile(fileId) ?? []) add(module);
+		for (const module of server.moduleGraph.getModulesByFile(fileId) ?? []) add(module);
 	}
 	return modules;
 }
@@ -2914,17 +2915,48 @@ function preferAcceptingClientModules(modules, requireAcceptingClientModule = fa
 function invalidateModules(server, modules) {
 	for (const module of modules) server.moduleGraph.invalidateModule(module);
 }
+//#endregion
+//#region src/plugin/hmr.ts
+const VIZE_COMPONENTS_CSS_BASENAME = "vize-components.css";
+const VIZE_COMPONENTS_CSS_FILE = `assets/${VIZE_COMPONENTS_CSS_BASENAME}`;
+/**
+* The cached SFCs that pulled `dependencyFile` in through
+* `<script src>` / `<template src>` / `<style src>`.
+*
+* This runs as the first statement of every hot update, before the `.vue` fast
+* path, so editing an ordinary SFC pays for it too. It used to walk both caches
+* end to end with a `path.resolve` per dependency, which made HMR latency grow
+* with the number of components in the project; the caches now carry a reverse
+* index that answers it in constant time. See `compiled-module-cache.ts`.
+*/
+function getVueFilesDependingOn(state, dependencyFile) {
+	const normalizedDependency = path.resolve(dependencyFile);
+	const owners = /* @__PURE__ */ new Set();
+	for (const cache of [state.cache, state.ssrCache]) for (const vueFile of ownersOfDependency(cache, normalizedDependency)) owners.add(vueFile);
+	return [...owners];
+}
 async function handleHotUpdateHook(state, ctx, options = {}) {
 	const { file, server, read } = ctx;
+	const clientDependencyOwners = new Set(ownersOfDependency(state.cache, path.resolve(file)));
 	const dependencyOwners = getVueFilesDependingOn(state, file);
 	if (dependencyOwners.length > 0) {
 		const affectedModules = /* @__PURE__ */ new Set();
 		for (const vueFile of dependencyOwners) {
 			const collectedModules = await collectModulesByFile(server, getVueModuleFileCandidates(vueFile));
 			const modules = options.requireAcceptingClientModule ? preferAcceptingClientModules(collectedModules, true) : collectedModules;
-			if (options.requireAcceptingClientModule && modules.size === 0) continue;
-			state.cache.delete(vueFile);
-			state.ssrCache.delete(vueFile);
+			if (options.requireAcceptingClientModule && modules.size === 0) {
+				if (!options.ensureAcceptingClientModule || !clientDependencyOwners.has(vueFile)) continue;
+				try {
+					const ensured = await options.ensureAcceptingClientModule(vueFile);
+					modules.add(ensured);
+				} catch (error) {
+					state.logger.error(`Failed to restore the client HMR owner for ${vueFile}:`, error);
+					options.onRecompileError?.(error);
+					return;
+				}
+			}
+			evictCompiledModule(state.cache, vueFile);
+			evictCompiledModule(state.ssrCache, vueFile);
 			state.collectedCss.delete(vueFile);
 			state.precompileMetadata.delete(vueFile);
 			state.pendingHmrUpdateTypes.set(vueFile, "full-reload");
@@ -3044,6 +3076,7 @@ async function handleHotUpdateEnvironmentHook(state, environment, options) {
 		...options,
 		server
 	}, {
+		ensureAcceptingClientModule: (vueFile) => environment.moduleGraph.ensureEntryFromUrl(toPluginVisibleVirtualId(vueFile), false),
 		requireAcceptingClientModule: true,
 		onRecompileError: () => {
 			recompileFailed = true;

package/dist/internal/config-bridge.d.mts

@@ -1,4 +1,4 @@
-import { f as ResolvedVizeConfig } from "../types-T_Fu8G5I.mjs";
+import { f as ResolvedVizeConfig } from "../types-D_BZmgv-.mjs";
 import { ResolvedConfig } from "vite";
 
 //#region src/internal/config-bridge.d.ts

package/dist/{types-T_Fu8G5I.d.mts → types-D_BZmgv-.d.mts}

@@ -409,6 +409,10 @@ interface LanguageServerConfig {
    * Enable completions
    */
   completion?: boolean;
+  /**
+   * Enable TypeScript signature help
+   */
+  signatureHelp?: boolean;
   /**
    * Enable hover information
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.345.0",
+  "version": "0.347.7",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -45,10 +45,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.345.0",
+    "@vizejs/native": "0.347.7",
     "oxc-parser": "0.133.0",
     "tinyglobby": "0.2.16",
-    "vize": "0.345.0"
+    "vize": "0.347.7"
   },
   "devDependencies": {
     "@types/node": "25.9.2",