@vitest/coverage-v8 0.32.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
+Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { V8CoverageProvider } from './provider.js';
+import 'node:inspector';
+import 'vitest/coverage';
+import 'vitest';
+import 'vitest/node';
+
+declare const _default: {
+    getProvider(): Promise<V8CoverageProvider>;
+    startCoverage(): void;
+    takeCoverage(): Promise<unknown>;
+    stopCoverage(): void;
+};
+
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,54 @@
+import inspector from 'node:inspector';
+import { provider } from 'std-env';
+
+const session = new inspector.Session();
+function startCoverage() {
+  session.connect();
+  session.post("Profiler.enable");
+  session.post("Profiler.startPreciseCoverage", {
+    callCount: true,
+    detailed: true
+  });
+}
+async function takeCoverage() {
+  return new Promise((resolve, reject) => {
+    session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
+      if (error)
+        return reject(error);
+      const result = coverage.result.filter(filterResult);
+      resolve({ result });
+    });
+    if (provider === "stackblitz")
+      resolve({ result: [] });
+  });
+}
+function stopCoverage() {
+  session.post("Profiler.stopPreciseCoverage");
+  session.post("Profiler.disable");
+  session.disconnect();
+}
+function filterResult(coverage) {
+  if (!coverage.url.startsWith("file://"))
+    return false;
+  if (coverage.url.includes("/node_modules/"))
+    return false;
+  return true;
+}
+
+var coverage = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  startCoverage: startCoverage,
+  stopCoverage: stopCoverage,
+  takeCoverage: takeCoverage
+});
+
+var index = {
+  ...coverage,
+  async getProvider() {
+    const name = "./provider.js";
+    const { V8CoverageProvider } = await import(name);
+    return new V8CoverageProvider();
+  }
+};
+
+export { index as default };

package/dist/provider.d.ts

@@ -0,0 +1,34 @@
+import { Profiler } from 'node:inspector';
+import { BaseCoverageProvider } from 'vitest/coverage';
+import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
+import { Vitest } from 'vitest/node';
+
+interface TestExclude {
+    new (opts: {
+        cwd?: string | string[];
+        include?: string | string[];
+        exclude?: string | string[];
+        extension?: string | string[];
+        excludeNodeModules?: boolean;
+    }): {
+        shouldInstrument(filePath: string): boolean;
+        glob(cwd: string): Promise<string[]>;
+    };
+}
+type Options = ResolvedCoverageOptions<'v8'>;
+declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
+    name: string;
+    ctx: Vitest;
+    options: Options;
+    testExclude: InstanceType<TestExclude>;
+    coverages: Profiler.TakePreciseCoverageReturnType[];
+    initialize(ctx: Vitest): void;
+    resolveOptions(): Options;
+    clean(clean?: boolean): Promise<void>;
+    onAfterSuiteRun({ coverage }: AfterSuiteRunMeta): void;
+    reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
+    private getUntestedFiles;
+    private getSources;
+}
+
+export { V8CoverageProvider };

package/dist/provider.js

@@ -0,0 +1,313 @@
+import { existsSync, promises } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import v8ToIstanbul from 'v8-to-istanbul';
+import { mergeProcessCovs } from '@bcoe/v8-coverage';
+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 MagicString from 'magic-string';
+import remapping from '@ampproject/remapping';
+import c from 'picocolors';
+import { provider } from 'std-env';
+import { coverageConfigDefaults, defaultExclude, defaultInclude } from 'vitest/config';
+import { BaseCoverageProvider } from 'vitest/coverage';
+import _TestExclude from 'test-exclude';
+
+function normalizeWindowsPath(input = "") {
+  if (!input || !input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+function cwd() {
+  if (typeof process !== "undefined") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  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 === 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("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+
+const WRAPPER_LENGTH = 185;
+const VITE_EXPORTS_LINE_PATTERN = /Object\.defineProperty\(__vite_ssr_exports__.*\n/g;
+class V8CoverageProvider extends BaseCoverageProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "v8";
+    this.coverages = [];
+  }
+  initialize(ctx) {
+    const config = ctx.config.coverage;
+    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),
+      lines: config["100"] ? 100 : config.lines,
+      functions: config["100"] ? 100 : config.functions,
+      branches: config["100"] ? 100 : config.branches,
+      statements: config["100"] ? 100 : config.statements
+    };
+    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: this.options.extension
+    });
+  }
+  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 });
+    this.coverages = [];
+  }
+  onAfterSuiteRun({ coverage }) {
+    this.coverages.push(coverage);
+  }
+  async reportCoverage({ allTestsRun } = {}) {
+    if (provider === "stackblitz")
+      this.ctx.logger.log(c.blue(" % ") + c.yellow("@vitest/coverage-v8 does not work on Stackblitz. Report will be empty."));
+    const merged = mergeProcessCovs(this.coverages);
+    const scriptCoverages = merged.result.filter((result) => this.testExclude.shouldInstrument(fileURLToPath(result.url)));
+    if (this.options.all && allTestsRun) {
+      const coveredFiles = Array.from(scriptCoverages.map((r) => r.url));
+      const untestedFiles = await this.getUntestedFiles(coveredFiles);
+      scriptCoverages.push(...untestedFiles);
+    }
+    const converted = await Promise.all(scriptCoverages.map(async ({ url, functions }) => {
+      const sources = await this.getSources(url);
+      const wrapperLength = sources.sourceMap ? WRAPPER_LENGTH : 0;
+      const converter = v8ToIstanbul(url, wrapperLength, sources);
+      await converter.load();
+      converter.applyCoverage(functions);
+      return converter.toIstanbul();
+    }));
+    const mergedCoverage = converted.reduce((coverage, previousCoverageMap) => {
+      const map = libCoverage.createCoverageMap(coverage);
+      map.merge(previousCoverageMap);
+      return map;
+    }, libCoverage.createCoverageMap({}));
+    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[0], {
+        skipFull: this.options.skipFull,
+        projectRoot: this.ctx.config.root,
+        ...reporter[1]
+      }).execute(context);
+    }
+    if (this.options.branches || this.options.functions || this.options.lines || this.options.statements) {
+      this.checkThresholds({
+        coverageMap,
+        thresholds: {
+          branches: this.options.branches,
+          functions: this.options.functions,
+          lines: this.options.lines,
+          statements: this.options.statements
+        },
+        perFile: this.options.perFile
+      });
+    }
+    if (this.options.thresholdAutoUpdate && allTestsRun) {
+      this.updateThresholds({
+        coverageMap,
+        thresholds: {
+          branches: this.options.branches,
+          functions: this.options.functions,
+          lines: this.options.lines,
+          statements: this.options.statements
+        },
+        perFile: this.options.perFile,
+        configurationFile: this.ctx.server.config.configFile
+      });
+    }
+  }
+  async getUntestedFiles(testedFiles) {
+    const includedFiles = await this.testExclude.glob(this.ctx.config.root);
+    const uncoveredFiles = includedFiles.map((file) => pathToFileURL(resolve(this.ctx.config.root, file))).filter((file) => !testedFiles.includes(file.href));
+    return await Promise.all(uncoveredFiles.map(async (uncoveredFile) => {
+      const { source } = await this.getSources(uncoveredFile.href);
+      return {
+        url: uncoveredFile.href,
+        scriptId: "0",
+        // Create a made up function to mark whole file as uncovered. Note that this does not exist in source maps.
+        functions: [{
+          ranges: [{
+            startOffset: 0,
+            endOffset: source.length,
+            count: 0
+          }],
+          isBlockCoverage: true,
+          // This is magical value that indicates an empty report: https://github.com/istanbuljs/v8-to-istanbul/blob/fca5e6a9e6ef38a9cdc3a178d5a6cf9ef82e6cab/lib/v8-to-istanbul.js#LL131C40-L131C40
+          functionName: "(empty-report)"
+        }]
+      };
+    }));
+  }
+  async getSources(url) {
+    var _a;
+    const filePath = normalize(fileURLToPath(url));
+    const transformResult = this.ctx.projects.map((project) => {
+      var _a2;
+      return (_a2 = project.vitenode.fetchCache.get(filePath)) == null ? void 0 : _a2.result;
+    }).filter(Boolean).shift();
+    const map = transformResult == null ? void 0 : transformResult.map;
+    const code = transformResult == null ? void 0 : transformResult.code;
+    const sourcesContent = ((_a = map == null ? void 0 : map.sourcesContent) == null ? void 0 : _a[0]) || await promises.readFile(filePath, "utf-8");
+    if (!map)
+      return { source: code || sourcesContent };
+    return {
+      originalSource: sourcesContent,
+      source: code || sourcesContent,
+      sourceMap: {
+        sourcemap: removeViteHelpersFromSourceMaps(code, {
+          ...map,
+          version: 3,
+          sources: [url],
+          sourcesContent: [sourcesContent]
+        })
+      }
+    };
+  }
+}
+function removeViteHelpersFromSourceMaps(source, map) {
+  if (!source || !source.match(VITE_EXPORTS_LINE_PATTERN))
+    return map;
+  const sourceWithoutHelpers = new MagicString(source);
+  sourceWithoutHelpers.replaceAll(VITE_EXPORTS_LINE_PATTERN, "\n");
+  const mapWithoutHelpers = sourceWithoutHelpers.generateMap({
+    hires: true
+  });
+  const combinedMap = remapping(
+    [{ ...mapWithoutHelpers, version: 3 }, map],
+    () => null
+  );
+  return combinedMap;
+}
+
+export { V8CoverageProvider };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@vitest/coverage-v8",
+  "type": "module",
+  "version": "0.32.0",
+  "description": "V8 coverage provider for Vitest",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/coverage-v8#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/coverage-v8"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "keywords": [
+    "vite",
+    "vitest",
+    "test",
+    "coverage",
+    "v8"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "vitest": ">=0.32.0 <1"
+  },
+  "dependencies": {
+    "@ampproject/remapping": "^2.2.1",
+    "@bcoe/v8-coverage": "^0.2.3",
+    "istanbul-lib-coverage": "^3.2.0",
+    "istanbul-lib-report": "^3.0.0",
+    "istanbul-lib-source-maps": "^4.0.1",
+    "istanbul-reports": "^3.1.5",
+    "magic-string": "^0.30.0",
+    "picocolors": "^1.0.0",
+    "std-env": "^3.3.2",
+    "test-exclude": "^6.0.0",
+    "v8-to-istanbul": "^9.1.0"
+  },
+  "devDependencies": {
+    "@types/istanbul-lib-coverage": "^2.0.4",
+    "@types/istanbul-lib-report": "^3.0.0",
+    "@types/istanbul-lib-source-maps": "^4.0.1",
+    "@types/istanbul-reports": "^3.0.1",
+    "pathe": "^1.1.0",
+    "vite-node": "0.32.0",
+    "vitest": "0.32.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch --watch.include 'src/**'"
+  }
+}