@vitest/coverage-v8 1.0.0-beta.5 → 1.0.0

package/dist/index.d.ts

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

package/dist/provider.d.ts

@@ -1,4 +1,3 @@
-import { Profiler } from 'node:inspector';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
 import { Vitest } from 'vitest/node';
@@ -17,8 +16,8 @@ interface TestExclude {
     };
 }
 type Options = ResolvedCoverageOptions<'v8'>;
-type RawCoverage = Profiler.TakePreciseCoverageReturnType;
-type CoverageByTransformMode = Record<AfterSuiteRunMeta['transformMode'], RawCoverage[]>;
+type Filename = string;
+type CoverageFilesByTransformMode = Record<AfterSuiteRunMeta['transformMode'], Filename[]>;
 type ProjectName = NonNullable<AfterSuiteRunMeta['projectName']> | typeof DEFAULT_PROJECT;
 declare const DEFAULT_PROJECT: unique symbol;
 declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
@@ -26,7 +25,9 @@ declare class V8CoverageProvider extends BaseCoverageProvider implements Coverag
     ctx: Vitest;
     options: Options;
     testExclude: InstanceType<TestExclude>;
-    coverages: Map<ProjectName, CoverageByTransformMode>;
+    coverageFiles: Map<ProjectName, CoverageFilesByTransformMode>;
+    coverageFilesDirectory: string;
+    pendingPromises: Promise<void>[];
     initialize(ctx: Vitest): void;
     resolveOptions(): Options;
     clean(clean?: boolean): Promise<void>;
@@ -34,7 +35,7 @@ declare class V8CoverageProvider extends BaseCoverageProvider implements Coverag
     reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
     private getUntestedFiles;
     private getSources;
-    private mergeAndTransformCoverage;
+    private convertCoverage;
 }
 
 export { V8CoverageProvider };

package/dist/provider.js

@@ -11,6 +11,7 @@ import { parseModule } from 'magicast';
 import remapping from '@ampproject/remapping';
 import c from 'picocolors';
 import { provider } from 'std-env';
+import createDebug from 'debug';
 import { builtinModules } from 'node:module';
 import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config';
 import { BaseCoverageProvider } from 'vitest/coverage';
@@ -170,12 +171,16 @@ 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");
+const debug = createDebug("vitest:coverage");
+let uniqueId = 0;
 class V8CoverageProvider extends BaseCoverageProvider {
   name = "v8";
   ctx;
   options;
   testExclude;
-  coverages = /* @__PURE__ */ new Map();
+  coverageFiles = /* @__PURE__ */ new Map();
+  coverageFilesDirectory;
+  pendingPromises = [];
   initialize(ctx) {
     const config = ctx.config.coverage;
     this.ctx = ctx;
@@ -203,6 +208,7 @@ class V8CoverageProvider extends BaseCoverageProvider {
       extension: this.options.extension,
       relativePath: !this.options.allowExternal
     });
+    this.coverageFilesDirectory = resolve(this.options.reportsDirectory, ".tmp");
   }
   resolveOptions() {
     return this.options;
@@ -210,7 +216,11 @@ 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 = /* @__PURE__ */ new Map();
+    if (existsSync(this.coverageFilesDirectory))
+      await promises.rm(this.coverageFilesDirectory, { recursive: true, force: true, maxRetries: 10 });
+    await promises.mkdir(this.coverageFilesDirectory, { recursive: true });
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    this.pendingPromises = [];
   }
   /*
    * Coverage and meta information passed from Vitest runners.
@@ -220,29 +230,49 @@ class V8CoverageProvider extends BaseCoverageProvider {
   onAfterSuiteRun({ coverage, transformMode, projectName }) {
     if (transformMode !== "web" && transformMode !== "ssr")
       throw new Error(`Invalid transform mode: ${transformMode}`);
-    let entry = this.coverages.get(projectName || DEFAULT_PROJECT);
+    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
     if (!entry) {
       entry = { web: [], ssr: [] };
-      this.coverages.set(projectName || DEFAULT_PROJECT, entry);
+      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
     }
-    entry[transformMode].push(coverage);
+    const filename = resolve(this.coverageFilesDirectory, `coverage-${uniqueId++}.json`);
+    entry[transformMode].push(filename);
+    const promise = promises.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."));
-    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()
-    );
+    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)) {
+        let merged = { result: [] };
+        for (const chunk of 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.readFile(filename, "utf-8");
+            const coverage = JSON.parse(contents);
+            merged = mergeProcessCovs([merged, coverage]);
+          }));
+        }
+        const converted = await this.convertCoverage(merged, projectName, transformMode);
+        const transformedCoverage = await transformCoverage(converted);
+        coverageMap.merge(transformedCoverage);
+      }
+    }
     if (this.options.all && allTestsRun) {
-      const coveredFiles = coverageMaps.map((map) => map.files()).flat();
+      const coveredFiles = coverageMap.files();
       const untestedCoverage = await this.getUntestedFiles(coveredFiles);
-      const untestedCoverageResults = untestedCoverage.map((files) => ({ result: [files] }));
-      coverageMaps.push(await this.mergeAndTransformCoverage(untestedCoverageResults));
+      const converted = await this.convertCoverage(untestedCoverage);
+      coverageMap.merge(await transformCoverage(converted));
     }
-    const coverageMap = mergeCoverageMaps(...coverageMaps);
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
@@ -281,30 +311,43 @@ class V8CoverageProvider extends BaseCoverageProvider {
           }
         });
       }
+      this.coverageFiles = /* @__PURE__ */ new Map();
+      await promises.rm(this.coverageFilesDirectory, { recursive: true });
     }
   }
   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.pathname));
-    return await Promise.all(uncoveredFiles.map(async (uncoveredFile) => {
-      const { source } = await this.getSources(uncoveredFile.href, transformResults);
-      return {
-        url: uncoveredFile.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: source.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)"
-        }]
-      };
-    }));
+    let merged = { result: [] };
+    let index = 0;
+    for (const chunk of 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 { source } = await this.getSources(filename.href, transformResults);
+        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: source.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]);
+    }
+    return merged;
   }
   async getSources(url, transformResults, functions = []) {
     const filePath = normalize(fileURLToPath(url));
@@ -330,31 +373,33 @@ class V8CoverageProvider extends BaseCoverageProvider {
       }
     };
   }
-  async mergeAndTransformCoverage(coverages, projectName, transformMode) {
+  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;
     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);
+    const scriptCoverages = coverage.result.filter((result) => this.testExclude.shouldInstrument(fileURLToPath(result.url)));
+    const coverageMap = libCoverage.createCoverageMap({});
+    let index = 0;
+    for (const chunk of 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.sourceMap ? WRAPPER_LENGTH : 0;
+        const converter = v8ToIstanbul(url, wrapperLength, sources);
+        await converter.load();
+        converter.applyCoverage(functions);
+        coverageMap.merge(converter.toIstanbul());
+      }));
+    }
+    return coverageMap;
   }
 }
-function mergeCoverageMaps(...coverageMaps) {
-  return coverageMaps.reduce((coverage, previousCoverageMap) => {
-    const map = libCoverage.createCoverageMap(coverage);
-    map.merge(previousCoverageMap);
-    return map;
-  }, libCoverage.createCoverageMap({}));
+async function transformCoverage(coverageMap) {
+  const sourceMapStore = libSourceMaps.createSourceMapStore();
+  return await sourceMapStore.transformCoverage(coverageMap);
 }
 function removeViteHelpersFromSourceMaps(source, map) {
   if (!source || !source.match(VITE_EXPORTS_LINE_PATTERN))
@@ -388,5 +433,17 @@ function normalizeTransformResults(fetchCache) {
 function hasTerminalReporter(reporters) {
   return reporters.some(([reporter]) => reporter === "text" || reporter === "text-summary" || reporter === "text-lcov" || reporter === "teamcity");
 }
+function toSlices(array, size) {
+  return array.reduce((chunks, item) => {
+    const index = Math.max(0, chunks.length - 1);
+    const lastChunk = chunks[index] || [];
+    chunks[index] = lastChunk;
+    if (lastChunk.length >= size)
+      chunks.push([item]);
+    else
+      lastChunk.push(item);
+    return chunks;
+  }, []);
+}
 
 export { V8CoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -42,6 +42,7 @@
   "dependencies": {
     "@ampproject/remapping": "^2.2.1",
     "@bcoe/v8-coverage": "^0.2.3",
+    "debug": "^4.3.4",
     "istanbul-lib-coverage": "^3.2.2",
     "istanbul-lib-report": "^3.0.1",
     "istanbul-lib-source-maps": "^4.0.1",
@@ -49,18 +50,19 @@
     "magic-string": "^0.30.5",
     "magicast": "^0.3.2",
     "picocolors": "^1.0.0",
-    "std-env": "^3.4.3",
+    "std-env": "^3.5.0",
     "test-exclude": "^6.0.0",
-    "v8-to-istanbul": "^9.1.3"
+    "v8-to-istanbul": "^9.2.0"
   },
   "devDependencies": {
+    "@types/debug": "^4.1.12",
     "@types/istanbul-lib-coverage": "^2.0.6",
     "@types/istanbul-lib-report": "^3.0.3",
     "@types/istanbul-lib-source-maps": "^4.0.4",
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^1.1.1",
-    "vite-node": "1.0.0-beta.5",
-    "vitest": "1.0.0-beta.5"
+    "vite-node": "1.0.0",
+    "vitest": "1.0.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",