@vitest/coverage-istanbul 0.27.2 → 0.28.0

package/dist/{index-db0ef407.js → index-2345780c.js}

@@ -1,7 +1,7 @@
 const COVERAGE_STORE_KEY = "__VITEST_COVERAGE__";
 
 async function getProvider() {
-  const { IstanbulCoverageProvider } = await import('./provider-dcf29321.js');
+  const { IstanbulCoverageProvider } = await import('./provider-e9fe5ea1.js');
   return new IstanbulCoverageProvider();
 }
 function takeCoverage() {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CoverageProvider, Vitest, ResolvedCoverageOptions, CoverageIstanbulOptions, AfterSuiteRunMeta, ReportContext } from 'vitest';
+import { CoverageProvider, Vitest, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
 import { CoverageMap } from 'istanbul-lib-coverage';
 import { Instrumenter } from 'istanbul-lib-instrument';
 
@@ -187,6 +187,7 @@ interface AcornNode {
 	type: string;
 }
 
+type Options = ResolvedCoverageOptions<'istanbul'>;
 type Threshold = 'lines' | 'functions' | 'statements' | 'branches';
 interface TestExclude {
     new (opts: {
@@ -203,9 +204,7 @@ interface TestExclude {
 declare class IstanbulCoverageProvider implements CoverageProvider {
     name: string;
     ctx: Vitest;
-    options: ResolvedCoverageOptions & CoverageIstanbulOptions & {
-        provider: 'istanbul';
-    };
+    options: Options;
     instrumenter: Instrumenter;
     testExclude: InstanceType<TestExclude>;
     /**
@@ -216,14 +215,14 @@ declare class IstanbulCoverageProvider implements CoverageProvider {
      */
     coverages: any[];
     initialize(ctx: Vitest): void;
-    resolveOptions(): ResolvedCoverageOptions;
+    resolveOptions(): Options;
     onFileTransform(sourceCode: string, id: string, pluginCtx: TransformPluginContext): {
         code: string;
         map: any;
     } | undefined;
     onAfterSuiteRun({ coverage }: AfterSuiteRunMeta): void;
     clean(clean?: boolean): Promise<void>;
-    reportCoverage({ allTestsRun }: ReportContext): Promise<void>;
+    reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
     checkThresholds(coverageMap: CoverageMap, thresholds: Record<Threshold, number | undefined>): void;
     includeUntestedFiles(coverageMap: CoverageMap): Promise<void>;
 }

package/dist/index.js

@@ -1 +1 @@
-export { g as getProvider, t as takeCoverage } from './index-db0ef407.js';
+export { g as getProvider, t as takeCoverage } from './index-2345780c.js';

package/dist/{provider-dcf29321.js → provider-e9fe5ea1.js}

@@ -1,84 +1,37 @@
 import { existsSync, promises } from 'fs';
-import path from 'path';
-import { defaultExclude, defaultInclude, configDefaults } from 'vitest/config';
+import { defaultExclude, defaultInclude, coverageConfigDefaults } 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-db0ef407.js';
+import { C as COVERAGE_STORE_KEY } from './index-2345780c.js';
 
 function normalizeWindowsPath(input = "") {
-  if (!input.includes("\\")) {
+  if (!input || !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 ".";
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+function cwd() {
+  if (typeof process !== "undefined") {
+    return process.cwd().replace(/\\/g, "/");
   }
-  return normalize(joined);
-};
-const resolve = function(...args) {
-  args = args.map((arg) => normalizeWindowsPath(arg));
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
   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) {
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
       continue;
     }
-    resolvedPath = `${path2}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path2);
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
   }
   resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
   if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
@@ -86,22 +39,22 @@ const resolve = function(...args) {
   }
   return resolvedPath.length > 0 ? resolvedPath : ".";
 };
-function normalizeString(path2, allowAboveRoot) {
+function normalizeString(path, 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];
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
     } else if (char === "/") {
       break;
     } else {
       char = "/";
     }
     if (char === "/") {
-      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
+      if (lastSlash === index - 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("/");
@@ -112,13 +65,13 @@ function normalizeString(path2, allowAboveRoot) {
               res = res.slice(0, lastSlashIndex);
               lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
             }
-            lastSlash = i;
+            lastSlash = index;
             dots = 0;
             continue;
-          } else if (res.length !== 0) {
+          } else if (res.length > 0) {
             res = "";
             lastSegmentLength = 0;
-            lastSlash = i;
+            lastSlash = index;
             dots = 0;
             continue;
           }
@@ -129,13 +82,13 @@ function normalizeString(path2, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path2.slice(lastSlash + 1, i)}`;
+          res += `/${path.slice(lastSlash + 1, index)}`;
         } else {
-          res = path2.slice(lastSlash + 1, i);
+          res = path.slice(lastSlash + 1, index);
         }
-        lastSegmentLength = i - lastSlash - 1;
+        lastSegmentLength = index - lastSlash - 1;
       }
-      lastSlash = i;
+      lastSlash = index;
       dots = 0;
     } else if (char === "." && dots !== -1) {
       ++dots;
@@ -148,50 +101,20 @@ function normalizeString(path2, allowAboveRoot) {
 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 _from = resolve(from).split("/");
+  const _to = resolve(to).split("/");
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
 };
 
-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";
@@ -238,7 +161,7 @@ class IstanbulCoverageProvider {
       await promises.rm(this.options.reportsDirectory, { recursive: true, force: true, maxRetries: 10 });
     this.coverages = [];
   }
-  async reportCoverage({ allTestsRun }) {
+  async reportCoverage({ allTestsRun } = {}) {
     const mergedCoverage = this.coverages.reduce((coverage, previousCoverageMap) => {
       const map = libCoverage.createCoverageMap(coverage);
       map.merge(previousCoverageMap);
@@ -320,14 +243,14 @@ class IstanbulCoverageProvider {
   }
 }
 function resolveIstanbulOptions(options, root) {
-  const reportsDirectory = resolve(root, options.reportsDirectory || configDefaults.coverage.reportsDirectory);
+  const reportsDirectory = resolve(root, options.reportsDirectory || coverageConfigDefaults.reportsDirectory);
+  const reporter = options.reporter || coverageConfigDefaults.reporter;
   const resolved = {
-    ...configDefaults.coverage,
+    ...coverageConfigDefaults,
     ...options,
     provider: "istanbul",
     reportsDirectory,
-    tempDirectory: resolve(reportsDirectory, "tmp"),
-    reporter: Array.isArray(options.reporter) ? options.reporter : [options.reporter]
+    reporter: Array.isArray(reporter) ? reporter : [reporter]
   };
   return resolved;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "0.27.2",
+  "version": "0.28.0",
   "description": "Istanbul coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "istanbul-lib-source-maps": "^4.0.1",
     "istanbul-reports": "^3.1.5",
     "test-exclude": "^6.0.0",
-    "vitest": "0.27.2"
+    "vitest": "0.28.0"
   },
   "devDependencies": {
     "@types/istanbul-lib-coverage": "^2.0.4",
@@ -51,7 +51,7 @@
     "@types/istanbul-lib-report": "^3.0.0",
     "@types/istanbul-lib-source-maps": "^4.0.1",
     "@types/istanbul-reports": "^3.0.1",
-    "pathe": "^0.2.0"
+    "pathe": "^1.1.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",