vitest 0.28.5 → 0.29.0

package/dist/{chunk-runtime-mocker.dafe0f77.js → chunk-runtime-mocker.a048e92d.js}

@@ -1,12 +1,16 @@
-import { ViteNodeRunner } from 'vite-node/client';
-import { isInternalRequest } from 'vite-node/utils';
-import { isAbsolute, dirname, join, basename, extname, resolve, normalize } from 'pathe';
+import { pathToFileURL } from 'node:url';
+import { ModuleCacheMap, ViteNodeRunner } from 'vite-node/client';
+import { isInternalRequest, isPrimitive } from 'vite-node/utils';
+import { isAbsolute, dirname, join, basename, extname, resolve, normalize, relative } from 'pathe';
 import { i as isNodeBuiltin } from './vendor-index.bdee400f.js';
-import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-global.442d1d33.js';
+import { processError } from '@vitest/runner/utils';
+import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-global.727b6d25.js';
+import { d as distDir } from './chunk-constants.797d3ebf.js';
 import { existsSync, readdirSync } from 'node:fs';
 import { getColors, getType } from '@vitest/utils';
-import { g as getAllMockableProperties } from './chunk-utils-base.904102a8.js';
+import { e as getAllMockableProperties } from './chunk-utils-base.81f83dbd.js';
 import { spyOn } from '@vitest/spy';
+import { r as rpc } from './chunk-runtime-rpc.971b3848.js';
 
 class RefTracker {
   constructor() {
@@ -46,6 +50,11 @@ const _VitestMocker = class {
   get moduleCache() {
     return this.executor.moduleCache;
   }
+  deleteCachedItem(id) {
+    const mockId = this.getMockPath(id);
+    if (this.moduleCache.has(mockId))
+      this.moduleCache.delete(mockId);
+  }
   getSuiteFilepath() {
     return getWorkerState().filepath || "global";
   }
@@ -218,9 +227,7 @@ ${c.green(`vi.mock("${mockpath}", async () => {
     const mock = this.mockMap.get(suitefile);
     if (mock && id in mock)
       delete mock[id];
-    const mockId = this.getMockPath(id);
-    if (this.moduleCache.get(mockId))
-      this.moduleCache.delete(mockId);
+    this.deleteCachedItem(id);
   }
   mockPath(originalId, path, external, factory) {
     const suitefile = this.getSuiteFilepath();
@@ -231,6 +238,7 @@ ${c.green(`vi.mock("${mockpath}", async () => {
     resolves[id] = originalId;
     this.mockMap.set(suitefile, mocks);
     this.resolveCache.set(suitefile, resolves);
+    this.deleteCachedItem(id);
   }
   async importActual(rawId, importee) {
     const { id, fsPath } = await this.resolvePath(rawId, importee);
@@ -292,6 +300,48 @@ async function createVitestExecutor(options) {
   await runner.executeId("/@vite/env");
   return runner;
 }
+let _viteNode;
+const moduleCache = new ModuleCacheMap();
+const mockMap = /* @__PURE__ */ new Map();
+async function startViteNode(ctx) {
+  if (_viteNode)
+    return _viteNode;
+  const { config } = ctx;
+  const processExit = process.exit;
+  process.exit = (code = process.exitCode || 0) => {
+    const error = new Error(`process.exit called with "${code}"`);
+    rpc().onWorkerExit(error, code);
+    return processExit(code);
+  };
+  function catchError(err, type) {
+    var _a;
+    const worker = getWorkerState();
+    const error = processError(err);
+    if (worker.filepath && !isPrimitive(error)) {
+      error.VITEST_TEST_NAME = (_a = worker.current) == null ? void 0 : _a.name;
+      error.VITEST_TEST_PATH = relative(config.root, worker.filepath);
+    }
+    rpc().onUnhandledError(error, type);
+  }
+  process.on("uncaughtException", (e) => catchError(e, "Uncaught Exception"));
+  process.on("unhandledRejection", (e) => catchError(e, "Unhandled Rejection"));
+  const executor = await createVitestExecutor({
+    fetchModule(id) {
+      return rpc().fetch(id, ctx.environment.name);
+    },
+    resolveId(id, importer) {
+      return rpc().resolveId(id, importer, ctx.environment.name);
+    },
+    moduleCache,
+    mockMap,
+    interopDefault: config.deps.interopDefault,
+    root: config.root,
+    base: config.base
+  });
+  const { run } = await import(pathToFileURL(resolve(distDir, "entry.js")).href);
+  _viteNode = { run, executor };
+  return _viteNode;
+}
 class VitestExecutor extends ViteNodeRunner {
   constructor(options) {
     super(options);
@@ -309,10 +359,10 @@ class VitestExecutor extends ViteNodeRunner {
     const environment = getCurrentEnvironment();
     return environment === "node" ? !isNodeBuiltin(id) : !id.startsWith("node:");
   }
-  async resolveUrl(id, importee) {
-    if (importee && importee.startsWith("mock:"))
-      importee = importee.slice(5);
-    return super.resolveUrl(id, importee);
+  async resolveUrl(id, importer) {
+    if (importer && importer.startsWith("mock:"))
+      importer = importer.slice(5);
+    return super.resolveUrl(id, importer);
   }
   async dependencyRequest(id, fsPath, callstack) {
     const mocked = await this.mocker.requestWithMock(fsPath, callstack);
@@ -331,4 +381,4 @@ class VitestExecutor extends ViteNodeRunner {
   }
 }
 
-export { VitestExecutor as V, createVitestExecutor as c };
+export { VitestExecutor as V, mockMap as a, moduleCache as m, startViteNode as s };

package/dist/chunk-runtime-rpc.971b3848.js

@@ -0,0 +1,61 @@
+import { getSafeTimers } from '@vitest/utils';
+import { g as getWorkerState } from './chunk-utils-global.727b6d25.js';
+
+const { get } = Reflect;
+const safeRandom = Math.random;
+function withSafeTimers(fn) {
+  const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentClearTimeout = globalThis.clearTimeout;
+  const currentRandom = globalThis.Math.random;
+  const currentNextTick = globalThis.process.nextTick;
+  const currentSetImmediate = globalThis.setImmediate;
+  const currentClearImmediate = globalThis.clearImmediate;
+  try {
+    globalThis.setTimeout = setTimeout;
+    globalThis.clearTimeout = clearTimeout;
+    globalThis.Math.random = safeRandom;
+    globalThis.process.nextTick = nextTick;
+    globalThis.setImmediate = setImmediate;
+    globalThis.clearImmediate = clearImmediate;
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.clearTimeout = currentClearTimeout;
+    globalThis.Math.random = currentRandom;
+    globalThis.setImmediate = currentSetImmediate;
+    globalThis.clearImmediate = currentClearImmediate;
+    nextTick(() => {
+      globalThis.process.nextTick = currentNextTick;
+    });
+  }
+}
+const promises = /* @__PURE__ */ new Set();
+const rpcDone = () => {
+  if (!promises.size)
+    return;
+  const awaitable = Array.from(promises);
+  return Promise.all(awaitable);
+};
+const rpc = () => {
+  const { rpc: rpc2 } = getWorkerState();
+  return new Proxy(rpc2, {
+    get(target, p, handler) {
+      const sendCall = get(target, p, handler);
+      const safeSendCall = (...args) => withSafeTimers(async () => {
+        const result = sendCall(...args);
+        promises.add(result);
+        try {
+          return await result;
+        } finally {
+          promises.delete(result);
+        }
+      });
+      safeSendCall.asEvent = sendCall.asEvent;
+      return safeSendCall;
+    }
+  });
+};
+
+export { rpcDone as a, rpc as r };

package/dist/{chunk-runtime-setup.30ab0a4b.js → chunk-runtime-setup.992bb661.js}

@@ -1,5 +1,5 @@
 import { setSafeTimers } from '@vitest/utils';
-import { a as resetRunOnceCounter } from './chunk-integrations-run-once.38756e30.js';
+import { a as resetRunOnceCounter } from './chunk-integrations-run-once.9012f759.js';
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
@@ -10,7 +10,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals)
-    (await import('./chunk-integrations-globals.59432f4f.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.b56fcb06.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)

package/dist/{chunk-utils-base.904102a8.js → chunk-utils-base.81f83dbd.js}

@@ -6,6 +6,14 @@ function collectOwnProperties(obj, collector) {
   Object.getOwnPropertyNames(obj).forEach(collect);
   Object.getOwnPropertySymbols(obj).forEach(collect);
 }
+function groupBy(collection, iteratee) {
+  return collection.reduce((acc, item) => {
+    const key = iteratee(item);
+    acc[key] || (acc[key] = []);
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
 function getAllMockableProperties(obj, isModule) {
   const allProps = /* @__PURE__ */ new Map();
   let curr = obj;
@@ -70,5 +78,11 @@ function isMergeableObject(item) {
 function stdout() {
   return console._stdout || process.stdout;
 }
+function getEnvironmentTransformMode(config, environment) {
+  var _a, _b;
+  if (!((_b = (_a = config.deps) == null ? void 0 : _a.experimentalOptimizer) == null ? void 0 : _b.enabled))
+    return void 0;
+  return environment === "happy-dom" || environment === "jsdom" ? "web" : "ssr";
+}
 
-export { noop as a, stdout as b, deepMerge as d, getAllMockableProperties as g, isObject as i, notNullish as n, slash as s, toArray as t };
+export { getEnvironmentTransformMode as a, noop as b, stdout as c, deepMerge as d, getAllMockableProperties as e, groupBy as g, isObject as i, notNullish as n, slash as s, toArray as t };

package/dist/{chunk-utils-global.442d1d33.js → chunk-utils-global.727b6d25.js}

@@ -63,11 +63,5 @@ function getCallLastIndex(code) {
   }
   return null;
 }
-class AggregateErrorPonyfill extends Error {
-  constructor(errors, message = "") {
-    super(message);
-    this.errors = [...errors];
-  }
-}
 
-export { AggregateErrorPonyfill as A, getCallLastIndex as a, getCurrentEnvironment as b, relativePath as c, removeUndefinedValues as d, isWindows as e, getWorkerState as g, isRunningInBenchmark as i, resetModules as r };
+export { getCallLastIndex as a, getCurrentEnvironment as b, relativePath as c, removeUndefinedValues as d, isWindows as e, getWorkerState as g, isRunningInBenchmark as i, resetModules as r };

package/dist/{chunk-utils-import.847b4a2d.js → chunk-utils-import.ec15dcad.js}

@@ -1,16 +1,16 @@
 import { getCurrentSuite } from '@vitest/runner';
 import { createChainable, getNames } from '@vitest/runner/utils';
 import { getSafeTimers, noop, createSimpleStackTrace } from '@vitest/utils';
-import { g as getWorkerState, i as isRunningInBenchmark, a as getCallLastIndex, b as getCurrentEnvironment, r as resetModules } from './chunk-utils-global.442d1d33.js';
+import { g as getWorkerState, i as isRunningInBenchmark, a as getCallLastIndex, b as getCurrentEnvironment, r as resetModules } from './chunk-utils-global.727b6d25.js';
 import * as chai$1 from 'chai';
 import { expect } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
 import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, getState, setState } from '@vitest/expect';
-import { r as rpc } from './chunk-runtime-rpc.9c0386cc.js';
+import { r as rpc } from './chunk-runtime-rpc.971b3848.js';
 import { join, dirname } from 'pathe';
 import { g as getSnapshotEnvironment } from './chunk-snapshot-env.a347d647.js';
-import { i as isObject } from './chunk-utils-base.904102a8.js';
-import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, a as parseErrorStacktrace, g as getFullName, b as parseSingleStack } from './chunk-utils-tasks.d07dcea9.js';
+import { i as isObject } from './chunk-utils-base.81f83dbd.js';
+import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, a as parseErrorStacktrace, g as getFullName, b as parseSingleStack } from './chunk-utils-tasks.b41c8284.js';
 import require$$0 from 'util';
 import { spyOn, fn, isMockFunction, spies } from '@vitest/spy';
 
@@ -2568,7 +2568,7 @@ const addSerializer = (plugin) => {
 const getSerializers = () => PLUGINS;
 
 const SNAPSHOT_VERSION = "1";
-const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}`;
+const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}, https://vitest.dev/guide/snapshot.html`;
 const testNameToKey = (testName, count) => `${testName} ${count}`;
 const keyToTestName = (key) => {
   if (!/ \d+$/.test(key))

package/dist/{chunk-utils-tasks.d07dcea9.js → chunk-utils-tasks.b41c8284.js}

@@ -1,6 +1,6 @@
 import { getNames, getTests } from '@vitest/runner/utils';
 import { resolve } from 'pathe';
-import { n as notNullish } from './chunk-utils-base.904102a8.js';
+import { n as notNullish } from './chunk-utils-base.81f83dbd.js';
 
 function hasFailedSnapshot(suite) {
   return getTests(suite).some((s) => {

package/dist/cli-wrapper.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'url';
 import c from 'picocolors';
-import { e as execa } from './vendor-index.618ca5a1.js';
+import { e as execa } from './vendor-index.2cbcdd1e.js';
 import { E as EXIT_CODE_RESTART } from './chunk-constants.797d3ebf.js';
 import 'node:buffer';
 import 'node:path';
@@ -11,7 +11,6 @@ import 'path';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
 import 'node:url';
-import 'os';
 import 'node:os';
 import 'assert';
 import 'events';

package/dist/cli.js

@@ -1,33 +1,33 @@
 import { normalize } from 'pathe';
 import cac from 'cac';
 import c from 'picocolors';
-import { v as version, s as startVitest, d as divider } from './chunk-node-pkg.9a107dfb.js';
+import { v as version, s as startVitest, d as divider } from './chunk-node-pkg.88e7e848.js';
 import './chunk-constants.797d3ebf.js';
 import 'node:url';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
-import './chunk-integrations-coverage.48e6286b.js';
+import './chunk-integrations-coverage.e0a6acd2.js';
 import 'local-pkg';
-import 'util';
-import 'path';
-import './chunk-env-node.ffd1183b.js';
+import './chunk-env-node.affdd278.js';
 import 'node:console';
 import 'vite';
 import 'node:path';
 import 'node:process';
 import 'node:fs';
+import 'path';
 import 'os';
+import 'util';
 import 'stream';
 import 'events';
 import 'fs';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'vite-node/client';
 import 'vite-node/server';
-import './chunk-utils-global.442d1d33.js';
+import './chunk-utils-global.727b6d25.js';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'node:fs/promises';
-import './vendor-index.618ca5a1.js';
+import './vendor-index.2cbcdd1e.js';
 import 'node:buffer';
 import 'node:child_process';
 import 'child_process';
@@ -38,12 +38,13 @@ import 'source-map';
 import 'module';
 import 'acorn';
 import 'acorn-walk';
+import 'node:v8';
+import './vendor-index.783e7f3e.js';
+import './chunk-utils-base.81f83dbd.js';
 import 'node:worker_threads';
 import 'tinypool';
-import './vendor-index.783e7f3e.js';
 import 'perf_hooks';
-import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.d07dcea9.js';
+import './chunk-utils-tasks.b41c8284.js';
 import 'crypto';
 import 'vite-node/utils';
 import '@vitest/utils/diff';
@@ -53,7 +54,7 @@ import 'strip-literal';
 import 'readline';
 
 const cli = cac("vitest");
-cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "Enabled threads (default: true)").option("--silent", "Silent console output from tests").option("--isolate", "Isolate environment for each test file (default: true)").option("--reporter <name>", "Specify reporters").option("--outputDiffMaxSize <length>", "Object diff output max size (default: 10000)").option("--outputDiffMaxLines <length>", "Max lines in diff output window (default: 50)").option("--outputTruncateLength <length>", "Diff output line length (default: 80)").option("--outputDiffLines <lines>", "Number of lines in single diff (default: 15)").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser", "Run tests in browser").option("--environment <env>", "Specify runner environment (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").help();
+cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "Enabled threads (default: true)").option("--single-thread", "Run tests inside a single thread, requires --threads (default: false)").option("--silent", "Silent console output from tests").option("--isolate", "Isolate environment for each test file (default: true)").option("--reporter <name>", "Specify reporters").option("--outputDiffMaxSize <length>", "Object diff output max size (default: 10000)").option("--outputDiffMaxLines <length>", "Max lines in diff output window (default: 50)").option("--outputTruncateLength <length>", "Diff output line length (default: 80)").option("--outputDiffLines <lines>", "Number of lines in single diff (default: 15)").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser", "Run tests in browser").option("--environment <env>", "Specify runner environment (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").help();
 cli.command("run [...filters]").action(run);
 cli.command("related [...filters]").action(runRelated);
 cli.command("watch [...filters]").action(watch);

package/dist/config.cjs

@@ -30,7 +30,7 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reporter: ["text", "html", "clover", "json"],
+  reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
 export { ConfigEnv } from 'vite';
-import { a1 as ResolvedCoverageOptions, U as UserConfig$1, a4 as CoverageC8Options, _ as CoverageProviderModule, a2 as BaseCoverageOptions, a3 as CoverageIstanbulOptions, $ as CoverageReporter, F as FakeTimerInstallOpts } from './types-0373403c.js';
+import { a3 as ResolvedCoverageOptions, U as UserConfig$1, a6 as CoverageC8Options, a7 as CustomProviderOptions, a5 as CoverageIstanbulOptions, ah as HtmlOptions, ai as FileOptions, aj as CloverOptions, ak as CoberturaOptions, al as HtmlSpaOptions, am as LcovOptions, an as LcovOnlyOptions, ao as TeamcityOptions, ap as TextOptions, aq as ProjectOptions, F as FakeTimerInstallOpts } from './types-7cd96283.js';
 import '@vitest/expect';
 import '@vitest/runner/types';
 import '@vitest/runner';
@@ -11,6 +11,7 @@ import 'vite-node/client';
 import 'vite-node/server';
 import 'node:worker_threads';
 import 'vite-node';
+import 'source-map';
 import 'node:fs';
 
 declare const defaultInclude: string[];
@@ -44,17 +45,17 @@ declare const config: {
         include: never[];
     };
     coverage: {
-        provider?: "c8" | undefined;
+        provider: "c8";
     } & CoverageC8Options & Required<Pick<({
         provider?: undefined;
     } & CoverageC8Options) | ({
-        provider: CoverageProviderModule;
-    } & BaseCoverageOptions) | ({
-        provider?: "c8" | undefined;
+        provider: "custom";
+    } & CustomProviderOptions) | ({
+        provider: "c8";
     } & CoverageC8Options) | ({
         provider: "istanbul";
-    } & CoverageIstanbulOptions), "exclude" | "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "extension" | "reporter">> & {
-        reporter: CoverageReporter[];
+    } & CoverageIstanbulOptions), "exclude" | "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "extension">> & {
+        reporter: (["html", Partial<HtmlOptions>] | ["json", Partial<FileOptions>] | ["none", {}] | ["clover", Partial<CloverOptions>] | ["cobertura", Partial<CoberturaOptions>] | ["html-spa", Partial<HtmlSpaOptions>] | ["json-summary", Partial<FileOptions>] | ["lcov", Partial<LcovOptions>] | ["lcovonly", Partial<LcovOnlyOptions>] | ["teamcity", Partial<TeamcityOptions>] | ["text", Partial<TextOptions>] | ["text-lcov", Partial<ProjectOptions>] | ["text-summary", Partial<FileOptions>])[];
     };
     fakeTimers: FakeTimerInstallOpts;
     maxConcurrency: number;

package/dist/config.js

@@ -26,7 +26,7 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reporter: ["text", "html", "clover", "json"],
+  reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {

package/dist/coverage.d.ts

@@ -0,0 +1,142 @@
+import { a4 as BaseCoverageOptions, a3 as ResolvedCoverageOptions } from './types-7cd96283.js';
+import '@vitest/expect';
+import 'vite';
+import '@vitest/runner/types';
+import '@vitest/runner';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import 'tinybench';
+import 'vite-node/client';
+import 'vite-node/server';
+import 'node:worker_threads';
+import 'vite-node';
+import 'source-map';
+import 'node:fs';
+
+// Type definitions for istanbul-lib-coverage 2.0
+// Project: https://istanbul.js.org, https://github.com/istanbuljs/istanbuljs
+// Definitions by: Jason Cheatham <https://github.com/jason0x43>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+interface CoverageSummaryData {
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+declare class CoverageSummary {
+    constructor(data: CoverageSummary | CoverageSummaryData);
+    merge(obj: CoverageSummary): CoverageSummary;
+    toJSON(): CoverageSummaryData;
+    isEmpty(): boolean;
+    data: CoverageSummaryData;
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+interface CoverageMapData {
+    [key: string]: FileCoverage | FileCoverageData;
+}
+
+declare class CoverageMap {
+    constructor(data: CoverageMapData | CoverageMap);
+    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
+    files(): string[];
+    fileCoverageFor(filename: string): FileCoverage;
+    filter(callback: (key: string) => boolean): void;
+    getCoverageSummary(): CoverageSummary;
+    merge(data: CoverageMapData | CoverageMap): void;
+    toJSON(): CoverageMapData;
+    data: CoverageMapData;
+}
+
+interface Location {
+    line: number;
+    column: number;
+}
+
+interface Range {
+    start: Location;
+    end: Location;
+}
+
+interface BranchMapping {
+    loc: Range;
+    type: string;
+    locations: Range[];
+    line: number;
+}
+
+interface FunctionMapping {
+    name: string;
+    decl: Range;
+    loc: Range;
+    line: number;
+}
+
+interface FileCoverageData {
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+interface Totals {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+
+interface Coverage {
+    covered: number;
+    total: number;
+    coverage: number;
+}
+
+declare class FileCoverage implements FileCoverageData {
+    constructor(data: string | FileCoverage | FileCoverageData);
+    merge(other: FileCoverageData): void;
+    getBranchCoverageByLine(): { [line: number]: Coverage };
+    getLineCoverage(): { [line: number]: number };
+    getUncoveredLines(): number[];
+    resetHits(): void;
+    computeBranchTotals(): Totals;
+    computeSimpleTotals(): Totals;
+    toSummary(): CoverageSummary;
+    toJSON(): object;
+
+    data: FileCoverageData;
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+type Threshold = 'lines' | 'functions' | 'statements' | 'branches';
+declare class BaseCoverageProvider {
+    /**
+     * Check if current coverage is above configured thresholds and bump the thresholds if needed
+     */
+    updateThresholds({ configurationFile, coverageMap, thresholds }: {
+        coverageMap: CoverageMap;
+        thresholds: Record<Threshold, number | undefined>;
+        configurationFile?: string;
+    }): void;
+    /**
+     * Resolve reporters from various configuration options
+     */
+    resolveReporters(configReporters: NonNullable<BaseCoverageOptions['reporter']>): ResolvedCoverageOptions['reporter'];
+}
+
+export { BaseCoverageProvider };

package/dist/coverage.js

@@ -0,0 +1,49 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const THRESHOLD_KEYS = ["lines", "functions", "statements", "branches"];
+class BaseCoverageProvider {
+  updateThresholds({ configurationFile, coverageMap, thresholds }) {
+    if (!configurationFile)
+      throw new Error('Missing configurationFile. The "coverage.thresholdAutoUpdate" can only be enabled when configuration file is used.');
+    const summary = coverageMap.getCoverageSummary();
+    const thresholdsToUpdate = [];
+    for (const key of THRESHOLD_KEYS) {
+      const threshold = thresholds[key] || 100;
+      const actual = summary[key].pct;
+      if (actual > threshold)
+        thresholdsToUpdate.push(key);
+    }
+    if (thresholdsToUpdate.length === 0)
+      return;
+    const originalConfig = readFileSync(configurationFile, "utf8");
+    let updatedConfig = originalConfig;
+    for (const threshold of thresholdsToUpdate) {
+      const previousThreshold = (thresholds[threshold] || 100).toString();
+      const pattern = new RegExp(`(${threshold}\\s*:\\s*)${previousThreshold.replace(".", "\\.")}`);
+      const matches = originalConfig.match(pattern);
+      if (matches)
+        updatedConfig = updatedConfig.replace(matches[0], matches[1] + summary[threshold].pct);
+      else
+        console.error(`Unable to update coverage threshold ${threshold}. No threshold found using pattern ${pattern}`);
+    }
+    if (updatedConfig !== originalConfig) {
+      console.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
+      writeFileSync(configurationFile, updatedConfig, "utf-8");
+    }
+  }
+  resolveReporters(configReporters) {
+    if (!Array.isArray(configReporters))
+      return [[configReporters, {}]];
+    const resolvedReporters = [];
+    for (const reporter of configReporters) {
+      if (Array.isArray(reporter)) {
+        resolvedReporters.push([reporter[0], reporter[1] || {}]);
+      } else {
+        resolvedReporters.push([reporter, {}]);
+      }
+    }
+    return resolvedReporters;
+  }
+}
+
+export { BaseCoverageProvider };