@vitest/coverage-v8 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { V8CoverageProvider } from './provider.js';
+import 'istanbul-lib-coverage';
 import 'vitest/coverage';
 import 'vitest';
 import 'vitest/node';

package/dist/index.js

@@ -13,13 +13,15 @@ function startCoverage() {
 async function takeCoverage() {
   return new Promise((resolve, reject) => {
     session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
-      if (error)
+      if (error) {
         return reject(error);
+      }
       const result = coverage.result.filter(filterResult);
       resolve({ result });
     });
-    if (provider === "stackblitz")
+    if (provider === "stackblitz") {
       resolve({ result: [] });
+    }
   });
 }
 function stopCoverage() {
@@ -28,10 +30,12 @@ function stopCoverage() {
   session.disconnect();
 }
 function filterResult(coverage) {
-  if (!coverage.url.startsWith("file://"))
+  if (!coverage.url.startsWith("file://")) {
     return false;
-  if (coverage.url.includes("/node_modules/"))
+  }
+  if (coverage.url.includes("/node_modules/")) {
     return false;
+  }
   return true;
 }
 

package/dist/provider.d.ts

@@ -1,3 +1,4 @@
+import { CoverageMap } from 'istanbul-lib-coverage';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
 import { Vitest } from 'vitest/node';
@@ -32,7 +33,10 @@ declare class V8CoverageProvider extends BaseCoverageProvider implements Coverag
     resolveOptions(): Options;
     clean(clean?: boolean): Promise<void>;
     onAfterSuiteRun({ coverage, transformMode, projectName }: AfterSuiteRunMeta): void;
-    reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
+    generateCoverage({ allTestsRun }: ReportContext): Promise<CoverageMap>;
+    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+    generateReports(coverageMap: CoverageMap, allTestsRun?: boolean): Promise<void>;
+    mergeReports(coverageMaps: unknown[]): Promise<void>;
     private getUntestedFiles;
     private getSources;
     private convertCoverage;

package/dist/provider.js

@@ -1,4 +1,4 @@
-import { existsSync, promises as promises$1, writeFileSync } from 'node:fs';
+import { existsSync, promises as promises$1, readdirSync, writeFileSync } from 'node:fs';
 import { pathToFileURL, fileURLToPath as fileURLToPath$1 } from 'node:url';
 import require$$0 from 'assert';
 import require$$2 from 'util';
@@ -2186,10 +2186,9 @@ const isAbsolute = function(p) {
 const isWindows = process.platform === "win32";
 const drive = isWindows ? process.cwd()[0] : null;
 drive ? drive === drive.toUpperCase() ? drive.toLowerCase() : drive.toUpperCase() : null;
-const queryRE = /\?.*$/s;
-const hashRE = /#.*$/s;
+const postfixRE = /[?#].*$/;
 function cleanUrl(url) {
-  return url.replace(hashRE, "").replace(queryRE, "");
+  return url.replace(postfixRE, "");
 }
 /* @__PURE__ */ new Set([
   ...builtinModules,
@@ -2210,7 +2209,7 @@ function cleanUrl(url) {
 
 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 DECORATOR_METADATA_PATTERN = /_ts_metadata\("design:paramtypes", \[[^\]]*\]\),*/g;
 const DEFAULT_PROJECT = Symbol.for("default-project");
 const debug = createDebug("vitest:coverage");
 let uniqueId = 0;
@@ -2231,8 +2230,13 @@ class V8CoverageProvider extends BaseCoverageProvider {
       ...config,
       // Resolved fields
       provider: "v8",
-      reporter: this.resolveReporters(config.reporter || coverageConfigDefaults.reporter),
-      reportsDirectory: resolve(ctx.config.root, config.reportsDirectory || coverageConfigDefaults.reportsDirectory),
+      reporter: this.resolveReporters(
+        config.reporter || coverageConfigDefaults.reporter
+      ),
+      reportsDirectory: resolve(
+        ctx.config.root,
+        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
+      ),
       thresholds: config.thresholds && {
         ...config.thresholds,
         lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
@@ -2251,16 +2255,29 @@ class V8CoverageProvider extends BaseCoverageProvider {
     });
     const shard = this.ctx.config.shard;
     const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-    this.coverageFilesDirectory = resolve(this.options.reportsDirectory, tempDirectory);
+    this.coverageFilesDirectory = resolve(
+      this.options.reportsDirectory,
+      tempDirectory
+    );
   }
   resolveOptions() {
     return this.options;
   }
   async clean(clean = true) {
-    if (clean && existsSync(this.options.reportsDirectory))
-      await promises$1.rm(this.options.reportsDirectory, { recursive: true, force: true, maxRetries: 10 });
-    if (existsSync(this.coverageFilesDirectory))
-      await promises$1.rm(this.coverageFilesDirectory, { recursive: true, force: true, maxRetries: 10 });
+    if (clean && existsSync(this.options.reportsDirectory)) {
+      await promises$1.rm(this.options.reportsDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    if (existsSync(this.coverageFilesDirectory)) {
+      await promises$1.rm(this.coverageFilesDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
     await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
     this.coverageFiles = /* @__PURE__ */ new Map();
     this.pendingPromises = [];
@@ -2271,41 +2288,57 @@ class V8CoverageProvider extends BaseCoverageProvider {
    * backwards compatibility is a breaking change.
    */
   onAfterSuiteRun({ coverage, transformMode, projectName }) {
-    if (transformMode !== "web" && transformMode !== "ssr")
+    if (transformMode !== "web" && transformMode !== "ssr") {
       throw new Error(`Invalid transform mode: ${transformMode}`);
+    }
     let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
     if (!entry) {
       entry = { web: [], ssr: [] };
       this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
     }
-    const filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+    const filename = resolve(
+      this.coverageFilesDirectory,
+      `coverage-${uniqueId++}.json`
+    );
     entry[transformMode].push(filename);
     const promise = promises$1.writeFile(filename, JSON.stringify(coverage), "utf-8");
     this.pendingPromises.push(promise);
   }
-  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."));
+  async generateCoverage({ allTestsRun }) {
     const coverageMap = libCoverage.createCoverageMap({});
     let index = 0;
     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)) {
+        for (const chunk of this.toSlices(
+          filenames,
+          this.options.processingConcurrency
+        )) {
           if (debug.enabled) {
             index += chunk.length;
             debug("Covered files %d/%d", index, total);
           }
-          await Promise.all(chunk.map(async (filename) => {
-            const contents = await promises$1.readFile(filename, "utf-8");
-            const coverage = JSON.parse(contents);
-            merged = mergeProcessCovs([merged, coverage]);
-          }));
+          await Promise.all(
+            chunk.map(async (filename) => {
+              const contents = await promises$1.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              merged = mergeProcessCovs([merged, coverage]);
+            })
+          );
         }
-        const converted = await this.convertCoverage(merged, projectName, transformMode);
+        const converted = await this.convertCoverage(
+          merged,
+          projectName,
+          transformMode
+        );
         const transformedCoverage = await transformCoverage(converted);
         coverageMap.merge(transformedCoverage);
       }
@@ -2316,13 +2349,40 @@ class V8CoverageProvider extends BaseCoverageProvider {
       const converted = await this.convertCoverage(untestedCoverage);
       coverageMap.merge(await transformCoverage(converted));
     }
+    return coverageMap;
+  }
+  async reportCoverage(coverageMap, { allTestsRun }) {
+    if (provider === "stackblitz") {
+      this.ctx.logger.log(
+        c.blue(" % ") + c.yellow(
+          "@vitest/coverage-v8 does not work on Stackblitz. Report will be empty."
+        )
+      );
+    }
+    await this.generateReports(
+      coverageMap || libCoverage.createCoverageMap({}),
+      allTestsRun
+    );
+    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
+    if (!keepResults) {
+      this.coverageFiles = /* @__PURE__ */ new Map();
+      await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
+      if (readdirSync(this.options.reportsDirectory).length === 0) {
+        await promises$1.rm(this.options.reportsDirectory, { recursive: true });
+      }
+    }
+  }
+  async generateReports(coverageMap, allTestsRun) {
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
       watermarks: this.options.watermarks
     });
-    if (this.hasTerminalReporter(this.options.reporter))
-      this.ctx.logger.log(c.blue(" % ") + c.dim("Coverage report from ") + c.yellow(this.name));
+    if (this.hasTerminalReporter(this.options.reporter)) {
+      this.ctx.logger.log(
+        c.blue(" % ") + c.dim("Coverage report from ") + c.yellow(this.name)
+      );
+    }
     for (const reporter of this.options.reporter) {
       reports.create(reporter[0], {
         skipFull: this.options.skipFull,
@@ -2342,62 +2402,95 @@ class V8CoverageProvider extends BaseCoverageProvider {
         perFile: this.options.thresholds.perFile
       });
       if (this.options.thresholds.autoUpdate && allTestsRun) {
-        if (!this.ctx.server.config.configFile)
-          throw new Error('Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.');
+        if (!this.ctx.server.config.configFile) {
+          throw new Error(
+            'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
+          );
+        }
         const configFilePath = this.ctx.server.config.configFile;
-        const configModule = parseModule(await promises$1.readFile(configFilePath, "utf8"));
+        const configModule = parseModule(
+          await promises$1.readFile(configFilePath, "utf8")
+        );
         this.updateThresholds({
           thresholds: resolvedThresholds,
           perFile: this.options.thresholds.perFile,
           configurationFile: configModule,
-          onUpdate: () => writeFileSync(configFilePath, configModule.generate().code, "utf-8")
+          onUpdate: () => writeFileSync(
+            configFilePath,
+            configModule.generate().code,
+            "utf-8"
+          )
         });
       }
     }
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-    if (!keepResults) {
-      this.coverageFiles = /* @__PURE__ */ new Map();
-      await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
+  }
+  async mergeReports(coverageMaps) {
+    const coverageMap = libCoverage.createCoverageMap({});
+    for (const coverage of coverageMaps) {
+      coverageMap.merge(coverage);
     }
+    await this.generateReports(coverageMap, true);
   }
   async getUntestedFiles(testedFiles) {
-    const transformResults = normalizeTransformResults(this.ctx.vitenode.fetchCache);
+    const transformResults = normalizeTransformResults(
+      this.ctx.vitenode.fetchCache
+    );
     const allFiles = await this.testExclude.glob(this.ctx.config.root);
-    let includedFiles = allFiles.map((file) => resolve(this.ctx.config.root, file));
-    if (this.ctx.config.changed)
-      includedFiles = (this.ctx.config.related || []).filter((file) => includedFiles.includes(file));
+    let includedFiles = allFiles.map(
+      (file) => resolve(this.ctx.config.root, file)
+    );
+    if (this.ctx.config.changed) {
+      includedFiles = (this.ctx.config.related || []).filter(
+        (file) => includedFiles.includes(file)
+      );
+    }
     const uncoveredFiles = includedFiles.map((file) => pathToFileURL(file)).filter((file) => !testedFiles.includes(file.pathname));
     let merged = { result: [] };
     let index = 0;
-    for (const chunk of this.toSlices(uncoveredFiles, this.options.processingConcurrency)) {
+    for (const chunk of this.toSlices(
+      uncoveredFiles,
+      this.options.processingConcurrency
+    )) {
       if (debug.enabled) {
         index += chunk.length;
         debug("Uncovered files %d/%d", index, uncoveredFiles.length);
       }
-      const coverages = await Promise.all(chunk.map(async (filename) => {
-        const { originalSource, source } = await this.getSources(filename.href, transformResults);
-        if (source && stripLiteral(source).trim() === "")
-          return null;
-        const coverage = {
-          url: filename.href,
-          scriptId: "0",
-          // Create a made up function to mark whole file as uncovered. Note that this does not exist in source maps.
-          functions: [{
-            ranges: [{
-              startOffset: 0,
-              endOffset: originalSource.length,
-              count: 0
-            }],
-            isBlockCoverage: true,
-            // This is magical value that indicates an empty report: https://github.com/istanbuljs/v8-to-istanbul/blob/fca5e6a9e6ef38a9cdc3a178d5a6cf9ef82e6cab/lib/v8-to-istanbul.js#LL131C40-L131C40
-            functionName: "(empty-report)"
-          }]
-        };
-        return { result: [coverage] };
-      }));
+      const coverages = await Promise.all(
+        chunk.map(async (filename) => {
+          const { originalSource, source } = await this.getSources(
+            filename.href,
+            transformResults
+          );
+          if (source && stripLiteral(source).trim() === "") {
+            return null;
+          }
+          const coverage = {
+            url: filename.href,
+            scriptId: "0",
+            // Create a made up function to mark whole file as uncovered. Note that this does not exist in source maps.
+            functions: [
+              {
+                ranges: [
+                  {
+                    startOffset: 0,
+                    endOffset: originalSource.length,
+                    count: 0
+                  }
+                ],
+                isBlockCoverage: true,
+                // This is magical value that indicates an empty report: https://github.com/istanbuljs/v8-to-istanbul/blob/fca5e6a9e6ef38a9cdc3a178d5a6cf9ef82e6cab/lib/v8-to-istanbul.js#LL131C40-L131C40
+                functionName: "(empty-report)"
+              }
+            ]
+          };
+          return { result: [coverage] };
+        })
+      );
       merged = mergeProcessCovs([
         merged,
-        ...coverages.filter((cov) => cov != null)
+        ...coverages.filter(
+          (cov) => cov != null
+        )
       ]);
     }
     return merged;
@@ -2424,8 +2517,9 @@ class V8CoverageProvider extends BaseCoverageProvider {
       };
     }
     const sources = [url];
-    if (map.sources && map.sources[0] && !url.endsWith(map.sources[0]))
+    if (map.sources && map.sources[0] && !url.endsWith(map.sources[0])) {
       sources[0] = new URL(map.sources[0], url).href;
+    }
     return {
       isExecuted,
       originalSource: sourcesContent,
@@ -2444,22 +2538,39 @@ class V8CoverageProvider extends BaseCoverageProvider {
     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 scriptCoverages = coverage.result.filter((result) => this.testExclude.shouldInstrument(fileURLToPath$1(result.url)));
+    const scriptCoverages = coverage.result.filter(
+      (result) => this.testExclude.shouldInstrument(fileURLToPath$1(result.url))
+    );
     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);
       }
-      await Promise.all(chunk.map(async ({ url, functions }) => {
-        const sources = await this.getSources(url, transformResults, functions);
-        const wrapperLength = sources.isExecuted ? WRAPPER_LENGTH : 0;
-        const converter = v8ToIstanbul$1(url, wrapperLength, sources, void 0, this.options.ignoreEmptyLines);
-        await converter.load();
-        converter.applyCoverage(functions);
-        coverageMap.merge(converter.toIstanbul());
-      }));
+      await Promise.all(
+        chunk.map(async ({ url, functions }) => {
+          const sources = await this.getSources(
+            url,
+            transformResults,
+            functions
+          );
+          const wrapperLength = sources.isExecuted ? WRAPPER_LENGTH : 0;
+          const converter = v8ToIstanbul$1(
+            url,
+            wrapperLength,
+            sources,
+            void 0,
+            this.options.ignoreEmptyLines
+          );
+          await converter.load();
+          converter.applyCoverage(functions);
+          coverageMap.merge(converter.toIstanbul());
+        })
+      );
     }
     return coverageMap;
   }
@@ -2469,10 +2580,12 @@ async function transformCoverage(coverageMap) {
   return await sourceMapStore.transformCoverage(coverageMap);
 }
 function excludeGeneratedCode(source, map) {
-  if (!source)
+  if (!source) {
     return map;
-  if (!source.match(VITE_EXPORTS_LINE_PATTERN) && !source.match(DECORATOR_METADATA_PATTERN))
+  }
+  if (!source.match(VITE_EXPORTS_LINE_PATTERN) && !source.match(DECORATOR_METADATA_PATTERN)) {
     return map;
+  }
   const trimmed = new MagicString(source);
   trimmed.replaceAll(VITE_EXPORTS_LINE_PATTERN, "\n");
   trimmed.replaceAll(DECORATOR_METADATA_PATTERN, (match) => "\n".repeat(match.split("\n").length - 1));
@@ -2485,7 +2598,10 @@ function excludeGeneratedCode(source, map) {
 }
 function findLongestFunctionLength(functions) {
   return functions.reduce((previous, current) => {
-    const maxEndOffset = current.ranges.reduce((endOffset, range) => Math.max(endOffset, range.endOffset), 0);
+    const maxEndOffset = current.ranges.reduce(
+      (endOffset, range) => Math.max(endOffset, range.endOffset),
+      0
+    );
     return Math.max(previous, maxEndOffset);
   }, 0);
 }
@@ -2493,8 +2609,9 @@ function normalizeTransformResults(fetchCache) {
   const normalized = /* @__PURE__ */ new Map();
   for (const [key, value] of fetchCache.entries()) {
     const cleanEntry = cleanUrl(key);
-    if (!normalized.has(cleanEntry))
+    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": "2.0.0-beta.1",
+  "version": "2.0.0-beta.11",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,22 +37,22 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "2.0.0-beta.1"
+    "vitest": "2.0.0-beta.11"
   },
   "dependencies": {
     "@ampproject/remapping": "^2.3.0",
     "@bcoe/v8-coverage": "^0.2.3",
-    "debug": "^4.3.4",
+    "debug": "^4.3.5",
     "istanbul-lib-coverage": "^3.2.2",
     "istanbul-lib-report": "^3.0.1",
     "istanbul-lib-source-maps": "^5.0.4",
     "istanbul-reports": "^3.1.7",
     "magic-string": "^0.30.10",
     "magicast": "^0.3.4",
-    "picocolors": "^1.0.0",
+    "picocolors": "^1.0.1",
     "std-env": "^3.7.0",
     "strip-literal": "^2.1.0",
-    "test-exclude": "^6.0.0"
+    "test-exclude": "^7.0.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
@@ -62,8 +62,8 @@
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^1.1.2",
     "v8-to-istanbul": "^9.2.0",
-    "vitest": "2.0.0-beta.1",
-    "vite-node": "2.0.0-beta.1"
+    "vite-node": "2.0.0-beta.11",
+    "vitest": "2.0.0-beta.11"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",