@vitest/coverage-v8 2.1.2 → 2.1.3

package/dist/browser.d.ts

@@ -1,8 +1,9 @@
 import { V8CoverageProvider } from './provider.js';
+import 'magicast';
 import 'istanbul-lib-coverage';
+import 'test-exclude';
 import 'vitest/coverage';
 import 'vitest/node';
-import 'vitest';
 
 declare const _default: {
     startCoverage(): Promise<void>;

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { Profiler } from 'node:inspector';
 import { V8CoverageProvider } from './provider.js';
+import 'magicast';
 import 'istanbul-lib-coverage';
+import 'test-exclude';
 import 'vitest/coverage';
 import 'vitest/node';
-import 'vitest';
 
 declare const _default: {
     startCoverage(): void;

package/dist/provider.d.ts

@@ -1,60 +1,18 @@
-import { CoverageMap } from 'istanbul-lib-coverage';
+import * as magicast from 'magicast';
+import libCoverage, { CoverageMap } from 'istanbul-lib-coverage';
+import TestExclude from 'test-exclude';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import { Vitest } from 'vitest/node';
-import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
+import { ResolvedCoverageOptions, CoverageProvider, Vitest, ReportContext } from 'vitest/node';
 
-interface TestExclude {
-    new (opts: {
-        cwd?: string | string[];
-        include?: string | string[];
-        exclude?: string | string[];
-        extension?: string | string[];
-        excludeNodeModules?: boolean;
-        relativePath?: boolean;
-    }): {
-        shouldInstrument: (filePath: string) => boolean;
-        glob: (cwd: string) => Promise<string[]>;
-    };
-}
-type Options = ResolvedCoverageOptions<'v8'>;
-/**
- * Holds info about raw coverage results that are stored on file system:
- *
- * ```json
- * "project-a": {
- *   "web": {
- *     "tests/math.test.ts": "coverage-1.json",
- *     "tests/utils.test.ts": "coverage-2.json",
- * //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
- *   },
- *   "ssr": { ... },
- *   "browser": { ... },
- * },
- * "project-b": ...
- * ```
- */
-type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta['projectName']> | typeof DEFAULT_PROJECT, Record<AfterSuiteRunMeta['transformMode'], {
-    [TestFilenames: string]: string;
-}>>;
-declare const DEFAULT_PROJECT: unique symbol;
-declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
-    name: string;
-    ctx: Vitest;
-    options: Options;
-    testExclude: InstanceType<TestExclude>;
-    coverageFiles: CoverageFiles;
-    coverageFilesDirectory: string;
-    pendingPromises: Promise<void>[];
+declare class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOptions<'v8'>> implements CoverageProvider {
+    name: "v8";
+    version: string;
+    testExclude: InstanceType<typeof TestExclude>;
     initialize(ctx: Vitest): void;
-    resolveOptions(): Options;
-    clean(clean?: boolean): Promise<void>;
-    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+    createCoverageMap(): libCoverage.CoverageMap;
     generateCoverage({ allTestsRun }: ReportContext): Promise<CoverageMap>;
-    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
-    private cleanAfterRun;
-    onTestFailure(): Promise<void>;
     generateReports(coverageMap: CoverageMap, allTestsRun?: boolean): Promise<void>;
-    mergeReports(coverageMaps: unknown[]): Promise<void>;
+    parseConfigModule(configFilePath: string): Promise<magicast.ProxifiedModule<any>>;
     private getUntestedFiles;
     private getSources;
     private convertCoverage;

package/dist/provider.js

@@ -1,5 +1,5 @@
-import { existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
+import { promises } from 'node:fs';
 import require$$0 from 'assert';
 import require$$2 from 'util';
 import require$$3 from 'path';
@@ -7,20 +7,19 @@ import require$$4 from 'url';
 import require$$9 from 'fs';
 import require$$11 from 'module';
 import { mergeProcessCovs } from '@bcoe/v8-coverage';
-import libReport from 'istanbul-lib-report';
-import reports from 'istanbul-reports';
 import libCoverage from 'istanbul-lib-coverage';
+import libReport from 'istanbul-lib-report';
 import libSourceMaps from 'istanbul-lib-source-maps';
-import MagicString from 'magic-string';
-import { parseModule } from 'magicast';
-import remapping from '@ampproject/remapping';
-import c from 'tinyrainbow';
+import reports from 'istanbul-reports';
 import { provider } from 'std-env';
+import c from 'tinyrainbow';
 import createDebug from 'debug';
-import { builtinModules } from 'node:module';
-import { coverageConfigDefaults } from 'vitest/config';
+import MagicString from 'magic-string';
+import TestExclude from 'test-exclude';
+import remapping from '@ampproject/remapping';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import _TestExclude from 'test-exclude';
+import { builtinModules } from 'node:module';
+import { parseModule } from 'magicast';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -2540,57 +2539,20 @@ function cleanUrl(url) {
   "wasi"
 ]);
 
-var version = "2.1.2";
+var version = "2.1.3";
 
 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 {
   name = "v8";
-  ctx;
-  options;
+  version = version;
   testExclude;
-  coverageFiles = /* @__PURE__ */ new Map();
-  coverageFilesDirectory;
-  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,
-      // User's options
-      ...config,
-      // Resolved fields
-      provider: "v8",
-      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,
-        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
-        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
-        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
-      }
-    };
-    this.testExclude = new _TestExclude({
+    this._initialize(ctx);
+    this.testExclude = new TestExclude({
       cwd: ctx.config.root,
       include: this.options.include,
       exclude: this.options.exclude,
@@ -2598,82 +2560,18 @@ Update your dependencies and make sure the versions match.`
       extension: this.options.extension,
       relativePath: !this.options.allowExternal
     });
-    const shard = this.ctx.config.shard;
-    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
-    this.coverageFilesDirectory = resolve(
-      this.options.reportsDirectory,
-      tempDirectory
-    );
-  }
-  resolveOptions() {
-    return this.options;
   }
-  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
-      });
-    }
-    await promises.mkdir(this.coverageFilesDirectory, { recursive: true });
-    this.coverageFiles = /* @__PURE__ */ new Map();
-    this.pendingPromises = [];
-  }
-  /*
-   * 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, testFiles }) {
-    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: {}, browser: {} };
-      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
-    }
-    const testFilenames = testFiles.join();
-    const filename = resolve(
-      this.coverageFilesDirectory,
-      `coverage-${uniqueId++}.json`
-    );
-    entry[transformMode][testFilenames] = filename;
-    const promise = promises.writeFile(filename, JSON.stringify(coverage), "utf-8");
-    this.pendingPromises.push(promise);
+  createCoverageMap() {
+    return libCoverage.createCoverageMap({});
   }
   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, coverageByTestfiles] of Object.entries(coveragePerProject)) {
-        let merged = { result: [] };
-        const filenames = Object.values(coverageByTestfiles);
-        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);
-          }
-          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 coverageMap = this.createCoverageMap();
+    let merged = { result: [] };
+    await this.readCoverageFiles({
+      onFileRead(coverage) {
+        merged = mergeProcessCovs([merged, coverage]);
+      },
+      onFinished: async (project, transformMode) => {
         const converted = await this.convertCoverage(
           merged,
           project,
@@ -2681,8 +2579,10 @@ Update your dependencies and make sure the versions match.`
         );
         const transformedCoverage = await transformCoverage(converted);
         coverageMap.merge(transformedCoverage);
-      }
-    }
+        merged = { result: [] };
+      },
+      onDebug: debug
+    });
     if (this.options.all && (allTestsRun || !this.options.cleanOnRerun)) {
       const coveredFiles = coverageMap.files();
       const untestedCoverage = await this.getUntestedFiles(coveredFiles);
@@ -2694,7 +2594,7 @@ Update your dependencies and make sure the versions match.`
     }
     return coverageMap;
   }
-  async reportCoverage(coverageMap, { allTestsRun }) {
+  async generateReports(coverageMap, allTestsRun) {
     if (provider === "stackblitz") {
       this.ctx.logger.log(
         c.blue(" % ") + c.yellow(
@@ -2702,28 +2602,6 @@ Update your dependencies and make sure the versions match.`
         )
       );
     }
-    await this.generateReports(
-      coverageMap || libCoverage.createCoverageMap({}),
-      allTestsRun
-    );
-    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
-    if (!keepResults) {
-      await this.cleanAfterRun();
-    }
-  }
-  async cleanAfterRun() {
-    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 onTestFailure() {
-    if (!this.options.reportOnFailure) {
-      await this.cleanAfterRun();
-    }
-  }
-  async generateReports(coverageMap, allTestsRun) {
     const context = libReport.createContext({
       dir: this.options.reportsDirectory,
       coverageMap,
@@ -2742,46 +2620,13 @@ Update your dependencies and make sure the versions match.`
       }).execute(context);
     }
     if (this.options.thresholds) {
-      const resolvedThresholds = this.resolveThresholds({
-        coverageMap,
-        thresholds: this.options.thresholds,
-        createCoverageMap: () => libCoverage.createCoverageMap({}),
-        root: this.ctx.config.root
-      });
-      this.checkThresholds({
-        thresholds: resolvedThresholds,
-        perFile: this.options.thresholds.perFile,
-        onError: (error) => this.ctx.logger.error(error)
-      });
-      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.'
-          );
-        }
-        const configFilePath = this.ctx.server.config.configFile;
-        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"
-          )
-        });
-      }
+      await this.reportThresholds(coverageMap, allTestsRun);
     }
   }
-  async mergeReports(coverageMaps) {
-    const coverageMap = libCoverage.createCoverageMap({});
-    for (const coverage of coverageMaps) {
-      coverageMap.merge(coverage);
-    }
-    await this.generateReports(coverageMap, true);
+  async parseConfigModule(configFilePath) {
+    return parseModule(
+      await promises.readFile(configFilePath, "utf8")
+    );
   }
   async getUntestedFiles(testedFiles) {
     const transformResults = normalizeTransformResults(
@@ -2800,10 +2645,7 @@ Update your dependencies and make sure the versions match.`
     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);
@@ -2916,7 +2758,7 @@ Update your dependencies and make sure the versions match.`
         scriptCoverages.push(result);
       }
     }
-    const coverageMap = libCoverage.createCoverageMap({});
+    const coverageMap = this.createCoverageMap();
     let index = 0;
     for (const chunk of this.toSlices(scriptCoverages, this.options.processingConcurrency)) {
       if (debug.enabled) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-v8",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "V8 coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -41,8 +41,8 @@
     "dist"
   ],
   "peerDependencies": {
-    "@vitest/browser": "2.1.2",
-    "vitest": "2.1.2"
+    "@vitest/browser": "2.1.3",
+    "vitest": "2.1.3"
   },
   "peerDependenciesMeta": {
     "@vitest/browser": {
@@ -69,11 +69,12 @@
     "@types/istanbul-lib-report": "^3.0.3",
     "@types/istanbul-lib-source-maps": "^4.0.4",
     "@types/istanbul-reports": "^3.0.4",
+    "@types/test-exclude": "^6.0.2",
     "pathe": "^1.1.2",
     "v8-to-istanbul": "^9.3.0",
-    "@vitest/browser": "2.1.2",
-    "vite-node": "2.1.2",
-    "vitest": "2.1.2"
+    "@vitest/browser": "2.1.3",
+    "vite-node": "2.1.3",
+    "vitest": "2.1.3"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",