@vitest/coverage-v8 4.1.5 → 5.0.0-beta.2

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import { CoverageProviderModule } from 'vitest/node';
 
-declare const mod: CoverageProviderModule;
+declare const mod: CoverageProviderModule & {
+	extendedContextCoverageDir?: string;
+	session?: unknown | null;
+};
 
 export { mod as default };

package/dist/index.js

@@ -1,17 +1,28 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { readdir, readFile, rm } from 'node:fs/promises';
 import inspector from 'node:inspector/promises';
+import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { provider } from 'std-env';
 import { l as loadProvider } from './load-provider-CdgAx3rL.js';
 import { n as normalize } from './pathe.M-eThtNZ-BTaAGrLg.js';
 
-const session = new inspector.Session();
 let enabled = false;
 const mod = {
-	async startCoverage({ isolate }) {
+	extendedContextCoverageDir: undefined,
+	session: null,
+	async startCoverage({ isolate, autoAttachSubprocess, reportsDirectory }) {
 		if (isolate === false && enabled) {
 			return;
 		}
 		enabled = true;
+		if (autoAttachSubprocess) {
+			this.extendedContextCoverageDir = resolve(reportsDirectory, "tmp", randomUUID());
+			process.env.NODE_V8_COVERAGE = this.extendedContextCoverageDir;
+		}
+		this.session ||= new inspector.Session();
+		const session = this.session;
 		session.connect();
 		await session.post("Profiler.enable");
 		await session.post("Profiler.startPreciseCoverage", {
@@ -23,15 +34,36 @@ const mod = {
 		if (provider === "stackblitz") {
 			return { result: [] };
 		}
+		const session = this.session;
+		if (!session) {
+			throw new Error("V8 provider missing inspector session.");
+		}
 		const coverage = await session.post("Profiler.takePreciseCoverage");
 		const result = [];
 		// Reduce amount of data sent over rpc by doing some early result filtering
 		for (const entry of coverage.result) {
 			if (filterResult(entry)) {
-				result.push({
-					...entry,
-					startOffset: options?.moduleExecutionInfo?.get(normalize(fileURLToPath(entry.url)))?.startOffset || 0
-				});
+				entry.startOffset = options?.moduleExecutionInfo?.get(normalize(fileURLToPath(entry.url)))?.startOffset || 0;
+				result.push(entry);
+			}
+		}
+		if (this.extendedContextCoverageDir && existsSync(this.extendedContextCoverageDir)) {
+			const filenames = await readdir(this.extendedContextCoverageDir);
+			const contents = await Promise.all(filenames.filter((filename) => filename.endsWith(".json")).map(async (filename) => {
+				const path = `${this.extendedContextCoverageDir}/${filename}`;
+				const content = await readFile(path, "utf8");
+				await rm(path);
+				return content;
+			}));
+			for (const content of contents) {
+				const json = JSON.parse(content);
+				for (const entry of json.result) {
+					if (filterResult(entry)) {
+						entry.startOffset = 0;
+						entry.isExtendedContext = true;
+						result.push(entry);
+					}
+				}
 			}
 		}
 		return { result };
@@ -40,9 +72,14 @@ const mod = {
 		if (isolate === false) {
 			return;
 		}
+		const session = this.session;
+		if (!session) {
+			throw new Error("V8 provider missing inspector session.");
+		}
 		await session.post("Profiler.stopPreciseCoverage");
 		await session.post("Profiler.disable");
 		session.disconnect();
+		this.session = null;
 	},
 	async getProvider() {
 		return loadProvider();

package/dist/provider.d.ts

@@ -5,6 +5,8 @@ import { BaseCoverageProvider, CoverageProvider, Vitest, ReportContext } from 'v
 
 interface ScriptCoverageWithOffset extends Profiler.ScriptCoverage {
 	startOffset: number;
+	/** Whether script ran outside Vite, e.g. in sub-processes or worker threads */
+	isExtendedContext?: boolean;
 }
 declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
 	name: "v8";

package/dist/provider.js

@@ -12,7 +12,7 @@ import c from 'tinyrainbow';
 import { BaseCoverageProvider, parseAstAsync } from 'vitest/node';
 import { n as normalize } from './pathe.M-eThtNZ-BTaAGrLg.js';
 
-var version = "4.1.5";
+var version = "5.0.0-beta.2";
 
 const FILE_PROTOCOL = "file://";
 const debug = createDebug("vitest:coverage");
@@ -21,6 +21,16 @@ class V8CoverageProvider extends BaseCoverageProvider {
 	version = version;
 	initialize(ctx) {
 		this._initialize(ctx);
+		if (this.options.autoAttachSubprocess) {
+			const isAnyThreadsPools = ctx.projects.some((p) => p.config.pool === "threads" || p.config.pool === "vmThreads");
+			if (isAnyThreadsPools) {
+				// Work-around for https://github.com/nodejs/node/issues/46378
+				// Node never does anything with this directory, it's just required so that
+				// the next Workers read **their** env.NODE_V8_COVERAGE.
+				// Node never creates this .unused directory at all.
+				process.env.NODE_V8_COVERAGE = `${this.coverageFilesDirectory}/.unused`;
+			}
+		}
 	}
 	createCoverageMap() {
 		return libCoverage.createCoverageMap({});
@@ -29,15 +39,22 @@ class V8CoverageProvider extends BaseCoverageProvider {
 		const start = debug.enabled ? performance.now() : 0;
 		const coverageMap = this.createCoverageMap();
 		let merged = { result: [] };
+		const autoAttachSubprocess = this.options.autoAttachSubprocess;
 		await this.readCoverageFiles({
 			onFileRead(coverage) {
 				merged = mergeProcessCovs([merged, coverage]);
+				// mergeProcessCovs sometimes loses autoAttachSubprocess
+				const fromExtendedContext = autoAttachSubprocess ? coverage.result.filter((r) => r.isExtendedContext) : [];
 				// mergeProcessCovs sometimes loses startOffset, e.g. in vue
 				merged.result.forEach((result) => {
 					if (!result.startOffset) {
 						const original = coverage.result.find((r) => r.url === result.url);
 						result.startOffset = original?.startOffset || 0;
 					}
+					if (autoAttachSubprocess && !result.isExtendedContext) {
+						const actual = fromExtendedContext.find((r) => r.url === result.url);
+						result.isExtendedContext = actual?.isExtendedContext;
+					}
 				});
 			},
 			onFinished: async (project, environment) => {
@@ -189,11 +206,11 @@ class V8CoverageProvider extends BaseCoverageProvider {
 			}
 		});
 	}
-	async getSources(url, onTransform, functions = []) {
+	async getSources(url, onTransform, functions = [], isExtendedContext = false) {
 		// TODO: need to standardize file urls before this call somehow, this is messy
 		const filepath = url.match(/^file:\/\/\/\w:\//) ? url.slice(8) : removeStartsWith(url, FILE_PROTOCOL);
 		// TODO: do we still need to "catch" here? why would it fail?
-		const transformResult = await onTransform(filepath).catch(() => null);
+		const transformResult = await onTransform(filepath, isExtendedContext).catch(() => null);
 		const map = transformResult?.map;
 		const code = transformResult?.code;
 		if (code == null) {
@@ -223,8 +240,8 @@ class V8CoverageProvider extends BaseCoverageProvider {
 		if (environment === "__browser__" && !project.browser) {
 			throw new Error(`Cannot access browser module graph because it was torn down.`);
 		}
-		const onTransform = async (filepath) => {
-			const result = await this.transformFile(filepath, project, environment);
+		const onTransform = async (filepath, isExtendedContext = false) => {
+			const result = await this.transformFile(filepath, project, environment, !isExtendedContext);
 			if (result && environment === "__browser__" && project.browser) {
 				return {
 					...result,
@@ -258,14 +275,14 @@ class V8CoverageProvider extends BaseCoverageProvider {
 				index += chunk.length;
 				debug("Converting %d/%d", index, scriptCoverages.length);
 			}
-			await Promise.all(chunk.map(async ({ url, functions, startOffset }) => {
+			await Promise.all(chunk.map(async ({ url, functions, startOffset, isExtendedContext }) => {
 				let timeout;
 				let start;
 				if (debug.enabled) {
 					start = performance.now();
 					timeout = setTimeout(() => debug(c.bgRed(`File "${fileURLToPath(url)}" is taking longer than 3s`)), 3e3);
 				}
-				const sources = await this.getSources(url, onTransform, functions);
+				const sources = await this.getSources(url, onTransform, functions, isExtendedContext);
 				coverageMap.merge(await this.remapCoverage(url, startOffset, sources, functions));
 				if (debug.enabled) {
 					clearTimeout(timeout);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "4.1.5",
+  "version": "5.0.0-beta.2",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -41,8 +41,8 @@
     "dist"
   ],
   "peerDependencies": {
-    "@vitest/browser": "4.1.5",
-    "vitest": "4.1.5"
+    "@vitest/browser": "5.0.0-beta.2",
+    "vitest": "5.0.0-beta.2"
   },
   "peerDependenciesMeta": {
     "@vitest/browser": {
@@ -59,16 +59,16 @@
     "obug": "^2.1.1",
     "std-env": "^4.0.0-rc.1",
     "tinyrainbow": "^3.1.0",
-    "@vitest/utils": "4.1.5"
+    "@vitest/utils": "5.0.0-beta.2"
   },
   "devDependencies": {
     "@types/istanbul-lib-coverage": "^2.0.6",
     "@types/istanbul-lib-report": "^3.0.3",
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^2.0.3",
-    "vitest": "4.1.5",
-    "@vitest/browser": "4.1.5",
-    "@vitest/browser-playwright": "4.1.5"
+    "@vitest/browser-playwright": "5.0.0-beta.2",
+    "vitest": "5.0.0-beta.2",
+    "@vitest/browser": "5.0.0-beta.2"
   },
   "scripts": {
     "build": "premove dist && rollup -c",