@vizejs/vite-plugin 0.481.0 → 0.483.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { t as vize } from "./plugin-BJpHdKQz.mjs";
-import { l as rewriteStaticAssetUrls } from "./vue-version-BUu5UzZ5.mjs";
+import { t as vize } from "./plugin-BvYQcGKz.mjs";
+import { u as rewriteStaticAssetUrls } from "./vue-version-JgVRwvCy.mjs";
 import { a as resolveViteConfigExport, i as resolveConfigExport, n as defineConfig, o as vizeConfigStore, r as loadConfig, t as VIZE_CONFIG_FILE_ENV } from "./config-DE1fZbgD.mjs";
 //#region src/index.ts
 const __internal = { rewriteStaticAssetUrls };

package/dist/{plugin-BJpHdKQz.mjs → plugin-BvYQcGKz.mjs}

@@ -1,4 +1,4 @@
-import { a as applyDefineReplacements, c as rewriteImportMetaGlobBase, i as isLegacyVueVersion, l as rewriteStaticAssetUrls, o as createLogger, r as isLegacyVueCompatibilityMode, s as rewriteDynamicTemplateImports, t as createLegacyVueCompatibilityPlugin, u as shouldApplyDefineInVirtualModule } from "./vue-version-BUu5UzZ5.mjs";
+import { a as removeHostVueSfcCompilers, c as rewriteDynamicTemplateImports, d as shouldApplyDefineInVirtualModule, i as isLegacyVueVersion, l as rewriteImportMetaGlobBase, o as applyDefineReplacements, r as isLegacyVueCompatibilityMode, s as createLogger, t as createLegacyVueCompatibilityPlugin, u as rewriteStaticAssetUrls } from "./vue-version-JgVRwvCy.mjs";
 import { a as resolveViteConfigExport, i as resolveConfigExport, o as vizeConfigStore, r as loadConfig } from "./config-DE1fZbgD.mjs";
 import { n as registerResolvedVizeConfig, r as unregisterResolvedVizeConfig } from "./config-bridge-Dv6U7_RC.mjs";
 import { createRequire } from "node:module";
@@ -2071,6 +2071,133 @@ function isOptimizedVueDependency(state, id) {
 	return normalized.includes("/node_modules/.vite/deps/vue.");
 }
 //#endregion
+//#region src/plugin/ssr-modules.ts
+/**
+* Point a compiled SSR module at the `vue/server-renderer` subpath.
+*
+* The compiler emits `@vue/server-renderer`, which is not a dependency every
+* app declares; the subpath re-export always resolves alongside `vue` itself.
+*/
+function normalizeVueServerRendererImport(code) {
+	return code.replace(/\bfrom\s+(['"])@vue\/server-renderer\1/g, "from \"vue/server-renderer\"");
+}
+/**
+* Marks a module whose registration has already been appended.
+*
+* Idempotency cannot key on the helper identifiers: an SFC is free to declare
+* `__vize_useSSRContext` itself, and skipping registration for it would cost it
+* its initial stylesheet.
+*/
+const REGISTRATION_MARKER = "/* @vize-ssr-modules-registered */";
+/**
+* Matches the `_sfc_main` component declaration the emitted module carries.
+*
+* A bare `\b_sfc_main\b` also matches the identifier inside a string literal or
+* a comment, and wrapping a component that was never declared is a
+* `ReferenceError` at render time.
+*/
+const SFC_MAIN_DECLARATION = /\b(?:const|let|var)\s+_sfc_main\s*=/;
+/**
+* Register an SFC in `ssrContext.modules` during SSR, the way
+* `@vitejs/plugin-vue` does.
+*
+* After rendering, `vue-bundle-renderer` intersects `ssrContext.modules` with
+* the client manifest to decide which stylesheets belong in the document head.
+* A component that never registers itself contributes no `<link>`, so the
+* server-rendered markup arrives unstyled and only gains its styles once the
+* route chunk loads on the client — a flash of unstyled content that never
+* recovers when JavaScript is disabled (#3868).
+*
+* The key must be the module's path relative to the Vite root with POSIX
+* separators, because that is what the client manifest is keyed on.
+*/
+function ssrModuleRegistrationCode(filePath, root, helpers = {}, frameworkRoot) {
+	const moduleId = JSON.stringify(frameworkRoot === void 0 ? toManifestModuleId(filePath, root) : path.relative(frameworkRoot, filePath).replace(/\\/g, "/"));
+	const useSSRContext = helpers.useSSRContext ?? "__vize_useSSRContext";
+	const sfcSetup = helpers.sfcSetup ?? "__vize_sfc_setup";
+	return {
+		prologue: `${REGISTRATION_MARKER}\nimport { useSSRContext as ${useSSRContext} } from "vue";`,
+		epilogue: [
+			`const ${sfcSetup} = _sfc_main.setup;`,
+			`_sfc_main.setup = (props, ctx) => {`,
+			`  const ssrContext = ${useSSRContext}();`,
+			`  (ssrContext.modules || (ssrContext.modules = new Set())).add(${moduleId});`,
+			`  return ${sfcSetup} ? ${sfcSetup}(props, ctx) : undefined;`,
+			`};`
+		].join("\n")
+	};
+}
+/**
+* The client-manifest key for `filePath`: relative to `root`, POSIX separators.
+*
+* A path outside the root keeps its absolute form rather than becoming a `../`
+* chain, matching how Vite keys modules it cannot root-relativize. Only a real
+* parent-directory step counts as outside: a filename that merely begins with
+* `..` still lives in the root and is keyed relative to it.
+*/
+function toManifestModuleId(filePath, root) {
+	const relative = path.relative(root, filePath).replace(/\\/g, "/");
+	if (!relative || relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) return filePath.replace(/\\/g, "/");
+	return relative;
+}
+/**
+* Wrap an emitted module with the registration.
+*
+* The wrapper is appended, so it closes over whatever `setup` the emitter's own
+* rewrites left in place, but its `import` is *prepended*. A trailing `import`
+* is legal ESM, yet it makes the module's last import statement its last line,
+* and Nuxt's auto-import injection then inserts nothing — a component relying on
+* an auto-imported composable loses that binding and throws `ReferenceError` at
+* render time (#3868). Leading the module with the import keeps the import
+* section where every downstream transform expects to find it.
+*
+* `useSSRContext()` throws outside a render, so this is a no-op unless `isSsr`.
+* Modules without an `_sfc_main` declaration — a render-function-only output, or
+* a boundary placeholder — have no component object to wrap and are returned
+* untouched.
+*/
+function appendSsrModuleRegistration(code, filePath, root, isSsr, frameworkRoot) {
+	if (!isSsr || !SFC_MAIN_DECLARATION.test(code)) return code;
+	if (code.includes(REGISTRATION_MARKER)) return code;
+	const { prologue, epilogue } = ssrModuleRegistrationCode(filePath, root, {
+		useSSRContext: freeIdentifier("__vize_useSSRContext", code),
+		sfcSetup: freeIdentifier("__vize_sfc_setup", code)
+	}, frameworkRoot);
+	return `${prologue}\n${code}\n${epilogue}`;
+}
+/**
+* `base`, or `base` plus the smallest numeric suffix the module does not use.
+*
+* Re-declaring an identifier the SFC already bound is a `SyntaxError`, which
+* would take down the whole module rather than just its stylesheet.
+*/
+function freeIdentifier(base, code) {
+	if (!new RegExp(`\\b${base}\\b`).test(code)) return base;
+	for (let suffix = 2;; suffix++) {
+		const candidate = `${base}${suffix}`;
+		if (!new RegExp(`\\b${candidate}\\b`).test(code)) return candidate;
+	}
+}
+/**
+* Whether the environment bundles `request` instead of loading it at runtime.
+*
+* Node SSR leaves Vue external, but a worker runtime such as Cloudflare's
+* workerd (Void, `@cloudflare/vite-plugin`) sets `noExternal: true` and has no
+* `node_modules` to import from, so Vue must stay in its bundle.
+*/
+function ssrEnvironmentBundles(resolve, request) {
+	const { noExternal, external } = resolve ?? {};
+	const packageName = request.split("/", request.startsWith("@") ? 2 : 1).join("/");
+	if (external !== true && (external?.includes(request) || external?.includes(packageName))) return false;
+	if (noExternal === true) return true;
+	if (noExternal === void 0) return false;
+	return (Array.isArray(noExternal) ? noExternal : [noExternal]).some((pattern) => typeof pattern === "string" ? pattern === packageName : pattern.test(packageName));
+}
+/** Keep compiler/config root separate from Nuxt's source-relative manifest IDs. */
+function registerSfcModule(state, code, filePath, isSsr) {
+	return appendSsrModuleRegistration(code, filePath, state.root, isSsr, state.mergedOptions.ssrModuleIdRoot);
+}
+//#endregion
 //#region src/plugin/tree-shaking.ts
 /** Template-only client output has no authored top-level script effects. */
 function isPureTemplateOnlyModule(compiled) {
@@ -2558,10 +2685,11 @@ async function resolveIdHook(ctx, state, id, importer, options) {
 						return devSsrVueEntry;
 					}
 				}
-				return {
+				if (!ssrEnvironmentBundles(ctx.environment?.config?.resolve, ssrExternalVueRequest)) return {
 					id: ssrExternalVueRequest,
 					external: true
 				};
+				return resolveWithVite(ctx, state, ssrExternalVueRequest, cleanImporter, { skipSelf: true });
 			}
 			if (!id.startsWith("./") && !id.startsWith("../") && !id.startsWith("/")) {
 				const isVueRuntime = isVueRuntimeRequest(id);
@@ -2771,118 +2899,6 @@ function shouldLoadCompiledVueSfcPath(state, realPath, hasNuxtComponentQuery = f
 	return true;
 }
 //#endregion
-//#region src/plugin/ssr-modules.ts
-/**
-* Point a compiled SSR module at the `vue/server-renderer` subpath.
-*
-* The compiler emits `@vue/server-renderer`, which is not a dependency every
-* app declares; the subpath re-export always resolves alongside `vue` itself.
-*/
-function normalizeVueServerRendererImport(code) {
-	return code.replace(/\bfrom\s+(['"])@vue\/server-renderer\1/g, "from \"vue/server-renderer\"");
-}
-/**
-* Marks a module whose registration has already been appended.
-*
-* Idempotency cannot key on the helper identifiers: an SFC is free to declare
-* `__vize_useSSRContext` itself, and skipping registration for it would cost it
-* its initial stylesheet.
-*/
-const REGISTRATION_MARKER = "/* @vize-ssr-modules-registered */";
-/**
-* Matches the `_sfc_main` component declaration the emitted module carries.
-*
-* A bare `\b_sfc_main\b` also matches the identifier inside a string literal or
-* a comment, and wrapping a component that was never declared is a
-* `ReferenceError` at render time.
-*/
-const SFC_MAIN_DECLARATION = /\b(?:const|let|var)\s+_sfc_main\s*=/;
-/**
-* Register an SFC in `ssrContext.modules` during SSR, the way
-* `@vitejs/plugin-vue` does.
-*
-* After rendering, `vue-bundle-renderer` intersects `ssrContext.modules` with
-* the client manifest to decide which stylesheets belong in the document head.
-* A component that never registers itself contributes no `<link>`, so the
-* server-rendered markup arrives unstyled and only gains its styles once the
-* route chunk loads on the client — a flash of unstyled content that never
-* recovers when JavaScript is disabled (#3868).
-*
-* The key must be the module's path relative to the Vite root with POSIX
-* separators, because that is what the client manifest is keyed on.
-*/
-function ssrModuleRegistrationCode(filePath, root, helpers = {}, frameworkRoot) {
-	const moduleId = JSON.stringify(frameworkRoot === void 0 ? toManifestModuleId(filePath, root) : path.relative(frameworkRoot, filePath).replace(/\\/g, "/"));
-	const useSSRContext = helpers.useSSRContext ?? "__vize_useSSRContext";
-	const sfcSetup = helpers.sfcSetup ?? "__vize_sfc_setup";
-	return {
-		prologue: `${REGISTRATION_MARKER}\nimport { useSSRContext as ${useSSRContext} } from "vue";`,
-		epilogue: [
-			`const ${sfcSetup} = _sfc_main.setup;`,
-			`_sfc_main.setup = (props, ctx) => {`,
-			`  const ssrContext = ${useSSRContext}();`,
-			`  (ssrContext.modules || (ssrContext.modules = new Set())).add(${moduleId});`,
-			`  return ${sfcSetup} ? ${sfcSetup}(props, ctx) : undefined;`,
-			`};`
-		].join("\n")
-	};
-}
-/**
-* The client-manifest key for `filePath`: relative to `root`, POSIX separators.
-*
-* A path outside the root keeps its absolute form rather than becoming a `../`
-* chain, matching how Vite keys modules it cannot root-relativize. Only a real
-* parent-directory step counts as outside: a filename that merely begins with
-* `..` still lives in the root and is keyed relative to it.
-*/
-function toManifestModuleId(filePath, root) {
-	const relative = path.relative(root, filePath).replace(/\\/g, "/");
-	if (!relative || relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) return filePath.replace(/\\/g, "/");
-	return relative;
-}
-/**
-* Wrap an emitted module with the registration.
-*
-* The wrapper is appended, so it closes over whatever `setup` the emitter's own
-* rewrites left in place, but its `import` is *prepended*. A trailing `import`
-* is legal ESM, yet it makes the module's last import statement its last line,
-* and Nuxt's auto-import injection then inserts nothing — a component relying on
-* an auto-imported composable loses that binding and throws `ReferenceError` at
-* render time (#3868). Leading the module with the import keeps the import
-* section where every downstream transform expects to find it.
-*
-* `useSSRContext()` throws outside a render, so this is a no-op unless `isSsr`.
-* Modules without an `_sfc_main` declaration — a render-function-only output, or
-* a boundary placeholder — have no component object to wrap and are returned
-* untouched.
-*/
-function appendSsrModuleRegistration(code, filePath, root, isSsr, frameworkRoot) {
-	if (!isSsr || !SFC_MAIN_DECLARATION.test(code)) return code;
-	if (code.includes(REGISTRATION_MARKER)) return code;
-	const { prologue, epilogue } = ssrModuleRegistrationCode(filePath, root, {
-		useSSRContext: freeIdentifier("__vize_useSSRContext", code),
-		sfcSetup: freeIdentifier("__vize_sfc_setup", code)
-	}, frameworkRoot);
-	return `${prologue}\n${code}\n${epilogue}`;
-}
-/**
-* `base`, or `base` plus the smallest numeric suffix the module does not use.
-*
-* Re-declaring an identifier the SFC already bound is a `SyntaxError`, which
-* would take down the whole module rather than just its stylesheet.
-*/
-function freeIdentifier(base, code) {
-	if (!new RegExp(`\\b${base}\\b`).test(code)) return base;
-	for (let suffix = 2;; suffix++) {
-		const candidate = `${base}${suffix}`;
-		if (!new RegExp(`\\b${candidate}\\b`).test(code)) return candidate;
-	}
-}
-/** Keep compiler/config root separate from Nuxt's source-relative manifest IDs. */
-function registerSfcModule(state, code, filePath, isSsr) {
-	return appendSsrModuleRegistration(code, filePath, state.root, isSsr, state.mergedOptions.ssrModuleIdRoot);
-}
-//#endregion
 //#region src/plugin/vite-transform.ts
 function createVirtualTypeScriptTransformer(viteApi) {
 	return async (code, id) => {
@@ -3441,6 +3457,84 @@ async function handleHotUpdateEnvironmentHook(state, environment, options) {
 	return modules;
 }
 //#endregion
+//#region src/plugin/manifest.ts
+/** The query `toPluginVisibleVirtualId` gives a main SFC module. */
+const MAIN_SFC_QUERY = "?vue&vize";
+function sourceIdentity(key) {
+	const query = key.indexOf("?");
+	if (query < 0 || key.slice(query) !== MAIN_SFC_QUERY) return null;
+	const source = key.slice(0, query);
+	return source.endsWith(".vue") ? source : null;
+}
+/**
+* Key a Vite build manifest by SFC source path, as `@vitejs/plugin-vue` does.
+*
+* Vize's main SFC modules carry `?vue&vize`, so Vite keys their chunks
+* `pages/index.vue?vue&vize`. Servers that look up a route's CSS and preloads
+* by its source file (Void, Vite SSR setups) would miss them.
+*/
+function restoreManifestSourceIds(manifest) {
+	const identities = /* @__PURE__ */ new Map();
+	for (const [key, entry] of Object.entries(manifest)) {
+		const source = sourceIdentity(key);
+		if (!source || entry.src !== key || Object.hasOwn(manifest, source)) continue;
+		identities.set(key, source);
+	}
+	if (identities.size === 0) return false;
+	for (const [key, entry] of Object.entries(manifest)) {
+		const source = identities.get(key);
+		if (source) {
+			delete manifest[key];
+			manifest[source] = entry;
+			entry.src = source;
+		}
+		for (const field of ["imports", "dynamicImports"]) {
+			const references = entry[field];
+			if (references?.some((reference) => identities.has(reference))) entry[field] = references.map((reference) => identities.get(reference) ?? reference);
+		}
+	}
+	return true;
+}
+/** Same for `build.ssrManifest`, whose keys are module IDs. */
+function restoreSsrManifestSourceIds(manifest) {
+	let changed = false;
+	for (const key of Object.keys(manifest)) {
+		const source = sourceIdentity(key);
+		if (!source || Object.hasOwn(manifest, source)) continue;
+		manifest[source] = manifest[key];
+		delete manifest[key];
+		changed = true;
+	}
+	return changed;
+}
+function manifestFileName(option, fallback) {
+	if (!option) return null;
+	return typeof option === "string" ? option : fallback;
+}
+function rewriteAsset(bundle, fileName, restore) {
+	const asset = fileName ? bundle[fileName] : void 0;
+	if (asset?.type !== "asset" || asset.source === void 0) return;
+	const text = typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source);
+	const manifest = JSON.parse(text);
+	if (restore(manifest)) asset.source = JSON.stringify(manifest, null, 2);
+}
+function createManifestPlugin() {
+	return {
+		name: "vite-plugin-vize:manifest",
+		apply: "build",
+		generateBundle: {
+			order: "post",
+			handler(_, bundle) {
+				const build = this.environment?.config.build;
+				if (!build) return;
+				const assets = bundle;
+				rewriteAsset(assets, manifestFileName(build.manifest, ".vite/manifest.json"), restoreManifestSourceIds);
+				rewriteAsset(assets, manifestFileName(build.ssrManifest, ".vite/ssr-manifest.json"), restoreSsrManifestSourceIds);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/plugin/compat.ts
 /**
 * The `vite:vue` shim a host framework probes for a Vue plugin.
@@ -4334,6 +4428,8 @@ function vize(options = {}, compilerDefaults = {}, hostContext) {
 				const sharedConfigPromise = resolveSharedConfig(options, state.root, configEnv, state.logger, resolvedConfig, hostContext);
 				const sharedConfig = await register(resolvedConfig, state.root, sharedConfigPromise);
 				state.mergedOptions = mergeCompilerOptions(options, sharedConfig, compilerDefaults);
+				const replaced = removeHostVueSfcCompilers(resolvedConfig.plugins, state.mergedOptions);
+				if (replaced > 0) state.logger.log(`Replaced ${replaced} @vitejs/plugin-vue instance(s) with Vize.`);
 				state.fileCompilerOptions = createFileCompilerOptions(sharedConfig, state.root, options, compilerDefaults);
 				state.compilerScopeIdentity = sharedConfig?.entries;
 				state.dynamicImportAliasRules = [];
@@ -4426,7 +4522,8 @@ function vize(options = {}, compilerDefaults = {}, hostContext) {
 			}
 		},
 		createStylePostTransformPlugin(),
-		createPostTransformPlugin(state)
+		createPostTransformPlugin(state),
+		...hostContext === "nuxt" ? [] : [createManifestPlugin()]
 	];
 }
 //#endregion

package/dist/plugin-t5V0g-uQ.mjs

@@ -0,0 +1,2 @@
+import { t as vize } from "./plugin-BvYQcGKz.mjs";
+export { vize };

package/dist/vite-plus.mjs

@@ -303,10 +303,10 @@ function defineConfig(config = {}, integration = {}) {
 		const source = await resolveConfig(config, env);
 		const { vp, metadata, compiler } = normalizeConfig(source, integration);
 		const { options } = metadata;
-		const legacy = compiler !== false && (await import("./vue-version-DGtIj1Bv.mjs")).isLegacyVueCompatibilityMode(compiler);
+		const legacy = compiler !== false && (await import("./vue-version-C75M7lgZ.mjs")).isLegacyVueCompatibilityMode(compiler);
 		const plugins = compiler === false || legacy ? [...vp.plugins ?? []] : await withoutVueCompiler(vp.plugins ?? []);
 		if (compiler !== false) {
-			const { vize } = await import("./plugin-C1ZHQliC.mjs");
+			const { vize } = await import("./plugin-t5V0g-uQ.mjs");
 			plugins.push(vize({
 				...compiler,
 				configMode: false,

package/dist/{vue-version-DGtIj1Bv.mjs → vue-version-C75M7lgZ.mjs}

@@ -1,2 +1,2 @@
-import { r as isLegacyVueCompatibilityMode } from "./vue-version-BUu5UzZ5.mjs";
+import { r as isLegacyVueCompatibilityMode } from "./vue-version-JgVRwvCy.mjs";
 export { isLegacyVueCompatibilityMode };

package/dist/{vue-version-BUu5UzZ5.mjs → vue-version-JgVRwvCy.mjs}

@@ -71,5 +71,23 @@ function createLegacyVueCompatibilityPlugin(options) {
 		}
 	};
 }
+/**
+* Remove `@vitejs/plugin-vue` instances that sit beside Vize, such as the one a
+* framework adapter bundles (`@void/vue`'s `voidVue()`), so one compiler owns
+* each `.vue` module. Vize's own `vite:vue` shim has no compiler hooks and stays.
+* An explicit `exclude` keeps the host compiler for the SFCs Vize skips.
+*/
+function removeHostVueSfcCompilers(plugins, options) {
+	if (options.exclude !== void 0) return 0;
+	let removed = 0;
+	for (let index = plugins.length - 1; index >= 0; index--) {
+		const plugin = plugins[index];
+		if (plugin.name === "vite:vue" && (plugin.transform || plugin.load)) {
+			plugins.splice(index, 1);
+			removed++;
+		}
+	}
+	return removed;
+}
 //#endregion
-export { applyDefineReplacements as a, rewriteImportMetaGlobBase as c, isLegacyVueVersion as i, rewriteStaticAssetUrls as l, hasHostVueSfcCompilerPlugin as n, createLogger as o, isLegacyVueCompatibilityMode as r, rewriteDynamicTemplateImports as s, createLegacyVueCompatibilityPlugin as t, shouldApplyDefineInVirtualModule as u };
+export { removeHostVueSfcCompilers as a, rewriteDynamicTemplateImports as c, shouldApplyDefineInVirtualModule as d, isLegacyVueVersion as i, rewriteImportMetaGlobBase as l, hasHostVueSfcCompilerPlugin as n, applyDefineReplacements as o, isLegacyVueCompatibilityMode as r, createLogger as s, createLegacyVueCompatibilityPlugin as t, rewriteStaticAssetUrls as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.481.0",
+  "version": "0.483.0",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -51,13 +51,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.481.0",
-    "@vizejs/unplugin": "0.481.0",
+    "@vizejs/native": "0.483.0",
+    "@vizejs/unplugin": "0.483.0",
     "jsonc-parser": "^3.3.1",
     "oxc-parser": "0.144.0",
     "picomatch": "4.0.5",
     "tinyglobby": "0.2.17",
-    "vize": "0.481.0"
+    "vize": "0.483.0"
   },
   "devDependencies": {
     "@types/node": "25.9.2",

package/dist/plugin-C1ZHQliC.mjs

@@ -1,2 +0,0 @@
-import { t as vize } from "./plugin-BJpHdKQz.mjs";
-export { vize };