@vitest/coverage-istanbul 0.24.2 → 0.24.4

package/dist/index-cc7ec1dd.js

@@ -0,0 +1,11 @@
+const COVERAGE_STORE_KEY = "__VITEST_COVERAGE__";
+
+async function getProvider() {
+  const { IstanbulCoverageProvider } = await import('./provider-97efd69a.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.d.ts

@@ -0,0 +1,234 @@
+import { CoverageProvider, Vitest, ResolvedCoverageOptions, CoverageIstanbulOptions, AfterSuiteRunMeta } from 'vitest';
+import { CoverageMap } from 'istanbul-lib-coverage';
+import { Instrumenter } from 'istanbul-lib-instrument';
+
+interface RollupError extends RollupLogProps {
+	parserError?: Error;
+	stack?: string;
+	watchFiles?: string[];
+}
+
+interface RollupWarning extends RollupLogProps {
+	chunkName?: string;
+	cycle?: string[];
+	exportName?: string;
+	exporter?: string;
+	guess?: string;
+	importer?: string;
+	missing?: string;
+	modules?: string[];
+	names?: string[];
+	reexporter?: string;
+	source?: string;
+	sources?: string[];
+}
+
+interface RollupLogProps {
+	code?: string;
+	frame?: string;
+	hook?: string;
+	id?: string;
+	loc?: {
+		column: number;
+		file?: string;
+		line: number;
+	};
+	message: string;
+	name?: string;
+	plugin?: string;
+	pluginCode?: string;
+	pos?: number;
+	url?: string;
+}
+
+interface SourceMap {
+	file: string;
+	mappings: string;
+	names: string[];
+	sources: string[];
+	sourcesContent: string[];
+	version: number;
+	toString(): string;
+	toUrl(): string;
+}
+
+type PartialNull<T> = {
+	[P in keyof T]: T[P] | null;
+};
+
+interface ModuleOptions {
+	meta: CustomPluginOptions;
+	moduleSideEffects: boolean | 'no-treeshake';
+	syntheticNamedExports: boolean | string;
+}
+
+interface PluginCache {
+	delete(id: string): boolean;
+	get<T = any>(id: string): T;
+	has(id: string): boolean;
+	set<T = any>(id: string, value: T): void;
+}
+
+interface MinimalPluginContext {
+	meta: PluginContextMeta;
+}
+
+interface EmittedAsset {
+	fileName?: string;
+	name?: string;
+	source?: string | Uint8Array;
+	type: 'asset';
+}
+
+interface EmittedChunk {
+	fileName?: string;
+	id: string;
+	implicitlyLoadedAfterOneOf?: string[];
+	importer?: string;
+	name?: string;
+	preserveSignature?: PreserveEntrySignaturesOption;
+	type: 'chunk';
+}
+
+type EmittedFile = EmittedAsset | EmittedChunk;
+
+type EmitAsset = (name: string, source?: string | Uint8Array) => string;
+
+type EmitChunk = (id: string, options?: { name?: string }) => string;
+
+type EmitFile = (emittedFile: EmittedFile) => string;
+
+interface ModuleInfo extends ModuleOptions {
+	ast: AcornNode | null;
+	code: string | null;
+	dynamicImporters: readonly string[];
+	dynamicallyImportedIdResolutions: readonly ResolvedId[];
+	dynamicallyImportedIds: readonly string[];
+	hasDefaultExport: boolean | null;
+	/** @deprecated Use `moduleSideEffects` instead */
+	hasModuleSideEffects: boolean | 'no-treeshake';
+	id: string;
+	implicitlyLoadedAfterOneOf: readonly string[];
+	implicitlyLoadedBefore: readonly string[];
+	importedIdResolutions: readonly ResolvedId[];
+	importedIds: readonly string[];
+	importers: readonly string[];
+	isEntry: boolean;
+	isExternal: boolean;
+	isIncluded: boolean | null;
+}
+
+type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+
+interface CustomPluginOptions {
+	[plugin: string]: any;
+}
+
+interface PluginContext extends MinimalPluginContext {
+	addWatchFile: (id: string) => void;
+	cache: PluginCache;
+	/** @deprecated Use `this.emitFile` instead */
+	emitAsset: EmitAsset;
+	/** @deprecated Use `this.emitFile` instead */
+	emitChunk: EmitChunk;
+	emitFile: EmitFile;
+	error: (err: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	/** @deprecated Use `this.getFileName` instead */
+	getAssetFileName: (assetReferenceId: string) => string;
+	/** @deprecated Use `this.getFileName` instead */
+	getChunkFileName: (chunkReferenceId: string) => string;
+	getFileName: (fileReferenceId: string) => string;
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+	getWatchFiles: () => string[];
+	/** @deprecated Use `this.resolve` instead */
+	isExternal: IsExternal;
+	load: (
+		options: { id: string; resolveDependencies?: boolean } & Partial<PartialNull<ModuleOptions>>
+	) => Promise<ModuleInfo>;
+	/** @deprecated Use `this.getModuleIds` instead */
+	moduleIds: IterableIterator<string>;
+	parse: (input: string, options?: any) => AcornNode;
+	resolve: (
+		source: string,
+		importer?: string,
+		options?: { custom?: CustomPluginOptions; isEntry?: boolean; skipSelf?: boolean }
+	) => Promise<ResolvedId | null>;
+	/** @deprecated Use `this.resolve` instead */
+	resolveId: (source: string, importer?: string) => Promise<string | null>;
+	setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void;
+	warn: (warning: RollupWarning | string, pos?: number | { column: number; line: number }) => void;
+}
+
+interface PluginContextMeta {
+	rollupVersion: string;
+	watchMode: boolean;
+}
+
+interface ResolvedId extends ModuleOptions {
+	external: boolean | 'absolute';
+	id: string;
+}
+
+type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+interface TransformPluginContext extends PluginContext {
+	getCombinedSourcemap: () => SourceMap;
+}
+type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
+
+interface AcornNode {
+	end: number;
+	start: number;
+	type: string;
+}
+
+declare type Threshold = 'lines' | 'functions' | 'statements' | 'branches';
+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[]>;
+    };
+}
+declare class IstanbulCoverageProvider implements CoverageProvider {
+    name: string;
+    ctx: Vitest;
+    options: ResolvedCoverageOptions & CoverageIstanbulOptions & {
+        provider: 'istanbul';
+    };
+    instrumenter: Instrumenter;
+    testExclude: InstanceType<TestExclude>;
+    /**
+     * Coverage objects collected from workers.
+     * Some istanbul utilizers write these into file system instead of storing in memory.
+     * If storing in memory causes issues, we can simply write these into fs in `onAfterSuiteRun`
+     * and read them back when merging coverage objects in `onAfterAllFilesRun`.
+     */
+    coverages: any[];
+    initialize(ctx: Vitest): void;
+    resolveOptions(): ResolvedCoverageOptions;
+    onFileTransform(sourceCode: string, id: string, pluginCtx: TransformPluginContext): {
+        code: string;
+        map: any;
+    } | undefined;
+    onAfterSuiteRun({ coverage }: AfterSuiteRunMeta): void;
+    clean(clean?: boolean): Promise<void>;
+    reportCoverage(): Promise<void>;
+    checkThresholds(coverageMap: CoverageMap, thresholds: Record<Threshold, number | undefined>): void;
+    includeUntestedFiles(coverageMap: CoverageMap): Promise<void>;
+}
+
+declare function getProvider(): Promise<IstanbulCoverageProvider>;
+declare function takeCoverage(): any;
+
+export { getProvider, takeCoverage };

package/dist/index.js

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

package/dist/provider-97efd69a.js

@@ -0,0 +1,337 @@
+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-cc7ec1dd.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 sourceMap = pluginCtx.getCombinedSourcemap();
+    sourceMap.sources = sourceMap.sources.map(removeQueryParameters);
+    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
+        );
+        const lastCoverage = this.instrumenter.lastFileCoverage();
+        if (lastCoverage)
+          coverageMap.addFileCoverage(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;
+}
+function removeQueryParameters(filename) {
+  return filename.split("?")[0];
+}
+
+export { IstanbulCoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "0.24.2",
+  "version": "0.24.4",
   "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.24.2"
+    "vitest": "0.24.4"
   },
   "devDependencies": {
     "@types/istanbul-lib-coverage": "^2.0.4",