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

package/dist/provider.d.ts

@@ -38,8 +38,11 @@ declare class IstanbulCoverageProvider extends BaseCoverageProvider implements C
     } | undefined;
     onAfterSuiteRun({ coverage, transformMode, projectName }: AfterSuiteRunMeta): void;
     clean(clean?: boolean): Promise<void>;
-    reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
-    getCoverageMapForUncoveredFiles(coveredFiles: string[]): Promise<CoverageMap>;
+    generateCoverage({ allTestsRun }: ReportContext): Promise<CoverageMap>;
+    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+    generateReports(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
+    mergeReports(coverageMaps: unknown[]): Promise<void>;
+    private getCoverageMapForUncoveredFiles;
 }
 
 export { IstanbulCoverageProvider };

package/dist/provider.js

@@ -1,4 +1,4 @@
-import { promises, existsSync, writeFileSync } from 'node:fs';
+import { promises, existsSync, readdirSync, writeFileSync } from 'node:fs';
 import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import c from 'picocolors';
@@ -128,8 +128,13 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
       ...config,
       // Resolved fields
       provider: "istanbul",
-      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
+      ),
+      reporter: this.resolveReporters(
+        config.reporter || coverageConfigDefaults.reporter
+      ),
       thresholds: config.thresholds && {
         ...config.thresholds,
         lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
@@ -159,18 +164,29 @@ class IstanbulCoverageProvider 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;
   }
   onFileTransform(sourceCode, id, pluginCtx) {
-    if (!this.testExclude.shouldInstrument(id))
+    if (!this.testExclude.shouldInstrument(id)) {
       return;
+    }
     const sourceMap = pluginCtx.getCombinedSourcemap();
     sourceMap.sources = sourceMap.sources.map(removeQueryParameters);
-    sourceCode = sourceCode.replaceAll("_ts_decorate", "/* istanbul ignore next */_ts_decorate");
-    const code = this.instrumenter.instrumentSync(sourceCode, id, sourceMap);
+    sourceCode = sourceCode.replaceAll(
+      "_ts_decorate",
+      "/* istanbul ignore next */_ts_decorate"
+    );
+    const code = this.instrumenter.instrumentSync(
+      sourceCode,
+      id,
+      sourceMap
+    );
     const map = this.instrumenter.lastSourceMap();
     return { code, map };
   }
@@ -180,65 +196,112 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
    * backwards compatibility is a breaking change.
    */
   onAfterSuiteRun({ coverage, transformMode, projectName }) {
-    if (!coverage)
+    if (!coverage) {
       return;
-    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.writeFile(filename, JSON.stringify(coverage), "utf-8");
     this.pendingPromises.push(promise);
   }
   async clean(clean = true) {
-    if (clean && existsSync(this.options.reportsDirectory))
-      await promises.rm(this.options.reportsDirectory, { recursive: true, force: true, maxRetries: 10 });
-    if (existsSync(this.coverageFilesDirectory))
-      await promises.rm(this.coverageFilesDirectory, { recursive: true, force: true, maxRetries: 10 });
+    if (clean && existsSync(this.options.reportsDirectory)) {
+      await promises.rm(this.options.reportsDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    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 = [];
   }
-  async reportCoverage({ allTestsRun } = {}) {
+  async generateCoverage({ allTestsRun }) {
     const coverageMap = libCoverage.createCoverageMap({});
     let index = 0;
     const total = this.pendingPromises.length;
     await Promise.all(this.pendingPromises);
     this.pendingPromises = [];
     for (const coveragePerProject of this.coverageFiles.values()) {
-      for (const filenames of [coveragePerProject.ssr, coveragePerProject.web]) {
+      for (const filenames of [
+        coveragePerProject.ssr,
+        coveragePerProject.web
+      ]) {
         const coverageMapByTransformMode = libCoverage.createCoverageMap({});
-        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.readFile(filename, "utf-8");
-            const coverage = JSON.parse(contents);
-            coverageMapByTransformMode.merge(coverage);
-          }));
+          await Promise.all(
+            chunk.map(async (filename) => {
+              const contents = await promises.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              coverageMapByTransformMode.merge(coverage);
+            })
+          );
         }
-        const transformedCoverage = await transformCoverage(coverageMapByTransformMode);
+        const transformedCoverage = await transformCoverage(
+          coverageMapByTransformMode
+        );
         coverageMap.merge(transformedCoverage);
       }
     }
     if (this.options.all && allTestsRun) {
       const coveredFiles = coverageMap.files();
-      const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(coveredFiles);
+      const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(
+        coveredFiles
+      );
       coverageMap.merge(await transformCoverage(uncoveredCoverage));
     }
+    return coverageMap;
+  }
+  async reportCoverage(coverageMap, { allTestsRun }) {
+    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.rm(this.coverageFilesDirectory, { recursive: true });
+      if (readdirSync(this.options.reportsDirectory).length === 0) {
+        await promises.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,
@@ -258,30 +321,46 @@ class IstanbulCoverageProvider 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.readFile(configFilePath, "utf8"));
+        const configModule = parseModule(
+          await promises.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.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 getCoverageMapForUncoveredFiles(coveredFiles) {
     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));
-    const uncoveredFiles = includedFiles.filter((file) => !coveredFiles.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.filter((file) => !coveredFiles.includes(file)).sort();
     const cacheKey = (/* @__PURE__ */ new Date()).getTime();
     const coverageMap = libCoverage.createCoverageMap({});
     for (const [index, filename] of uncoveredFiles.entries()) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.11",
   "description": "Istanbul coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,18 +37,18 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "2.0.0-beta.1"
+    "vitest": "2.0.0-beta.11"
   },
   "dependencies": {
-    "debug": "^4.3.4",
+    "debug": "^4.3.5",
     "istanbul-lib-coverage": "^3.2.2",
     "istanbul-lib-instrument": "^6.0.2",
     "istanbul-lib-report": "^3.0.1",
     "istanbul-lib-source-maps": "^5.0.4",
     "istanbul-reports": "^3.1.7",
     "magicast": "^0.3.4",
-    "picocolors": "^1.0.0",
-    "test-exclude": "^6.0.0"
+    "picocolors": "^1.0.1",
+    "test-exclude": "^7.0.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
@@ -58,7 +58,7 @@
     "@types/istanbul-lib-source-maps": "^4.0.4",
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^1.1.2",
-    "vitest": "2.0.0-beta.1"
+    "vitest": "2.0.0-beta.11"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",