@vizejs/vite-plugin 0.306.0 → 0.310.0

package/dist/index.mjs

@@ -4,9 +4,9 @@ import crypto, { createHash } from "node:crypto";
 import * as native from "@vizejs/native";
 import { applyViteDefineReplacements, buildInspectorGraph, chunkVitePrecompileFiles, classifyVitePluginRequest, createViteBareImportBases, createViteBareImportCandidates, createViteVirtualId, detectViteHmrUpdateType, diffVitePrecompileFiles, generateViteHmrCode, hasViteHmrChanges, isViteBareSpecifier, normalizeViteCssModuleFilename, normalizeViteDevMiddlewareUrl, normalizeVitePrecompileBatchSize, normalizeViteRequireBase, normalizeViteResolvedVuePath, resolveViteAliasRequest, resolveViteCssImports, resolveViteRelativeImport, resolveViteVuePath, rewriteViteDynamicTemplateImports, rewriteViteImportMetaGlobBase, rewriteViteStaticAssetUrls, scopeViteCssForPipeline, shouldApplyViteDefineInVirtualModule, splitViteIdQuery, toViteBrowserImportPrefix, transformViteCssVarsForPipeline } from "@vizejs/native";
 import { parseSync } from "oxc-parser";
+import path from "node:path";
 import fs from "node:fs";
 import { glob } from "tinyglobby";
-import path from "node:path";
 import zlib from "node:zlib";
 import { pathToFileURL } from "node:url";
 import * as vite from "vite";
@@ -687,6 +687,84 @@ function clearBuildCaches(state) {
 	state.viteResolveCache?.clear();
 }
 //#endregion
+//#region src/plugin/compiled-module-cache.ts
+/**
+* Compiled-module caches carrying a reverse index from a `src`-imported
+* dependency to the SFCs that pulled it in.
+*
+* Every hot update has to answer "which SFCs own this changed file?" before it
+* can do anything else, and that answer used to come from a full scan of both
+* caches with a `path.resolve` per dependency per cached file. HMR latency then
+* grew with the number of components in the project, on the interactive path,
+* for every save — including saves of ordinary `.vue` files, because the scan
+* runs before the `.vue` fast path.
+*
+* The index is maintained by overriding `set`/`delete`/`clear` rather than by a
+* second structure updated at each call site. `state.cache` is handed to
+* `compileFile` and `compileBatch`, and is also mutated directly from
+* `precompile-run.ts`, `hmr.ts` and `state.ts`; a structure kept in sync by hand
+* across those would drift the first time a new writer appeared. Subclassing
+* puts the bookkeeping where the mutation is.
+*
+* The keys are `path.resolve`d exactly as the previous scan resolved them, so a
+* dependency recorded as a relative path indexes and looks up identically.
+*/
+var CompiledModuleCache = class extends Map {
+	#ownersByDependency = /* @__PURE__ */ new Map();
+	/**
+	* Deliberately takes no entries: `Map`'s constructor would call the
+	* overridden `set` from inside `super()`, before `#ownersByDependency` exists.
+	*/
+	constructor() {
+		super();
+	}
+	set(file, compiled) {
+		this.#unindex(file);
+		super.set(file, compiled);
+		for (const dependency of compiled.dependencies ?? []) {
+			const key = path.resolve(dependency);
+			const owners = this.#ownersByDependency.get(key);
+			if (owners) owners.add(file);
+			else this.#ownersByDependency.set(key, new Set([file]));
+		}
+		return this;
+	}
+	delete(file) {
+		this.#unindex(file);
+		return super.delete(file);
+	}
+	clear() {
+		this.#ownersByDependency.clear();
+		super.clear();
+	}
+	/** 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);
+			if (!owners) continue;
+			owners.delete(file);
+			if (owners.size === 0) this.#ownersByDependency.delete(key);
+		}
+	}
+};
+/**
+* Owners of `resolvedDependency` in one cache.
+*
+* Plain `Map`s — the hand-built states in unit tests — keep the original linear
+* scan, so an unindexed cache answers exactly what the indexed one does.
+*/
+function ownersOfDependency(cache, resolvedDependency) {
+	if (cache instanceof CompiledModuleCache) return cache.ownersOf(resolvedDependency);
+	const owners = [];
+	for (const [file, compiled] of cache) if (compiled.dependencies?.some((dependency) => path.resolve(dependency) === resolvedDependency)) owners.push(file);
+	return owners;
+}
+//#endregion
 //#region src/compile-options.ts
 function buildCompileFileOptions(filePath, options) {
 	return {
@@ -2539,10 +2617,20 @@ async function transformHook(state, code, id, options) {
 //#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, compiled] of cache) if (compiled.dependencies?.some((dependency) => path.resolve(dependency) === normalizedDependency)) owners.add(vueFile);
+	for (const cache of [state.cache, state.ssrCache]) for (const vueFile of ownersOfDependency(cache, normalizedDependency)) owners.add(vueFile);
 	return [...owners];
 }
 function unique(values) {
@@ -3248,8 +3336,8 @@ function resolveCompatibilityOptions(options, compilerConfig = {}) {
 function vize(options = {}) {
 	if (isLegacyVueCompatibilityMode(options)) return [createLegacyVueCompatibilityPlugin(options)];
 	const state = {
-		cache: /* @__PURE__ */ new Map(),
-		ssrCache: /* @__PURE__ */ new Map(),
+		cache: new CompiledModuleCache(),
+		ssrCache: new CompiledModuleCache(),
 		collectedCss: /* @__PURE__ */ new Map(),
 		precompileMetadata: /* @__PURE__ */ new Map(),
 		pendingHmrUpdateTypes: /* @__PURE__ */ new Map(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.306.0",
+  "version": "0.310.0",
   "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.306.0",
+    "@vizejs/native": "0.310.0",
     "oxc-parser": "0.133.0",
     "tinyglobby": "0.2.16",
-    "vize": "0.306.0"
+    "vize": "0.310.0"
   },
   "devDependencies": {
     "@types/node": "25.9.2",