@vizejs/vite-plugin 0.345.0 → 0.350.2

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 VizeInspectorLintPlanProvider, c as VizeCompatibilityOptions, d as LoadConfigOptions, f as ResolvedVizeConfig, i as VizeVueFeatures, l as VizeVueVersion, m as VizeConfig, n as CompiledModule, o as VizeInspectorLintPlanRequest, p as UserConfigExport, r as MacroArtifact, s as VizeInspectorOptions, t as VizeOptions, u as ConfigEnv } from "./types-0tlI4YFk.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts

package/dist/index.mjs

@@ -448,6 +448,13 @@ function isCssModule(block) {
 function needsCssPipeline(block) {
 	return block.content.includes("@apply");
 }
+function styleVirtualSuffix(block) {
+	const lang = block.lang ?? "css";
+	return block.module !== false ? `.module.${lang}` : `.${lang}`;
+}
+function createStyleImportUrl(filePath, params, block) {
+	return `${filePath}?${params.toString()}${styleVirtualSuffix(block)}`;
+}
 /**
 * Check if any style blocks in the compiled module require delegation to
 * Vite's CSS pipeline (preprocessor, CSS Modules, or PostCSS transforms).
@@ -505,7 +512,7 @@ function generateScopeId(filename) {
 * emitted as imports and `compiled.css` is not used.
 */
 function usesStyleImports(compiled, options) {
-	return !!options.filePath && !!compiled.styles?.length && (hasDelegatedStyles(compiled) || !options.ssr && options.isProduction && !!options.extractCss);
+	return !!options.filePath && !!compiled.styles?.length && (options.customElement || hasDelegatedStyles(compiled) || !options.ssr && options.isProduction && !!options.extractCss);
 }
 /**
 * Whether `generateOutput` will embed `compiled.css` in the module.
@@ -524,7 +531,7 @@ function usesStyleImports(compiled, options) {
 * 300-file bench corpus).
 */
 function embedsInlineCss(compiled, options) {
-	return !usesStyleImports(compiled, options) && !options.ssr && !!compiled.css && !(options.isProduction && !!options.extractCss);
+	return !usesStyleImports(compiled, options) && !options.customElement && !options.ssr && !!compiled.css && !(options.isProduction && !!options.extractCss);
 }
 function generateOutput(compiled, options) {
 	return generateOutputWithMap(compiled, options).code;
@@ -538,7 +545,7 @@ function generateOutput(compiled, options) {
 * `null` when the compiler produced none.
 */
 function generateOutputWithMap(compiled, options) {
-	const { isProduction, isDev, ssr, hmrUpdateType, extractCss, filePath } = options;
+	const { customElement, isProduction, isDev, ssr, hmrUpdateType, extractCss, filePath } = options;
 	const emitted = new MappedModule(compiled.code, parseSourceMap(compiled.map));
 	const moduleInfo = compiled.moduleShape ?? analyzeModuleOutput(emitted.code);
 	const hasExportDefault = moduleInfo.hasDefaultExport;
@@ -565,6 +572,7 @@ function generateOutputWithMap(compiled, options) {
 	if (usesStyleImports(compiled, options)) {
 		const styleImports = [];
 		const cssModuleImports = [];
+		const customElementStyleBindings = [];
 		for (const block of compiled.styles) {
 			const lang = block.lang ?? "css";
 			const params = new URLSearchParams();
@@ -573,19 +581,27 @@ function generateOutputWithMap(compiled, options) {
 			params.set("index", String(block.index));
 			if (block.scoped) params.set("scoped", `data-v-${compiled.scopeId}`);
 			params.set("lang", lang);
-			if (isCssModule(block)) {
+			if (customElement) {
+				if (isCssModule(block)) throw new Error("<style module> is not supported in custom element mode");
+				params.set("inline", "");
+				const bindingName = `_style_${block.index}`;
+				const importUrl = createStyleImportUrl(filePath, params, block);
+				styleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
+				customElementStyleBindings.push(bindingName);
+			} else if (isCssModule(block)) {
 				const bindingName = typeof block.module === "string" ? block.module : "$style";
 				params.set("module", typeof block.module === "string" ? block.module : "");
-				const importUrl = `${filePath}?${params.toString()}`;
+				const importUrl = createStyleImportUrl(filePath, params, block);
 				cssModuleImports.push(`import ${bindingName} from ${JSON.stringify(importUrl)};`);
 			} else {
-				const importUrl = `${filePath}?${params.toString()}`;
+				const importUrl = createStyleImportUrl(filePath, params, block);
 				styleImports.push(`import ${JSON.stringify(importUrl)};`);
 			}
 		}
 		const allImports = [...styleImports, ...cssModuleImports].join("\n");
 		if (allImports) emitted.edit(insertAfterStaticImports(emitted.code, allImports));
-		if (cssModuleImports.length > 0) {
+		if (customElementStyleBindings.length > 0) emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, `_sfc_main.styles = [${customElementStyleBindings.join(", ")}];`, { normalizeSemicolon: true }));
+		else if (cssModuleImports.length > 0) {
 			const moduleBindings = [];
 			for (const block of compiled.styles) if (isCssModule(block)) {
 				const bindingName = typeof block.module === "string" ? block.module : "$style";
@@ -725,6 +741,37 @@ function createLogger(debug) {
 	};
 }
 //#endregion
+//#region src/plugin/plugin-vue-options.ts
+const PLUGIN_VUE_COMPAT_VERSION = "6.0.7";
+const DEFAULT_CUSTOM_ELEMENT_PATTERN = /\.ce\.vue$/;
+function booleanCompilerOption(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolvePluginVueCompileOptions(options) {
+	const compilerOptions = options.template?.compilerOptions;
+	const resolved = { styleTrim: options.style?.trim ?? true };
+	const templateCacheHandlers = booleanCompilerOption(compilerOptions?.cacheHandlers);
+	const templateComments = booleanCompilerOption(compilerOptions?.comments);
+	const templateHoistStatic = booleanCompilerOption(compilerOptions?.hoistStatic);
+	const templatePrefixIdentifiers = booleanCompilerOption(compilerOptions?.prefixIdentifiers);
+	if (templateCacheHandlers !== void 0) resolved.templateCacheHandlers = templateCacheHandlers;
+	if (templateComments !== void 0) resolved.templateComments = templateComments;
+	if (templateHoistStatic !== void 0) resolved.templateHoistStatic = templateHoistStatic;
+	if (templatePrefixIdentifiers !== void 0) resolved.templatePrefixIdentifiers = templatePrefixIdentifiers;
+	return resolved;
+}
+function resolveCustomElementOption(options) {
+	const featureCustomElement = options.features?.customElement;
+	if (featureCustomElement) return featureCustomElement;
+	if (options.customElement !== void 0) return options.customElement;
+	return DEFAULT_CUSTOM_ELEMENT_PATTERN;
+}
+function isPluginVueCustomElement(options, filePath) {
+	const customElement = resolveCustomElementOption(options);
+	if (typeof customElement === "boolean") return customElement;
+	return createFilter(customElement, void 0)(filePath);
+}
+//#endregion
 //#region src/plugin/precompile.ts
 const DEFAULT_PRECOMPILE_IGNORE_PATTERNS = [
 	"node_modules/**",
@@ -770,8 +817,10 @@ function getCompileOptionsForRequest(state, ssr) {
 		ssr,
 		vapor: !ssr && (state.mergedOptions?.vapor ?? false),
 		customRenderer: state.mergedOptions?.customRenderer ?? false,
-		templateSyntax: state.mergedOptions?.templateSyntax ?? "standard"
+		templateSyntax: state.mergedOptions?.templateSyntax ?? "standard",
+		...resolvePluginVueCompileOptions(state.mergedOptions ?? {})
 	};
+	if (state.mergedOptions?.customElements !== void 0) options.customElements = state.mergedOptions.customElements;
 	if (state.mergedOptions?.mode !== void 0) options.mode = state.mergedOptions.mode;
 	if (state.mergedOptions?.runtimeModuleName !== void 0) options.runtimeModuleName = state.mergedOptions.runtimeModuleName;
 	if (state.mergedOptions?.runtimeGlobalName !== void 0) options.runtimeGlobalName = state.mergedOptions.runtimeGlobalName;
@@ -826,6 +875,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 +886,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 +903,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
@@ -888,10 +957,16 @@ function buildCompileFileOptions(filePath, options) {
 		ssr: options.ssr,
 		vapor: options.vapor,
 		customRenderer: options.customRenderer ?? false,
+		...options.customElements === void 0 ? {} : { customElements: options.customElements },
 		experimentalInTagComments: options.experimentalInTagComments ?? false,
 		experimentalPatternedTemplate: options.experimentalPatternedTemplate ?? false,
 		experimentalServerScript: options.experimentalServerScript ?? false,
 		scopeId: `data-v-${generateScopeId(filePath)}`,
+		styleTrim: options.styleTrim,
+		...options.templateCacheHandlers === void 0 ? {} : { templateCacheHandlers: options.templateCacheHandlers },
+		...options.templateComments === void 0 ? {} : { templateComments: options.templateComments },
+		...options.templateHoistStatic === void 0 ? {} : { templateHoistStatic: options.templateHoistStatic },
+		...options.templatePrefixIdentifiers === void 0 ? {} : { templatePrefixIdentifiers: options.templatePrefixIdentifiers },
 		...options.mode === void 0 ? {} : { mode: options.mode },
 		...options.templateSyntax === void 0 ? {} : { templateSyntax: options.templateSyntax },
 		...options.runtimeModuleName === void 0 ? {} : { runtimeModuleName: options.runtimeModuleName },
@@ -904,6 +979,7 @@ function buildCompileBatchOptions(options) {
 		ssr: options.ssr,
 		vapor: options.vapor,
 		customRenderer: options.customRenderer ?? false,
+		...options.customElements === void 0 ? {} : { customElements: options.customElements },
 		experimentalInTagComments: options.experimentalInTagComments ?? false,
 		experimentalPatternedTemplate: options.experimentalPatternedTemplate ?? false,
 		experimentalServerScript: options.experimentalServerScript ?? false,
@@ -911,6 +987,11 @@ function buildCompileBatchOptions(options) {
 		includeMacroArtifacts: true,
 		includeHashes: true,
 		includeSourceMap: options.sourceMap,
+		styleTrim: options.styleTrim,
+		...options.templateCacheHandlers === void 0 ? {} : { templateCacheHandlers: options.templateCacheHandlers },
+		...options.templateComments === void 0 ? {} : { templateComments: options.templateComments },
+		...options.templateHoistStatic === void 0 ? {} : { templateHoistStatic: options.templateHoistStatic },
+		...options.templatePrefixIdentifiers === void 0 ? {} : { templatePrefixIdentifiers: options.templatePrefixIdentifiers },
 		...options.mode === void 0 ? {} : { mode: options.mode },
 		...options.templateSyntax === void 0 ? {} : { templateSyntax: options.templateSyntax },
 		...options.runtimeModuleName === void 0 ? {} : { runtimeModuleName: options.runtimeModuleName },
@@ -1568,19 +1649,26 @@ function writeManifest(file, container, onDiagnostic) {
 * that reaches the native compiler reaches the key with it.
 */
 function resolvePrecompileBatchOptions(state) {
+	const requestOptions = getCompileOptionsForRequest(state, false);
 	return {
-		sourceMap: getCompileOptionsForRequest(state, false).sourceMap,
+		sourceMap: requestOptions.sourceMap,
 		ssr: false,
 		vapor: state.mergedOptions.vapor ?? false,
 		mode: state.mergedOptions.mode,
 		customRenderer: state.mergedOptions.customRenderer ?? false,
+		customElements: state.mergedOptions.customElements,
 		templateSyntax: state.mergedOptions.templateSyntax ?? "standard",
 		experimentalInTagComments: state.mergedOptions.experimentalInTagComments ?? false,
 		experimentalPatternedTemplate: state.mergedOptions.experimentalPatternedTemplate ?? false,
 		experimentalServerScript: state.mergedOptions.experimentalServerScript ?? false,
 		runtimeModuleName: state.mergedOptions.runtimeModuleName,
 		runtimeGlobalName: state.mergedOptions.runtimeGlobalName,
-		vueVersion: state.mergedOptions.vueVersion
+		vueVersion: state.mergedOptions.vueVersion,
+		styleTrim: requestOptions.styleTrim,
+		templateCacheHandlers: requestOptions.templateCacheHandlers,
+		templateComments: requestOptions.templateComments,
+		templateHoistStatic: requestOptions.templateHoistStatic,
+		templatePrefixIdentifiers: requestOptions.templatePrefixIdentifiers
 	};
 }
 function openCacheForRun(state, batchOptions) {
@@ -1662,7 +1750,10 @@ async function compileAll(state) {
 				state.cache.set(file, restored);
 				const metadata = currentMetadata.get(file);
 				if (metadata) state.precompileMetadata.set(file, metadata);
-				syncCollectedCssForFile(state, file, restored);
+				syncCollectedCssForFile({
+					...state,
+					extractCss: state.extractCss && !isPluginVueCustomElement(state.mergedOptions, file)
+				}, file, restored);
 				restoredCount++;
 				continue;
 			}
@@ -1692,7 +1783,10 @@ async function compileAll(state) {
 			const compiled = state.cache.get(fileResult.path);
 			const sourceHash = sourceHashes.get(fileResult.path);
 			if (compiled && sourceHash !== void 0) cache.set(fileResult.path, sourceHash, compiled);
-			syncCollectedCssForFile(state, fileResult.path, compiled);
+			syncCollectedCssForFile({
+				...state,
+				extractCss: state.extractCss && !isPluginVueCustomElement(state.mergedOptions, fileResult.path)
+			}, fileResult.path, compiled);
 		}
 	}
 	cache.retain(new Set(sfcFiles));
@@ -2619,6 +2713,13 @@ async function transformVizeVirtualModule(state, code, realPath, ssr, forceTypeS
 	}
 }
 //#endregion
+//#region src/plugin/load-style.ts
+function normalizeStyleVirtualId(id) {
+	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
+	if (!withoutPrefix.includes("?vue")) return id;
+	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
+}
+//#endregion
 //#region src/plugin/load.ts
 const SERVER_PLACEHOLDER_CODE = `import { createElementBlock, defineComponent } from "vue";
 export default defineComponent({
@@ -2649,11 +2750,6 @@ function findMacroArtifactModule(state, realPath, ssr, kind) {
 	}, realPath, compiled);
 	return compiled?.macroArtifacts?.find((artifact) => artifact.kind === kind)?.moduleCode ?? null;
 }
-function normalizeStyleVirtualId(id) {
-	const withoutPrefix = id.startsWith("\0") ? id.slice(1) : id;
-	if (!withoutPrefix.includes("?vue")) return id;
-	return withoutPrefix.replace(/\.module\.\w+$/, "").replace(/\.\w+$/, "");
-}
 function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions) {
 	const placeholderCode = getBoundaryPlaceholderCode(realPath, !!loadOptions?.ssr);
 	if (placeholderCode) {
@@ -2664,7 +2760,8 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 		};
 	}
 	const cache = getEnvironmentCache(state, isSsr);
-	const extractCss = shouldExtractCssForRequest(state, isSsr);
+	const customElement = isPluginVueCustomElement(state.mergedOptions, realPath);
+	const extractCss = shouldExtractCssForRequest(state, isSsr) && !customElement;
 	let compiled = cache.get(realPath);
 	if (!compiled && fs.existsSync(realPath)) {
 		state.logger.log(`load: on-demand compiling ${realPath}`);
@@ -2683,6 +2780,7 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 		ssr: isSsr,
 		hmrUpdateType: loadOptions?.ssr ? void 0 : state.pendingHmrUpdateTypes.get(realPath),
 		extractCss,
+		customElement,
 		filePath: realPath
 	};
 	if (compiled.css && !hasDelegated && embedsInlineCss(compiled, outputOptions)) compiled = {
@@ -2843,25 +2941,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 +2970,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 +2993,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");
@@ -2962,6 +3072,15 @@ async function handleHotUpdateHook(state, ctx, options = {}) {
 		state.logger.log(`Re-compiled: ${path.relative(state.root, file)} (${updateType})`);
 		const modules = preferAcceptingClientModules(initialModules ?? await collectModulesByFile(server, getVueModuleFileCandidates(file)), options.requireAcceptingClientModule);
 		const hasDelegated = hasDelegatedStyles(newCompiled);
+		if (isPluginVueCustomElement(state.mergedOptions, file) && updateType === "style-only") {
+			if (modules.size > 0) {
+				state.pendingHmrUpdateTypes.set(file, "full-reload");
+				invalidateModules(server, modules);
+				return [...modules];
+			}
+			state.pendingHmrUpdateTypes.delete(file);
+			return [];
+		}
 		if (hasDelegated && updateType === "style-only") {
 			const affectedModules = /* @__PURE__ */ new Set();
 			for (const block of newCompiled.styles ?? []) {
@@ -3044,6 +3163,7 @@ async function handleHotUpdateEnvironmentHook(state, environment, options) {
 		...options,
 		server
 	}, {
+		ensureAcceptingClientModule: (vueFile) => environment.moduleGraph.ensureEntryFromUrl(toPluginVisibleVirtualId(vueFile), false),
 		requireAcceptingClientModule: true,
 		onRecompileError: () => {
 			recompileFailed = true;
@@ -3066,6 +3186,10 @@ async function handleHotUpdateEnvironmentHook(state, environment, options) {
 */
 function createVueCompatPlugin(state, options) {
 	let compilerSfc = null;
+	const templateOptions = { compilerOptions: {
+		directiveTransforms: {},
+		nodeTransforms: []
+	} };
 	const loadCompilerSfc = () => {
 		if (!compilerSfc) try {
 			compilerSfc = createRequire(import.meta.url)("@vue/compiler-sfc");
@@ -3089,7 +3213,7 @@ function createVueCompatPlugin(state, options) {
 					compiler: loadCompilerSfc(),
 					isProduction: state.isProduction ?? false,
 					root: state.root ?? process.cwd(),
-					template: {}
+					template: templateOptions
 				};
 			},
 			get include() {
@@ -3105,7 +3229,8 @@ function createVueCompatPlugin(state, options) {
 			set exclude(value) {
 				assertUnresolved("exclude");
 				options.exclude = value;
-			}
+			},
+			version: PLUGIN_VUE_COMPAT_VERSION
 		}
 	};
 }
@@ -3746,10 +3871,7 @@ function resolveVueFeatureDefines(features, define) {
 	};
 }
 //#endregion
-//#region src/plugin/index.ts
-function aliasSortKey(find) {
-	return typeof find === "string" ? find.length : find.source.length;
-}
+//#region src/plugin/index-helpers.ts
 function shouldExtractCssForBuild(state, context) {
 	if (!state.isProduction) return false;
 	const environmentName = context.environment?.name;
@@ -3766,6 +3888,11 @@ function resolveCompatibilityOptions(options, compilerConfig = {}) {
 	if (compatibility.hostCompiler === void 0 && isLegacyVueVersion(vueVersion)) compatibility.hostCompiler = true;
 	return compatibility;
 }
+function aliasSortKey(find) {
+	return typeof find === "string" ? find.length : find.source.length;
+}
+//#endregion
+//#region src/plugin/index.ts
 function vize(options = {}) {
 	if (isLegacyVueCompatibilityMode(options)) return [createLegacyVueCompatibilityPlugin(options)];
 	const state = {
@@ -3845,6 +3972,7 @@ function vize(options = {}) {
 					sourceMap: options.sourceMap ?? compilerConfig.sourceMap,
 					...resolveExperimentalCompilerOptions(options, compilerConfig, sharedConfig?.experimentals),
 					customRenderer: options.customRenderer ?? compilerConfig.customRenderer ?? false,
+					customElements: options.customElements ?? compilerConfig.customElements,
 					templateSyntax,
 					compatibility,
 					vueVersion,
@@ -3920,6 +4048,9 @@ function vize(options = {}) {
 			async hotUpdate(options) {
 				return handleHotUpdateEnvironmentHook(state, this.environment, options);
 			},
+			shouldTransformCachedModule({ id }) {
+				return id?.includes(".vue") ? true : void 0;
+			},
 			async handleHotUpdate(ctx) {
 				return handleHotUpdateHook(state, ctx);
 			},

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-0tlI4YFk.mjs";
 import { ResolvedConfig } from "vite";
 
 //#region src/internal/config-bridge.d.ts

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

@@ -74,6 +74,10 @@ interface CompilerConfig {
    * Treat lowercase non-HTML tags as custom renderer elements
    */
   customRenderer?: boolean;
+  /**
+   * Tag patterns that compile as custom elements instead of Vue components
+   */
+  customElements?: string[];
   /**
    * Enable SSR mode
    */
@@ -409,6 +413,10 @@ interface LanguageServerConfig {
    * Enable completions
    */
   completion?: boolean;
+  /**
+   * Enable TypeScript signature help
+   */
+  signatureHelp?: boolean;
   /**
    * Enable hover information
    */
@@ -708,6 +716,36 @@ interface ExperimentalPluginOptions extends ExperimentalCompileFlags {
   experimentals?: ExperimentalOptions;
 }
 //#endregion
+//#region src/compatibility-types.d.ts
+type VizeVueVersion = 0.11 | 1 | 2 | "2.7" | 3 | "legacy";
+interface VizeCompatibilityOptions {
+  /**
+   * Host Vue version. Vue 0.11/1/2/2.7 opt into host-compiler compatibility.
+   */
+  vueVersion?: VizeVueVersion;
+  /**
+   * Keep .vue files on the existing Vue compiler for legacy Vue runtimes.
+   * @default true when vueVersion is 0.11, 1, 2, "2.7", or "legacy"
+   */
+  hostCompiler?: boolean;
+  /**
+   * Enable function-body output for CDN/global Vue evaluation.
+   */
+  scriptSetupInStandalone?: boolean;
+  /**
+   * Allow Vapor output for Options API SFCs when vapor is enabled.
+   */
+  optionsApiVapor?: boolean;
+  /**
+   * Override the host Nuxt major when this option object is shared with Nuxt.
+   */
+  nuxtVersion?: 2 | 3 | 4;
+  /**
+   * Override the host Webpack major when this option object is shared with unplugin.
+   */
+  webpackVersion?: 4 | 5;
+}
+//#endregion
 //#region src/inspector-types.d.ts
 interface VizeInspectorLintPlanRequest {
   /** Project-relative files whose effective lint rules should be explained. */
@@ -721,6 +759,36 @@ interface VizeInspectorOptions {
   lintPlan?: VizeInspectorLintPlanProvider;
 }
 //#endregion
+//#region src/plugin-vue-types.d.ts
+type VitePluginVueFilterPattern = string | RegExp | (string | RegExp)[];
+type VitePluginVueCustomElementOption = boolean | VitePluginVueFilterPattern;
+type VitePluginVueComponentIdGenerator = "filepath" | "filepath-source" | ((filepath: string, source: string, isProduction: boolean, getHash: (text: string) => string) => string);
+interface VitePluginVueScriptOptions {
+  hoistStatic?: boolean;
+  propsDestructure?: boolean | "error";
+  globalTypeFiles?: string[];
+  [key: string]: unknown;
+}
+interface VitePluginVueTemplateCompilerOptions {
+  comments?: boolean;
+  hoistStatic?: boolean;
+  cacheHandlers?: boolean;
+  prefixIdentifiers?: boolean;
+  [key: string]: unknown;
+}
+interface VitePluginVueTemplateOptions {
+  compilerOptions?: VitePluginVueTemplateCompilerOptions;
+  transformAssetUrls?: boolean | Record<string, unknown>;
+  preprocessCustomRequire?: unknown;
+  preprocessOptions?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+interface VitePluginVueStyleOptions {
+  trim?: boolean;
+  inMap?: unknown;
+  [key: string]: unknown;
+}
+//#endregion
 //#region src/vue-features.d.ts
 /** Vue runtime feature flags shared with `@vitejs/plugin-vue`. */
 interface VizeVueFeatures {
@@ -740,6 +808,12 @@ interface VizeVueFeatures {
    * @default false
    */
   prodHydrationMismatchDetails?: boolean;
+  /** Custom-element matcher from `@vitejs/plugin-vue`'s `features` bag. */
+  customElement?: VitePluginVueCustomElementOption;
+  /** Vue 3.5 reactive props destructure feature flag. */
+  propsDestructure?: boolean | "error";
+  /** Scope-id strategy hook accepted for plugin-vue config compatibility. */
+  componentIdGenerator?: VitePluginVueComponentIdGenerator;
 }
 //#endregion
 //#region src/utils/module-output.d.ts
@@ -764,7 +838,7 @@ type ModuleOutputInfo = {
   defaultExportIsSfcMain: boolean;
 };
 //#endregion
-//#region src/types.d.ts
+//#region src/sfc-types.d.ts
 interface MacroArtifact {
   kind: string;
   name: string;
@@ -774,34 +848,51 @@ interface MacroArtifact {
   start: number;
   end: number;
 }
-type VizeVueVersion = 0.11 | 1 | 2 | "2.7" | 3 | "legacy";
-interface VizeCompatibilityOptions {
-  /**
-   * Host Vue version. Vue 0.11/1/2/2.7 opt into host-compiler compatibility.
-   */
-  vueVersion?: VizeVueVersion;
-  /**
-   * Keep .vue files on the existing Vue compiler for legacy Vue runtimes.
-   * @default true when vueVersion is 0.11, 1, 2, "2.7", or "legacy"
-   */
-  hostCompiler?: boolean;
-  /**
-   * Enable function-body output for CDN/global Vue evaluation.
-   */
-  scriptSetupInStandalone?: boolean;
-  /**
-   * Allow Vapor output for Options API SFCs when vapor is enabled.
-   */
-  optionsApiVapor?: boolean;
+interface StyleBlockInfo {
+  /** Raw style content (uncompiled for preprocessor langs) */
+  content: string;
+  /** External source path from `<style src>`, when present */
+  src?: string | null;
+  /** Language of the style block (e.g., "css", "scss", "less", "sass", "stylus") */
+  lang: string | null;
+  /** Whether the style block has the scoped attribute */
+  scoped: boolean;
+  /** CSS Modules: true for unnamed `module`, or the binding name for `module="name"` */
+  module: boolean | string;
+  /** Index of this style block in the SFC */
+  index: number;
+}
+interface CompiledModule {
+  code: string;
   /**
-   * Override the host Nuxt major when this option object is shared with Nuxt.
+   * Source Map v3 document (JSON) describing `code`, when the compiler was
+   * asked for one (#3399). Absent when source maps are off, when the SFC has no
+   * script block, and for the rspack and unplugin builders, which do not request
+   * maps. Persisted with the rest of the module in the pre-compile cache.
    */
-  nuxtVersion?: 2 | 3 | 4;
+  map?: string;
+  css?: string;
+  scopeId: string;
+  hasScoped: boolean;
+  templateHash?: string;
+  styleHash?: string;
+  scriptHash?: string;
+  /** Compile-time macro artifacts extracted from the source SFC */
+  macroArtifacts?: MacroArtifact[];
+  /** Per-block style metadata extracted from the source SFC */
+  styles?: StyleBlockInfo[];
+  /** Files loaded through SFC `src` imports */
+  dependencies?: string[];
   /**
-   * Override the host Webpack major when this option object is shared with unplugin.
+   * Module shape reported by the native compiler, so `generateOutput` need not
+   * re-parse the emitted module (#3425). Absent for a cache entry written before
+   * the field existed, and for the rspack and unplugin builders, which never set
+   * it — both fall back to parsing.
    */
-  webpackVersion?: 4 | 5;
+  moduleShape?: ModuleOutputInfo;
 }
+//#endregion
+//#region src/types.d.ts
 interface VizeOptions extends ExperimentalPluginOptions {
   /**
    * Inline shared Vize config for Vite Plus-first projects.
@@ -812,6 +903,19 @@ interface VizeOptions extends ExperimentalPluginOptions {
   inspector?: VizeInspectorOptions;
   /** Vue runtime feature flags compatible with `@vitejs/plugin-vue`. */
   features?: VizeVueFeatures;
+  /** `@vitejs/plugin-vue` script option bag accepted for drop-in config parity. */
+  script?: VitePluginVueScriptOptions;
+  /** `@vitejs/plugin-vue` template option bag. */
+  template?: VitePluginVueTemplateOptions;
+  /** `@vitejs/plugin-vue` style option bag. */
+  style?: VitePluginVueStyleOptions;
+  /** Lower-level compiler override accepted for plugin-vue config parity. */
+  compiler?: unknown;
+  /**
+   * Top-level custom-element matcher supported by `@vitejs/plugin-vue`.
+   * @default /\.ce\.vue$/
+   */
+  customElement?: VitePluginVueCustomElementOption;
   /**
    * Vue major version for the host project.
    *
@@ -894,6 +998,11 @@ interface VizeOptions extends ExperimentalPluginOptions {
    * @default false
    */
   customRenderer?: boolean;
+  /**
+   * Tag patterns that compile as custom elements instead of Vue components.
+   * Supports exact tags and `*` wildcards, e.g. `["Tres*", "primitive"]`.
+   */
+  customElements?: string[];
   /**
    * Template syntax compatibility mode.
    * @default "standard"
@@ -947,48 +1056,5 @@ interface VizeOptions extends ExperimentalPluginOptions {
    */
   debug?: boolean;
 }
-interface StyleBlockInfo {
-  /** Raw style content (uncompiled for preprocessor langs) */
-  content: string;
-  /** External source path from `<style src>`, when present */
-  src?: string | null;
-  /** Language of the style block (e.g., "css", "scss", "less", "sass", "stylus") */
-  lang: string | null;
-  /** Whether the style block has the scoped attribute */
-  scoped: boolean;
-  /** CSS Modules: true for unnamed `module`, or the binding name for `module="name"` */
-  module: boolean | string;
-  /** Index of this style block in the SFC */
-  index: number;
-}
-interface CompiledModule {
-  code: string;
-  /**
-   * Source Map v3 document (JSON) describing `code`, when the compiler was
-   * asked for one (#3399). Absent when source maps are off, when the SFC has no
-   * script block, and for the rspack and unplugin builders, which do not request
-   * maps. Persisted with the rest of the module in the pre-compile cache.
-   */
-  map?: string;
-  css?: string;
-  scopeId: string;
-  hasScoped: boolean;
-  templateHash?: string;
-  styleHash?: string;
-  scriptHash?: string;
-  /** Compile-time macro artifacts extracted from the source SFC */
-  macroArtifacts?: MacroArtifact[];
-  /** Per-block style metadata extracted from the source SFC */
-  styles?: StyleBlockInfo[];
-  /** Files loaded through SFC `src` imports */
-  dependencies?: string[];
-  /**
-   * Module shape reported by the native compiler, so `generateOutput` need not
-   * re-parse the emitted module (#3425). Absent for a cache entry written before
-   * the field existed, and for the rspack and unplugin builders, which never set
-   * it — both fall back to parsing.
-   */
-  moduleShape?: ModuleOutputInfo;
-}
 //#endregion
-export { VizeVueVersion as a, VizeInspectorLintPlanRequest as c, LoadConfigOptions as d, ResolvedVizeConfig as f, VizeOptions as i, VizeInspectorOptions as l, VizeConfig as m, MacroArtifact as n, VizeVueFeatures as o, UserConfigExport as p, VizeCompatibilityOptions as r, VizeInspectorLintPlanProvider as s, CompiledModule as t, ConfigEnv as u };
+export { VizeInspectorLintPlanProvider as a, VizeCompatibilityOptions as c, LoadConfigOptions as d, ResolvedVizeConfig as f, VizeVueFeatures as i, VizeVueVersion as l, VizeConfig as m, CompiledModule as n, VizeInspectorLintPlanRequest as o, UserConfigExport as p, MacroArtifact as r, VizeInspectorOptions as s, VizeOptions as t, ConfigEnv as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizejs/vite-plugin",
-  "version": "0.345.0",
+  "version": "0.350.2",
   "description": "High-performance native Vite plugin for Vue SFC compilation powered by Vize",
   "keywords": [
     "compiler",
@@ -45,16 +45,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@vizejs/native": "0.345.0",
-    "oxc-parser": "0.133.0",
-    "tinyglobby": "0.2.16",
-    "vize": "0.345.0"
+    "@vizejs/native": "0.350.2",
+    "oxc-parser": "0.144.0",
+    "tinyglobby": "0.2.17",
+    "vize": "0.350.2"
   },
   "devDependencies": {
     "@types/node": "25.9.2",
     "typescript": "6.0.3",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.21",
-    "vite-plus": "0.1.21"
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
+    "vite-plus": "0.1.24"
   },
   "peerDependencies": {
     "vite": "^7.3.0 || ^8.0.0"