vitest 3.2.0-beta.2 → 3.2.0-beta.3

package/dist/chunks/index.D3XRDfWc.js

@@ -0,0 +1,213 @@
+import process from 'node:process';
+import fs from 'node:fs/promises';
+import path, { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { x } from 'tinyexec';
+
+const AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun",
+  "deno"
+];
+const LOCKS = {
+  "bun.lock": "bun",
+  "bun.lockb": "bun",
+  "deno.lock": "deno",
+  "pnpm-lock.yaml": "pnpm",
+  "pnpm-workspace.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+const INSTALL_METADATA = {
+  "node_modules/.deno/": "deno",
+  "node_modules/.pnpm/": "pnpm",
+  "node_modules/.yarn-state.yml": "yarn",
+  // yarn v2+ (node-modules)
+  "node_modules/.yarn_integrity": "yarn",
+  // yarn v1
+  "node_modules/.package-lock.json": "npm",
+  ".pnp.cjs": "yarn",
+  // yarn v3+ (pnp)
+  ".pnp.js": "yarn",
+  // yarn v2 (pnp)
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+};
+
+async function pathExists(path2, type) {
+  try {
+    const stat = await fs.stat(path2);
+    return type === "file" ? stat.isFile() : stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function* lookup(cwd = process.cwd()) {
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  return !filepath || !pathExists(filepath, "file") ? null : await handlePackageManager(filepath, onUnknown);
+}
+async function detect(options = {}) {
+  const {
+    cwd,
+    strategies = ["lockfile", "packageManager-field", "devEngines-field"],
+    onUnknown
+  } = options;
+  let stopDir;
+  if (typeof options.stopDir === "string") {
+    const resolved = path.resolve(options.stopDir);
+    stopDir = (dir) => dir === resolved;
+  } else {
+    stopDir = options.stopDir;
+  }
+  for (const directory of lookup(cwd)) {
+    for (const strategy of strategies) {
+      switch (strategy) {
+        case "lockfile": {
+          for (const lock of Object.keys(LOCKS)) {
+            if (await pathExists(path.join(directory, lock), "file")) {
+              const name = LOCKS[lock];
+              const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+              if (result)
+                return result;
+              else
+                return { name, agent: name };
+            }
+          }
+          break;
+        }
+        case "packageManager-field":
+        case "devEngines-field": {
+          const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+          if (result)
+            return result;
+          break;
+        }
+        case "install-metadata": {
+          for (const metadata of Object.keys(INSTALL_METADATA)) {
+            const fileOrDir = metadata.endsWith("/") ? "dir" : "file";
+            if (await pathExists(path.join(directory, metadata), fileOrDir)) {
+              const name = INSTALL_METADATA[metadata];
+              const agent = name === "yarn" ? isMetadataYarnClassic(metadata) ? "yarn" : "yarn@berry" : name;
+              return { name, agent };
+            }
+          }
+          break;
+        }
+      }
+    }
+    if (stopDir?.(directory))
+      break;
+  }
+  return null;
+}
+function getNameAndVer(pkg) {
+  const handelVer = (version) => version?.match(/\d+(\.\d+){0,2}/)?.[0] ?? version;
+  if (typeof pkg.packageManager === "string") {
+    const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+    return { name, ver: handelVer(ver) };
+  }
+  if (typeof pkg.devEngines?.packageManager?.name === "string") {
+    return {
+      name: pkg.devEngines.packageManager.name,
+      ver: handelVer(pkg.devEngines.packageManager.version)
+    };
+  }
+  return void 0;
+}
+async function handlePackageManager(filepath, onUnknown) {
+  try {
+    const pkg = JSON.parse(await fs.readFile(filepath, "utf8"));
+    let agent;
+    const nameAndVer = getNameAndVer(pkg);
+    if (nameAndVer) {
+      const name = nameAndVer.name;
+      const ver = nameAndVer.ver;
+      let version = ver;
+      if (name === "yarn" && ver && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && ver && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function isMetadataYarnClassic(metadataPath) {
+  return metadataPath.endsWith(".yarn_integrity");
+}
+
+// src/detect.ts
+async function detectPackageManager(cwd = process.cwd()) {
+  const result = await detect({
+    cwd,
+    onUnknown(packageManager) {
+      console.warn("[@antfu/install-pkg] Unknown packageManager:", packageManager);
+      return void 0;
+    }
+  });
+  return result?.agent || null;
+}
+async function installPackage(names, options = {}) {
+  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
+  const [agent] = detectedAgent.split("@");
+  if (!Array.isArray(names))
+    names = [names];
+  const args = (typeof options.additionalArgs === "function" ? options.additionalArgs(agent, detectedAgent) : options.additionalArgs) || [];
+  if (options.preferOffline) {
+    if (detectedAgent === "yarn@berry")
+      args.unshift("--cached");
+    else
+      args.unshift("--prefer-offline");
+  }
+  if (agent === "pnpm") {
+    args.unshift(
+      /**
+       * Prevent pnpm from removing installed devDeps while `NODE_ENV` is `production`
+       * @see https://pnpm.io/cli/install#--prod--p
+       */
+      "--prod=false"
+    );
+    if (existsSync(resolve(options.cwd ?? process.cwd(), "pnpm-workspace.yaml"))) {
+      args.unshift("-w");
+    }
+  }
+  return x(
+    agent,
+    [
+      agent === "yarn" ? "add" : "install",
+      options.dev ? "-D" : "",
+      ...args,
+      ...names
+    ].filter(Boolean),
+    {
+      nodeOptions: {
+        stdio: options.silent ? "ignore" : "inherit",
+        cwd: options.cwd
+      },
+      throwOnError: true
+    }
+  );
+}
+
+export { detectPackageManager, installPackage };

package/dist/chunks/{index.CfXMNXHg.js → index.DNgLEKsQ.js}

@@ -1,5 +1,5 @@
-import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.BFR5YIgu.js';
-import { b as bench } from './benchmark.BoF7jW0Q.js';
+import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.pkoYCV6A.js';
+import { b as bench } from './benchmark.Cf_PACH1.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import * as chai from 'chai';
@@ -7,6 +7,8 @@ import { assert, should } from 'chai';
 
 const assertType = function assertType() {};
 
+// TODO: deprecate <reference types="vitest" /> in favor of `<reference types="vitest/config" />`
+
 var VitestIndex = /*#__PURE__*/Object.freeze({
   __proto__: null,
   afterAll: afterAll,

package/dist/chunks/{index.CmC5OK9L.js → index.JOzufsrU.js}

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
 import * as pathe from 'pathe';
 import c from 'tinyrainbow';
-import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName } from './index.CV36oG_L.js';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName } from './index.Bter3jj9.js';
 import { stripVTControlCharacters } from 'node:util';
 import { notNullish } from '@vitest/utils';
 
@@ -249,6 +249,7 @@ class BenchmarkReporter extends DefaultReporter {
 	}
 	async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
 		super.onFinished(files, errors);
+		// write output for future comparison
 		let outputFile = this.ctx.config.benchmark?.outputJson;
 		if (outputFile) {
 			outputFile = pathe.resolve(this.ctx.config.root, outputFile);

package/dist/chunks/{inspector.DbDkSkFn.js → inspector.BFsh5KO0.js}

@@ -13,11 +13,13 @@ function setupInspect(ctx) {
 	const isEnabled = config.inspector.enabled;
 	if (isEnabled) {
 		inspector = __require("node:inspector");
+		// Inspector may be open already if "isolate: false" is used
 		const isOpen = inspector.url() !== undefined;
 		if (!isOpen) {
 			inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
 			if (config.inspectBrk) {
 				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
+				// Stop at first test file
 				if (firstTestFile) {
 					session = new inspector.Session();
 					session.connect();
@@ -46,6 +48,7 @@ function closeInspector(config) {
 	}
 }
 function shouldKeepOpen(config) {
+	// In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used
 	const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread;
 	const isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
 	return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);

package/dist/chunks/{node.3xsWotC9.js → node.Be-ntJnD.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.CgTj3MsC.js';
+import { g as getWorkerState } from './utils.BlI4TC7Y.js';
 import '@vitest/utils';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {

package/dist/chunks/{reporters.d.CLC9rhKy.d.ts → reporters.d.Bt4IGtsa.d.ts}

@@ -1,13 +1,13 @@
 import { Task, TaskMeta, Suite, File, TaskResultPack, SequenceSetupFiles, SequenceHooks, CancelReason } from '@vitest/runner';
-import { b as Awaitable, U as UserConsoleLog, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor, f as EnvironmentOptions, P as ProvidedContext } from './environment.d.D8YDy2v5.js';
+import { b as Awaitable, U as UserConsoleLog, c as Arrayable$1, A as AfterSuiteRunMeta, L as LabelColor, f as EnvironmentOptions, P as ProvidedContext } from './environment.d.cL3nLXbE.js';
 import { ParsedStack, TestError, SerializedError, ErrorWithDiff, Arrayable, Awaitable as Awaitable$1 } from '@vitest/utils';
 import { Writable } from 'node:stream';
 import { TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions, ViteDevServer, ModuleNode } from 'vite';
 import { Console } from 'node:console';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { T as TestExecutionMethod } from './worker.d.CoCI7hzP.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.UqE-KR0o.js';
+import { T as TestExecutionMethod } from './worker.d.BKbBp2ga.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.D2ROskhv.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -714,7 +714,6 @@ declare class DefaultReporter extends BaseReporter {
 	onHookStart(hook: ReportedHookContext): void;
 	onHookEnd(hook: ReportedHookContext): void;
 	onInit(ctx: Vitest): void;
-	onPathsCollected(paths?: string[]): void;
 	onTestRunEnd(): void;
 }
 
@@ -826,6 +825,9 @@ declare class FileCoverage implements FileCoverageData {
     b: { [key: string]: number[] };
 }
 
+// for compatibility reasons, the reporter produces a JSON similar to the one produced by the Jest JSON reporter
+// the following types are extracted from the Jest repository (and simplified)
+// the commented-out fields are the missing ones
 type Status = "passed" | "failed" | "skipped" | "pending" | "todo" | "disabled";
 type Milliseconds = number;
 interface Callsite {
@@ -946,8 +948,13 @@ declare class DotReporter extends BaseReporter {
 	private createSummary;
 }
 
+interface GithubActionsReporterOptions {
+	onWritePath?: (path: string) => string;
+}
 declare class GithubActionsReporter implements Reporter {
 	ctx: Vitest;
+	options: GithubActionsReporterOptions;
+	constructor(options?: GithubActionsReporterOptions);
 	onInit(ctx: Vitest): void;
 	onFinished(files?: File[], errors?: unknown[]): void;
 }
@@ -1425,6 +1432,7 @@ interface Thresholds {
 }
 
 type BuiltinEnvironment = "node" | "jsdom" | "happy-dom" | "edge-runtime";
+// Record is used, so user can get intellisense for builtin environments, but still allow custom environments
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 
 type CSSModuleScopeStrategy = "stable" | "scoped" | "non-scoped";
@@ -2173,6 +2181,11 @@ interface TypecheckConfig {
 	* Path to tsconfig, relative to the project root.
 	*/
 	tsconfig?: string;
+	/**
+	* Minimum time in milliseconds it takes to spawn the typechecker.
+	* @default 10_000
+	*/
+	spawnTimeout?: number;
 }
 interface UserConfig extends InlineConfig {
 	/**
@@ -2351,6 +2364,7 @@ interface BrowserProvider {
 	openPage: (sessionId: string, url: string, beforeNavigate?: () => Promise<void>) => Promise<void>;
 	getCDPSession?: (sessionId: string) => Promise<CDPSession>;
 	close: () => Awaitable$1<void>;
+	// eslint-disable-next-line ts/method-signature-style -- we want to allow extended options
 	initialize(ctx: TestProject, options: BrowserProviderInitializationOptions): Awaitable$1<void>;
 }
 interface BrowserProviderModule {
@@ -2613,6 +2627,8 @@ declare class TestProject {
 	* It is based on the root of the project (not consistent between OS) and its name.
 	*/
 	get hash(): string;
+	// "provide" is a property, not a method to keep the context when destructed in the global setup,
+	// making it a method would be a breaking change, and can be done in Vitest 3 at minimum
 	/**
 	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
@@ -2664,6 +2680,7 @@ declare class TestProject {
 	teardownGlobalSetup(): Promise<void>;
 	/** @deprecated use `vitest.logger` instead */
 	get logger(): Logger;
+	// it's possible that file path was imported with different queries (?raw, ?url, etc)
 	/** @deprecated use `.vite` or `.browser.vite` directly */
 	getModulesByFilepath(file: string): Set<ModuleNode>;
 	/** @deprecated use `.vite` or `.browser.vite` directly */
@@ -2879,7 +2896,7 @@ declare class Vitest {
 	private _cache?;
 	private _snapshot?;
 	private _workspaceConfigPath?;
-	constructor(mode: VitestRunMode, options?: VitestOptions);
+	constructor(mode: VitestRunMode, cliOptions: UserConfig, options?: VitestOptions);
 	private _onRestartListeners;
 	private _onClose;
 	private _onSetServer;
@@ -2914,7 +2931,7 @@ declare class Vitest {
 	*/
 	get cache(): VitestCache;
 	/** @deprecated internal */
-	setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
+	setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
 	/**
 	* Inject new test projects into the workspace.
 	* @param config Glob, config path or a custom config options.
@@ -3046,6 +3063,7 @@ declare class Vitest {
 	*/
 	resetGlobalTestNamePattern(): void;
 	private _rerunTimer;
+	// we can't use a single `triggerId` yet because vscode extension relies on this
 	private scheduleRerun;
 	/**
 	* Invalidate a file in all projects.

package/dist/chunks/{rpc.D9_013TY.js → rpc.BKExFSRG.js}

@@ -1,6 +1,6 @@
 import { getSafeTimers } from '@vitest/utils';
 import { c as createBirpc } from './index.CJ0plNrh.js';
-import { g as getWorkerState } from './utils.CgTj3MsC.js';
+import { g as getWorkerState } from './utils.BlI4TC7Y.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {
@@ -56,6 +56,7 @@ function createRuntimeRpc(options) {
 			if (functionName === "fetch" || functionName === "transform" || functionName === "resolveId") {
 				message += ` with "${JSON.stringify(args)}"`;
 			}
+			// JSON.stringify cannot serialize Error instances
 			if (functionName === "onUnhandledError") {
 				message += ` with "${args[0]?.message || args[0]}"`;
 			}

package/dist/chunks/{runBaseTests.Dn2vyej_.js → runBaseTests.B_M1TTsK.js}

@@ -1,9 +1,9 @@
 import { performance } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.DswW_LEs.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.CYo3Y0dD.js';
-import { a as globalExpect, v as vi } from './vi.BFR5YIgu.js';
-import { c as closeInspector } from './inspector.DbDkSkFn.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.CbT4iuwc.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.CF-O-dZX.js';
+import { a as globalExpect, v as vi } from './vi.pkoYCV6A.js';
+import { c as closeInspector } from './inspector.BFsh5KO0.js';
 import { createRequire } from 'node:module';
 import timers from 'node:timers';
 import timersPromises from 'node:timers/promises';
@@ -11,13 +11,13 @@ import util from 'node:util';
 import { getSafeTimers } from '@vitest/utils';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
 import { installSourcemapsSupport } from 'vite-node/source-map';
-import { V as VitestIndex } from './index.CfXMNXHg.js';
-import { g as getWorkerState, r as resetModules } from './utils.CgTj3MsC.js';
+import { V as VitestIndex } from './index.DNgLEKsQ.js';
+import { g as getWorkerState, r as resetModules } from './utils.BlI4TC7Y.js';
 import 'chai';
 import 'node:path';
 import '../path.js';
 import 'node:url';
-import './rpc.D9_013TY.js';
+import './rpc.BKExFSRG.js';
 import './index.CJ0plNrh.js';
 import './coverage.0iPg4Wrz.js';
 import '@vitest/snapshot';
@@ -27,10 +27,11 @@ import './_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
-import './date.CDOsz-HY.js';
-import './benchmark.BoF7jW0Q.js';
+import './date.ByMsSlOr.js';
+import './benchmark.Cf_PACH1.js';
 import 'expect-type';
 
+// this should only be used in Node
 let globalSetup = false;
 async function setupGlobalEnv(config, { environment }, executor) {
 	await setupCommonEnv(config);
@@ -48,10 +49,12 @@ async function setupGlobalEnv(config, { environment }, executor) {
 	globalSetup = true;
 	if (environment.transformMode === "web") {
 		const _require = createRequire(import.meta.url);
+		// always mock "required" `css` files, because we cannot process them
 		_require.extensions[".css"] = resolveCss;
 		_require.extensions[".scss"] = resolveCss;
 		_require.extensions[".sass"] = resolveCss;
 		_require.extensions[".less"] = resolveCss;
+		// since we are using Vite, we can assume how these will be resolved
 		KNOWN_ASSET_TYPES.forEach((type) => {
 			_require.extensions[`.${type}`] = resolveAsset;
 		});
@@ -59,6 +62,7 @@ async function setupGlobalEnv(config, { environment }, executor) {
 	} else {
 		process.env.SSR = "1";
 	}
+	// @ts-expect-error not typed global for patched timers
 	globalThis.__vitest_required__ = {
 		util,
 		timers,
@@ -76,22 +80,25 @@ function resolveAsset(mod, url) {
 	mod.exports = url;
 }
 async function setupConsoleLogSpy() {
-	const { createCustomConsole } = await import('./console.K1NMVOSc.js');
+	const { createCustomConsole } = await import('./console.Cwr-MFPV.js');
 	globalThis.console = createCustomConsole();
 }
 async function withEnv({ environment }, options, fn) {
+	// @ts-expect-error untyped global
 	globalThis.__vitest_environment__ = environment.name;
 	globalExpect.setState({ environment: environment.name });
 	const env = await environment.setup(globalThis, options);
 	try {
 		await fn();
 	} finally {
+		// Run possible setTimeouts, e.g. the onces used by ConsoleLogSpy
 		const { setTimeout } = getSafeTimers();
 		await new Promise((resolve) => setTimeout(resolve));
 		await env.teardown(globalThis);
 	}
 }
 
+// browser shouldn't call this!
 async function run(method, files, config, environment, executor) {
 	const workerState = getWorkerState();
 	const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
@@ -122,7 +129,9 @@ async function run(method, files, config, environment, executor) {
 			} else {
 				await collectTests([file], runner);
 			}
+			// reset after tests, because user might call `vi.setConfig` in setupFile
 			vi.resetConfig();
+			// mocks should not affect different files
 			vi.restoreAllMocks();
 		}
 		await stopCoverageInsideWorker(config.coverage, executor, { isolate });

package/dist/chunks/{setup-common.CYo3Y0dD.js → setup-common.CF-O-dZX.js}

@@ -34,7 +34,7 @@ async function setupCommonEnv(config) {
 	globalSetup = true;
 	setSafeTimers();
 	if (config.globals) {
-		(await import('./globals.CpxW8ccg.js')).registerApiGlobally();
+		(await import('./globals.CI21aWXF.js')).registerApiGlobally();
 	}
 }
 function setupDefines(defines) {
@@ -46,6 +46,7 @@ function setupEnv(env) {
 	if (typeof process === "undefined") {
 		return;
 	}
+	// same boolean-to-string assignment as VitestPlugin.configResolved
 	const { PROD, DEV,...restEnvs } = env;
 	process.env.PROD = PROD ? "1" : "";
 	process.env.DEV = DEV ? "1" : "";