@vizejs/vite-plugin 0.310.0 → 0.312.0

package/README.md

@@ -181,8 +181,9 @@ interface VizeNativeOptions {
   ssr?: boolean;
 
   /**
-   * Enable source map generation
-   * @default true in development, false in production
+   * Enable source map generation. The emitted map's `sources` names the
+   * authored `.vue` file, not the virtual `.vue.ts` module.
+   * @default true in development, false in production unless `build.sourcemap` is set
    */
   sourceMap?: boolean;
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as VizeVueVersion, c as ResolvedVizeConfig, i as VizeOptions, l as UserConfigExport, n as MacroArtifact, o as ConfigEnv, r as VizeCompatibilityOptions, s as LoadConfigOptions, t as CompiledModule, u as VizeConfig } from "./types-x-lq08Y8.mjs";
+import { a as VizeVueVersion, c as ResolvedVizeConfig, i as VizeOptions, l as UserConfigExport, n as MacroArtifact, o as ConfigEnv, r as VizeCompatibilityOptions, s as LoadConfigOptions, t as CompiledModule, u as VizeConfig } from "./types-Cm3dJq25.mjs";
 import { Plugin } from "vite";
 
 //#region src/virtual.d.ts

package/dist/index.mjs

@@ -230,6 +230,89 @@ function insertBeforeSfcMainDefaultExport(code, insertion, options = {}) {
 	return `${code.slice(0, exportStart)}${insertion}\n${code.slice(exportStart)}`;
 }
 //#endregion
+//#region src/utils/source-map.ts
+function isSourceMapV3(value) {
+	if (value === null || typeof value !== "object") return false;
+	const map = value;
+	return map.version === 3 && Array.isArray(map.sources) && Array.isArray(map.names) && typeof map.mappings === "string";
+}
+/**
+* Parse a compiler-produced map, or `null` when there is nothing usable.
+*
+* A malformed map is worse than no map — Vite would chain garbage into the
+* bundle's map — so anything that is not a v3 document is dropped.
+*/
+function parseSourceMap(json) {
+	if (!json) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return null;
+	}
+	return isSourceMapV3(parsed) ? parsed : null;
+}
+function countNewlines(text) {
+	let total = 0;
+	for (let index = text.indexOf("\n"); index !== -1; index = text.indexOf("\n", index + 1)) total++;
+	return total;
+}
+/**
+* Insert `count` unmapped generated lines at generated line `atLine`.
+*
+* Returns the map unchanged when the insertion lands past the last mapped line,
+* because nothing after it needs moving.
+*/
+function shiftMappedLines(map, atLine, count) {
+	if (count <= 0) return map;
+	const groups = map.mappings.split(";");
+	if (atLine >= groups.length) return map;
+	const shifted = [
+		...groups.slice(0, atLine),
+		...Array(count).fill(""),
+		...groups.slice(atLine)
+	];
+	return {
+		...map,
+		mappings: shifted.join(";")
+	};
+}
+/**
+* A module's code and the map that describes it, edited together.
+*
+* Every write goes through {@link edit}, so the map is corrected in the same
+* step that changes the code and the two cannot drift.
+*/
+var MappedModule = class {
+	code;
+	map;
+	constructor(code, map) {
+		this.code = code;
+		this.map = map;
+	}
+	/** Replace the module with `next`, realigning the map to the new line layout. */
+	edit(next) {
+		const previous = this.code;
+		this.code = next;
+		if (this.map === null || next === previous) return;
+		const limit = Math.min(previous.length, next.length);
+		let prefix = 0;
+		while (prefix < limit && previous.charCodeAt(prefix) === next.charCodeAt(prefix)) prefix++;
+		let suffix = 0;
+		while (suffix < limit - prefix && previous.charCodeAt(previous.length - 1 - suffix) === next.charCodeAt(next.length - 1 - suffix)) suffix++;
+		const removed = previous.slice(prefix, previous.length - suffix);
+		const addedLines = countNewlines(next.slice(prefix, next.length - suffix)) - countNewlines(removed);
+		if (addedLines === 0) return;
+		if (addedLines < 0) {
+			this.map = null;
+			return;
+		}
+		const editLine = countNewlines(previous.slice(0, prefix));
+		const startsAtLineStart = prefix === 0 || previous.charCodeAt(prefix - 1) === 10;
+		this.map = shiftMappedLines(this.map, startsAtLineStart ? editLine : editLine + 1, addedLines);
+	}
+};
+//#endregion
 //#region src/utils/css.ts
 function scopeCssForPipeline(css, scopeId) {
 	return scopeViteCssForPipeline(css, scopeId);
@@ -433,29 +516,40 @@ function embedsInlineCss(compiled, options) {
 	return !usesStyleImports(compiled, options) && !options.ssr && !!compiled.css && !(options.isProduction && !!options.extractCss);
 }
 function generateOutput(compiled, options) {
+	return generateOutputWithMap(compiled, options).code;
+}
+/**
+* `generateOutput` plus the source map that describes the module it returns.
+*
+* The compiler's map (`compiled.map`) describes `compiled.code`; every rewrite
+* below goes through {@link MappedModule}, which realigns the map to the lines
+* it inserts, so the returned map describes the returned code (#3399). `map` is
+* `null` when the compiler produced none.
+*/
+function generateOutputWithMap(compiled, options) {
 	const { isProduction, isDev, ssr, hmrUpdateType, extractCss, filePath } = options;
-	let output = compiled.code;
-	const moduleInfo = analyzeModuleOutput(output);
+	const emitted = new MappedModule(compiled.code, parseSourceMap(compiled.map));
+	const moduleInfo = compiled.moduleShape ?? analyzeModuleOutput(emitted.code);
 	const hasExportDefault = moduleInfo.hasDefaultExport;
 	const hasNamedRenderExport = moduleInfo.hasNamedRenderExport;
 	const hasNamedSsrRenderExport = moduleInfo.hasNamedSsrRenderExport;
 	const hasSfcMainDefined = moduleInfo.hasSfcMainDefined;
 	if (hasExportDefault && !hasSfcMainDefined) {
-		output = rewriteDefaultExportToSfcMain(output, moduleInfo);
-		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
-		output += "\nexport default _sfc_main;";
+		emitted.edit(rewriteDefaultExportToSfcMain(emitted.code, moduleInfo));
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
 	} else if (hasExportDefault && hasSfcMainDefined) {
-		if (compiled.hasScoped && compiled.scopeId) output = insertBeforeSfcMainDefaultExport(output, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`, { moduleInfo });
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, `_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`, { moduleInfo }));
 	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedRenderExport) {
-		output += "\nconst _sfc_main = {};";
-		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
-		output += "\n_sfc_main.render = render;";
-		output += "\nexport default _sfc_main;";
+		emitted.edit(`${emitted.code}\nconst _sfc_main = {};`);
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\n_sfc_main.render = render;`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
 	} else if (!hasExportDefault && !hasSfcMainDefined && hasNamedSsrRenderExport) {
-		output += "\nconst _sfc_main = {};";
-		if (compiled.hasScoped && compiled.scopeId) output += `\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`;
-		output += "\n_sfc_main.ssrRender = ssrRender;";
-		output += "\nexport default _sfc_main;";
+		emitted.edit(`${emitted.code}\nconst _sfc_main = {};`);
+		if (compiled.hasScoped && compiled.scopeId) emitted.edit(`${emitted.code}\n_sfc_main.__scopeId = "data-v-${compiled.scopeId}";`);
+		emitted.edit(`${emitted.code}\n_sfc_main.ssrRender = ssrRender;`);
+		emitted.edit(`${emitted.code}\nexport default _sfc_main;`);
 	}
 	if (usesStyleImports(compiled, options)) {
 		const styleImports = [];
@@ -479,7 +573,7 @@ function generateOutput(compiled, options) {
 			}
 		}
 		const allImports = [...styleImports, ...cssModuleImports].join("\n");
-		if (allImports) output = insertAfterStaticImports(output, allImports);
+		if (allImports) emitted.edit(insertAfterStaticImports(emitted.code, allImports));
 		if (cssModuleImports.length > 0) {
 			const moduleBindings = [];
 			for (const block of compiled.styles) if (isCssModule(block)) {
@@ -490,14 +584,17 @@ function generateOutput(compiled, options) {
 				});
 			}
 			const cssModuleSetup = moduleBindings.map((m) => `_sfc_main.__cssModules = _sfc_main.__cssModules || {};\n_sfc_main.__cssModules[${JSON.stringify(m.name)}] = ${m.bindingName};`).join("\n");
-			output = insertBeforeSfcMainDefaultExport(output, cssModuleSetup, { normalizeSemicolon: true });
+			emitted.edit(insertBeforeSfcMainDefaultExport(emitted.code, cssModuleSetup, { normalizeSemicolon: true }));
 		}
-	} else if (!ssr && compiled.css && !(isProduction && extractCss)) output = prependInlineStyleInjection(output, compiled.css, compiled.scopeId);
+	} else if (!ssr && compiled.css && !(isProduction && extractCss)) emitted.edit(prependInlineStyleInjection(emitted.code, compiled.css, compiled.scopeId));
 	if (!isProduction && isDev && hasExportDefault) {
-		const effectiveHmrUpdateType = hmrUpdateType === "template-only" && !supportsTemplateOnlyHmr(output) ? "full-reload" : hmrUpdateType ?? "full-reload";
-		output += generateHmrCode(compiled.scopeId, effectiveHmrUpdateType);
+		const effectiveHmrUpdateType = hmrUpdateType === "template-only" && !supportsTemplateOnlyHmr(emitted.code) ? "full-reload" : hmrUpdateType ?? "full-reload";
+		emitted.edit(`${emitted.code}${generateHmrCode(compiled.scopeId, effectiveHmrUpdateType)}`);
 	}
-	return output;
+	return {
+		code: emitted.code,
+		map: emitted.map
+	};
 }
 const RESOLVED_CSS_MODULE = "\0vize:all-styles.css";
 /** Create a virtual module ID from a real .vue file path */
@@ -651,7 +748,7 @@ function getEnvironmentCache(state, ssr) {
 }
 function getCompileOptionsForRequest(state, ssr) {
 	const options = {
-		sourceMap: state.mergedOptions?.sourceMap ?? !state.isProduction,
+		sourceMap: state.mergedOptions?.sourceMap ?? (!state.isProduction || !!state.viteBuildSourcemap),
 		ssr,
 		vapor: !ssr && (state.mergedOptions?.vapor ?? false),
 		customRenderer: state.mergedOptions?.customRenderer ?? false,
@@ -795,6 +892,7 @@ function buildCompileBatchOptions(options) {
 		includeStyles: true,
 		includeMacroArtifacts: true,
 		includeHashes: true,
+		includeSourceMap: options.sourceMap,
 		...options.mode === void 0 ? {} : { mode: options.mode },
 		...options.templateSyntax === void 0 ? {} : { templateSyntax: options.templateSyntax },
 		...options.runtimeModuleName === void 0 ? {} : { runtimeModuleName: options.runtimeModuleName },
@@ -901,6 +999,7 @@ function compileFile(filePath, cache, options, source, diagnostics) {
 	});
 	const compiled = {
 		code: result.code,
+		...result.map ? { map: result.map } : {},
 		css: result.css,
 		scopeId,
 		hasScoped: result.hasScoped,
@@ -964,6 +1063,7 @@ function compileBatch(files, cache, options) {
 	for (const fileResult of result.results) {
 		if (fileResult.errors.length === 0) cache.set(fileResult.path, {
 			code: fileResult.code,
+			...fileResult.map ? { map: fileResult.map } : {},
 			css: fileResult.css,
 			scopeId: fileResult.scopeId,
 			hasScoped: fileResult.hasScoped,
@@ -1039,7 +1139,7 @@ function resolveCompilerIdentity() {
 */
 function computePrecompileCacheKey(compileOptions) {
 	const material = stableStringify({
-		format: 2,
+		format: 3,
 		compiler: resolveCompilerIdentity(),
 		options: compileOptions
 	});
@@ -1158,7 +1258,7 @@ function encodePrecompileManifest(options) {
 	const indexBody = compressBody(Buffer.from(JSON.stringify(index), "utf8"));
 	const payloadBody = compressBody(Buffer.concat(records));
 	const header = Buffer.from(JSON.stringify({
-		format: 2,
+		format: 3,
 		key,
 		codec: hasZstd ? "zstd" : "gzip",
 		index: indexBody.length,
@@ -1234,7 +1334,7 @@ function decodePrecompileManifest(bytes, options) {
 		return reject("unparsable header");
 	}
 	if (typeof header !== "object" || header === null || Array.isArray(header)) return reject("unrecognized header");
-	if (header.format !== 2 || header.key !== key) return reject("foreign format or key");
+	if (header.format !== 3 || header.key !== key) return reject("foreign format or key");
 	if (!isByteLength(header.index) || !isByteLength(header.payload)) return reject("unrecognized body lengths");
 	const indexStart = headerEnd + 1;
 	const payloadStart = indexStart + header.index;
@@ -1450,6 +1550,7 @@ function writeManifest(file, container, onDiagnostic) {
 */
 function resolvePrecompileBatchOptions(state) {
 	return {
+		sourceMap: getCompileOptionsForRequest(state, false).sourceMap,
 		ssr: false,
 		vapor: state.mergedOptions.vapor ?? false,
 		mode: state.mergedOptions.mode,
@@ -2464,12 +2565,15 @@ function loadCompiledSfcModule(state, realPath, isSsr, currentBase, loadOptions)
 		...compiled,
 		css: resolveCssImports(compiled.css, realPath, state.cssAliasRules, state.server !== null, currentBase)
 	};
-	const generatedOutput = generateOutput(compiled, outputOptions);
-	const normalizedOutput = rewriteImportMetaGlobBase(rewriteStaticAssetUrls(rewriteDynamicTemplateImports(isSsr ? normalizeVueServerRendererImport(generatedOutput) : generatedOutput, state.dynamicImportAliasRules), state.dynamicImportAliasRules), realPath, state.root);
+	const emitted = generateOutputWithMap(compiled, outputOptions);
+	const rewritten = new MappedModule(isSsr ? normalizeVueServerRendererImport(emitted.code) : emitted.code, emitted.map);
+	rewritten.edit(rewriteDynamicTemplateImports(rewritten.code, state.dynamicImportAliasRules));
+	rewritten.edit(rewriteStaticAssetUrls(rewritten.code, state.dynamicImportAliasRules));
+	rewritten.edit(rewriteImportMetaGlobBase(rewritten.code, realPath, state.root));
 	if (!loadOptions?.ssr) state.pendingHmrUpdateTypes.delete(realPath);
 	return {
-		code: normalizedOutput,
-		map: null
+		code: rewritten.code,
+		map: rewritten.map
 	};
 }
 function loadDefinePageArtifact(state, realPath, ssr) {
@@ -3343,6 +3447,7 @@ function vize(options = {}) {
 		pendingHmrUpdateTypes: /* @__PURE__ */ new Map(),
 		viteResolveCache: /* @__PURE__ */ new Map(),
 		isProduction: false,
+		viteBuildSourcemap: false,
 		root: "",
 		clientViteBase: "/",
 		serverViteBase: "/",
@@ -3381,6 +3486,7 @@ function vize(options = {}) {
 			async configResolved(resolvedConfig) {
 				state.root = options.root ?? resolvedConfig.root;
 				state.isProduction = options.isProduction ?? resolvedConfig.isProduction;
+				state.viteBuildSourcemap = !!resolvedConfig.build?.sourcemap;
 				const isSsrBuild = !!resolvedConfig.build?.ssr;
 				const currentBase = resolvedConfig.command === "serve" ? options.devUrlBase ?? resolvedConfig.base ?? "/" : resolvedConfig.base ?? "/";
 				if (isSsrBuild) state.serverViteBase = currentBase;

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

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

package/dist/{types-x-lq08Y8.d.mts → types-Cm3dJq25.d.mts}

@@ -660,6 +660,28 @@ interface ExperimentalPluginOptions extends ExperimentalCompileFlags {
   experimentals?: ExperimentalOptions;
 }
 //#endregion
+//#region src/utils/module-output.d.ts
+type ModuleOutputInfo = {
+  hasDefaultExport: boolean;
+  hasSfcMainDefined: boolean;
+  hasNamedRenderExport: boolean;
+  hasNamedSsrRenderExport: boolean;
+  defaultExportKeywordEnd: number | null;
+  defaultExportStart: number | null;
+  /**
+   * End offset of the whole `export default ...` statement, or `null`.
+   *
+   * Recorded so {@link insertBeforeSfcMainDefaultExport} can reuse the caller's
+   * analysis instead of parsing the module a second time (#3425).
+   */
+  defaultExportEnd: number | null;
+  /**
+   * Whether the default export's declaration is exactly the `_sfc_main`
+   * identifier -- the only shape {@link insertBeforeSfcMainDefaultExport} acts on.
+   */
+  defaultExportIsSfcMain: boolean;
+};
+//#endregion
 //#region src/types.d.ts
 interface MacroArtifact {
   kind: string;
@@ -755,7 +777,10 @@ interface VizeOptions extends ExperimentalPluginOptions {
    */
   isProduction?: boolean;
   ssr?: boolean;
-  /** Enable source map generation */
+  /**
+   * Enable source map generation.
+   * @default development on; production off unless Vite's `build.sourcemap` is set
+   */
   sourceMap?: boolean;
   /**
    * Enable Vapor mode compilation
@@ -845,6 +870,13 @@ interface StyleBlockInfo {
 }
 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;
@@ -857,6 +889,13 @@ interface CompiledModule {
   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, ResolvedVizeConfig as c, VizeOptions as i, UserConfigExport as l, MacroArtifact as n, ConfigEnv as o, VizeCompatibilityOptions as r, LoadConfigOptions as s, CompiledModule as t, VizeConfig as u };

package/package.json

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