@vitest/coverage-v8 2.1.0-beta.4 → 2.1.0-beta.6

package/dist/browser.d.ts

@@ -0,0 +1,16 @@
+import { V8CoverageProvider } from './provider.js';
+import 'istanbul-lib-coverage';
+import 'vitest/coverage';
+import 'vitest/node';
+import 'vitest';
+
+declare const _default: {
+    startCoverage(): Promise<void>;
+    takeCoverage(): Promise<{
+        result: any[];
+    }>;
+    stopCoverage(): Promise<void>;
+    getProvider(): Promise<V8CoverageProvider>;
+};
+
+export { _default as default };

package/dist/browser.js

@@ -0,0 +1,50 @@
+import { cdp } from '@vitest/browser/context';
+import { l as loadProvider } from './load-provider-Bl5rgjsL.js';
+
+const session = cdp();
+var browser = {
+  async startCoverage() {
+    await session.send("Profiler.enable");
+    await session.send("Profiler.startPreciseCoverage", {
+      callCount: true,
+      detailed: true
+    });
+  },
+  async takeCoverage() {
+    const coverage = await session.send("Profiler.takePreciseCoverage");
+    const result = [];
+    for (const entry of coverage.result) {
+      if (filterResult(entry)) {
+        result.push({
+          ...entry,
+          url: decodeURIComponent(entry.url.replace(window.location.origin, ""))
+        });
+      }
+    }
+    return { result };
+  },
+  async stopCoverage() {
+    await session.send("Profiler.stopPreciseCoverage");
+    await session.send("Profiler.disable");
+  },
+  async getProvider() {
+    return loadProvider();
+  }
+};
+function filterResult(coverage) {
+  if (!coverage.url.startsWith(window.location.origin)) {
+    return false;
+  }
+  if (coverage.url.includes("/node_modules/")) {
+    return false;
+  }
+  if (coverage.url.includes("__vitest_browser__")) {
+    return false;
+  }
+  if (coverage.url.includes("__vitest__/assets")) {
+    return false;
+  }
+  return true;
+}
+
+export { browser as default };

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import { Profiler } from 'node:inspector';
 import { V8CoverageProvider } from './provider.js';
 import 'istanbul-lib-coverage';
 import 'vitest/coverage';
-import 'vitest';
 import 'vitest/node';
+import 'vitest';
 
 declare const _default: {
     startCoverage(): void;

package/dist/index.js

@@ -1,34 +1,40 @@
 import inspector from 'node:inspector';
 import { provider } from 'std-env';
+import { l as loadProvider } from './load-provider-Bl5rgjsL.js';
 
 const session = new inspector.Session();
-function startCoverage() {
-  session.connect();
-  session.post("Profiler.enable");
-  session.post("Profiler.startPreciseCoverage", {
-    callCount: true,
-    detailed: true
-  });
-}
-async function takeCoverage() {
-  return new Promise((resolve, reject) => {
-    session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
-      if (error) {
-        return reject(error);
+var index = {
+  startCoverage() {
+    session.connect();
+    session.post("Profiler.enable");
+    session.post("Profiler.startPreciseCoverage", {
+      callCount: true,
+      detailed: true
+    });
+  },
+  takeCoverage() {
+    return new Promise((resolve, reject) => {
+      session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
+        if (error) {
+          return reject(error);
+        }
+        const result = coverage.result.filter(filterResult);
+        resolve({ result });
+      });
+      if (provider === "stackblitz") {
+        resolve({ result: [] });
       }
-      const result = coverage.result.filter(filterResult);
-      resolve({ result });
     });
-    if (provider === "stackblitz") {
-      resolve({ result: [] });
-    }
-  });
-}
-function stopCoverage() {
-  session.post("Profiler.stopPreciseCoverage");
-  session.post("Profiler.disable");
-  session.disconnect();
-}
+  },
+  stopCoverage() {
+    session.post("Profiler.stopPreciseCoverage");
+    session.post("Profiler.disable");
+    session.disconnect();
+  },
+  async getProvider() {
+    return loadProvider();
+  }
+};
 function filterResult(coverage) {
   if (!coverage.url.startsWith("file://")) {
     return false;
@@ -39,21 +45,4 @@ function filterResult(coverage) {
   return true;
 }
 
-var index = {
-  startCoverage() {
-    return startCoverage();
-  },
-  takeCoverage() {
-    return takeCoverage();
-  },
-  stopCoverage() {
-    return stopCoverage();
-  },
-  async getProvider() {
-    const name = "./provider.js";
-    const { V8CoverageProvider } = await import(name);
-    return new V8CoverageProvider();
-  }
-};
-
 export { index as default };

package/dist/load-provider-Bl5rgjsL.js

@@ -0,0 +1,10 @@
+const name = "./provider.js";
+async function loadProvider() {
+  const { V8CoverageProvider } = await import(
+    /* @vite-ignore */
+    name
+  );
+  return new V8CoverageProvider();
+}
+
+export { loadProvider as l };

package/dist/provider.d.ts

@@ -1,7 +1,7 @@
 import { CoverageMap } from 'istanbul-lib-coverage';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
 import { Vitest } from 'vitest/node';
+import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
 
 interface TestExclude {
     new (opts: {

package/dist/provider.js

@@ -2248,10 +2248,13 @@ function cleanUrl(url) {
   "wasi"
 ]);
 
+var version = "2.1.0-beta.6";
+
 const WRAPPER_LENGTH = 185;
 const VITE_EXPORTS_LINE_PATTERN = /Object\.defineProperty\(__vite_ssr_exports__.*\n/g;
 const DECORATOR_METADATA_PATTERN = /_ts_metadata\("design:paramtypes", \[[^\]]*\]\),*/g;
 const DEFAULT_PROJECT = Symbol.for("default-project");
+const FILE_PROTOCOL = "file://";
 const debug = createDebug("vitest:coverage");
 let uniqueId = 0;
 class V8CoverageProvider extends BaseCoverageProvider {
@@ -2264,6 +2267,15 @@ class V8CoverageProvider extends BaseCoverageProvider {
   pendingPromises = [];
   initialize(ctx) {
     const config = ctx.config.coverage;
+    if (ctx.version !== version) {
+      ctx.logger.warn(
+        c.yellow(
+          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-v8@${version} `))}.
+Running mixed versions is not supported and may lead into bugs
+Update your dependencies and make sure the versions match.`
+        )
+      );
+    }
     this.ctx = ctx;
     this.options = {
       ...coverageConfigDefaults,
@@ -2329,12 +2341,12 @@ class V8CoverageProvider extends BaseCoverageProvider {
    * backwards compatibility is a breaking change.
    */
   onAfterSuiteRun({ coverage, transformMode, projectName }) {
-    if (transformMode !== "web" && transformMode !== "ssr") {
+    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
       throw new Error(`Invalid transform mode: ${transformMode}`);
     }
     let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
     if (!entry) {
-      entry = { web: [], ssr: [] };
+      entry = { web: [], ssr: [], browser: [] };
       this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
     }
     const filename = resolve(
@@ -2351,18 +2363,11 @@ class V8CoverageProvider extends BaseCoverageProvider {
     const total = this.pendingPromises.length;
     await Promise.all(this.pendingPromises);
     this.pendingPromises = [];
-    for (const [
-      projectName,
-      coveragePerProject
-    ] of this.coverageFiles.entries()) {
-      for (const [transformMode, filenames] of Object.entries(
-        coveragePerProject
-      )) {
+    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
+      for (const [transformMode, filenames] of Object.entries(coveragePerProject)) {
         let merged = { result: [] };
-        for (const chunk of this.toSlices(
-          filenames,
-          this.options.processingConcurrency
-        )) {
+        const project = this.ctx.projects.find((p) => p.getName() === projectName) || this.ctx.getCoreWorkspaceProject();
+        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
           if (debug.enabled) {
             index += chunk.length;
             debug("Covered files %d/%d", index, total);
@@ -2377,7 +2382,7 @@ class V8CoverageProvider extends BaseCoverageProvider {
         }
         const converted = await this.convertCoverage(
           merged,
-          projectName,
+          project,
           transformMode
         );
         const transformedCoverage = await transformCoverage(converted);
@@ -2390,6 +2395,9 @@ class V8CoverageProvider extends BaseCoverageProvider {
       const converted = await this.convertCoverage(untestedCoverage);
       coverageMap.merge(await transformCoverage(converted));
     }
+    if (this.options.excludeAfterRemap) {
+      coverageMap.filter((filename) => this.testExclude.shouldInstrument(filename));
+    }
     return coverageMap;
   }
   async reportCoverage(coverageMap, { allTestsRun }) {
@@ -2477,6 +2485,7 @@ class V8CoverageProvider extends BaseCoverageProvider {
     const transformResults = normalizeTransformResults(
       this.ctx.vitenode.fetchCache
     );
+    const transform = this.createUncoveredFileTransformer(this.ctx);
     const allFiles = await this.testExclude.glob(this.ctx.config.root);
     let includedFiles = allFiles.map(
       (file) => resolve(this.ctx.config.root, file)
@@ -2501,7 +2510,8 @@ class V8CoverageProvider extends BaseCoverageProvider {
         chunk.map(async (filename) => {
           const { originalSource } = await this.getSources(
             filename.href,
-            transformResults
+            transformResults,
+            transform
           );
           const coverage = {
             url: filename.href,
@@ -2534,58 +2544,79 @@ class V8CoverageProvider extends BaseCoverageProvider {
     }
     return merged;
   }
-  async getSources(url, transformResults, functions = []) {
+  async getSources(url, transformResults, onTransform, functions = []) {
     const filePath = normalize(fileURLToPath$1(url));
     let isExecuted = true;
     let transformResult = transformResults.get(filePath);
     if (!transformResult) {
       isExecuted = false;
-      transformResult = await this.ctx.vitenode.transformRequest(filePath).catch(() => null);
+      transformResult = await onTransform(removeStartsWith(url, FILE_PROTOCOL)).catch(() => void 0);
     }
     const map = transformResult?.map;
     const code = transformResult?.code;
-    const sourcesContent = map?.sourcesContent?.[0] || await promises$1.readFile(filePath, "utf-8").catch(() => {
-      const length = findLongestFunctionLength(functions);
-      return ".".repeat(length);
-    });
+    const sourcesContent = map?.sourcesContent || [];
+    if (!sourcesContent[0]) {
+      sourcesContent[0] = await promises$1.readFile(filePath, "utf-8").catch(() => {
+        const length = findLongestFunctionLength(functions);
+        return ".".repeat(length);
+      });
+    }
     if (!map) {
       return {
         isExecuted,
-        source: code || sourcesContent,
-        originalSource: sourcesContent
+        source: code || sourcesContent[0],
+        originalSource: sourcesContent[0]
       };
     }
-    const sources = [url];
-    if (map.sources && map.sources[0] && !url.endsWith(map.sources[0])) {
-      sources[0] = new URL(map.sources[0], url).href;
+    const sources = (map.sources || []).filter((source) => source != null).map((source) => new URL(source, url).href);
+    if (sources.length === 0) {
+      sources.push(url);
     }
     return {
       isExecuted,
-      originalSource: sourcesContent,
-      source: code || sourcesContent,
+      originalSource: sourcesContent[0],
+      source: code || sourcesContent[0],
       sourceMap: {
         sourcemap: excludeGeneratedCode(code, {
           ...map,
           version: 3,
           sources,
-          sourcesContent: [sourcesContent]
+          sourcesContent
         })
       }
     };
   }
-  async convertCoverage(coverage, projectName, transformMode) {
-    const viteNode = this.ctx.projects.find((project) => project.getName() === projectName)?.vitenode || this.ctx.vitenode;
-    const fetchCache = transformMode ? viteNode.fetchCaches[transformMode] : viteNode.fetchCache;
+  async convertCoverage(coverage, project = this.ctx.getCoreWorkspaceProject(), transformMode) {
+    let fetchCache = project.vitenode.fetchCache;
+    if (transformMode) {
+      fetchCache = transformMode === "browser" ? /* @__PURE__ */ new Map() : project.vitenode.fetchCaches[transformMode];
+    }
     const transformResults = normalizeTransformResults(fetchCache);
-    const scriptCoverages = coverage.result.filter(
-      (result) => this.testExclude.shouldInstrument(fileURLToPath$1(result.url))
-    );
+    async function onTransform(filepath) {
+      if (transformMode === "browser" && project.browser) {
+        const result = await project.browser.vite.transformRequest(removeStartsWith(filepath, project.config.root));
+        if (result) {
+          return { ...result, code: `${result.code}// <inline-source-map>` };
+        }
+      }
+      return project.vitenode.transformRequest(filepath);
+    }
+    const scriptCoverages = [];
+    for (const result of coverage.result) {
+      if (transformMode === "browser") {
+        if (result.url.startsWith("/@fs")) {
+          result.url = `${FILE_PROTOCOL}${removeStartsWith(result.url, "/@fs")}`;
+        } else {
+          result.url = `${FILE_PROTOCOL}${project.config.root}${result.url}`;
+        }
+      }
+      if (this.testExclude.shouldInstrument(fileURLToPath$1(result.url))) {
+        scriptCoverages.push(result);
+      }
+    }
     const coverageMap = libCoverage.createCoverageMap({});
     let index = 0;
-    for (const chunk of this.toSlices(
-      scriptCoverages,
-      this.options.processingConcurrency
-    )) {
+    for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
       if (debug.enabled) {
         index += chunk.length;
         debug("Converting %d/%d", index, scriptCoverages.length);
@@ -2595,6 +2626,7 @@ class V8CoverageProvider extends BaseCoverageProvider {
           const sources = await this.getSources(
             url,
             transformResults,
+            onTransform,
             functions
           );
           const wrapperLength = sources.isExecuted ? WRAPPER_LENGTH : 0;
@@ -2606,7 +2638,12 @@ class V8CoverageProvider extends BaseCoverageProvider {
             this.options.ignoreEmptyLines
           );
           await converter.load();
-          converter.applyCoverage(functions);
+          try {
+            converter.applyCoverage(functions);
+          } catch (error) {
+            this.ctx.logger.error(`Failed to convert coverage for ${url}.
+`, error);
+          }
           coverageMap.merge(converter.toIstanbul());
         })
       );
@@ -2654,5 +2691,11 @@ function normalizeTransformResults(fetchCache) {
   }
   return normalized;
 }
+function removeStartsWith(filepath, start) {
+  if (filepath.startsWith(start)) {
+    return filepath.slice(start.length);
+  }
+  return filepath;
+}
 
 export { V8CoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "2.1.0-beta.4",
+  "version": "2.1.0-beta.6",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -28,6 +28,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
     "./*": "./*"
   },
   "main": "./dist/index.js",
@@ -37,7 +41,13 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "2.1.0-beta.4"
+    "@vitest/browser": "2.1.0-beta.6",
+    "vitest": "2.1.0-beta.6"
+  },
+  "peerDependenciesMeta": {
+    "@vitest/browser": {
+      "optional": true
+    }
   },
   "dependencies": {
     "@ampproject/remapping": "^2.3.0",
@@ -61,8 +71,9 @@
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^1.1.2",
     "v8-to-istanbul": "^9.3.0",
-    "vite-node": "2.1.0-beta.4",
-    "vitest": "2.1.0-beta.4"
+    "@vitest/browser": "2.1.0-beta.6",
+    "vite-node": "2.1.0-beta.6",
+    "vitest": "2.1.0-beta.6"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",