vitest 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/chunks/{config.d.D91DHYaD.d.ts → config.d.DXq1aBpy.d.ts}

@@ -1,75 +1,96 @@
 import { PrettyFormatOptions } from '@vitest/pretty-format';
-import { SequenceHooks, SequenceSetupFiles, SerializableRetry, TestTagDefinition } from '@vitest/runner';
+import { VitestRunnerConfig, SequenceHooks } from '@vitest/runner';
 import { L as LabelColor, g as SnapshotUpdateState } from './general.d.DFAHgpC2.js';
 import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.d.DOJxxZV9.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 
-/**
- * Names of clock methods that may be faked by install.
- */
-type FakeMethod =
-    | "setTimeout"
-    | "clearTimeout"
-    | "setImmediate"
-    | "clearImmediate"
-    | "setInterval"
-    | "clearInterval"
-    | "Date"
-    | "nextTick"
-    | "hrtime"
-    | "requestAnimationFrame"
-    | "cancelAnimationFrame"
-    | "requestIdleCallback"
-    | "cancelIdleCallback"
-    | "performance"
-    | "queueMicrotask";
-
-interface FakeTimerInstallOpts {
-    /**
-     * Installs fake timers with the specified unix epoch (default: 0)
-     */
-    now?: number | Date | undefined;
-
-    /**
-     * An array with names of global methods and APIs to fake. By default, `@sinonjs/fake-timers` does not replace `nextTick()` and `queueMicrotask()`.
-     * For instance, `FakeTimers.install({ toFake: ['setTimeout', 'nextTick'] })` will fake only `setTimeout()` and `nextTick()`
-     */
-    toFake?: FakeMethod[] | undefined;
-
-    /**
-     * The maximum number of timers that will be run when calling runAll() (default: 1000)
-     */
-    loopLimit?: number | undefined;
-
-    /**
-     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
-     * 20ms for every 20ms change in the real system time) (default: false)
-     */
-    shouldAdvanceTime?: boolean | undefined;
-
-    /**
-     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
-     * in the real system time (default: 20)
-     */
-    advanceTimeDelta?: number | undefined;
-
-    /**
-     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by
-     * default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers. (default: false)
-     */
-    shouldClearNativeTimers?: boolean | undefined;
-
-    /**
-     * Tells FakeTimers to not throw an error when faking a timer that does not exist in the global object. (default: false)
-     */
-    ignoreMissingTimers?: boolean | undefined;
-}
+type VoidVarArgsFunc = (...args: unknown[]) => void;
+type SetImmediate = (callback: VoidVarArgsFunc, ...args: unknown[]) => NodeImmediate;
+type SetTimeout = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
+type ClearTimeout = (id?: TimerId) => void;
+type SetInterval = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
+type ClearInterval = (id?: TimerId) => void;
+type QueueMicrotask = (callback: VoidVarArgsFunc) => void;
+type TimeRemaining = () => number;
+type IdleDeadline = {
+    didTimeout: boolean;
+    timeRemaining: TimeRemaining;
+};
+type RequestIdleCallbackCallback = (deadline: IdleDeadline) => any;
+type RequestIdleCallback = (callback: RequestIdleCallbackCallback, options?: {
+    timeout?: number;
+}) => number;
+type AnimationFrameCallback = (timestamp: number) => any;
+type RequestAnimationFrame = (callback: AnimationFrameCallback) => TimerId;
+type CancelAnimationFrame = (id: TimerId) => void;
+type CancelIdleCallback = (id: TimerId) => void;
+type ClearImmediate = (id: NodeImmediate) => void;
+type FakeMethod = "setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask";
+type TimerId = number | NodeImmediate | Timer;
+type GlobalObject = Record<string, any> & {
+    setTimeout?: SetTimeout;
+    clearTimeout?: ClearTimeout;
+    setInterval?: SetInterval;
+    clearInterval?: ClearInterval;
+    setImmediate?: SetImmediate;
+    clearImmediate?: ClearImmediate;
+    queueMicrotask?: QueueMicrotask;
+    requestAnimationFrame?: RequestAnimationFrame;
+    cancelAnimationFrame?: CancelAnimationFrame;
+    requestIdleCallback?: RequestIdleCallback;
+    cancelIdleCallback?: CancelIdleCallback;
+    process?: any;
+    performance?: any;
+    Performance?: any;
+    Intl?: any;
+    Promise?: typeof Promise;
+    Date: typeof Date & {
+        isFake?: boolean;
+        toSource?: () => string;
+        clock?: any;
+    };
+};
+type TimerInitialProps = {
+    func: VoidVarArgsFunc;
+    args?: unknown[];
+    type?: 'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback';
+    delay?: number;
+    callAt?: number;
+    createdAt?: number;
+    immediate?: boolean;
+    id?: number;
+    error?: Error;
+    interval?: number;
+    animation?: boolean;
+    requestIdleCallback?: boolean;
+    order?: number;
+    heapIndex?: number;
+};
+type Config = {
+    now?: number | Date;
+    toFake?: FakeMethod[];
+    toNotFake?: FakeMethod[];
+    loopLimit?: number;
+    shouldAdvanceTime?: boolean;
+    advanceTimeDelta?: number;
+    shouldClearNativeTimers?: boolean;
+    ignoreMissingTimers?: boolean;
+    target?: GlobalObject;
+};
+type Timer = TimerInitialProps;
+type NodeImmediateHasRef = () => boolean;
+type NodeImmediateRef = () => NodeImmediate;
+type NodeImmediateUnref = () => NodeImmediate;
+type NodeImmediate = {
+    hasRef: NodeImmediateHasRef;
+    ref: NodeImmediateRef;
+    unref: NodeImmediateUnref;
+};
 
 /**
 * Config that tests have access to.
 */
-interface SerializedConfig {
-	name: string | undefined;
+interface SerializedConfig extends VitestRunnerConfig {
 	color?: LabelColor;
 	globals: boolean;
 	base: string | undefined;
@@ -78,23 +99,14 @@ interface SerializedConfig {
 	runner: string | undefined;
 	isolate: boolean;
 	maxWorkers: number;
-	mode: "test" | "benchmark";
 	bail: number | undefined;
 	environmentOptions?: Record<string, any>;
-	root: string;
-	setupFiles: string[];
-	passWithNoTests: boolean;
-	testNamePattern: RegExp | undefined;
-	allowOnly: boolean;
-	testTimeout: number;
-	hookTimeout: number;
 	clearMocks: boolean;
 	mockReset: boolean;
 	restoreMocks: boolean;
 	unstubGlobals: boolean;
 	unstubEnvs: boolean;
-	fakeTimers: FakeTimerInstallOpts;
-	maxConcurrency: number;
+	fakeTimers: Config;
 	defines: Record<string, any>;
 	expect: {
 		requireAssertions?: boolean;
@@ -104,13 +116,6 @@ interface SerializedConfig {
 		};
 	};
 	printConsoleTrace: boolean | undefined;
-	sequence: {
-		shuffle?: boolean;
-		concurrent?: boolean;
-		seed: number;
-		hooks: SequenceHooks;
-		setupFiles: SequenceSetupFiles;
-	};
 	deps: {
 		web: {
 			transformAssets?: boolean;
@@ -145,8 +150,6 @@ interface SerializedConfig {
 		allowWrite: boolean | undefined;
 	};
 	diff: string | SerializedDiffOptions | undefined;
-	retry: SerializableRetry;
-	includeTaskLocation: boolean | undefined;
 	inspect: boolean | string | undefined;
 	inspectBrk: boolean | string | undefined;
 	inspector: {
@@ -170,6 +173,7 @@ interface SerializedConfig {
 		locators: {
 			testIdAttribute: string;
 			exact: boolean;
+			errorFormat: "html" | "aria" | "all";
 		};
 		screenshotFailures: boolean;
 		providerOptions: {
@@ -189,8 +193,11 @@ interface SerializedConfig {
 	detectAsyncLeaks: boolean;
 	coverage: SerializedCoverageConfig;
 	benchmark: {
-		includeSamples: boolean;
-	} | undefined;
+		enabled: boolean;
+		retainSamples: boolean;
+		suppressExportGetterWarnings: boolean;
+		projectName: string;
+	};
 	serializedDefines: string;
 	experimental: {
 		fsModuleCache: boolean;
@@ -211,12 +218,9 @@ interface SerializedConfig {
 			browserSdkPath?: string;
 		} | undefined;
 	};
-	tags: TestTagDefinition[];
-	tagsFilter: string[] | undefined;
-	strictTags: boolean;
 	mergeReportsLabel: string | undefined;
 	slowTestThreshold: number | undefined;
-	isAgent: boolean;
+	disableColors: boolean;
 }
 interface SerializedCoverageConfig {
 	provider: "istanbul" | "v8" | "custom" | undefined;
@@ -237,4 +241,4 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedRootConfig as S, SerializedConfig as a, RuntimeConfig as b, SerializedCoverageConfig as c };
+export type { BrowserTraceViewMode as B, Config as C, RuntimeOptions as R, SerializedRootConfig as S, SerializedConfig as a, RuntimeConfig as b, SerializedCoverageConfig as c };

package/dist/chunks/{creator.BqL2U_x4.js → creator.D66cVXYh.js}

@@ -78,7 +78,7 @@ import { render } from 'vitest-browser-vue'
 import HelloWorld from './HelloWorld.vue'
 
 test('renders name', async () => {
-  const { getByText } = render(HelloWorld, {
+  const { getByText } = await render(HelloWorld, {
     props: { name: 'Vitest' },
   })
   await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
@@ -107,7 +107,7 @@ import { render } from 'vitest-browser-svelte'
 import HelloWorld from './HelloWorld.svelte'
 
 test('renders name', async () => {
-  const { getByText } = render(HelloWorld, { name: 'Vitest' })
+  const { getByText } = await render(HelloWorld, { name: 'Vitest' })
   await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
 })
 `

package/dist/chunks/{defaults.szbHWQun.js → defaults.CUUnbOrq.js}

@@ -1,15 +1,17 @@
 import nodeos__default from 'node:os';
-import './env.D4Lgay0q.js';
+import './env.BKKtU2WC.js';
 import { isCI, isAgent } from 'std-env';
 
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
 const defaultExclude = ["**/node_modules/**", "**/.git/**"];
 const benchmarkConfigDefaults = {
+	enabled: false,
 	include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
 	exclude: defaultExclude,
 	includeSource: [],
-	reporters: ["default"],
-	includeSamples: false
+	retainSamples: false,
+	suppressExportGetterWarnings: false,
+	projectName: ""
 };
 // These are the generic defaults for coverage. Providers may also set some provider specific defaults.
 const coverageConfigDefaults = {
@@ -57,7 +59,7 @@ const configDefaults = Object.freeze({
 	include: defaultInclude,
 	exclude: defaultExclude,
 	teardownTimeout: 1e4,
-	forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+	forceRerunTriggers: ["**/package.json", "**/{vitest,vite}.config.*"],
 	update: false,
 	reporters: [isAgent ? "minimal" : "default", ...process.env.GITHUB_ACTIONS === "true" ? ["github-actions"] : []],
 	silent: false,

package/dist/chunks/{env.D4Lgay0q.js → env.BKKtU2WC.js}

@@ -4,5 +4,6 @@ const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.v
 const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 const isWindows = (isNode || isDeno) && process.platform === "win32";
 const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
+const isForceColor = () => "FORCE_COLOR" in process.env;
 
-export { isWindows as a, isTTY as i };
+export { isTTY as a, isWindows as b, isForceColor as i };

package/dist/chunks/global.d.BtKPuz2X.d.ts

@@ -0,0 +1,194 @@
+import { P as PromisifyAssertion, T as Tester, E as ExpectStatic } from './browser.d.BGxB4Xum.js';
+import { Plugin } from '@vitest/pretty-format';
+import { BaselineData, Test } from '@vitest/runner';
+import { i as SnapshotState, U as UserConsoleLog } from './general.d.DFAHgpC2.js';
+import { TaskResultCompleted, TaskResultRuntimeInfo, TaskResultTimestampProviderInfo, Fn, FnOptions, BenchOptions } from 'tinybench';
+
+type ExtractBenchNames<T extends BenchRegistration<any>[]> = Exclude<{ [K in keyof T] : T[K] extends BenchRegistration<infer N> ? N : never }[number], never>;
+type BenchResult = TaskResultCompleted & TaskResultRuntimeInfo & TaskResultTimestampProviderInfo;
+interface BenchStorage<T extends string> {
+	get: (name: T) => BenchResult;
+}
+
+/**
+* Options accepted by `bench(name, options, fn)`. Extends tinybench's
+* `FnOptions` with Vitest-specific fields.
+*/
+interface BenchFnOptions extends FnOptions {
+	/**
+	* Path (relative to the project root) where the benchmark result is written
+	* after a successful run. The string `${projectName}` is substituted with
+	* the current project name. Absolute paths are accepted as long as they
+	* resolve inside the project root.
+	*/
+	writeResult?: string;
+	/**
+	* Mark this benchmark as a per-project entry. Per-project tasks still appear
+	* in the inline comparison table for the current run, and Vitest additionally
+	* collects them across projects and prints a single cross-project table at
+	* the end of the run.
+	*/
+	perProject?: boolean;
+}
+interface BenchRegistration<Name extends string> {
+	name: Name;
+	/**
+	* The benchmark function. Absent for registrations created via `bench.from()`.
+	*/
+	fn?: Fn;
+	/**
+	* Per-benchmark options (`beforeEach`, `beforeAll`, etc.). Absent for
+	* registrations created via `bench.from()`.
+	*/
+	fnOpts?: FnOptions;
+	run: (options?: BenchOptions) => Promise<BenchResult>;
+}
+interface BenchCompare {
+	<Args extends BenchRegistration<any>[]>(...args: Args): Promise<BenchStorage<ExtractBenchNames<Args>>>;
+	<Args extends BenchRegistration<any>[]>(...args: [...Args, BenchOptions]): Promise<BenchStorage<ExtractBenchNames<Args>>>;
+}
+interface BenchFactory {
+	<Name extends string>(name: Name | Function, fn: Fn): BenchRegistration<Name>;
+	<Name extends string>(name: Name | Function, options: BenchFnOptions, fn: Fn): BenchRegistration<Name>;
+}
+interface BenchFromSource {
+	(): BaselineData | Promise<BaselineData>;
+}
+interface BenchFrom {
+	<Name extends string>(name: Name | Function, source: string | BenchFromSource): BenchRegistration<Name>;
+}
+interface Bench extends BenchFactory {
+	compare: BenchCompare;
+	from: BenchFrom;
+}
+
+interface SnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;
+	(hint?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, hint?: string): void;
+	(hint?: string): void;
+}
+declare module "vitest" {
+	interface MatcherState {
+		environment: string;
+		snapshotState: SnapshotState;
+		task?: Readonly<Test>;
+	}
+	interface ExpectPollOptions {
+		interval?: number;
+		timeout?: number;
+		message?: string;
+	}
+	interface ExpectStatic {
+		assert: Chai.AssertStatic;
+		unreachable: (message?: string) => never;
+		soft: <T>(actual: T, message?: string) => Assertion<T>;
+		poll: <T>(actual: (options: {
+			signal: AbortSignal;
+		}) => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+		addEqualityTesters: (testers: Array<Tester>) => void;
+		assertions: (expected: number) => void;
+		hasAssertions: () => void;
+		addSnapshotSerializer: (plugin: Plugin) => void;
+	}
+	interface Assertion<T> {
+		matchSnapshot: SnapshotMatcher<T>;
+		toMatchSnapshot: SnapshotMatcher<T>;
+		toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+		/**
+		* Checks that an error thrown by a function matches a previously recorded snapshot.
+		*
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* expect(functionWithError).toThrowErrorMatchingSnapshot();
+		*/
+		toThrowErrorMatchingSnapshot: (hint?: string) => void;
+		/**
+		* Checks that an error thrown by a function matches an inline snapshot within the test file.
+		* Useful for keeping snapshots close to the test code.
+		*
+		* @param snapshot - Optional inline snapshot string to match.
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* const throwError = () => { throw new Error('Error occurred') };
+		* expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+		*/
+		toThrowErrorMatchingInlineSnapshot: (snapshot?: string, hint?: string) => void;
+		/**
+		* Compares the received value to a snapshot saved in a specified file.
+		* Useful for cases where snapshot content is large or needs to be shared across tests.
+		*
+		* @param filepath - Path to the snapshot file.
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+		*/
+		toMatchFileSnapshot: (filepath: string, hint?: string) => Promise<void>;
+		/**
+		* Asserts that a benchmark result is faster than another benchmark result.
+		* Compares mean latency — lower is faster.
+		*
+		* @example
+		* const result = await bench.compare(
+		*   bench('lib1', () => { lib1() }),
+		*   bench('lib2', () => { lib2() }),
+		* )
+		* expect(result.get('lib1')).toBeFasterThan(result.get('lib2'))
+		* expect(result.get('lib1')).toBeFasterThan(result.get('lib2'), { delta: 0.1 })
+		*/
+		toBeFasterThan: (expected: BenchResult, options?: {
+			delta?: number;
+		}) => void;
+		/**
+		* Asserts that a benchmark result is slower than another benchmark result.
+		* Compares mean latency — higher is slower.
+		*
+		* @example
+		* const result = await bench.compare(
+		*   bench('lib1', () => { lib1() }),
+		*   bench('lib2', () => { lib2() }),
+		* )
+		* expect(result.get('lib2')).toBeSlowerThan(result.get('lib1'))
+		* expect(result.get('lib2')).toBeSlowerThan(result.get('lib1'), { delta: 0.2 })
+		*/
+		toBeSlowerThan: (expected: BenchResult, options?: {
+			delta?: number;
+		}) => void;
+	}
+}
+declare module "@vitest/runner" {
+	interface TestContext {
+		/**
+		* `expect` instance bound to the current test.
+		*
+		* This API is useful for running snapshot tests concurrently because global expect cannot track them.
+		*/
+		readonly expect: ExpectStatic;
+		/**
+		* Create a benchmark to run. It will be reported after the test is finished.
+		* @see {@link https://vitest.dev/guide/benchmarking}
+		*/
+		readonly bench: Bench;
+		/** @internal */
+		_local: boolean;
+	}
+	interface TaskMeta {
+		typecheck?: boolean;
+		benchmark?: boolean;
+		__vitest_label__?: string;
+	}
+	interface File {
+		prepareDuration?: number;
+		environmentLoad?: number;
+	}
+	interface TaskBase {
+		logs?: UserConsoleLog[];
+	}
+}
+
+export type { Bench as B, BenchFnOptions as a, BenchFromSource as b, BenchRegistration as c, BenchResult as d, BenchStorage as e };

package/dist/chunks/{globals.EHmmu0nC.js → globals.BuY-yD0m.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants.-juJ8b_4.js';
-import { i as index } from './index.D_7-4CaB.js';
+import { i as index } from './index.CE58PZNH.js';
 import '@vitest/runner';
 import './utils.BX5Fg8C4.js';
 import '@vitest/utils/timers';
@@ -20,6 +20,7 @@ import '@vitest/pretty-format';
 import '@vitest/utils/diff';
 import '@vitest/utils/display';
 import 'tinyrainbow';
+import 'tinybench';
 import 'expect-type';
 
 function registerApiGlobally() {