@vitest/coverage-v8 3.2.4 → 4.0.0-beta.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021-Present Vitest Team
+Copyright (c) 2021-Present VoidZero Inc. and Vitest contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.js

@@ -1,7 +1,8 @@
-import inspector from 'node:inspector';
+import inspector from 'node:inspector/promises';
 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;
@@ -12,39 +13,35 @@ const mod = {
 		}
 		enabled = true;
 		session.connect();
-		await new Promise((resolve) => session.post("Profiler.enable", resolve));
-		await new Promise((resolve) => session.post("Profiler.startPreciseCoverage", {
+		await session.post("Profiler.enable");
+		await session.post("Profiler.startPreciseCoverage", {
 			callCount: true,
 			detailed: true
-		}, resolve));
+		});
 	},
-	takeCoverage(options) {
-		return new Promise((resolve, reject) => {
-			session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
-				if (error) {
-					return reject(error);
-				}
-				try {
-					const result = coverage.result.filter(filterResult).map((res) => ({
-						...res,
-						startOffset: options?.moduleExecutionInfo?.get(fileURLToPath(res.url))?.startOffset || 0
-					}));
-					resolve({ result });
-				} catch (e) {
-					reject(e);
-				}
-			});
-			if (provider === "stackblitz") {
-				resolve({ result: [] });
+	async takeCoverage(options) {
+		if (provider === "stackblitz") {
+			return { result: [] };
+		}
+		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
+				});
 			}
-		});
+		}
+		return { result };
 	},
 	async stopCoverage({ isolate }) {
 		if (isolate === false) {
 			return;
 		}
-		await new Promise((resolve) => session.post("Profiler.stopPreciseCoverage", resolve));
-		await new Promise((resolve) => session.post("Profiler.disable", resolve));
+		await session.post("Profiler.stopPreciseCoverage");
+		await session.post("Profiler.disable");
 		session.disconnect();
 	},
 	async getProvider() {

package/dist/pathe.M-eThtNZ-BTaAGrLg.js

@@ -0,0 +1,104 @@
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+
+export { normalize as n };

package/dist/provider.d.ts

@@ -2,7 +2,6 @@ import { CoverageMap } from 'istanbul-lib-coverage';
 import { ProxifiedModule } from 'magicast';
 import { Profiler } from 'node:inspector';
 import { ResolvedCoverageOptions, CoverageProvider, Vitest, ReportContext } from 'vitest/node';
-import TestExclude from 'test-exclude';
 import { BaseCoverageProvider } from 'vitest/coverage';
 
 interface ScriptCoverageWithOffset extends Profiler.ScriptCoverage {
@@ -11,14 +10,13 @@ interface ScriptCoverageWithOffset extends Profiler.ScriptCoverage {
 declare class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOptions<"v8">> implements CoverageProvider {
 	name: "v8";
 	version: string;
-	testExclude: InstanceType<typeof TestExclude>;
 	initialize(ctx: Vitest): void;
 	createCoverageMap(): CoverageMap;
 	generateCoverage({ allTestsRun }: ReportContext): Promise<CoverageMap>;
 	generateReports(coverageMap: CoverageMap, allTestsRun?: boolean): Promise<void>;
 	parseConfigModule(configFilePath: string): Promise<ProxifiedModule<any>>;
-	private getUntestedFiles;
-	private v8ToIstanbul;
+	private getCoverageMapForUncoveredFiles;
+	private remapCoverage;
 	private getSources;
 	private convertCoverage;
 }