vitest 3.0.8 → 3.0.9

package/dist/chunks/{resolveConfig.L1_HR0_0.js → coverage.gV8doR2Y.js}

@@ -1,33 +1,36 @@
+import fs, { statSync, realpathSync, promises as promises$1, mkdirSync, existsSync, readdirSync, writeFileSync } from 'node:fs';
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
+import require$$0 from 'util';
+import require$$0$1 from 'path';
+import { relative, resolve, dirname, isAbsolute, join, normalize } from 'pathe';
+import c from 'tinyrainbow';
+import { c as configDefaults, e as benchmarkConfigDefaults, a as coverageConfigDefaults } from './defaults.C2Ndd9wx.js';
 import crypto from 'node:crypto';
 import { slash, createDefer, shuffle, toArray } from '@vitest/utils';
-import fs, { statSync, realpathSync, promises as promises$1, mkdirSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
+import { writeFile, rename, stat, unlink } from 'node:fs/promises';
 import { builtinModules, createRequire } from 'node:module';
 import p, { win32, resolve as resolve$1 } from 'node:path';
 import process$1 from 'node:process';
 import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
-import { relative, resolve, dirname, isAbsolute, join, normalize } from 'pathe';
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
-import c from 'tinyrainbow';
-import { e as extraInlineDeps, a as defaultBrowserPort, b as defaultInspectPort, d as defaultPort } from './constants.fzPh7AOq.js';
+import { e as extraInlineDeps, d as defaultBrowserPort, b as defaultInspectPort, a as defaultPort } from './constants.DTYd6dNH.js';
+import { a as isWindows } from './env.D4Lgay0q.js';
 import * as nodeos from 'node:os';
 import nodeos__default from 'node:os';
-import { w as wrapSerializableConfig, a as Typechecker, b as isWindows } from './typechecker.cZ0LjdSi.js';
-import { isCI, provider } from 'std-env';
 import { isatty } from 'node:tty';
-import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
-import require$$0 from 'util';
-import require$$0$1 from 'path';
 import { version } from 'vite';
 import EventEmitter from 'node:events';
 import { c as createBirpc } from './index.68735LiX.js';
 import Tinypool$1, { Tinypool } from 'tinypool';
+import { w as wrapSerializableConfig, a as Typechecker } from './typechecker.BlF3eHsb.js';
 import { MessageChannel } from 'node:worker_threads';
 import { hasFailed } from '@vitest/runner/utils';
 import { rootDir } from '../path.js';
 import { slash as slash$1 } from 'vite-node/utils';
+import { isCI, provider } from 'std-env';
+import { r as resolveCoverageProviderModule } from './coverage.A3sS5-Wm.js';
 
 function groupBy(collection, iteratee) {
   return collection.reduce((acc, item) => {
@@ -2302,120 +2305,6 @@ function resolvePackage(name, options = {}) {
   }
 }
 
-const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
-const defaultExclude = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/cypress/**",
-  "**/.{idea,git,cache,output,temp}/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
-];
-const benchmarkConfigDefaults = {
-  include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
-  exclude: defaultExclude,
-  includeSource: [],
-  reporters: ["default"],
-  includeSamples: false
-};
-const defaultCoverageExcludes = [
-  "coverage/**",
-  "dist/**",
-  "**/node_modules/**",
-  "**/[.]**",
-  "packages/*/test?(s)/**",
-  "**/*.d.ts",
-  "**/virtual:*",
-  "**/__x00__*",
-  "**/\0*",
-  "cypress/**",
-  "test?(s)/**",
-  "test?(-*).?(c|m)[jt]s?(x)",
-  "**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
-  "**/__tests__/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
-  "**/vitest.{workspace,projects}.[jt]s?(on)",
-  "**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
-];
-const coverageConfigDefaults = {
-  provider: "v8",
-  enabled: false,
-  all: true,
-  clean: true,
-  cleanOnRerun: true,
-  reportsDirectory: "./coverage",
-  exclude: defaultCoverageExcludes,
-  reportOnFailure: false,
-  reporter: [
-    ["text", {}],
-    ["html", {}],
-    ["clover", {}],
-    ["json", {}]
-  ],
-  extension: [
-    ".js",
-    ".cjs",
-    ".mjs",
-    ".ts",
-    ".mts",
-    ".tsx",
-    ".jsx",
-    ".vue",
-    ".svelte",
-    ".marko",
-    ".astro"
-  ],
-  allowExternal: false,
-  excludeAfterRemap: false,
-  ignoreEmptyLines: true,
-  processingConcurrency: Math.min(
-    20,
-    nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length
-  )
-};
-const fakeTimersDefaults = {
-  loopLimit: 1e4,
-  shouldClearNativeTimers: true
-};
-const configDefaults = Object.freeze({
-  allowOnly: !isCI,
-  isolate: true,
-  watch: !isCI,
-  globals: false,
-  environment: "node",
-  pool: "forks",
-  clearMocks: false,
-  restoreMocks: false,
-  mockReset: false,
-  unstubGlobals: false,
-  unstubEnvs: false,
-  include: defaultInclude,
-  exclude: defaultExclude,
-  teardownTimeout: 1e4,
-  forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
-  update: false,
-  reporters: [],
-  silent: false,
-  hideSkippedTests: false,
-  api: false,
-  ui: false,
-  uiBase: "/__vitest__/",
-  open: !isCI,
-  css: {
-    include: []
-  },
-  coverage: coverageConfigDefaults,
-  fakeTimers: fakeTimersDefaults,
-  maxConcurrency: 5,
-  dangerouslyIgnoreUnhandledErrors: false,
-  typecheck: {
-    checker: "tsc",
-    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
-    exclude: defaultExclude
-  },
-  slowTestThreshold: 300,
-  disableConsoleIntercept: false
-});
-
 function getWorkersCountByPercentage(percent) {
   const maxWorkersCount = nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length;
   const workersCountByPercentage = Math.round(Number.parseInt(percent) / 100 * maxWorkersCount);
@@ -6650,7 +6539,7 @@ function createMethodsRPC(project, options = {}) {
       }
       promises.set(
         tmp,
-        writeFile(tmp, code, "utf-8").finally(() => promises.delete(tmp))
+        atomicWriteFile(tmp, code).catch(() => writeFile(tmp, code, "utf-8")).finally(() => promises.delete(tmp))
       );
       await promises.get(tmp);
       Object.assign(result, { id: tmp });
@@ -6721,6 +6610,21 @@ function handleRollupError(e) {
   }
   throw e;
 }
+async function atomicWriteFile(realFilePath, data) {
+  const dir = dirname(realFilePath);
+  const tmpFilePath = join(dir, `.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  try {
+    await writeFile(tmpFilePath, data, "utf-8");
+    await rename(tmpFilePath, realFilePath);
+  } finally {
+    try {
+      if (await stat(tmpFilePath)) {
+        await unlink(tmpFilePath);
+      }
+    } catch {
+    }
+  }
+}
 
 function createChildProcessChannel$1(project, collect = false) {
   const emitter = new EventEmitter();
@@ -7875,7 +7779,7 @@ function resolveInlineWorkerOption(value) {
     return Number(value);
   }
 }
-function resolveConfig(vitest, options, viteConfig) {
+function resolveConfig$1(vitest, options, viteConfig) {
   const mode = vitest.mode;
   const logger = vitest.logger;
   if (options.dom) {
@@ -8500,4 +8404,469 @@ function isPlaywrightChromiumOnly(vitest, config) {
   return true;
 }
 
-export { BaseSequencer as B, RandomSequencer as R, VitestCache as V, resolveConfig as a, resolveApiServerConfig as b, coverageConfigDefaults as c, createMethodsRPC as d, configDefaults as e, isBrowserEnabled as f, getFilePoolName as g, hash as h, isPackageExists as i, groupBy as j, createPool as k, mm as m, resolveCoverageReporters as r, stdout as s, wildcardPatternToRegExp as w };
+const THRESHOLD_KEYS = [
+  "lines",
+  "functions",
+  "statements",
+  "branches"
+];
+const GLOBAL_THRESHOLDS_KEY = "global";
+const DEFAULT_PROJECT = Symbol.for("default-project");
+let uniqueId = 0;
+async function getCoverageProvider(options, loader) {
+  const coverageModule = await resolveCoverageProviderModule(options, loader);
+  if (coverageModule) {
+    return coverageModule.getProvider();
+  }
+  return null;
+}
+class BaseCoverageProvider {
+  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$1.rm(this.options.reportsDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    if (existsSync(this.coverageFilesDirectory)) {
+      await promises$1.rm(this.coverageFilesDirectory, {
+        recursive: true,
+        force: true,
+        maxRetries: 10
+      });
+    }
+    await promises$1.mkdir(this.coverageFilesDirectory, { recursive: true });
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    this.pendingPromises = [];
+  }
+  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$1.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$1.readFile(filename, "utf-8");
+              const coverage = JSON.parse(contents);
+              onFileRead(coverage);
+            })
+          );
+        }
+        await onFinished(project, transformMode);
+      }
+    }
+  }
+  async cleanAfterRun() {
+    this.coverageFiles = /* @__PURE__ */ new Map();
+    await promises$1.rm(this.coverageFilesDirectory, { recursive: true });
+    if (readdirSync(this.options.reportsDirectory).length === 0) {
+      await promises$1.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) {
+    const resolvedThresholds = [];
+    const files = coverageMap.files();
+    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(this.options.thresholds[glob]);
+      const globCoverageMap = this.createCoverageMap();
+      const matchingFiles = files.filter(
+        (file) => mm.isMatch(relative(this.ctx.config.root, file), glob)
+      );
+      for (const file of matchingFiles) {
+        const fileCoverage = coverageMap.fileCoverageFor(file);
+        globCoverageMap.addFileCoverage(fileCoverage);
+      }
+      resolvedThresholds.push({
+        name: glob,
+        coverageMap: globCoverageMap,
+        thresholds: globThresholds
+      });
+    }
+    for (const file of files) {
+      const fileCoverage = coverageMap.fileCoverageFor(file);
+      globalCoverageMap.addFileCoverage(fileCoverage);
+    }
+    resolvedThresholds.unshift({
+      name: GLOBAL_THRESHOLDS_KEY,
+      coverageMap: globalCoverageMap,
+      thresholds: {
+        branches: this.options.thresholds?.branches,
+        functions: this.options.thresholds?.functions,
+        lines: this.options.thresholds?.lines,
+        statements: this.options.thresholds?.statements
+      }
+    });
+    return resolvedThresholds;
+  }
+  /**
+   * 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) {
+            continue;
+          }
+          if (threshold >= 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);
+            }
+          } else {
+            const uncovered = summary.data[thresholdKey].total - summary.data[thresholdKey].covered;
+            const absoluteThreshold = threshold * -1;
+            if (uncovered > absoluteThreshold) {
+              process.exitCode = 1;
+              let errorMessage = `ERROR: Uncovered ${thresholdKey} (${uncovered}) exceed ${name === GLOBAL_THRESHOLDS_KEY ? name : `"${name}"`} threshold (${absoluteThreshold})`;
+              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
+   */
+  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;
+        if (threshold >= 0) {
+          const actual = Math.min(
+            ...summaries.map((summary) => summary[key].pct)
+          );
+          if (actual > threshold) {
+            thresholdsToUpdate.push([key, actual]);
+          }
+        } else {
+          const absoluteThreshold = threshold * -1;
+          const actual = Math.max(
+            ...summaries.map((summary) => summary[key].total - summary[key].covered)
+          );
+          if (actual < absoluteThreshold) {
+            const updatedThreshold = actual === 0 ? 100 : actual * -1;
+            thresholdsToUpdate.push([key, updatedThreshold]);
+          }
+        }
+      }
+      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(
+      ([reporter]) => reporter === "text" || reporter === "text-summary" || reporter === "text-lcov" || reporter === "teamcity"
+    );
+  }
+  toSlices(array, size) {
+    return array.reduce((chunks, item) => {
+      const index = Math.max(0, chunks.length - 1);
+      const lastChunk = chunks[index] || [];
+      chunks[index] = lastChunk;
+      if (lastChunk.length >= size) {
+        chunks.push([item]);
+      } else {
+        lastChunk.push(item);
+      }
+      return chunks;
+    }, []);
+  }
+  createUncoveredFileTransformer(ctx) {
+    const servers = [
+      ...ctx.projects.map((project) => ({
+        root: project.config.root,
+        isBrowserEnabled: project.isBrowserEnabled(),
+        vitenode: project.vitenode
+      })),
+      // Check core last as it will match all files anyway
+      { root: ctx.config.root, vitenode: ctx.vitenode, isBrowserEnabled: ctx.getRootProject().isBrowserEnabled() }
+    ];
+    return async function transformFile(filename) {
+      let lastError;
+      for (const { root, vitenode, isBrowserEnabled } of servers) {
+        if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) {
+          continue;
+        }
+        if (isBrowserEnabled) {
+          const result = await vitenode.transformRequest(filename, void 0, "web").catch(() => null);
+          if (result) {
+            return result;
+          }
+        }
+        try {
+          return await vitenode.transformRequest(filename);
+        } catch (error) {
+          lastError = error;
+        }
+      }
+      throw lastError;
+    };
+  }
+}
+function resolveGlobThresholds(thresholds) {
+  if (!thresholds || typeof thresholds !== "object") {
+    return {};
+  }
+  if (100 in thresholds && thresholds[100] === true) {
+    return {
+      lines: 100,
+      branches: 100,
+      functions: 100,
+      statements: 100
+    };
+  }
+  return {
+    lines: "lines" in thresholds && typeof thresholds.lines === "number" ? thresholds.lines : void 0,
+    branches: "branches" in thresholds && typeof thresholds.branches === "number" ? thresholds.branches : void 0,
+    functions: "functions" in thresholds && typeof thresholds.functions === "number" ? thresholds.functions : void 0,
+    statements: "statements" in thresholds && typeof thresholds.statements === "number" ? thresholds.statements : void 0
+  };
+}
+function assertConfigurationModule(config) {
+  try {
+    if (typeof config.test.coverage.thresholds !== "object") {
+      throw new TypeError(
+        "Expected config.test.coverage.thresholds to be an object"
+      );
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Unable to parse thresholds from configuration file: ${message}`
+    );
+  }
+}
+function resolveConfig(configModule) {
+  const mod = configModule.exports.default;
+  try {
+    if (mod.$type === "object") {
+      return mod;
+    }
+    let config = resolveDefineConfig(mod);
+    if (config) {
+      return config;
+    }
+    if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
+      config = resolveMergeConfig(mod);
+      if (config) {
+        return config;
+      }
+    }
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : String(error));
+  }
+  throw new Error(
+    "Failed to update coverage thresholds. Configuration file is too complex."
+  );
+}
+function resolveDefineConfig(mod) {
+  if (mod.$type === "function-call" && mod.$callee === "defineConfig") {
+    if (mod.$args[0].$type === "object") {
+      return mod.$args[0];
+    }
+    if (mod.$args[0].$type === "arrow-function-expression") {
+      if (mod.$args[0].$body.$type === "object") {
+        return mod.$args[0].$body;
+      }
+      const config = resolveMergeConfig(mod.$args[0].$body);
+      if (config) {
+        return config;
+      }
+    }
+  }
+}
+function resolveMergeConfig(mod) {
+  if (mod.$type === "function-call" && mod.$callee === "mergeConfig") {
+    for (const arg of mod.$args) {
+      const config = resolveDefineConfig(arg);
+      if (config) {
+        return config;
+      }
+    }
+  }
+}
+
+export { BaseCoverageProvider as B, RandomSequencer as R, VitestCache as V, resolveApiServerConfig as a, BaseSequencer as b, createMethodsRPC as c, isBrowserEnabled as d, groupBy as e, getCoverageProvider as f, getFilePoolName as g, hash as h, isPackageExists as i, createPool as j, mm as m, resolveConfig$1 as r, stdout as s, wildcardPatternToRegExp as w };

package/dist/chunks/{creator.2CFRE1Yx.js → creator.BsBnpTzI.js}

@@ -5,7 +5,7 @@ import { detectPackageManager, installPackage } from './index.Bw6JxgX8.js';
 import { p as prompt, f as findUp } from './index.DBIGubLC.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';
-import { c as configFiles } from './constants.fzPh7AOq.js';
+import { c as configFiles } from './constants.DTYd6dNH.js';
 import 'node:process';
 import 'node:url';
 import './_commonjsHelpers.BFTU3MAI.js';