@vitest/coverage-istanbul 2.0.0-beta.8 → 2.0.0

package/dist/index.js

@@ -2,7 +2,10 @@ import { C as COVERAGE_STORE_KEY } from './constants-BCJfMgEg.js';
 
 async function getProvider() {
   const providerPath = "./provider.js";
-  const { IstanbulCoverageProvider } = await import(providerPath);
+  const { IstanbulCoverageProvider } = await import(
+    /* @vite-ignore */
+    providerPath
+  );
   return new IstanbulCoverageProvider();
 }
 function takeCoverage() {

package/dist/provider.js

@@ -1,5 +1,5 @@
 import { promises, existsSync, readdirSync, writeFileSync } from 'node:fs';
-import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config';
+import { coverageConfigDefaults } from 'vitest/config';
 import { BaseCoverageProvider } from 'vitest/coverage';
 import c from 'picocolors';
 import { parseModule } from 'magicast';
@@ -9,6 +9,7 @@ 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';
 
@@ -128,8 +129,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,
@@ -147,30 +153,48 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
       // @ts-expect-error missing type
       coverageGlobalScope: "globalThis",
       coverageGlobalScopeFunc: false,
-      ignoreClassMethods: this.options.ignoreClassMethods
+      ignoreClassMethods: this.options.ignoreClassMethods,
+      parserPlugins: [
+        ...defaults.instrumenter.parserPlugins,
+        ["importAttributes", { deprecatedAssertSyntax: true }]
+      ],
+      generatorOpts: {
+        importAttributesKeyword: "with"
+      }
     });
     this.testExclude = new _TestExclude({
       cwd: ctx.config.root,
-      include: typeof this.options.include === "undefined" ? void 0 : [...this.options.include],
-      exclude: [...defaultExclude, ...defaultInclude, ...this.options.exclude],
+      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);
+    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,25 +204,40 @@ 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 = [];
@@ -210,26 +249,38 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
     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;
@@ -243,8 +294,9 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
     if (!keepResults) {
       this.coverageFiles = /* @__PURE__ */ new Map();
       await promises.rm(this.coverageFilesDirectory, { recursive: true });
-      if (readdirSync(this.options.reportsDirectory).length === 0)
+      if (readdirSync(this.options.reportsDirectory).length === 0) {
         await promises.rm(this.options.reportsDirectory, { recursive: true });
+      }
     }
   }
   async generateReports(coverageMap, allTestsRun) {
@@ -253,8 +305,11 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
       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,
@@ -271,34 +326,50 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
       });
       this.checkThresholds({
         thresholds: resolvedThresholds,
-        perFile: this.options.thresholds.perFile
+        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.');
+        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"
+          )
         });
       }
     }
   }
   async mergeReports(coverageMaps) {
     const coverageMap = libCoverage.createCoverageMap({});
-    for (const coverage of coverageMaps)
+    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()) {
@@ -311,33 +382,11 @@ class IstanbulCoverageProvider extends BaseCoverageProvider {
   }
 }
 async function transformCoverage(coverageMap) {
-  includeImplicitElseBranches(coverageMap);
   const sourceMapStore = libSourceMaps.createSourceMapStore();
   return await sourceMapStore.transformCoverage(coverageMap);
 }
 function removeQueryParameters(filename) {
   return filename.split("?")[0];
 }
-function includeImplicitElseBranches(coverageMap) {
-  for (const file of coverageMap.files()) {
-    const fileCoverage = coverageMap.fileCoverageFor(file);
-    for (const branchMap of Object.values(fileCoverage.branchMap)) {
-      if (branchMap.type === "if") {
-        const lastIndex = branchMap.locations.length - 1;
-        if (lastIndex > 0) {
-          const elseLocation = branchMap.locations[lastIndex];
-          if (elseLocation && isEmptyCoverageRange(elseLocation)) {
-            const ifLocation = branchMap.locations[0];
-            elseLocation.start = { ...ifLocation.start };
-            elseLocation.end = { ...ifLocation.end };
-          }
-        }
-      }
-    }
-  }
-}
-function isEmptyCoverageRange(range) {
-  return range.start === void 0 || range.start.line === void 0 || range.start.column === void 0 || range.end === void 0 || range.end.line === void 0 || range.end.column === void 0;
-}
 
 export { IstanbulCoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "2.0.0-beta.8",
+  "version": "2.0.0",
   "description": "Istanbul coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,18 +37,19 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "2.0.0-beta.8"
+    "vitest": "2.0.0"
   },
   "dependencies": {
-    "debug": "^4.3.4",
+    "@istanbuljs/schema": "^0.1.3",
+    "debug": "^4.3.5",
     "istanbul-lib-coverage": "^3.2.2",
-    "istanbul-lib-instrument": "^6.0.2",
+    "istanbul-lib-instrument": "^6.0.3",
     "istanbul-lib-report": "^3.0.1",
-    "istanbul-lib-source-maps": "^5.0.4",
+    "istanbul-lib-source-maps": "^5.0.6",
     "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 +59,7 @@
     "@types/istanbul-lib-source-maps": "^4.0.4",
     "@types/istanbul-reports": "^3.0.4",
     "pathe": "^1.1.2",
-    "vitest": "2.0.0-beta.8"
+    "vitest": "2.0.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",