@vitest/coverage-istanbul 2.1.2 → 2.1.3

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { IstanbulCoverageProvider } from './provider.js';
-import 'vitest';
+import 'magicast';
+import 'vitest/node';
 import 'vitest/coverage';
+import 'test-exclude';
 import 'istanbul-lib-coverage';
 import 'istanbul-lib-instrument';
 

package/dist/provider.d.ts

@@ -1,65 +1,24 @@
-import { CoverageProvider, Vitest, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
+import * as magicast from 'magicast';
+import { ResolvedCoverageOptions, CoverageProvider, Vitest, ReportContext } from 'vitest/node';
 import { BaseCoverageProvider } from 'vitest/coverage';
-import { CoverageMap } from 'istanbul-lib-coverage';
+import TestExclude from 'test-exclude';
+import libCoverage, { CoverageMap } from 'istanbul-lib-coverage';
 import { Instrumenter } from 'istanbul-lib-instrument';
 
-type Options = ResolvedCoverageOptions<'istanbul'>;
-/**
- * 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;
-}>>;
-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[]>;
-    };
-}
-declare const DEFAULT_PROJECT: unique symbol;
-declare class IstanbulCoverageProvider extends BaseCoverageProvider implements CoverageProvider {
-    name: string;
-    ctx: Vitest;
-    options: Options;
+declare class IstanbulCoverageProvider extends BaseCoverageProvider<ResolvedCoverageOptions<'istanbul'>> implements CoverageProvider {
+    name: "istanbul";
+    version: string;
     instrumenter: Instrumenter;
-    testExclude: InstanceType<TestExclude>;
-    coverageFiles: CoverageFiles;
-    coverageFilesDirectory: string;
-    pendingPromises: Promise<void>[];
+    testExclude: InstanceType<typeof TestExclude>;
     initialize(ctx: Vitest): void;
-    resolveOptions(): Options;
     onFileTransform(sourceCode: string, id: string, pluginCtx: any): {
         code: string;
         map: any;
     } | undefined;
-    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
-    clean(clean?: boolean): Promise<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 | undefined): Promise<void>;
-    mergeReports(coverageMaps: unknown[]): Promise<void>;
+    parseConfigModule(configFilePath: string): Promise<magicast.ProxifiedModule<any>>;
     private getCoverageMapForUncoveredFiles;
 }
 

package/dist/provider.js

@@ -1,16 +1,15 @@
-import { promises, existsSync, readdirSync, writeFileSync } from 'node:fs';
-import { coverageConfigDefaults } from 'vitest/config';
+import { promises } from 'node:fs';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import c from 'tinyrainbow';
 import { parseModule } from 'magicast';
 import createDebug from 'debug';
+import TestExclude from 'test-exclude';
 import libReport from 'istanbul-lib-report';
 import reports from 'istanbul-reports';
 import libCoverage from 'istanbul-lib-coverage';
 import libSourceMaps from 'istanbul-lib-source-maps';
 import { createInstrumenter } from 'istanbul-lib-instrument';
 import { defaults } from '@istanbuljs/schema';
-import _TestExclude from 'test-exclude';
 import { C as COVERAGE_STORE_KEY } from './constants-BCJfMgEg.js';
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
@@ -108,53 +107,24 @@ const isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 
-var version = "2.1.2";
+var version = "2.1.3";
 
-const DEFAULT_PROJECT = Symbol.for("default-project");
 const debug = createDebug("vitest:coverage");
-let uniqueId = 0;
 class IstanbulCoverageProvider extends BaseCoverageProvider {
   name = "istanbul";
-  ctx;
-  options;
+  version = version;
   instrumenter;
   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-istanbul@${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: "istanbul",
-      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,
-        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._initialize(ctx);
+    this.testExclude = new TestExclude({
+      cwd: ctx.config.root,
+      include: this.options.include,
+      exclude: this.options.exclude,
+      excludeNodeModules: true,
+      extension: this.options.extension,
+      relativePath: !this.options.allowExternal
+    });
     this.instrumenter = createInstrumenter({
       produceSourceMap: true,
       autoWrap: false,
@@ -173,23 +143,6 @@ Update your dependencies and make sure the versions match.`
         importAttributesKeyword: "with"
       }
     });
-    this.testExclude = new _TestExclude({
-      cwd: ctx.config.root,
-      include: this.options.include,
-      exclude: this.options.exclude,
-      excludeNodeModules: true,
-      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;
   }
   onFileTransform(sourceCode, id, pluginCtx) {
     if (!this.testExclude.shouldInstrument(id)) {
@@ -209,92 +162,26 @@ Update your dependencies and make sure the versions match.`
     const map = this.instrumenter.lastSourceMap();
     return { code, map };
   }
-  /*
-   * 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 (!coverage) {
-      return;
-    }
-    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);
-  }
-  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 = [];
+  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 coveragePerProject of this.coverageFiles.values()) {
-      for (const coverageByTestfiles of [
-        coveragePerProject.ssr,
-        coveragePerProject.web,
-        coveragePerProject.browser
-      ]) {
-        const coverageMapByTransformMode = libCoverage.createCoverageMap({});
-        const filenames = Object.values(coverageByTestfiles);
-        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);
-            })
-          );
-        }
-        const transformedCoverage = await transformCoverage(
-          coverageMapByTransformMode
-        );
+    const coverageMap = this.createCoverageMap();
+    let coverageMapByTransformMode = this.createCoverageMap();
+    await this.readCoverageFiles({
+      onFileRead(coverage) {
+        coverageMapByTransformMode.merge(coverage);
+      },
+      onFinished: async () => {
+        const transformedCoverage = await transformCoverage(coverageMapByTransformMode);
         coverageMap.merge(transformedCoverage);
-      }
-    }
+        coverageMapByTransformMode = this.createCoverageMap();
+      },
+      onDebug: debug
+    });
     if (this.options.all && (allTestsRun || !this.options.cleanOnRerun)) {
       const coveredFiles = coverageMap.files();
-      const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(
-        coveredFiles
-      );
+      const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(coveredFiles);
       coverageMap.merge(await transformCoverage(uncoveredCoverage));
     }
     if (this.options.excludeAfterRemap) {
@@ -302,28 +189,6 @@ Update your dependencies and make sure the versions match.`
     }
     return coverageMap;
   }
-  async reportCoverage(coverageMap, { allTestsRun }) {
-    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,
@@ -343,46 +208,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 getCoverageMapForUncoveredFiles(coveredFiles) {
     const allFiles = await this.testExclude.glob(this.ctx.config.root);
@@ -396,7 +228,7 @@ Update your dependencies and make sure the versions match.`
     }
     const uncoveredFiles = includedFiles.filter((file) => !coveredFiles.includes(file)).sort();
     const cacheKey = (/* @__PURE__ */ new Date()).getTime();
-    const coverageMap = libCoverage.createCoverageMap({});
+    const coverageMap = this.createCoverageMap();
     const transform = this.createUncoveredFileTransformer(this.ctx);
     for (const [index, filename] of uncoveredFiles.entries()) {
       debug("Uncovered file %s %d/%d", filename, index, uncoveredFiles.length);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "Istanbul coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "2.1.2"
+    "vitest": "2.1.3"
   },
   "dependencies": {
     "@istanbuljs/schema": "^0.1.3",
@@ -58,8 +58,9 @@
     "@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",
-    "vitest": "2.1.2"
+    "vitest": "2.1.3"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",