vitest 5.0.0-beta.3 → 5.0.0-beta.4

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

@@ -1,5 +1,5 @@
 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';
@@ -90,8 +90,7 @@ type NodeImmediate = {
 /**
 * Config that tests have access to.
 */
-interface SerializedConfig {
-	name: string | undefined;
+interface SerializedConfig extends VitestRunnerConfig {
 	color?: LabelColor;
 	globals: boolean;
 	base: string | undefined;
@@ -100,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: Config;
-	maxConcurrency: number;
 	defines: Record<string, any>;
 	expect: {
 		requireAssertions?: boolean;
@@ -126,13 +116,6 @@ interface SerializedConfig {
 		};
 	};
 	printConsoleTrace: boolean | undefined;
-	sequence: {
-		shuffle?: boolean;
-		concurrent?: boolean;
-		seed: number;
-		hooks: SequenceHooks;
-		setupFiles: SequenceSetupFiles;
-	};
 	deps: {
 		web: {
 			transformAssets?: boolean;
@@ -167,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: {
@@ -212,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;
@@ -234,9 +218,6 @@ interface SerializedConfig {
 			browserSdkPath?: string;
 		} | undefined;
 	};
-	tags: TestTagDefinition[];
-	tagsFilter: string[] | undefined;
-	strictTags: boolean;
 	mergeReportsLabel: string | undefined;
 	slowTestThreshold: number | undefined;
 	disableColors: boolean;

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.DVfzlTkU.js → defaults.CUUnbOrq.js}

@@ -5,11 +5,13 @@ 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/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.8_qjZdeE.js → globals.BuY-yD0m.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants.-juJ8b_4.js';
-import { i as index } from './index.ukHtlBbI.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() {