@vitest/coverage-istanbul 3.0.9 → 3.1.0-beta.2

package/dist/index.js

@@ -1,36 +1,35 @@
 import { C as COVERAGE_STORE_KEY } from './constants-BCJfMgEg.js';
 
 const mod = {
-  takeCoverage() {
-    return globalThis[COVERAGE_STORE_KEY];
-  },
-  // Reset coverage map to prevent duplicate results if this is called twice in row
-  startCoverage() {
-    const coverageMap = globalThis[COVERAGE_STORE_KEY];
-    if (!coverageMap) {
-      return;
-    }
-    for (const filename in coverageMap) {
-      const branches = coverageMap[filename].b;
-      for (const key in branches) {
-        branches[key] = branches[key].map(() => 0);
-      }
-      for (const metric of ["f", "s"]) {
-        const entry = coverageMap[filename][metric];
-        for (const key in entry) {
-          entry[key] = 0;
-        }
-      }
-    }
-  },
-  async getProvider() {
-    const providerPath = "./provider.js";
-    const { IstanbulCoverageProvider } = await import(
-      /* @vite-ignore */
-      providerPath
-    );
-    return new IstanbulCoverageProvider();
-  }
+	takeCoverage() {
+		return globalThis[COVERAGE_STORE_KEY];
+	},
+	startCoverage() {
+		const coverageMap = globalThis[COVERAGE_STORE_KEY];
+		if (!coverageMap) {
+			return;
+		}
+		for (const filename in coverageMap) {
+			const branches = coverageMap[filename].b;
+			for (const key in branches) {
+				branches[key] = branches[key].map(() => 0);
+			}
+			for (const metric of ["f", "s"]) {
+				const entry = coverageMap[filename][metric];
+				for (const key in entry) {
+					entry[key] = 0;
+				}
+			}
+		}
+	},
+	async getProvider() {
+		const providerPath = "./provider.js";
+		const { IstanbulCoverageProvider } = await import(
+			/* @vite-ignore */
+			providerPath
+);
+		return new IstanbulCoverageProvider();
+	}
 };
 
 export { mod as default };

package/dist/provider.js

@@ -107,144 +107,131 @@ const isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
 
-var version = "3.0.9";
+var version = "3.1.0-beta.2";
 
 const debug = createDebug("vitest:coverage");
 class IstanbulCoverageProvider extends BaseCoverageProvider {
-  name = "istanbul";
-  version = version;
-  instrumenter;
-  testExclude;
-  initialize(ctx) {
-    this._initialize(ctx);
-    this.testExclude = new TestExclude({
-      cwd: ctx.config.root,
-      include: this.options.include,
-      exclude: this.options.exclude,
-      excludeNodeModules: true,
-      extension: this.options.extension,
-      relativePath: !this.options.allowExternal
-    });
-    this.instrumenter = createInstrumenter({
-      produceSourceMap: true,
-      autoWrap: false,
-      esModules: true,
-      compact: false,
-      coverageVariable: COVERAGE_STORE_KEY,
-      // @ts-expect-error missing type
-      coverageGlobalScope: "globalThis",
-      coverageGlobalScopeFunc: false,
-      ignoreClassMethods: this.options.ignoreClassMethods,
-      parserPlugins: [
-        ...defaults.instrumenter.parserPlugins,
-        ["importAttributes", { deprecatedAssertSyntax: true }]
-      ],
-      generatorOpts: {
-        importAttributesKeyword: "with"
-      }
-    });
-  }
-  onFileTransform(sourceCode, id, pluginCtx) {
-    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
-    );
-    const map = this.instrumenter.lastSourceMap();
-    return { code, map };
-  }
-  createCoverageMap() {
-    return libCoverage.createCoverageMap({});
-  }
-  async generateCoverage({ allTestsRun }) {
-    const coverageMap = this.createCoverageMap();
-    let coverageMapByTransformMode = this.createCoverageMap();
-    await this.readCoverageFiles({
-      onFileRead(coverage) {
-        coverageMapByTransformMode.merge(coverage);
-      },
-      onFinished: async () => {
-        const transformedCoverage = await transformCoverage(coverageMapByTransformMode);
-        coverageMap.merge(transformedCoverage);
-        coverageMapByTransformMode = this.createCoverageMap();
-      },
-      onDebug: debug
-    });
-    if (this.options.all && (allTestsRun || !this.options.cleanOnRerun)) {
-      const coveredFiles = coverageMap.files();
-      const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(coveredFiles);
-      coverageMap.merge(await transformCoverage(uncoveredCoverage));
-    }
-    if (this.options.excludeAfterRemap) {
-      coverageMap.filter((filename) => this.testExclude.shouldInstrument(filename));
-    }
-    return coverageMap;
-  }
-  async generateReports(coverageMap, allTestsRun) {
-    const context = libReport.createContext({
-      dir: this.options.reportsDirectory,
-      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)
-      );
-    }
-    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.thresholds) {
-      await this.reportThresholds(coverageMap, allTestsRun);
-    }
-  }
-  async parseConfigModule(configFilePath) {
-    return parseModule(
-      await promises.readFile(configFilePath, "utf8")
-    );
-  }
-  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)).sort();
-    const cacheKey = (/* @__PURE__ */ new Date()).getTime();
-    const coverageMap = this.createCoverageMap();
-    const transform = this.createUncoveredFileTransformer(this.ctx);
-    for (const [index, filename] of uncoveredFiles.entries()) {
-      debug("Uncovered file %s %d/%d", filename, index, uncoveredFiles.length);
-      await transform(`${filename}?v=${cacheKey}`);
-      const lastCoverage = this.instrumenter.lastFileCoverage();
-      coverageMap.addFileCoverage(lastCoverage);
-    }
-    return coverageMap;
-  }
+	name = "istanbul";
+	version = version;
+	instrumenter;
+	testExclude;
+	initialize(ctx) {
+		this._initialize(ctx);
+		this.testExclude = new TestExclude({
+			cwd: ctx.config.root,
+			include: this.options.include,
+			exclude: this.options.exclude,
+			excludeNodeModules: true,
+			extension: this.options.extension,
+			relativePath: !this.options.allowExternal
+		});
+		this.instrumenter = createInstrumenter({
+			produceSourceMap: true,
+			autoWrap: false,
+			esModules: true,
+			compact: false,
+			coverageVariable: COVERAGE_STORE_KEY,
+			coverageGlobalScope: "globalThis",
+			coverageGlobalScopeFunc: false,
+			ignoreClassMethods: this.options.ignoreClassMethods,
+			parserPlugins: [...defaults.instrumenter.parserPlugins, ["importAttributes", { deprecatedAssertSyntax: true }]],
+			generatorOpts: { importAttributesKeyword: "with" }
+		});
+	}
+	onFileTransform(sourceCode, id, pluginCtx) {
+		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);
+		const map = this.instrumenter.lastSourceMap();
+		return {
+			code,
+			map
+		};
+	}
+	createCoverageMap() {
+		return libCoverage.createCoverageMap({});
+	}
+	async generateCoverage({ allTestsRun }) {
+		const coverageMap = this.createCoverageMap();
+		let coverageMapByTransformMode = this.createCoverageMap();
+		await this.readCoverageFiles({
+			onFileRead(coverage) {
+				coverageMapByTransformMode.merge(coverage);
+			},
+			onFinished: async () => {
+				const transformedCoverage = await transformCoverage(coverageMapByTransformMode);
+				coverageMap.merge(transformedCoverage);
+				coverageMapByTransformMode = this.createCoverageMap();
+			},
+			onDebug: debug
+		});
+		if (this.options.all && (allTestsRun || !this.options.cleanOnRerun)) {
+			const coveredFiles = coverageMap.files();
+			const uncoveredCoverage = await this.getCoverageMapForUncoveredFiles(coveredFiles);
+			coverageMap.merge(await transformCoverage(uncoveredCoverage));
+		}
+		if (this.options.excludeAfterRemap) {
+			coverageMap.filter((filename) => this.testExclude.shouldInstrument(filename));
+		}
+		return coverageMap;
+	}
+	async generateReports(coverageMap, allTestsRun) {
+		const context = libReport.createContext({
+			dir: this.options.reportsDirectory,
+			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));
+		}
+		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.thresholds) {
+			await this.reportThresholds(coverageMap, allTestsRun);
+		}
+	}
+	async parseConfigModule(configFilePath) {
+		return parseModule(await promises.readFile(configFilePath, "utf8"));
+	}
+	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)).sort();
+		const cacheKey = new Date().getTime();
+		const coverageMap = this.createCoverageMap();
+		const transform = this.createUncoveredFileTransformer(this.ctx);
+		for (const [index, filename] of uncoveredFiles.entries()) {
+			debug("Uncovered file %s %d/%d", filename, index, uncoveredFiles.length);
+			await transform(`${filename}?v=${cacheKey}`);
+			const lastCoverage = this.instrumenter.lastFileCoverage();
+			coverageMap.addFileCoverage(lastCoverage);
+		}
+		return coverageMap;
+	}
 }
 async function transformCoverage(coverageMap) {
-  const sourceMapStore = libSourceMaps.createSourceMapStore();
-  return await sourceMapStore.transformCoverage(coverageMap);
+	const sourceMapStore = libSourceMaps.createSourceMapStore();
+	return await sourceMapStore.transformCoverage(coverageMap);
 }
+/**
+* Remove possible query parameters from filenames
+* - From `/src/components/Header.component.ts?vue&type=script&src=true&lang.ts`
+* - To `/src/components/Header.component.ts`
+*/
 function removeQueryParameters(filename) {
-  return filename.split("?")[0];
+	return filename.split("?")[0];
 }
 
 export { IstanbulCoverageProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/coverage-istanbul",
   "type": "module",
-  "version": "3.0.9",
+  "version": "3.1.0-beta.2",
   "description": "Istanbul coverage provider for Vitest",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "dist"
   ],
   "peerDependencies": {
-    "vitest": "3.0.9"
+    "vitest": "3.1.0-beta.2"
   },
   "dependencies": {
     "@istanbuljs/schema": "^0.1.3",
@@ -60,7 +60,7 @@
     "@types/istanbul-reports": "^3.0.4",
     "@types/test-exclude": "^6.0.2",
     "pathe": "^2.0.3",
-    "vitest": "3.0.9"
+    "vitest": "3.1.0-beta.2"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",