@vitest/coverage-v8 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/provider.d.ts

@@ -17,19 +17,24 @@ interface TestExclude {
     };
 }
 type Options = ResolvedCoverageOptions<'v8'>;
+type RawCoverage = Profiler.TakePreciseCoverageReturnType;
+type CoverageByTransformMode = Record<AfterSuiteRunMeta['transformMode'], RawCoverage[]>;
+type ProjectName = NonNullable<AfterSuiteRunMeta['projectName']> | typeof DEFAULT_PROJECT;
+declare const DEFAULT_PROJECT: unique symbol;
 declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
     name: string;
     ctx: Vitest;
     options: Options;
     testExclude: InstanceType<TestExclude>;
-    coverages: Profiler.TakePreciseCoverageReturnType[];
+    coverages: Map<ProjectName, CoverageByTransformMode>;
     initialize(ctx: Vitest): void;
     resolveOptions(): Options;
     clean(clean?: boolean): Promise<void>;
-    onAfterSuiteRun({ coverage }: AfterSuiteRunMeta): void;
+    onAfterSuiteRun({ coverage, transformMode, projectName }: AfterSuiteRunMeta): void;
     reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
     private getUntestedFiles;
     private getSources;
+    private mergeAndTransformCoverage;
 }
 
 export { V8CoverageProvider };

package/dist/provider.js

@@ -1,5 +1,5 @@
-import { existsSync, promises } from 'fs';
-import { fileURLToPath, pathToFileURL } from 'url';
+import { existsSync, promises } from 'node:fs';
+import { pathToFileURL, fileURLToPath } from 'node:url';
 import v8ToIstanbul from 'v8-to-istanbul';
 import { mergeProcessCovs } from '@bcoe/v8-coverage';
 import libReport from 'istanbul-lib-report';
@@ -10,7 +10,7 @@ import MagicString from 'magic-string';
 import remapping from '@ampproject/remapping';
 import c from 'picocolors';
 import { provider } from 'std-env';
-import { builtinModules } from 'module';
+import { builtinModules } from 'node:module';
 import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import _TestExclude from 'test-exclude';
@@ -168,12 +168,13 @@ function cleanUrl(url) {
 
 const WRAPPER_LENGTH = 185;
 const VITE_EXPORTS_LINE_PATTERN = /Object\.defineProperty\(__vite_ssr_exports__.*\n/g;
+const DEFAULT_PROJECT = Symbol.for("default-project");
 class V8CoverageProvider extends BaseCoverageProvider {
   name = "v8";
   ctx;
   options;
   testExclude;
-  coverages = [];
+  coverages = /* @__PURE__ */ new Map();
   initialize(ctx) {
     const config = ctx.config.coverage;
     this.ctx = ctx;
@@ -205,41 +206,42 @@ class V8CoverageProvider extends BaseCoverageProvider {
   async clean(clean = true) {
     if (clean && existsSync(this.options.reportsDirectory))
       await promises.rm(this.options.reportsDirectory, { recursive: true, force: true, maxRetries: 10 });
-    this.coverages = [];
+    this.coverages = /* @__PURE__ */ new Map();
   }
-  onAfterSuiteRun({ coverage }) {
-    this.coverages.push(coverage);
+  /*
+   * Coverage and meta information passed from Vitest runners.
+   * Note that adding new entries here and requiring on those without
+   * backwards compatibility is a breaking change.
+   */
+  onAfterSuiteRun({ coverage, transformMode, projectName }) {
+    if (transformMode !== "web" && transformMode !== "ssr")
+      throw new Error(`Invalid transform mode: ${transformMode}`);
+    let entry = this.coverages.get(projectName || DEFAULT_PROJECT);
+    if (!entry) {
+      entry = { web: [], ssr: [] };
+      this.coverages.set(projectName || DEFAULT_PROJECT, entry);
+    }
+    entry[transformMode].push(coverage);
   }
   async reportCoverage({ allTestsRun } = {}) {
     if (provider === "stackblitz")
       this.ctx.logger.log(c.blue(" % ") + c.yellow("@vitest/coverage-v8 does not work on Stackblitz. Report will be empty."));
-    const transformResults = normalizeTransformResults(this.ctx.projects.map((project) => project.vitenode.fetchCache));
-    const merged = mergeProcessCovs(this.coverages);
-    const scriptCoverages = merged.result.filter((result) => this.testExclude.shouldInstrument(fileURLToPath(result.url)));
+    const coverageMaps = await Promise.all(
+      Array.from(this.coverages.entries()).map(([projectName, coverages]) => [
+        this.mergeAndTransformCoverage(coverages.ssr, projectName, "ssr"),
+        this.mergeAndTransformCoverage(coverages.web, projectName, "web")
+      ]).flat()
+    );
     if (this.options.all && allTestsRun) {
-      const coveredFiles = Array.from(scriptCoverages.map((r) => r.url));
-      const untestedFiles = await this.getUntestedFiles(coveredFiles, transformResults);
-      scriptCoverages.push(...untestedFiles);
+      const coveredFiles = coverageMaps.map((map) => map.files()).flat();
+      const untestedCoverage = await this.getUntestedFiles(coveredFiles);
+      const untestedCoverageResults = untestedCoverage.map((files) => ({ result: [files] }));
+      coverageMaps.push(await this.mergeAndTransformCoverage(untestedCoverageResults));
     }
-    const converted = await Promise.all(scriptCoverages.map(async ({ url, functions }) => {
-      const sources = await this.getSources(url, transformResults, functions);
-      const wrapperLength = sources.sourceMap ? WRAPPER_LENGTH : 0;
-      const converter = v8ToIstanbul(url, wrapperLength, sources);
-      await converter.load();
-      converter.applyCoverage(functions);
-      return converter.toIstanbul();
-    }));
-    const mergedCoverage = converted.reduce((coverage, previousCoverageMap) => {
-      const map = libCoverage.createCoverageMap(coverage);
-      map.merge(previousCoverageMap);
-      return map;
-    }, libCoverage.createCoverageMap({}));
-    const sourceMapStore = libSourceMaps.createSourceMapStore();
-    const coverageMap = await sourceMapStore.transformCoverage(mergedCoverage);
+    const coverageMap = mergeCoverageMaps(...coverageMaps);
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
-      sourceFinder: sourceMapStore.sourceFinder,
       watermarks: this.options.watermarks
     });
     if (hasTerminalReporter(this.options.reporter))
@@ -277,9 +279,10 @@ class V8CoverageProvider extends BaseCoverageProvider {
       });
     }
   }
-  async getUntestedFiles(testedFiles, transformResults) {
+  async getUntestedFiles(testedFiles) {
+    const transformResults = normalizeTransformResults(this.ctx.vitenode.fetchCache);
     const includedFiles = await this.testExclude.glob(this.ctx.config.root);
-    const uncoveredFiles = includedFiles.map((file) => pathToFileURL(resolve(this.ctx.config.root, file))).filter((file) => !testedFiles.includes(file.href));
+    const uncoveredFiles = includedFiles.map((file) => pathToFileURL(resolve(this.ctx.config.root, file))).filter((file) => !testedFiles.includes(file.pathname));
     return await Promise.all(uncoveredFiles.map(async (uncoveredFile) => {
       const { source } = await this.getSources(uncoveredFile.href, transformResults);
       return {
@@ -300,12 +303,11 @@ class V8CoverageProvider extends BaseCoverageProvider {
     }));
   }
   async getSources(url, transformResults, functions = []) {
-    var _a;
     const filePath = normalize(fileURLToPath(url));
     const transformResult = transformResults.get(filePath);
-    const map = transformResult == null ? void 0 : transformResult.map;
-    const code = transformResult == null ? void 0 : transformResult.code;
-    const sourcesContent = ((_a = map == null ? void 0 : map.sourcesContent) == null ? void 0 : _a[0]) || await promises.readFile(filePath, "utf-8").catch(() => {
+    const map = transformResult?.map;
+    const code = transformResult?.code;
+    const sourcesContent = map?.sourcesContent?.[0] || await promises.readFile(filePath, "utf-8").catch(() => {
       const length = findLongestFunctionLength(functions);
       return ".".repeat(length);
     });
@@ -324,6 +326,31 @@ class V8CoverageProvider extends BaseCoverageProvider {
       }
     };
   }
+  async mergeAndTransformCoverage(coverages, projectName, transformMode) {
+    const viteNode = this.ctx.projects.find((project) => project.getName() === projectName)?.vitenode || this.ctx.vitenode;
+    const fetchCache = transformMode ? viteNode.fetchCaches[transformMode] : viteNode.fetchCache;
+    const transformResults = normalizeTransformResults(fetchCache);
+    const merged = mergeProcessCovs(coverages);
+    const scriptCoverages = merged.result.filter((result) => this.testExclude.shouldInstrument(fileURLToPath(result.url)));
+    const converted = await Promise.all(scriptCoverages.map(async ({ url, functions }) => {
+      const sources = await this.getSources(url, transformResults, functions);
+      const wrapperLength = sources.sourceMap ? WRAPPER_LENGTH : 0;
+      const converter = v8ToIstanbul(url, wrapperLength, sources);
+      await converter.load();
+      converter.applyCoverage(functions);
+      return converter.toIstanbul();
+    }));
+    const mergedCoverage = mergeCoverageMaps(...converted);
+    const sourceMapStore = libSourceMaps.createSourceMapStore();
+    return sourceMapStore.transformCoverage(mergedCoverage);
+  }
+}
+function mergeCoverageMaps(...coverageMaps) {
+  return coverageMaps.reduce((coverage, previousCoverageMap) => {
+    const map = libCoverage.createCoverageMap(coverage);
+    map.merge(previousCoverageMap);
+    return map;
+  }, libCoverage.createCoverageMap({}));
 }
 function removeViteHelpersFromSourceMaps(source, map) {
   if (!source || !source.match(VITE_EXPORTS_LINE_PATTERN))
@@ -345,14 +372,12 @@ function findLongestFunctionLength(functions) {
     return Math.max(previous, maxEndOffset);
   }, 0);
 }
-function normalizeTransformResults(fetchCaches) {
+function normalizeTransformResults(fetchCache) {
   const normalized = /* @__PURE__ */ new Map();
-  for (const fetchCache of fetchCaches) {
-    for (const [key, value] of fetchCache.entries()) {
-      const cleanEntry = cleanUrl(key);
-      if (!normalized.has(cleanEntry))
-        normalized.set(cleanEntry, value.result);
-    }
+  for (const [key, value] of fetchCache.entries()) {
+    const cleanEntry = cleanUrl(key);
+    if (!normalized.has(cleanEntry))
+      normalized.set(cleanEntry, value.result);
   }
   return normalized;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": ">=0.32.0 <1"
+    "vitest": "^1.0.0-0"
   },
   "dependencies": {
     "@ampproject/remapping": "^2.2.1",
@@ -46,7 +46,7 @@
     "istanbul-lib-report": "^3.0.1",
     "istanbul-lib-source-maps": "^4.0.1",
     "istanbul-reports": "^3.1.5",
-    "magic-string": "^0.30.4",
+    "magic-string": "^0.30.5",
     "picocolors": "^1.0.0",
     "std-env": "^3.3.3",
     "test-exclude": "^6.0.0",
@@ -58,8 +58,8 @@
     "@types/istanbul-lib-source-maps": "^4.0.1",
     "@types/istanbul-reports": "^3.0.1",
     "pathe": "^1.1.1",
-    "vite-node": "1.0.0-beta.2",
-    "vitest": "1.0.0-beta.2"
+    "vite-node": "1.0.0-beta.4",
+    "vitest": "1.0.0-beta.4"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",