@vizejs/vite-plugin 0.165.0 → 0.167.0

package/dist/index.mjs

@@ -537,6 +537,13 @@ function resolveVuePath(state, id, importer) {
 	return resolveViteVuePath(state.root, id, importer);
 }
 const EMPTY_NATIVE_ALIAS_RULES = [];
+const VUE_PEER_RUNTIME_PACKAGES = new Set(["vue-router"]);
+const VUE_PEER_RUNTIME_ESM_ENTRIES = new Map([["vue-router", [
+	"dist/vue-router.mjs",
+	"dist/vue-router.js",
+	"index.mjs",
+	"index.js"
+]]]);
 function resolveAliasRequest(state, id) {
 	return resolveViteAliasRequest(id, nativeCssAliasRules(state));
 }
@@ -573,6 +580,14 @@ function resolveBareImportWithNode(state, id, importer) {
 	}
 	return null;
 }
+function resolveBareImportFromPnpmHoistWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	for (const candidate of createViteBareImportBases(state.root, importer)) {
+		const hoisted = resolveBareImportFromPnpmHoist(request, candidate);
+		if (hoisted) return `${hoisted}${querySuffix}`;
+	}
+	return null;
+}
 function resolveBareImportCandidatesWithNode(state, id, importer, resolvedId) {
 	for (const candidate of createViteBareImportCandidates(id, nativeCssAliasRules(state), resolvedId)) {
 		const resolved = resolveBareImportWithNode(state, candidate, importer);
@@ -612,8 +627,36 @@ function resolveVueBundlerEntryWithNode(state, id, importer) {
 	}
 	return null;
 }
+function resolveVueBundlerEntryFromPnpmHoist(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	let relativeEntries;
+	if (request === "vue") relativeEntries = [
+		"dist/vue.runtime.esm-bundler.js",
+		"dist/vue.esm-bundler.js",
+		"index.mjs"
+	];
+	else if (request.startsWith("vue/dist/") && request.endsWith(".js")) relativeEntries = [request.slice(4)];
+	else return null;
+	const packageJson = resolveBareImportFromPnpmHoistWithNode(state, "vue/package.json", importer);
+	if (!packageJson) return null;
+	const packageRoot = path.dirname(splitViteIdQuery(packageJson).request);
+	for (const relativeEntry of relativeEntries) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	return null;
+}
 function isVueRuntimeRequest(id) {
-	return splitViteIdQuery(id).request === "vue";
+	const request = splitViteIdQuery(id).request;
+	return request === "vue" || request.startsWith("vue/dist/") && request.endsWith(".js");
+}
+function isVuePeerRuntimeRequest(id) {
+	const request = splitViteIdQuery(id).request;
+	const packageName = getBarePackageName(request);
+	return packageName ? VUE_PEER_RUNTIME_PACKAGES.has(packageName) : false;
+}
+function isProjectVueRuntimeRequest(id) {
+	return isVueRuntimeRequest(id) || isVuePeerRuntimeRequest(id);
 }
 function isVueServerRendererRequest(request) {
 	return request === "@vue/server-renderer" || request === "vue/server-renderer" || request.startsWith("vue/dist/") && request.endsWith("/server-renderer");
@@ -652,6 +695,104 @@ function isVuePackageEntry(id) {
 	const normalized = request.split(path.sep).join("/");
 	return normalized.endsWith("/node_modules/vue/index.js") || normalized.endsWith("/node_modules/vue/dist/vue.runtime.esm-bundler.js") || normalized.endsWith("/node_modules/vue/dist/vue.esm-bundler.js") || normalized.includes("/node_modules/.pnpm/vue@") || normalized.includes("/node_modules/.pnpm/@vue+");
 }
+function isInsidePath(parent, child) {
+	const relative = path.relative(parent, child);
+	return relative === "" || !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function normalizeNuxtVirtualImporterPath(importer) {
+	const { request } = splitViteIdQuery(importer);
+	for (const prefix of ["/@id/virtual:nuxt:", "virtual:nuxt:"]) {
+		if (!request.startsWith(prefix)) continue;
+		const encodedPath = request.slice(prefix.length);
+		try {
+			return decodeURIComponent(encodedPath);
+		} catch {
+			return encodedPath;
+		}
+	}
+	return null;
+}
+function normalizeImporterFilePath(importer) {
+	const nuxtVirtualPath = normalizeNuxtVirtualImporterPath(importer);
+	if (nuxtVirtualPath) return nuxtVirtualPath;
+	const request = classifyVitePluginRequest(importer);
+	return request.normalizedFsId ?? request.strippedVirtualPath ?? request.vizeVirtualPath ?? request.normalizedVuePath ?? splitViteIdQuery(importer).request;
+}
+function isProjectLocalImporter(state, importer) {
+	if (!importer) return false;
+	const importerPath = normalizeImporterFilePath(importer);
+	if (!path.isAbsolute(importerPath)) return false;
+	if (isInsidePath(state.root, importerPath)) return true;
+	try {
+		return isInsidePath(fs.realpathSync(state.root), fs.realpathSync(importerPath));
+	} catch {
+		return false;
+	}
+}
+function resolveProjectLocalPnpmVueRuntime(state, resolvedId) {
+	const normalizedResolvedId = normalizeResolvedVuePath(resolvedId) ?? resolvedId;
+	if (!isVuePackageEntry(normalizedResolvedId)) return null;
+	const { request, querySuffix } = splitViteIdQuery(normalizedResolvedId);
+	if (!request.split(path.sep).join("/").includes("/node_modules/.pnpm/")) return null;
+	let realPath = request;
+	try {
+		realPath = fs.realpathSync(request);
+	} catch {}
+	return isInsidePath(state.root, realPath) ? `${realPath}${querySuffix}` : null;
+}
+function resolveProjectLocalResolvedPath(state, resolvedId) {
+	const { request, querySuffix } = splitViteIdQuery(resolvedId);
+	if (!path.isAbsolute(request)) return null;
+	let realPath = request;
+	try {
+		realPath = fs.realpathSync(request);
+	} catch {}
+	return isInsidePath(state.root, realPath) ? `${realPath}${querySuffix}` : null;
+}
+function resolveVuePeerRuntimeEntryWithNode(state, id, importer) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	const packageName = getBarePackageName(request);
+	if (!packageName || !VUE_PEER_RUNTIME_PACKAGES.has(packageName)) return null;
+	const packageRoot = resolvePackageRootWithNode(state, packageName, importer);
+	if (!packageRoot || !resolveProjectLocalResolvedPath(state, packageRoot)) return null;
+	if (request === packageName) for (const relativeEntry of VUE_PEER_RUNTIME_ESM_ENTRIES.get(packageName) ?? ["index.mjs"]) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	const nodeResolved = resolveBareImportWithNode(state, id, importer);
+	return nodeResolved ? resolveProjectLocalResolvedPath(state, nodeResolved) : null;
+}
+function resolveVuePeerRuntimeEntryFromBaseWithNode(state, id, base) {
+	const { request, querySuffix } = splitViteIdQuery(id);
+	const packageName = getBarePackageName(request);
+	if (!packageName || !VUE_PEER_RUNTIME_PACKAGES.has(packageName)) return null;
+	let packageJson;
+	try {
+		packageJson = createRequire(base).resolve(`${packageName}/package.json`);
+	} catch {
+		return null;
+	}
+	const packageRoot = path.dirname(packageJson);
+	if (!resolveProjectLocalResolvedPath(state, packageRoot)) return null;
+	if (request === packageName) for (const relativeEntry of VUE_PEER_RUNTIME_ESM_ENTRIES.get(packageName) ?? ["index.mjs"]) {
+		const entry = path.join(packageRoot, relativeEntry);
+		if (fs.existsSync(entry)) return `${entry}${querySuffix}`;
+	}
+	try {
+		return resolveProjectLocalResolvedPath(state, `${createRequire(base).resolve(request)}${querySuffix}`);
+	} catch {
+		return null;
+	}
+}
+function resolveProjectNuxtVuePeerRuntimeEntryWithNode(state, id) {
+	const { request } = splitViteIdQuery(id);
+	if (getBarePackageName(request) !== "vue-router") return null;
+	const nuxtPackageJson = resolveBareImportWithNode(state, "nuxt/package.json", path.join(state.root, "package.json"));
+	if (!nuxtPackageJson) return null;
+	const nuxtPackageRoot = path.dirname(splitViteIdQuery(nuxtPackageJson).request);
+	if (!resolveProjectLocalResolvedPath(state, nuxtPackageRoot)) return null;
+	return resolveVuePeerRuntimeEntryFromBaseWithNode(state, id, path.join(nuxtPackageRoot, "package.json"));
+}
 function isOptimizedVueDependency(id) {
 	const { request } = splitViteIdQuery(id);
 	return request.split(path.sep).join("/").includes("/node_modules/.vite/deps/vue.");
@@ -674,11 +815,50 @@ function isVueResolvableFromRoot(root) {
 function normalizeResolvedVuePath(id) {
 	return normalizeViteResolvedVuePath(id);
 }
+async function resolveProjectVueRuntime(ctx, state, id, importer, isSsrRequest) {
+	if (isSsrRequest || !isProjectVueRuntimeRequest(id) || !isProjectLocalImporter(state, importer)) return null;
+	const viteImporter = normalizeViteRequireBase(importer) ?? importer;
+	if (isVuePeerRuntimeRequest(id)) {
+		const nuxtPeerEntry = resolveProjectNuxtVuePeerRuntimeEntryWithNode(state, id);
+		if (nuxtPeerEntry) {
+			state.logger.log(`resolveId: resolved Nuxt Vue peer runtime ${id} to ${nuxtPeerEntry}`);
+			return nuxtPeerEntry;
+		}
+		const projectLocalEntry = resolveVuePeerRuntimeEntryWithNode(state, id, viteImporter);
+		if (projectLocalEntry) {
+			state.logger.log(`resolveId: resolved project-local Vue peer runtime ${id} to ${projectLocalEntry}`);
+			return projectLocalEntry;
+		}
+		return null;
+	}
+	const pnpmHoistedEntry = resolveVueBundlerEntryFromPnpmHoist(state, id, viteImporter);
+	if (pnpmHoistedEntry) {
+		state.logger.log(`resolveId: resolved project pnpm-hoisted Vue runtime to ${pnpmHoistedEntry}`);
+		return pnpmHoistedEntry;
+	}
+	try {
+		const resolved = await ctx.resolve(id, viteImporter, { skipSelf: true });
+		if (resolved && !isOptimizedVueDependency(resolved.id)) {
+			const projectLocalEntry = resolveProjectLocalPnpmVueRuntime(state, resolved.id);
+			if (projectLocalEntry) {
+				state.logger.log(`resolveId: resolved project-local Vue runtime to ${projectLocalEntry}`);
+				return projectLocalEntry;
+			}
+		}
+	} catch {}
+	const importerLocalEntry = resolveVueBundlerEntryWithNode(state, id, viteImporter);
+	const projectLocalEntry = importerLocalEntry ? resolveProjectLocalPnpmVueRuntime(state, importerLocalEntry) : null;
+	if (projectLocalEntry) {
+		state.logger.log(`resolveId: resolved importer-local Vue runtime to ${projectLocalEntry}`);
+		return projectLocalEntry;
+	}
+	return null;
+}
 function nativeCssAliasRules(state) {
 	return state.cssAliasRules.length === 0 ? EMPTY_NATIVE_ALIAS_RULES : state.cssAliasRules.map(toNativeCssAliasRule);
 }
 function isPotentialVizeResolveId(id) {
-	return id.startsWith("\0") || id.startsWith("vize:") || id.startsWith("/@fs") || id === "virtual:vize-styles" || id.endsWith(".vue") || id.includes(".vue?") || id.includes(".vue.ts?") || id.includes("?macro=true") || id.includes("?definePage");
+	return id.startsWith("\0") || id.startsWith("vize:") || id.startsWith("/@fs") || isProjectVueRuntimeRequest(id) || id === "virtual:vize-styles" || id.endsWith(".vue") || id.includes(".vue?") || id.includes(".vue.ts?") || id.includes("?macro=true") || id.includes("?definePage");
 }
 function isPotentialVizeImporter(importer) {
 	if (importer === void 0) return false;
@@ -731,6 +911,8 @@ async function resolveIdHook(ctx, state, id, importer, options) {
 	const isSsrRequest = !!options?.ssr || (importerRequest?.isVizeSsrVirtual ?? false) || (importer ? isPluginVisibleSsrVirtualId(importer) : false);
 	const request = classifyVitePluginRequest(id);
 	const pluginVisibleVirtualPath = fromPluginVisibleVirtualId(id);
+	const projectVueRuntime = await resolveProjectVueRuntime(ctx, state, id, importer, isSsrRequest);
+	if (projectVueRuntime) return projectVueRuntime;
 	if (pluginVisibleVirtualPath) {
 		if (isDependencyScan) return toVirtualId(pluginVisibleVirtualPath, isSsrRequest);
 		return isSsrRequest ? toPluginVisibleVirtualId(pluginVisibleVirtualPath, true, request.querySuffix) : id;
@@ -839,6 +1021,16 @@ async function resolveIdHook(ctx, state, id, importer, options) {
 							id: normalizedFsId
 						};
 						if (isVueRuntime && state.server !== null && !isOptimizedVueDependency(resolved.id)) {
+							const pnpmHoistedEntry = resolveVueBundlerEntryFromPnpmHoist(state, id, cleanImporter);
+							if (pnpmHoistedEntry) {
+								state.logger.log(`resolveId: resolved pnpm-hoisted Vue runtime to ${pnpmHoistedEntry}`);
+								return pnpmHoistedEntry;
+							}
+							const projectLocalEntry = resolveProjectLocalPnpmVueRuntime(state, resolved.id);
+							if (projectLocalEntry) {
+								state.logger.log(`resolveId: resolved project-local Vue runtime to ${projectLocalEntry}`);
+								return projectLocalEntry;
+							}
 							if (isVueResolvableFromRoot(state.root)) {
 								state.logger.log(`resolveId: deferring Vue runtime ${resolved.id} to Vite optimizer`);
 								return null;
@@ -876,7 +1068,13 @@ async function resolveIdHook(ctx, state, id, importer, options) {
 					}
 				} catch {}
 				if (isVueRuntime) {
-					const vueBundlerEntry = isBuild || !isVueResolvableFromRoot(state.root) ? resolveVueBundlerEntryWithNode(state, id, cleanImporter) : null;
+					const importerLocalEntry = resolveVueBundlerEntryWithNode(state, id, cleanImporter);
+					const projectLocalEntry = importerLocalEntry ? resolveProjectLocalPnpmVueRuntime(state, importerLocalEntry) : null;
+					if (projectLocalEntry) {
+						state.logger.log(`resolveId: resolved project-local Vue runtime to ${projectLocalEntry}`);
+						return projectLocalEntry;
+					}
+					const vueBundlerEntry = isBuild || !isVueResolvableFromRoot(state.root) ? importerLocalEntry : null;
 					if (vueBundlerEntry) {
 						state.logger.log(`resolveId: resolved Vue runtime to ${vueBundlerEntry}`);
 						return vueBundlerEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.165.0",
+  "version": "0.167.0",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -39,9 +39,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.165.0",
+    "@vizejs/native": "0.167.0",
     "tinyglobby": "0.2.16",
-    "vize": "0.165.0"
+    "vize": "0.167.0"
   },
   "devDependencies": {
     "@types/node": "25.7.0",