@vitest/coverage-istanbul 0.23.4 → 0.24.1

package/dist/index-01de7c40.js

@@ -0,0 +1,11 @@
+const COVERAGE_STORE_KEY = "__VITEST_COVERAGE__";
+
+async function getProvider() {
+  const { IstanbulCoverageProvider } = await import('./provider-142aaa2f.js');
+  return new IstanbulCoverageProvider();
+}
+function takeCoverage() {
+  return globalThis[COVERAGE_STORE_KEY];
+}
+
+export { COVERAGE_STORE_KEY as C, getProvider as g, takeCoverage as t };

package/dist/index.js

@@ -1 +1 @@
-export { g as getProvider, t as takeCoverage } from './index-aa0610b9.js';
+export { g as getProvider, t as takeCoverage } from './index-01de7c40.js';

package/dist/provider-142aaa2f.js

@@ -0,0 +1,336 @@
+import { existsSync, promises } from 'fs';
+import path from 'path';
+import { defaultExclude, defaultInclude, configDefaults } from 'vitest/config';
+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 _TestExclude from 'test-exclude';
+import { C as COVERAGE_STORE_KEY } from './index-01de7c40.js';
+
+function normalizeWindowsPath(input = "") {
+  if (!input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+
+const _UNC_REGEX = /^[/][/]/;
+const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
+const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const delimiter = ":";
+const normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = path2.match(_UNC_REGEX);
+  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2[path2.length - 1] === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (hasUNCDrive) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+const join = function(...args) {
+  if (args.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (let i = 0; i < args.length; ++i) {
+    const arg = args[i];
+    if (arg.length > 0) {
+      if (joined === void 0) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined);
+};
+const resolve = function(...args) {
+  args = args.map((arg) => normalizeWindowsPath(arg));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path2 = i >= 0 ? args[i] : process.cwd();
+    if (path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let i = 0; i <= path2.length; ++i) {
+    if (i < path2.length) {
+      char = path2[i];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length !== 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path2.slice(lastSlash + 1, i)}`;
+        } else {
+          res = path2.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+  return path.posix.extname(normalizeWindowsPath(p));
+};
+const relative = function(from, to) {
+  return path.posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
+};
+const dirname = function(p) {
+  return path.posix.dirname(normalizeWindowsPath(p));
+};
+const format = function(p) {
+  return normalizeWindowsPath(path.posix.format(p));
+};
+const basename = function(p, ext) {
+  return path.posix.basename(normalizeWindowsPath(p), ext);
+};
+const parse = function(p) {
+  return path.posix.parse(normalizeWindowsPath(p));
+};
+
+const _path = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sep: sep,
+  delimiter: delimiter,
+  normalize: normalize,
+  join: join,
+  resolve: resolve,
+  normalizeString: normalizeString,
+  isAbsolute: isAbsolute,
+  toNamespacedPath: toNamespacedPath,
+  extname: extname,
+  relative: relative,
+  dirname: dirname,
+  format: format,
+  basename: basename,
+  parse: parse
+});
+
+({
+  ..._path
+});
+
+class IstanbulCoverageProvider {
+  constructor() {
+    this.name = "istanbul";
+    this.coverages = [];
+  }
+  initialize(ctx) {
+    this.ctx = ctx;
+    this.options = resolveIstanbulOptions(ctx.config.coverage, ctx.config.root);
+    this.instrumenter = createInstrumenter({
+      produceSourceMap: true,
+      autoWrap: false,
+      esModules: true,
+      compact: false,
+      coverageVariable: COVERAGE_STORE_KEY,
+      coverageGlobalScope: "globalThis",
+      coverageGlobalScopeFunc: false,
+      ignoreClassMethods: this.options.ignoreClassMethods
+    });
+    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],
+      excludeNodeModules: true,
+      extension: configDefaults.coverage.extension
+    });
+  }
+  resolveOptions() {
+    return this.options;
+  }
+  onFileTransform(sourceCode, id, pluginCtx) {
+    if (!this.testExclude.shouldInstrument(id))
+      return;
+    const { sourcesContent, ...sourceMap } = pluginCtx.getCombinedSourcemap();
+    const code = this.instrumenter.instrumentSync(sourceCode, id, sourceMap);
+    const map = this.instrumenter.lastSourceMap();
+    return { code, map };
+  }
+  onAfterSuiteRun({ coverage }) {
+    this.coverages.push(coverage);
+  }
+  async clean(clean = true) {
+    if (clean && existsSync(this.options.reportsDirectory))
+      await promises.rm(this.options.reportsDirectory, { recursive: true, force: true });
+    this.coverages = [];
+  }
+  async reportCoverage() {
+    const mergedCoverage = this.coverages.reduce((coverage, previousCoverageMap) => {
+      const map = libCoverage.createCoverageMap(coverage);
+      map.merge(previousCoverageMap);
+      return map;
+    }, {});
+    if (this.options.all)
+      await this.includeUntestedFiles(mergedCoverage);
+    const sourceMapStore = libSourceMaps.createSourceMapStore();
+    const coverageMap = await sourceMapStore.transformCoverage(mergedCoverage);
+    const context = libReport.createContext({
+      dir: this.options.reportsDirectory,
+      coverageMap,
+      sourceFinder: sourceMapStore.sourceFinder,
+      watermarks: this.options.watermarks
+    });
+    for (const reporter of this.options.reporter) {
+      reports.create(reporter, {
+        skipFull: this.options.skipFull,
+        projectRoot: this.ctx.config.root
+      }).execute(context);
+    }
+    if (this.options.branches || this.options.functions || this.options.lines || this.options.statements) {
+      this.checkThresholds(coverageMap, {
+        branches: this.options.branches,
+        functions: this.options.functions,
+        lines: this.options.lines,
+        statements: this.options.statements
+      });
+    }
+  }
+  checkThresholds(coverageMap, thresholds) {
+    const summaries = this.options.perFile ? coverageMap.files().map((file) => ({
+      file,
+      summary: coverageMap.fileCoverageFor(file).toSummary()
+    })) : [{
+      file: null,
+      summary: coverageMap.getCoverageSummary()
+    }];
+    for (const { summary, file } of summaries) {
+      for (const thresholdKey of ["lines", "functions", "statements", "branches"]) {
+        const threshold = thresholds[thresholdKey];
+        if (threshold !== void 0) {
+          const coverage = summary.data[thresholdKey].pct;
+          if (coverage < threshold) {
+            process.exitCode = 1;
+            let errorMessage = `ERROR: Coverage for ${thresholdKey} (${coverage}%) does not meet`;
+            if (!this.options.perFile)
+              errorMessage += " global";
+            errorMessage += ` threshold (${threshold}%)`;
+            if (this.options.perFile && file)
+              errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+            console.error(errorMessage);
+          }
+        }
+      }
+    }
+  }
+  async includeUntestedFiles(coverageMap) {
+    const includedFiles = await this.testExclude.glob(this.ctx.config.root);
+    const uncoveredFiles = includedFiles.map((file) => resolve(this.ctx.config.root, file)).filter((file) => !coverageMap.data[file]);
+    const transformResults = await Promise.all(uncoveredFiles.map(async (filename) => {
+      const transformResult = await this.ctx.vitenode.transformRequest(filename);
+      return { transformResult, filename };
+    }));
+    for (const { transformResult, filename } of transformResults) {
+      const sourceMap = transformResult == null ? void 0 : transformResult.map;
+      if (sourceMap) {
+        this.instrumenter.instrumentSync(
+          transformResult.code,
+          filename,
+          {
+            ...sourceMap,
+            version: sourceMap.version.toString()
+          }
+        );
+        const lastCoverage = this.instrumenter.lastFileCoverage();
+        if (lastCoverage)
+          coverageMap.data[lastCoverage.path] = lastCoverage;
+      }
+    }
+  }
+}
+function resolveIstanbulOptions(options, root) {
+  const reportsDirectory = resolve(root, options.reportsDirectory || configDefaults.coverage.reportsDirectory);
+  const resolved = {
+    ...configDefaults.coverage,
+    ...options,
+    provider: "istanbul",
+    reportsDirectory,
+    tempDirectory: resolve(reportsDirectory, "tmp"),
+    reporter: Array.isArray(options.reporter) ? options.reporter : [options.reporter]
+  };
+  return resolved;
+}
+
+export { IstanbulCoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "0.23.4",
+  "version": "0.24.1",
   "description": "Istanbul coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -38,12 +38,12 @@
   ],
   "dependencies": {
     "istanbul-lib-coverage": "^3.2.0",
-    "istanbul-lib-instrument": "^5.2.0",
+    "istanbul-lib-instrument": "^5.2.1",
     "istanbul-lib-report": "^3.0.0",
     "istanbul-lib-source-maps": "^4.0.1",
     "istanbul-reports": "^3.1.5",
     "test-exclude": "^6.0.0",
-    "vitest": "0.23.4"
+    "vitest": "0.24.1"
   },
   "devDependencies": {
     "@types/istanbul-lib-coverage": "^2.0.4",