vitest 2.1.2 → 2.1.4

package/dist/config.d.ts

@@ -1,23 +1,23 @@
-import './chunks/vite.8fk186v-.js';
-import { ConfigEnv, UserConfig } from 'vite';
-export { ConfigEnv, Plugin, UserConfig, mergeConfig } from 'vite';
-import { R as ResolvedCoverageOptions, b as CoverageV8Options, U as UserWorkspaceConfig, c as UserProjectConfigFn, d as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.DAfKSDh5.js';
-import '@vitest/runner';
-import '@vitest/pretty-format';
+import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
+export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
+import { R as ResolvedCoverageOptions, c as CoverageV8Options, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.anwo7Y6a.js';
+import './chunks/vite.BdBj-UWY.js';
 import './chunks/config.Crbj2GAb.js';
+import '@vitest/pretty-format';
+import '@vitest/runner';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.CzISCQ7o.js';
+import 'chai';
+import './chunks/environment.LoooBwUu.js';
 import 'node:stream';
-import 'vite-node/client';
-import '@vitest/snapshot/manager';
-import 'vite-node/server';
 import '@vitest/utils';
 import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import '@vitest/snapshot/manager';
 import 'node:fs';
-import 'chai';
-import './chunks/benchmark.JVlTzojj.js';
+import './chunks/benchmark.geERunq4.js';
 import '@vitest/runner/utils';
 import 'tinybench';
 
@@ -71,12 +71,17 @@ declare const configDefaults: Readonly<{
     disableConsoleIntercept: false;
 }>;
 
-type UserConfigFnObject = (env: ConfigEnv) => UserConfig;
-type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
-type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
-type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
-declare function defineConfig(config: UserConfig): UserConfig;
-declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+/**
+ * @deprecated Use `ViteUserConfig` instead
+ */
+type UserConfig = UserConfig$1;
+
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig$1>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig$1 | Promise<UserConfig$1>;
+type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
+declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
 declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
 declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
@@ -85,4 +90,4 @@ declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn
 declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
 declare function defineWorkspace(config: WorkspaceProjectConfiguration[]): WorkspaceProjectConfiguration[];
 
-export { type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
+export { type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };

package/dist/config.js

@@ -2,10 +2,6 @@ import os from 'node:os';
 import { isCI } from 'std-env';
 export { mergeConfig } from 'vite';
 
-const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
-(isNode || isDeno) && process.platform === "win32";
-
 const defaultBrowserPort = 63315;
 const extraInlineDeps = [
   /^(?!.*node_modules).*\.mjs$/,
@@ -14,6 +10,10 @@ const extraInlineDeps = [
   /vite\w*\/dist\/client\/env.mjs/
 ];
 
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+(isNode || isDeno) && process.platform === "win32";
+
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
 const defaultExclude = [
   "**/node_modules/**",

package/dist/coverage.d.ts

@@ -1,21 +1,21 @@
 import * as vite from 'vite';
-import { B as BaseCoverageOptions, R as ResolvedCoverageOptions, V as Vitest } from './chunks/reporters.DAfKSDh5.js';
-import '@vitest/runner';
-import '@vitest/pretty-format';
+import { R as ResolvedCoverageOptions, V as Vitest, a as ReportContext } from './chunks/reporters.anwo7Y6a.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.LoooBwUu.js';
 import './chunks/config.Crbj2GAb.js';
+import '@vitest/pretty-format';
+import '@vitest/runner';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.CzISCQ7o.js';
+import 'chai';
 import 'node:stream';
-import 'vite-node/client';
-import '@vitest/snapshot/manager';
-import 'vite-node/server';
 import '@vitest/utils';
 import '@vitest/utils/source-map';
+import 'vite-node/client';
+import 'vite-node/server';
+import '@vitest/snapshot/manager';
 import 'node:fs';
-import 'chai';
-import './chunks/benchmark.JVlTzojj.js';
+import './chunks/benchmark.geERunq4.js';
 import '@vitest/runner/utils';
 import 'tinybench';
 
@@ -129,39 +129,76 @@ interface ResolvedThreshold {
     name: string;
     thresholds: Partial<Record<Threshold, number | undefined>>;
 }
-declare class BaseCoverageProvider {
-    /**
-     * Check if current coverage is above configured thresholds and bump the thresholds if needed
-     */
-    updateThresholds({ thresholds: allThresholds, perFile, configurationFile, onUpdate, }: {
-        thresholds: ResolvedThreshold[];
-        perFile?: boolean;
-        configurationFile: unknown;
-        onUpdate: () => void;
-    }): void;
-    /**
-     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-     */
-    checkThresholds({ thresholds: allThresholds, perFile, onError, }: {
-        thresholds: ResolvedThreshold[];
-        perFile?: boolean;
-        onError: (error: string) => void;
-    }): void;
+/**
+ * Holds info about raw coverage results that are stored on file system:
+ *
+ * ```json
+ * "project-a": {
+ *   "web": {
+ *     "tests/math.test.ts": "coverage-1.json",
+ *     "tests/utils.test.ts": "coverage-2.json",
+ * //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+ *   },
+ *   "ssr": { ... },
+ *   "browser": { ... },
+ * },
+ * "project-b": ...
+ * ```
+ */
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta['projectName']> | symbol, Record<AfterSuiteRunMeta['transformMode'], {
+    [TestFilenames: string]: string;
+}>>;
+declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istanbul' | 'v8'>> {
+    ctx: Vitest;
+    readonly name: 'v8' | 'istanbul';
+    version: string;
+    options: Options;
+    coverageFiles: CoverageFiles;
+    pendingPromises: Promise<void>[];
+    coverageFilesDirectory: string;
+    _initialize(ctx: Vitest): void;
+    createCoverageMap(): CoverageMap;
+    generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
+    parseConfigModule(_: string): Promise<{
+        generate: () => {
+            code: string;
+        };
+    }>;
+    resolveOptions(): Options;
+    clean(clean?: boolean): Promise<void>;
+    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+    readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+        /** Callback invoked with a single coverage result */
+        onFileRead: (data: CoverageType) => void;
+        /** Callback invoked once all results of a project for specific transform mode are read */
+        onFinished: (project: Vitest['projects'][number], transformMode: AfterSuiteRunMeta['transformMode']) => Promise<void>;
+        onDebug: ((...logs: any[]) => void) & {
+            enabled: boolean;
+        };
+    }): Promise<void>;
+    cleanAfterRun(): Promise<void>;
+    onTestFailure(): Promise<void>;
+    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+    reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
     /**
      * Constructs collected coverage and users' threshold options into separate sets
      * where each threshold set holds their own coverage maps. Threshold set is either
      * for specific files defined by glob pattern or global for all other files.
      */
-    resolveThresholds({ coverageMap, thresholds, createCoverageMap, root, }: {
-        coverageMap: CoverageMap;
-        thresholds: NonNullable<BaseCoverageOptions['thresholds']>;
-        createCoverageMap: () => CoverageMap;
-        root: string;
-    }): ResolvedThreshold[];
+    private resolveThresholds;
     /**
-     * Resolve reporters from various configuration options
+     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+     */
+    private checkThresholds;
+    /**
+     * Check if current coverage is above configured thresholds and bump the thresholds if needed
      */
-    resolveReporters(configReporters: NonNullable<BaseCoverageOptions['reporter']>): ResolvedCoverageOptions['reporter'];
+    updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
+        thresholds: ResolvedThreshold[];
+        configurationFile: unknown;
+        onUpdate: () => void;
+    }): Promise<void>;
+    mergeReports(coverageMaps: unknown[]): Promise<void>;
     hasTerminalReporter(reporters: ResolvedCoverageOptions['reporter']): boolean;
     toSlices<T>(array: T[], size: number): T[][];
     createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<vite.TransformResult | null | undefined>;

package/dist/coverage.js

@@ -1,7 +1,9 @@
-import { relative } from 'pathe';
-import { m as mm, r as resolveCoverageReporters } from './chunks/resolveConfig.D1DENLPF.js';
+import { existsSync, promises, readdirSync, writeFileSync } from 'node:fs';
+import { c as coverageConfigDefaults, r as resolveCoverageReporters, m as mm } from './chunks/resolveConfig.DPmbhVlP.js';
+import { resolve, relative } from 'pathe';
+import c from 'tinyrainbow';
+import '@vitest/utils';
 import 'node:path';
-import 'node:fs';
 import 'node:fs/promises';
 import 'node:process';
 import 'node:module';
@@ -9,29 +11,24 @@ import 'node:url';
 import 'node:assert';
 import 'node:v8';
 import 'node:util';
-import 'tinyrainbow';
 import './chunks/constants.fzPh7AOq.js';
 import 'node:os';
-import './chunks/env.CmHVDJnw.js';
+import './chunks/RandomSequencer.CMRlh2v4.js';
 import 'std-env';
-import '@vitest/runner/utils';
-import './chunks/base.DwXGwWst.js';
-import '@vitest/utils';
-import 'node:crypto';
-import './chunks/RandomSequencer.Bh5-tlNJ.js';
 import 'node:perf_hooks';
+import '@vitest/runner/utils';
 import '@vitest/utils/source-map';
 import 'tinyexec';
-import 'path';
-import 'fs';
-import 'module';
 import 'vite';
+import 'fs';
 import 'vite-node/utils';
+import 'node:crypto';
 import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import 'util';
+import 'path';
 import 'node:events';
+import './chunks/index.68735LiX.js';
 import 'tinypool';
-import './chunks/index.BpSiYbpB.js';
 import 'node:worker_threads';
 import './path.js';
 
@@ -42,125 +39,196 @@ const THRESHOLD_KEYS = [
   "branches"
 ];
 const GLOBAL_THRESHOLDS_KEY = "global";
+const DEFAULT_PROJECT = Symbol.for("default-project");
+let uniqueId = 0;
 class BaseCoverageProvider {
-  /**
-   * Check if current coverage is above configured thresholds and bump the thresholds if needed
-   */
-  updateThresholds({
-    thresholds: allThresholds,
-    perFile,
-    configurationFile,
-    onUpdate
-  }) {
-    let updatedThresholds = false;
-    const config = resolveConfig(configurationFile);
-    assertConfigurationModule(config);
-    for (const { coverageMap, thresholds, name } of allThresholds) {
-      const summaries = perFile ? coverageMap.files().map(
-        (file) => coverageMap.fileCoverageFor(file).toSummary()
-      ) : [coverageMap.getCoverageSummary()];
-      const thresholdsToUpdate = [];
-      for (const key of THRESHOLD_KEYS) {
-        const threshold = thresholds[key] ?? 100;
-        const actual = Math.min(
-          ...summaries.map((summary) => summary[key].pct)
-        );
-        if (actual > threshold) {
-          thresholdsToUpdate.push([key, actual]);
-        }
-      }
-      if (thresholdsToUpdate.length === 0) {
-        continue;
-      }
-      updatedThresholds = true;
-      for (const [threshold, newValue] of thresholdsToUpdate) {
-        if (name === GLOBAL_THRESHOLDS_KEY) {
-          config.test.coverage.thresholds[threshold] = newValue;
-        } else {
-          const glob = config.test.coverage.thresholds[name];
-          glob[threshold] = newValue;
-        }
+  ctx;
+  name;
+  version;
+  options;
+  coverageFiles = /* @__PURE__ */ new Map();
+  pendingPromises = [];
+  coverageFilesDirectory;
+  _initialize(ctx) {
+    this.ctx = ctx;
+    if (ctx.version !== this.version) {
+      ctx.logger.warn(
+        c.yellow(
+          `Loaded ${c.inverse(c.yellow(` vitest@${ctx.version} `))} and ${c.inverse(c.yellow(` @vitest/coverage-${this.name}@${this.version} `))}.
+Running mixed versions is not supported and may lead into bugs
+Update your dependencies and make sure the versions match.`
+        )
+      );
+    }
+    const config = ctx.config.coverage;
+    this.options = {
+      ...coverageConfigDefaults,
+      // User's options
+      ...config,
+      // Resolved fields
+      provider: this.name,
+      reportsDirectory: resolve(
+        ctx.config.root,
+        config.reportsDirectory || coverageConfigDefaults.reportsDirectory
+      ),
+      reporter: resolveCoverageReporters(
+        config.reporter || coverageConfigDefaults.reporter
+      ),
+      thresholds: config.thresholds && {
+        ...config.thresholds,
+        lines: config.thresholds["100"] ? 100 : config.thresholds.lines,
+        branches: config.thresholds["100"] ? 100 : config.thresholds.branches,
+        functions: config.thresholds["100"] ? 100 : config.thresholds.functions,
+        statements: config.thresholds["100"] ? 100 : config.thresholds.statements
       }
+    };
+    const shard = this.ctx.config.shard;
+    const tempDirectory = `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`;
+    this.coverageFilesDirectory = resolve(
+      this.options.reportsDirectory,
+      tempDirectory
+    );
+  }
+  createCoverageMap() {
+    throw new Error("BaseReporter's createCoverageMap was not overwritten");
+  }
+  async generateReports(_, __) {
+    throw new Error("BaseReporter's generateReports was not overwritten");
+  }
+  async parseConfigModule(_) {
+    throw new Error("BaseReporter's parseConfigModule was not overwritten");
+  }
+  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
+      });
     }
-    if (updatedThresholds) {
-      console.log(
-        "Updating thresholds to configuration file. You may want to push with updated coverage thresholds."
-      );
-      onUpdate();
+    if (existsSync(this.coverageFilesDirectory)) {
+      await promises.rm(this.coverageFilesDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
     }
+    await promises.mkdir(this.coverageFilesDirectory, { recursive: true });
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    this.pendingPromises = [];
   }
-  /**
-   * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-   */
-  checkThresholds({
-    thresholds: allThresholds,
-    perFile,
-    onError
-  }) {
-    for (const { coverageMap, thresholds, name } of allThresholds) {
-      if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) {
-        continue;
-      }
-      const summaries = 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 ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
-              if (perFile && file) {
-                errorMessage += ` for ${relative("./", file).replace(
-                  /\\/g,
-                  "/"
-                )}`;
-              }
-              onError(errorMessage);
-            }
+  onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }) {
+    if (!coverage) {
+      return;
+    }
+    if (transformMode !== "web" && transformMode !== "ssr" && transformMode !== "browser") {
+      throw new Error(`Invalid transform mode: ${transformMode}`);
+    }
+    let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT);
+    if (!entry) {
+      entry = { web: {}, ssr: {}, browser: {} };
+      this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry);
+    }
+    const testFilenames = testFiles.join();
+    const filename = resolve(
+      this.coverageFilesDirectory,
+      `coverage-${uniqueId++}.json`
+    );
+    entry[transformMode][testFilenames] = filename;
+    const promise = promises.writeFile(filename, JSON.stringify(coverage), "utf-8");
+    this.pendingPromises.push(promise);
+  }
+  async readCoverageFiles({ onFileRead, onFinished, onDebug }) {
+    let index = 0;
+    const total = this.pendingPromises.length;
+    await Promise.all(this.pendingPromises);
+    this.pendingPromises = [];
+    for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
+      for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject)) {
+        const filenames = Object.values(coverageByTestfiles);
+        const project = this.ctx.getProjectByName(projectName);
+        for (const chunk of this.toSlices(filenames, this.options.processingConcurrency)) {
+          if (onDebug.enabled) {
+            index += chunk.length;
+            onDebug("Covered files %d/%d", index, total);
           }
+          await Promise.all(
+            chunk.map(async (filename) => {
+              const contents = await promises.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              onFileRead(coverage);
+            })
+          );
         }
+        await onFinished(project, transformMode);
       }
     }
   }
+  async cleanAfterRun() {
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    await promises.rm(this.coverageFilesDirectory, { recursive: true });
+    if (readdirSync(this.options.reportsDirectory).length === 0) {
+      await promises.rm(this.options.reportsDirectory, { recursive: true });
+    }
+  }
+  async onTestFailure() {
+    if (!this.options.reportOnFailure) {
+      await this.cleanAfterRun();
+    }
+  }
+  async reportCoverage(coverageMap, { allTestsRun }) {
+    await this.generateReports(
+      coverageMap || this.createCoverageMap(),
+      allTestsRun
+    );
+    const keepResults = !this.options.cleanOnRerun && this.ctx.config.watch;
+    if (!keepResults) {
+      await this.cleanAfterRun();
+    }
+  }
+  async reportThresholds(coverageMap, allTestsRun) {
+    const resolvedThresholds = this.resolveThresholds(coverageMap);
+    this.checkThresholds(resolvedThresholds);
+    if (this.options.thresholds?.autoUpdate && allTestsRun) {
+      if (!this.ctx.server.config.configFile) {
+        throw new Error(
+          'Missing configurationFile. The "coverage.thresholds.autoUpdate" can only be enabled when configuration file is used.'
+        );
+      }
+      const configFilePath = this.ctx.server.config.configFile;
+      const configModule = await this.parseConfigModule(configFilePath);
+      await this.updateThresholds({
+        thresholds: resolvedThresholds,
+        configurationFile: configModule,
+        onUpdate: () => writeFileSync(
+          configFilePath,
+          configModule.generate().code,
+          "utf-8"
+        )
+      });
+    }
+  }
   /**
    * Constructs collected coverage and users' threshold options into separate sets
    * where each threshold set holds their own coverage maps. Threshold set is either
    * for specific files defined by glob pattern or global for all other files.
    */
-  resolveThresholds({
-    coverageMap,
-    thresholds,
-    createCoverageMap,
-    root
-  }) {
+  resolveThresholds(coverageMap) {
     const resolvedThresholds = [];
     const files = coverageMap.files();
-    const globalCoverageMap = createCoverageMap();
-    for (const key of Object.keys(
-      thresholds
-    )) {
+    const globalCoverageMap = this.createCoverageMap();
+    for (const key of Object.keys(this.options.thresholds)) {
       if (key === "perFile" || key === "autoUpdate" || key === "100" || THRESHOLD_KEYS.includes(key)) {
         continue;
       }
       const glob = key;
-      const globThresholds = resolveGlobThresholds(thresholds[glob]);
-      const globCoverageMap = createCoverageMap();
+      const globThresholds = resolveGlobThresholds(this.options.thresholds[glob]);
+      const globCoverageMap = this.createCoverageMap();
       const matchingFiles = files.filter(
-        (file) => mm.isMatch(relative(root, file), glob)
+        (file) => mm.isMatch(relative(this.ctx.config.root, file), glob)
       );
       for (const file of matchingFiles) {
         const fileCoverage = coverageMap.fileCoverageFor(file);
@@ -180,19 +248,89 @@ class BaseCoverageProvider {
       name: GLOBAL_THRESHOLDS_KEY,
       coverageMap: globalCoverageMap,
       thresholds: {
-        branches: thresholds.branches,
-        functions: thresholds.functions,
-        lines: thresholds.lines,
-        statements: thresholds.statements
+        branches: this.options.thresholds?.branches,
+        functions: this.options.thresholds?.functions,
+        lines: this.options.thresholds?.lines,
+        statements: this.options.thresholds?.statements
       }
     });
     return resolvedThresholds;
   }
   /**
-   * Resolve reporters from various configuration options
+   * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+   */
+  checkThresholds(allThresholds) {
+    for (const { coverageMap, thresholds, name } of allThresholds) {
+      if (thresholds.branches === void 0 && thresholds.functions === void 0 && thresholds.lines === void 0 && thresholds.statements === void 0) {
+        continue;
+      }
+      const summaries = this.options.thresholds?.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 THRESHOLD_KEYS) {
+          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 ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${threshold}%)`;
+              if (this.options.thresholds?.perFile && file) {
+                errorMessage += ` for ${relative("./", file).replace(/\\/g, "/")}`;
+              }
+              this.ctx.logger.error(errorMessage);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Check if current coverage is above configured thresholds and bump the thresholds if needed
    */
-  resolveReporters(configReporters) {
-    return resolveCoverageReporters(configReporters);
+  async updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }) {
+    let updatedThresholds = false;
+    const config = resolveConfig(configurationFile);
+    assertConfigurationModule(config);
+    for (const { coverageMap, thresholds, name } of allThresholds) {
+      const summaries = this.options.thresholds?.perFile ? coverageMap.files().map(
+        (file) => coverageMap.fileCoverageFor(file).toSummary()
+      ) : [coverageMap.getCoverageSummary()];
+      const thresholdsToUpdate = [];
+      for (const key of THRESHOLD_KEYS) {
+        const threshold = thresholds[key] ?? 100;
+        const actual = Math.min(
+          ...summaries.map((summary) => summary[key].pct)
+        );
+        if (actual > threshold) {
+          thresholdsToUpdate.push([key, actual]);
+        }
+      }
+      if (thresholdsToUpdate.length === 0) {
+        continue;
+      }
+      updatedThresholds = true;
+      for (const [threshold, newValue] of thresholdsToUpdate) {
+        if (name === GLOBAL_THRESHOLDS_KEY) {
+          config.test.coverage.thresholds[threshold] = newValue;
+        } else {
+          const glob = config.test.coverage.thresholds[name];
+          glob[threshold] = newValue;
+        }
+      }
+    }
+    if (updatedThresholds) {
+      this.ctx.logger.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
+      onUpdate();
+    }
+  }
+  async mergeReports(coverageMaps) {
+    const coverageMap = this.createCoverageMap();
+    for (const coverage of coverageMaps) {
+      coverageMap.merge(coverage);
+    }
+    await this.generateReports(coverageMap, true);
   }
   hasTerminalReporter(reporters) {
     return reporters.some(