@vizejs/vite-plugin 0.331.0 → 0.333.0

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-DR5IFFd7.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-T_Fu8G5I.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts

package/dist/index.mjs

@@ -341,9 +341,20 @@ function toNativeCssAliasRule(rule) {
 }
 //#endregion
 //#region src/utils/filter.ts
+/**
+* Defaults the filter falls back to, and what the `vite:vue` shim reports
+* through `api.include` / `api.exclude` when neither is configured (#3227).
+*
+* `DEFAULT_INCLUDE_PATTERN` is `@vitejs/plugin-vue`'s own default.
+* `DEFAULT_EXCLUDE_PATTERN` has no upstream counterpart — plugin-vue leaves
+* `exclude` undefined — so the shim reports the pattern Vize actually filters
+* on rather than an upstream-shaped `undefined` it does not honor.
+*/
+const DEFAULT_INCLUDE_PATTERN = /\.vue$/;
+const DEFAULT_EXCLUDE_PATTERN = /node_modules/;
 function createFilter(include, exclude) {
-	const includePatterns = include ? Array.isArray(include) ? include : [include] : [/\.vue$/];
-	const excludePatterns = exclude ? Array.isArray(exclude) ? exclude : [exclude] : [/node_modules/];
+	const includePatterns = include ? Array.isArray(include) ? include : [include] : [DEFAULT_INCLUDE_PATTERN];
+	const excludePatterns = exclude ? Array.isArray(exclude) ? exclude : [exclude] : [DEFAULT_EXCLUDE_PATTERN];
 	return (id) => {
 		const matchInclude = includePatterns.some((pattern) => matchesFilterPattern(pattern, id));
 		const matchExclude = excludePatterns.some((pattern) => matchesFilterPattern(pattern, id));
@@ -2425,6 +2436,114 @@ 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 = {}) {
+	const moduleId = JSON.stringify(toManifestModuleId(filePath, root));
+	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) {
+	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)
+	});
+	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;
+	}
+}
+//#endregion
 //#region src/plugin/vite-transform.ts
 function createVirtualTypeScriptTransformer(viteApi) {
 	return async (code, id) => {
@@ -2515,9 +2634,6 @@ function getBoundaryPlaceholderCode(realPath, ssr) {
 	if (!ssr && boundaryKind === "server") return SERVER_PLACEHOLDER_CODE;
 	return null;
 }
-function normalizeVueServerRendererImport(code) {
-	return code.replace(/\bfrom\s+(['"])@vue\/server-renderer\1/g, "from \"vue/server-renderer\"");
-}
 function findMacroArtifactModule(state, realPath, ssr, kind) {
 	const cache = getEnvironmentCache(state, ssr);
 	const extractCss = shouldExtractCssForRequest(state, ssr);
@@ -2578,6 +2694,7 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 	rewritten.edit(rewriteDynamicTemplateImports(rewritten.code, state.dynamicImportAliasRules));
 	rewritten.edit(rewriteStaticAssetUrls(rewritten.code, state.dynamicImportAliasRules));
 	rewritten.edit(rewriteImportMetaGlobBase(rewritten.code, realPath, state.root));
+	rewritten.edit(appendSsrModuleRegistration(rewritten.code, realPath, state.root, isSsr));
 	return {
 		code: rewritten.code,
 		map: rewritten.map
@@ -2938,7 +3055,16 @@ async function handleHotUpdateEnvironmentHook(state, environment, options) {
 }
 //#endregion
 //#region src/plugin/compat.ts
-function createVueCompatPlugin(state) {
+/**
+* The `vite:vue` shim a host framework probes for a Vue plugin.
+*
+* `api.include` / `api.exclude` report the patterns behind `state.filter`, and
+* assigning them rewrites the plugin's own options — the only window where that
+* is meaningful is before `configResolved` builds the filter, so a later write
+* throws rather than silently doing nothing (#3227). Upstream guards the same
+* way, keyed on its `options` hook instead.
+*/
+function createVueCompatPlugin(state, options) {
 	let compilerSfc = null;
 	const loadCompilerSfc = () => {
 		if (!compilerSfc) try {
@@ -2951,16 +3077,36 @@ function createVueCompatPlugin(state) {
 		}
 		return compilerSfc;
 	};
+	const configured = () => state.initialized ? state.mergedOptions : options;
+	const assertUnresolved = (name) => {
+		if (state.initialized) throw new Error(`${name} cannot be updated after the filter is resolved`);
+	};
 	return {
 		name: "vite:vue",
-		api: { get options() {
-			return {
-				compiler: loadCompilerSfc(),
-				isProduction: state.isProduction ?? false,
-				root: state.root ?? process.cwd(),
-				template: {}
-			};
-		} }
+		api: {
+			get options() {
+				return {
+					compiler: loadCompilerSfc(),
+					isProduction: state.isProduction ?? false,
+					root: state.root ?? process.cwd(),
+					template: {}
+				};
+			},
+			get include() {
+				return configured().include ?? DEFAULT_INCLUDE_PATTERN;
+			},
+			set include(value) {
+				assertUnresolved("include");
+				options.include = value;
+			},
+			get exclude() {
+				return configured().exclude ?? DEFAULT_EXCLUDE_PATTERN;
+			},
+			set exclude(value) {
+				assertUnresolved("exclude");
+				options.exclude = value;
+			}
+		}
 	};
 }
 function normalizeVirtualStyleId(id) {
@@ -3584,11 +3730,18 @@ function parseDefine(value) {
 		return value;
 	}
 }
-/** Resolve Vue runtime defines with plugin-vue's precedence and defaults. */
-function resolveVueFeatureDefines(features, define, command) {
+/**
+* Resolve Vue runtime defines with plugin-vue's precedence and defaults.
+*
+* `__VUE_PROD_DEVTOOLS__` used to be `command === "serve"`, which left no way to
+* enable devtools for a production build (#3227). It now follows plugin-vue's
+* OR semantics, and defaults to `false` in dev as upstream does: a development
+* build enables devtools through Vue's own `__DEV__`, not through this flag.
+*/
+function resolveVueFeatureDefines(features, define) {
 	return {
 		__VUE_OPTIONS_API__: features?.optionsAPI ?? parseDefine(define?.__VUE_OPTIONS_API__) ?? true,
-		__VUE_PROD_DEVTOOLS__: command === "serve",
+		__VUE_PROD_DEVTOOLS__: (features?.prodDevtools || parseDefine(define?.__VUE_PROD_DEVTOOLS__)) ?? false,
 		__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: (features?.prodHydrationMismatchDetails || parseDefine(define?.__VUE_PROD_HYDRATION_MISMATCH_DETAILS__)) ?? false
 	};
 }
@@ -3643,14 +3796,14 @@ function vize(options = {}) {
 		logger: createLogger(options.debug ?? false)
 	};
 	return [
-		createVueCompatPlugin(state),
+		createVueCompatPlugin(state, options),
 		{
 			name: "vite-plugin-vize",
 			enforce: "pre",
-			config(userConfig, env) {
+			config(userConfig) {
 				patchCssModuleGenerateScopedName(userConfig);
 				return {
-					define: resolveVueFeatureDefines(options.features, userConfig.define, env.command),
+					define: resolveVueFeatureDefines(options.features, userConfig.define),
 					optimizeDeps: { exclude: ["virtual:vize-styles"] }
 				};
 			},

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

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

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

@@ -730,6 +730,11 @@ interface VizeVueFeatures {
    * @default true
    */
   optionsAPI?: boolean;
+  /**
+   * Enable Vue devtools support in production bundles.
+   * @default false
+   */
+  prodDevtools?: boolean;
   /**
    * Enable detailed hydration mismatch errors in production bundles.
    * @default false

package/package.json

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