vitest 0.24.5 → 0.25.1

package/dist/cli-wrapper.js

@@ -1,20 +1,19 @@
 import { fileURLToPath } from 'url';
-import { p as picocolors, E as EXIT_CODE_RESTART } from './chunk-utils-env.b1281522.js';
-import { e as execa } from './vendor-index.cc8d244b.js';
+import { p as picocolors, E as EXIT_CODE_RESTART } from './chunk-utils-env.03f840f2.js';
+import { e as execa } from './vendor-index.737c3cff.js';
 import 'tty';
 import 'path';
 import 'buffer';
 import 'child_process';
 import 'process';
-import './vendor-index.12d51d29.js';
+import './vendor-index.e1d4cf84.js';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
+import 'assert';
+import 'events';
 import 'stream';
 import 'util';
 import 'os';
-import './vendor-index.1a291e86.js';
-import 'assert';
-import 'events';
 
 const ENTRY = new URL("./cli.js", import.meta.url);
 const NODE_ARGS = [

package/dist/cli.js

@@ -1,14 +1,14 @@
-import { p as picocolors, n as normalize } from './chunk-utils-env.b1281522.js';
+import { p as picocolors, n as normalize } from './chunk-utils-env.03f840f2.js';
 import { EventEmitter } from 'events';
-import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.d9033432.js';
+import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.477f36a4.js';
 import 'tty';
 import 'url';
 import 'path';
-import './chunk-integrations-coverage.cca09977.js';
+import './chunk-integrations-coverage.befed097.js';
 import 'local-pkg';
-import './chunk-env-node.700b7e95.js';
+import './chunk-env-node.67948209.js';
 import 'console';
-import './chunk-mock-date.030959d3.js';
+import './chunk-typecheck-constants.4891f22f.js';
 import 'vite';
 import 'process';
 import 'fs';
@@ -16,20 +16,27 @@ import 'os';
 import 'util';
 import 'stream';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-vite-node-client.3868b3ba.js';
+import './chunk-vite-node-client.b2ab6dcf.js';
 import 'module';
 import 'vm';
-import './chunk-vite-node-utils.2144000e.js';
+import './chunk-vite-node-utils.8f0b4a12.js';
+import 'acorn';
 import 'assert';
 import 'debug';
 import 'perf_hooks';
+import 'fs/promises';
+import './vendor-index.737c3cff.js';
+import 'buffer';
+import 'child_process';
+import './vendor-index.e1d4cf84.js';
+import 'source-map';
+import 'acorn-walk';
 import 'worker_threads';
 import 'tinypool';
-import './chunk-utils-timers.8fca243e.js';
-import './chunk-utils-source-map.663e2952.js';
+import './chunk-utils-timers.06f993db.js';
+import './chunk-utils-source-map.c6dfbbc1.js';
 import 'crypto';
 import './vendor-index.9c919048.js';
-import './vendor-index.1a291e86.js';
 import './chunk-magic-string.ffe2b171.js';
 import 'strip-literal';
 import 'readline';
@@ -655,6 +662,7 @@ cli.command("related [...filters]").action(runRelated);
 cli.command("watch [...filters]").action(watch);
 cli.command("dev [...filters]").action(watch);
 cli.command("bench [...filters]").action(benchmark);
+cli.command("typecheck [...filters]").action(typecheck);
 cli.command("[...filters]").action((filters, options) => start("test", filters, options));
 cli.parse();
 async function runRelated(relatedFiles, argv) {
@@ -674,6 +682,10 @@ async function benchmark(cliFilters, options) {
   console.warn(picocolors.exports.yellow("Benchmarking is an experimental feature.\nBreaking changes might not follow semver, please pin Vitest's version when using it."));
   await start("benchmark", cliFilters, options);
 }
+async function typecheck(cliFilters = [], options = {}) {
+  console.warn(picocolors.exports.yellow("Testing types with tsc and vue-tsc is an experimental feature.\nBreaking changes might not follow semver, please pin Vitest's version when using it."));
+  await start("typecheck", cliFilters, options);
+}
 function normalizeOptions(argv) {
   argv.root = argv.root && normalize(argv.root);
   argv.config = argv.config && normalize(argv.config);
@@ -682,13 +694,15 @@ function normalizeOptions(argv) {
 }
 async function start(mode, cliFilters, options) {
   try {
-    if (await startVitest(mode, cliFilters.map(normalize), normalizeOptions(options)) === false)
-      process.exit();
+    const ctx = await startVitest(mode, cliFilters.map(normalize), normalizeOptions(options));
+    if (!(ctx == null ? void 0 : ctx.config.watch))
+      await (ctx == null ? void 0 : ctx.exit());
+    return ctx;
   } catch (e) {
-    process.exitCode = 1;
     console.error(`
 ${picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(" Unhandled Error "))))}`);
     console.error(e);
     console.error("\n\n");
+    process.exit(1);
   }
 }

package/dist/config.cjs

@@ -76,7 +76,12 @@ const config = {
   coverage: coverageConfigDefaults,
   fakeTimers: fakeTimersDefaults,
   maxConcurrency: 5,
-  dangerouslyIgnoreUnhandledErrors: false
+  dangerouslyIgnoreUnhandledErrors: false,
+  typecheck: {
+    checker: "tsc",
+    include: ["**/*.{test,spec}-d.{ts,js}"],
+    exclude: defaultExclude
+  }
 };
 const configDefaults = Object.freeze(config);
 

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
 export { ConfigEnv } from 'vite';
-import { U as UserConfig$1, ad as ResolvedCoverageOptions, F as FakeTimerInstallOpts } from './global-58e8e951.js';
+import { U as UserConfig$1, ao as ResolvedCoverageOptions, F as FakeTimerInstallOpts } from './types-f302dae9.js';
 import 'tinybench';
 import 'fs';
 import 'worker_threads';
@@ -38,6 +38,11 @@ declare const config: {
     fakeTimers: FakeTimerInstallOpts;
     maxConcurrency: number;
     dangerouslyIgnoreUnhandledErrors: boolean;
+    typecheck: {
+        checker: "tsc";
+        include: string[];
+        exclude: string[];
+    };
 };
 declare const configDefaults: Required<Pick<UserConfig$1, keyof typeof config>>;
 

package/dist/config.js

@@ -72,7 +72,12 @@ const config = {
   coverage: coverageConfigDefaults,
   fakeTimers: fakeTimersDefaults,
   maxConcurrency: 5,
-  dangerouslyIgnoreUnhandledErrors: false
+  dangerouslyIgnoreUnhandledErrors: false,
+  typecheck: {
+    checker: "tsc",
+    include: ["**/*.{test,spec}-d.{ts,js}"],
+    exclude: defaultExclude
+  }
 };
 const configDefaults = Object.freeze(config);
 

package/dist/entry.js

@@ -1,26 +1,27 @@
 import { promises } from 'fs';
-import { g as getWorkerState, a as resetModules } from './chunk-mock-date.030959d3.js';
-import { a as envs } from './chunk-env-node.700b7e95.js';
-import { a as setupGlobalEnv, s as startTests, w as withEnv } from './chunk-runtime-setup.ab6b6274.js';
+import { g as getWorkerState, a as resetModules } from './chunk-typecheck-constants.4891f22f.js';
+import { v as vi } from './chunk-runtime-test-state.4ed42543.js';
+import { a as envs } from './chunk-env-node.67948209.js';
+import { a as setupGlobalEnv, s as startTests, w as withEnv } from './chunk-runtime-setup.5c4e0f49.js';
 import 'path';
-import './chunk-utils-env.b1281522.js';
+import './chunk-utils-env.03f840f2.js';
 import 'tty';
 import 'url';
 import 'local-pkg';
-import 'console';
-import 'perf_hooks';
-import './chunk-integrations-coverage.cca09977.js';
-import './chunk-runtime-hooks.d748b085.js';
-import './chunk-runtime-chain.37ec5d73.js';
+import './chunk-runtime-chain.e387e274.js';
 import 'util';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.b418c0ab.js';
-import './chunk-utils-timers.8fca243e.js';
-import './chunk-utils-source-map.663e2952.js';
+import './chunk-runtime-rpc.1e7530d3.js';
+import './chunk-utils-timers.06f993db.js';
+import './chunk-utils-source-map.c6dfbbc1.js';
 import './spy.js';
 import 'tinyspy';
-import './chunk-runtime-error.17751c39.js';
+import 'console';
+import 'perf_hooks';
+import './chunk-integrations-coverage.befed097.js';
+import './chunk-runtime-error.6287172c.js';
+import 'source-map';
 
 function groupBy(collection, iteratee) {
   return collection.reduce((acc, item) => {
@@ -72,6 +73,7 @@ async function run(files, config) {
           workerState.filepath = file;
           await startTests([file], config);
           workerState.filepath = void 0;
+          vi.resetConfig();
         }
       });
     }

package/dist/environments.d.ts

@@ -1,4 +1,4 @@
-import { a3 as Environment } from './global-58e8e951.js';
+import { ae as Environment } from './types-f302dae9.js';
 import 'vite';
 import 'tinybench';
 import 'fs';

package/dist/environments.js

@@ -1,3 +1,3 @@
-export { e as builtinEnvironments, p as populateGlobal } from './chunk-env-node.700b7e95.js';
+export { e as builtinEnvironments, p as populateGlobal } from './chunk-env-node.67948209.js';
 import 'console';
 import 'local-pkg';

package/dist/index-2f5b6168.d.ts

@@ -0,0 +1,256 @@
+import { SpyImpl } from 'tinyspy';
+import { w as SuiteAPI, v as TestAPI, aw as BenchmarkAPI, y as SuiteHooks, H as HookListener, L as TestContext, p as Suite, x as HookCleanupCallback, O as OnTestFailedHandler, q as Test } from './types-f302dae9.js';
+
+declare type Not<T extends boolean> = T extends true ? false : true;
+declare type And<Types extends boolean[]> = Types[number] extends true ? true : false;
+declare type Eq<Left extends boolean, Right extends boolean> = Left extends true ? Right : Not<Right>;
+declare const secret: unique symbol;
+declare type Secret = typeof secret;
+declare type IsNever<T> = [T] extends [never] ? true : false;
+declare type IsAny<T> = [T] extends [Secret] ? Not<IsNever<T>> : false;
+declare type IsUnknown<T> = [unknown] extends [T] ? Not<IsAny<T>> : false;
+/**
+ * Recursively walk a type and replace it with a branded type related to the original. This is useful for
+ * equality-checking stricter than `A extends B ? B extends A ? true : false : false`, because it detects
+ * the difference between a few edge-case types that vanilla typescript doesn't by default:
+ * - `any` vs `unknown`
+ * - `{ readonly a: string }` vs `{ a: string }`
+ * - `{ a?: string }` vs `{ a: string | undefined }`
+ */
+declare type DeepBrand<T> = IsNever<T> extends true ? {
+    type: 'never';
+} : IsAny<T> extends true ? {
+    type: 'any';
+} : IsUnknown<T> extends true ? {
+    type: 'unknown';
+} : T extends string | number | boolean | symbol | bigint | null | undefined | void ? {
+    type: 'primitive';
+    value: T;
+} : T extends new (...args: any[]) => any ? {
+    type: 'constructor';
+    params: ConstructorParams<T>;
+    instance: DeepBrand<InstanceType<Extract<T, new (...args: any) => any>>>;
+} : T extends (...args: infer P) => infer R ? {
+    type: 'function';
+    params: DeepBrand<P>;
+    return: DeepBrand<R>;
+} : T extends any[] ? {
+    type: 'array';
+    items: {
+        [K in keyof T]: T[K];
+    };
+} : {
+    type: 'object';
+    properties: {
+        [K in keyof T]: DeepBrand<T[K]>;
+    };
+    readonly: ReadonlyKeys<T>;
+    required: RequiredKeys<T>;
+    optional: OptionalKeys<T>;
+    constructorParams: DeepBrand<ConstructorParams<T>>;
+};
+declare type RequiredKeys<T> = Extract<{
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T], keyof T>;
+declare type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+declare type ReadonlyKeys<T> = Extract<{
+    [K in keyof T]-?: ReadonlyEquivalent<{
+        [_K in K]: T[K];
+    }, {
+        -readonly [_K in K]: T[K];
+    }> extends true ? never : K;
+}[keyof T], keyof T>;
+declare type ReadonlyEquivalent<X, Y> = Extends<(<T>() => T extends X ? true : false), (<T>() => T extends Y ? true : false)>;
+declare type Extends<L, R> = IsNever<L> extends true ? IsNever<R> : [L] extends [R] ? true : false;
+declare type StrictExtends<L, R> = Extends<DeepBrand<L>, DeepBrand<R>>;
+declare type Equal<Left, Right> = And<[StrictExtends<Left, Right>, StrictExtends<Right, Left>]>;
+declare type Params<Actual> = Actual extends (...args: infer P) => any ? P : never;
+declare type ConstructorParams<Actual> = Actual extends new (...args: infer P) => any ? Actual extends new () => any ? P | [] : P : never;
+declare type MismatchArgs<B extends boolean, C extends boolean> = Eq<B, C> extends true ? [] : [never];
+interface ExpectTypeOf<Actual, B extends boolean> {
+    toBeAny: (...MISMATCH: MismatchArgs<IsAny<Actual>, B>) => true;
+    toBeUnknown: (...MISMATCH: MismatchArgs<IsUnknown<Actual>, B>) => true;
+    toBeNever: (...MISMATCH: MismatchArgs<IsNever<Actual>, B>) => true;
+    toBeFunction: (...MISMATCH: MismatchArgs<Extends<Actual, (...args: any[]) => any>, B>) => true;
+    toBeObject: (...MISMATCH: MismatchArgs<Extends<Actual, object>, B>) => true;
+    toBeArray: (...MISMATCH: MismatchArgs<Extends<Actual, any[]>, B>) => true;
+    toBeNumber: (...MISMATCH: MismatchArgs<Extends<Actual, number>, B>) => true;
+    toBeString: (...MISMATCH: MismatchArgs<Extends<Actual, string>, B>) => true;
+    toBeBoolean: (...MISMATCH: MismatchArgs<Extends<Actual, boolean>, B>) => true;
+    toBeVoid: (...MISMATCH: MismatchArgs<Extends<Actual, void>, B>) => true;
+    toBeSymbol: (...MISMATCH: MismatchArgs<Extends<Actual, symbol>, B>) => true;
+    toBeNull: (...MISMATCH: MismatchArgs<Extends<Actual, null>, B>) => true;
+    toBeUndefined: (...MISMATCH: MismatchArgs<Extends<Actual, undefined>, B>) => true;
+    toBeNullable: (...MISMATCH: MismatchArgs<Not<Equal<Actual, NonNullable<Actual>>>, B>) => true;
+    toMatchTypeOf: {
+        <Expected>(...MISMATCH: MismatchArgs<Extends<Actual, Expected>, B>): true;
+        <Expected>(expected: Expected, ...MISMATCH: MismatchArgs<Extends<Actual, Expected>, B>): true;
+    };
+    toEqualTypeOf: {
+        <Expected>(...MISMATCH: MismatchArgs<Equal<Actual, Expected>, B>): true;
+        <Expected>(expected: Expected, ...MISMATCH: MismatchArgs<Equal<Actual, Expected>, B>): true;
+    };
+    toBeCallableWith: B extends true ? (...args: Params<Actual>) => true : never;
+    toBeConstructibleWith: B extends true ? (...args: ConstructorParams<Actual>) => true : never;
+    toHaveProperty: <K extends string>(key: K, ...MISMATCH: MismatchArgs<Extends<K, keyof Actual>, B>) => K extends keyof Actual ? ExpectTypeOf<Actual[K], B> : true;
+    extract: <V>(v?: V) => ExpectTypeOf<Extract<Actual, V>, B>;
+    exclude: <V>(v?: V) => ExpectTypeOf<Exclude<Actual, V>, B>;
+    parameter: <K extends keyof Params<Actual>>(number: K) => ExpectTypeOf<Params<Actual>[K], B>;
+    parameters: ExpectTypeOf<Params<Actual>, B>;
+    constructorParameters: ExpectTypeOf<ConstructorParams<Actual>, B>;
+    instance: Actual extends new (...args: any[]) => infer I ? ExpectTypeOf<I, B> : never;
+    returns: Actual extends (...args: any[]) => infer R ? ExpectTypeOf<R, B> : never;
+    resolves: Actual extends PromiseLike<infer R> ? ExpectTypeOf<R, B> : never;
+    items: Actual extends ArrayLike<infer R> ? ExpectTypeOf<R, B> : never;
+    guards: Actual extends (v: any, ...args: any[]) => v is infer T ? ExpectTypeOf<T, B> : never;
+    asserts: Actual extends (v: any, ...args: any[]) => asserts v is infer T ? unknown extends T ? never : ExpectTypeOf<T, B> : never;
+    not: ExpectTypeOf<Actual, Not<B>>;
+}
+declare type _ExpectTypeOf = {
+    <Actual>(actual: Actual): ExpectTypeOf<Actual, true>;
+    <Actual>(): ExpectTypeOf<Actual, true>;
+};
+/**
+ * Similar to Jest's `expect`, but with type-awareness.
+ * Gives you access to a number of type-matchers that let you make assertions about the
+ * form of a reference or generic type parameter.
+ *
+ * @example
+ * import {foo, bar} from '../foo'
+ * import {expectTypeOf} from 'expect-type'
+ *
+ * test('foo types', () => {
+ *   // make sure `foo` has type {a: number}
+ *   expectTypeOf(foo).toMatchTypeOf({a: 1})
+ *   expectTypeOf(foo).toHaveProperty('a').toBeNumber()
+ *
+ *   // make sure `bar` is a function taking a string:
+ *   expectTypeOf(bar).parameter(0).toBeString()
+ *   expectTypeOf(bar).returns.not.toBeAny()
+ * })
+ *
+ * @description
+ * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples.
+ */
+declare const expectTypeOf: _ExpectTypeOf;
+
+interface AssertType {
+    <T>(value: T): void;
+}
+declare const assertType: AssertType;
+
+interface MockResultReturn<T> {
+    type: 'return';
+    value: T;
+}
+interface MockResultIncomplete {
+    type: 'incomplete';
+    value: undefined;
+}
+interface MockResultThrow {
+    type: 'throw';
+    value: any;
+}
+declare type MockResult<T> = MockResultReturn<T> | MockResultThrow | MockResultIncomplete;
+interface MockContext<TArgs, TReturns> {
+    calls: TArgs[];
+    instances: TReturns[];
+    invocationCallOrder: number[];
+    results: MockResult<TReturns>[];
+    lastCall: TArgs | undefined;
+}
+declare type Procedure = (...args: any[]) => any;
+declare type Methods<T> = {
+    [K in keyof T]: T[K] extends Procedure ? K : never;
+}[keyof T] & (string | symbol);
+declare type Properties<T> = {
+    [K in keyof T]: T[K] extends Procedure ? never : K;
+}[keyof T] & (string | symbol);
+declare type Classes<T> = {
+    [K in keyof T]: T[K] extends new (...args: any[]) => any ? K : never;
+}[keyof T] & (string | symbol);
+interface SpyInstance<TArgs extends any[] = any[], TReturns = any> {
+    getMockName(): string;
+    mockName(n: string): this;
+    mock: MockContext<TArgs, TReturns>;
+    mockClear(): this;
+    mockReset(): this;
+    mockRestore(): void;
+    getMockImplementation(): ((...args: TArgs) => TReturns) | undefined;
+    mockImplementation(fn: ((...args: TArgs) => TReturns) | (() => Promise<TReturns>)): this;
+    mockImplementationOnce(fn: ((...args: TArgs) => TReturns) | (() => Promise<TReturns>)): this;
+    mockReturnThis(): this;
+    mockReturnValue(obj: TReturns): this;
+    mockReturnValueOnce(obj: TReturns): this;
+    mockResolvedValue(obj: Awaited<TReturns>): this;
+    mockResolvedValueOnce(obj: Awaited<TReturns>): this;
+    mockRejectedValue(obj: any): this;
+    mockRejectedValueOnce(obj: any): this;
+}
+interface MockInstance<A extends any[] = any[], R = any> extends SpyInstance<A, R> {
+}
+interface Mock<TArgs extends any[] = any, TReturns = any> extends SpyInstance<TArgs, TReturns> {
+    new (...args: TArgs): TReturns;
+    (...args: TArgs): TReturns;
+}
+interface PartialMock<TArgs extends any[] = any, TReturns = any> extends SpyInstance<TArgs, Partial<TReturns>> {
+    new (...args: TArgs): TReturns;
+    (...args: TArgs): TReturns;
+}
+declare type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R ? Mock<ConstructorParameters<T>, R> : T;
+declare type MockedFunction<T extends Procedure> = Mock<Parameters<T>, ReturnType<T>> & {
+    [K in keyof T]: T[K];
+};
+declare type PartiallyMockedFunction<T extends Procedure> = PartialMock<Parameters<T>, ReturnType<T>> & {
+    [K in keyof T]: T[K];
+};
+declare type MockedFunctionDeep<T extends Procedure> = Mock<Parameters<T>, ReturnType<T>> & MockedObjectDeep<T>;
+declare type PartiallyMockedFunctionDeep<T extends Procedure> = PartialMock<Parameters<T>, ReturnType<T>> & MockedObjectDeep<T>;
+declare type MockedObject<T> = MaybeMockedConstructor<T> & {
+    [K in Methods<T>]: T[K] extends Procedure ? MockedFunction<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: T[K];
+};
+declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
+    [K in Methods<T>]: T[K] extends Procedure ? MockedFunctionDeep<T[K]> : T[K];
+} & {
+    [K in Properties<T>]: MaybeMockedDeep<T[K]>;
+};
+declare type MaybeMockedDeep<T> = T extends Procedure ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+declare type MaybePartiallyMockedDeep<T> = T extends Procedure ? PartiallyMockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+declare type MaybeMocked<T> = T extends Procedure ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+declare type MaybePartiallyMocked<T> = T extends Procedure ? PartiallyMockedFunction<T> : T extends object ? MockedObject<T> : T;
+interface Constructable {
+    new (...args: any[]): any;
+}
+declare type MockedClass<T extends Constructable> = MockInstance<T extends new (...args: infer P) => any ? P : never, InstanceType<T>> & {
+    prototype: T extends {
+        prototype: any;
+    } ? Mocked<T['prototype']> : never;
+} & T;
+declare type Mocked<T> = {
+    [P in keyof T]: T[P] extends (...args: infer Args) => infer Returns ? MockInstance<Args, Returns> : T[P] extends Constructable ? MockedClass<T[P]> : T[P];
+} & T;
+declare type EnhancedSpy<TArgs extends any[] = any[], TReturns = any> = SpyInstance<TArgs, TReturns> & SpyImpl<TArgs, TReturns>;
+declare function spyOn<T, S extends Properties<Required<T>>>(obj: T, methodName: S, accessType: 'get'): SpyInstance<[], T[S]>;
+declare function spyOn<T, G extends Properties<Required<T>>>(obj: T, methodName: G, accessType: 'set'): SpyInstance<[T[G]], void>;
+declare function spyOn<T, M extends (Methods<Required<T>> | Classes<Required<T>>)>(obj: T, methodName: M): Required<T>[M] extends (...args: infer A) => infer R | (new (...args: infer A) => infer R) ? SpyInstance<A, R> : never;
+declare function fn<TArgs extends any[] = any[], R = any>(): Mock<TArgs, R>;
+declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): Mock<TArgs, R>;
+
+declare const suite: SuiteAPI<{}>;
+declare const test: TestAPI<{}>;
+declare const bench: BenchmarkAPI;
+declare const describe: SuiteAPI<{}>;
+declare const it: TestAPI<{}>;
+
+declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number) => void;
+declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number) => void;
+declare const beforeEach: <ExtraContext = {}>(fn: HookListener<[TestContext & ExtraContext, Suite], HookCleanupCallback>, timeout?: number) => void;
+declare const afterEach: <ExtraContext = {}>(fn: HookListener<[TestContext & ExtraContext, Suite], void>, timeout?: number) => void;
+declare const onTestFailed: (fn: OnTestFailedHandler) => void;
+
+declare function createExpect(test?: Test): Vi.ExpectStatic;
+declare const globalExpect: Vi.ExpectStatic;
+
+export { AssertType as A, MockedClass as B, EnhancedSpy as E, MaybeMockedDeep as M, SpyInstance as S, MaybeMocked as a, MaybePartiallyMocked as b, MaybePartiallyMockedDeep as c, suite as d, describe as e, fn as f, bench as g, beforeAll as h, it as i, afterAll as j, beforeEach as k, afterEach as l, globalExpect as m, createExpect as n, onTestFailed as o, expectTypeOf as p, ExpectTypeOf as q, assertType as r, spyOn as s, test as t, MockedFunction as u, MockedObject as v, MockInstance as w, Mock as x, MockContext as y, Mocked as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-220c1d70.js';
-export { E as EnhancedSpy, r as Mock, u as MockContext, q as MockInstance, v as Mocked, w as MockedClass, o as MockedFunction, p as MockedObject, S as SpyInstance, j as afterAll, l as afterEach, h as beforeAll, k as beforeEach, g as bench, n as createExpect, e as describe, m as expect, i as it, d as suite, t as test } from './index-220c1d70.js';
-import { D as DoneCallback, F as FakeTimerInstallOpts, a as File, T as TaskResultPack, R as ResolvedConfig, M as ModuleGraphData, b as Reporter } from './global-58e8e951.js';
-export { L as AfterSuiteRunMeta, A as ApiConfig, Y as ArgumentsType, X as Arrayable, P as Awaitable, ae as BaseCoverageOptions, ak as BenchFunction, ai as Benchmark, al as BenchmarkAPI, aj as BenchmarkResult, ah as BenchmarkUserOptions, B as BuiltinEnvironment, C as CSSModuleScopeStrategy, a0 as Constructable, ag as CoverageC8Options, af as CoverageIstanbulOptions, ac as CoverageOptions, a9 as CoverageProvider, aa as CoverageProviderModule, ab as CoverageReporter, _ as DeepMerge, D as DoneCallback, a3 as Environment, E as EnvironmentOptions, a2 as EnvironmentReturn, a7 as ErrorWithDiff, a as File, n as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, Z as MergeInsertions, a1 as ModuleCache, M as ModuleGraphData, $ as MutableArray, Q as Nullable, a8 as OnServerRestartHandler, a6 as ParsedStack, a5 as Position, b as Reporter, K as ResolveIdFunction, R as ResolvedConfig, ad as ResolvedCoverageOptions, d as RunMode, r as RuntimeContext, u as SnapshotData, x as SnapshotMatchOptions, y as SnapshotResult, w as SnapshotStateOptions, G as SnapshotSummary, v as SnapshotUpdateState, S as Suite, m as SuiteAPI, p as SuiteCollector, q as SuiteFactory, o as SuiteHooks, i as Task, f as TaskBase, g as TaskResult, T as TaskResultPack, e as TaskState, h as Test, l as TestAPI, s as TestContext, j as TestFunction, k as TestOptions, z as UncheckedSnapshot, U as UserConfig, a4 as UserConsoleLog, t as Vitest, V as VitestEnvironment, c as VitestRunMode, W as WorkerContext, O as WorkerGlobalState, N as WorkerRPC } from './global-58e8e951.js';
+import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-2f5b6168.js';
+export { A as AssertType, E as EnhancedSpy, q as ExpectTypeOf, x as Mock, y as MockContext, w as MockInstance, z as Mocked, B as MockedClass, u as MockedFunction, v as MockedObject, S as SpyInstance, j as afterAll, l as afterEach, r as assertType, h as beforeAll, k as beforeEach, g as bench, n as createExpect, e as describe, m as expect, p as expectTypeOf, i as it, o as onTestFailed, d as suite, t as test } from './index-2f5b6168.js';
+import { D as DoneCallback, F as FakeTimerInstallOpts, R as RuntimeConfig, a as File, T as TaskResultPack, b as ResolvedConfig, M as ModuleGraphData, c as Reporter } from './types-f302dae9.js';
+export { a1 as AfterSuiteRunMeta, A as ApiConfig, a7 as ArgumentsType, a6 as Arrayable, a4 as Awaitable, ap as BaseCoverageOptions, av as BenchFunction, at as Benchmark, aw as BenchmarkAPI, au as BenchmarkResult, as as BenchmarkUserOptions, B as BuiltinEnvironment, i as CSSModuleScopeStrategy, C as CollectLineNumbers, f as CollectLines, ab as Constructable, h as Context, ar as CoverageC8Options, aq as CoverageIstanbulOptions, an as CoverageOptions, ak as CoverageProvider, al as CoverageProviderModule, am as CoverageReporter, a9 as DeepMerge, D as DoneCallback, ae as Environment, E as EnvironmentOptions, ad as EnvironmentReturn, ai as ErrorWithDiff, a as File, x as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, a8 as MergeInsertions, ac as ModuleCache, M as ModuleGraphData, aa as MutableArray, a5 as Nullable, aj as OnServerRestartHandler, O as OnTestFailedHandler, ah as ParsedStack, ag as Position, d as RawErrsMap, c as Reporter, a0 as ResolveIdFunction, b as ResolvedConfig, ao as ResolvedCoverageOptions, g as RootAndTarget, l as RunMode, R as RuntimeConfig, K as RuntimeContext, S as SequenceHooks, P as SnapshotData, X as SnapshotMatchOptions, Y as SnapshotResult, W as SnapshotStateOptions, _ as SnapshotSummary, Q as SnapshotUpdateState, p as Suite, w as SuiteAPI, z as SuiteCollector, G as SuiteFactory, y as SuiteHooks, s as Task, n as TaskBase, o as TaskResult, T as TaskResultPack, m as TaskState, q as Test, v as TestAPI, L as TestContext, t as TestFunction, u as TestOptions, e as TscErrorInfo, r as TypeCheck, k as TypecheckConfig, Z as UncheckedSnapshot, U as UserConfig, af as UserConsoleLog, N as Vitest, V as VitestEnvironment, j as VitestRunMode, $ as WorkerContext, a3 as WorkerGlobalState, a2 as WorkerRPC } from './types-f302dae9.js';
 import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
@@ -149,6 +149,15 @@ declare class VitestUtils {
      * importing a module, that you cannot wait otherwise.
      */
     dynamicImportSettled(): Promise<void>;
+    private _config;
+    /**
+     * Updates runtime config. You can only change values that are used when executing tests.
+     */
+    setConfig(config: RuntimeConfig): void;
+    /**
+     * If config was changed with `vi.setConfig`, this will reset it to the original state.
+     */
+    resetConfig(): void;
 }
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;

package/dist/index.js

@@ -1,19 +1,25 @@
-export { b as bench, c as createExpect, d as describe, e as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.37ec5d73.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, h as getRunningMode, f as isFirstRun, j as isWatchMode, e as runOnce, v as vi, g as vitest, w as withCallback } from './chunk-runtime-hooks.d748b085.js';
+export { b as bench, c as createExpect, d as describe, e as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.e387e274.js';
+import { e as dist } from './chunk-runtime-test-state.4ed42543.js';
+export { a as afterAll, d as afterEach, f as assertType, b as beforeAll, c as beforeEach, k as getRunningMode, h as isFirstRun, l as isWatchMode, o as onTestFailed, g as runOnce, v as vi, j as vitest, w as withCallback } from './chunk-runtime-test-state.4ed42543.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import 'util';
-import './chunk-mock-date.030959d3.js';
+import './chunk-typecheck-constants.4891f22f.js';
 import 'path';
-import './chunk-utils-env.b1281522.js';
+import './chunk-utils-env.03f840f2.js';
 import 'tty';
 import 'url';
 import 'local-pkg';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.b418c0ab.js';
-import './chunk-utils-timers.8fca243e.js';
+import './chunk-runtime-rpc.1e7530d3.js';
+import './chunk-utils-timers.06f993db.js';
 import 'fs';
-import './chunk-utils-source-map.663e2952.js';
+import './chunk-utils-source-map.c6dfbbc1.js';
 import './spy.js';
 import 'tinyspy';
+
+
+
+var expectTypeOf = dist.expectTypeOf;
+export { expectTypeOf };

package/dist/loader.js

@@ -1,11 +1,12 @@
 import { pathToFileURL } from 'url';
 import { readFile } from 'fs/promises';
-import { i as isNodeBuiltin, d as normalizeModuleId, h as hasCJSSyntax } from './chunk-vite-node-utils.2144000e.js';
-import { g as getWorkerState } from './chunk-mock-date.030959d3.js';
+import { i as isNodeBuiltin, d as normalizeModuleId, h as hasCJSSyntax } from './chunk-vite-node-utils.8f0b4a12.js';
+import { g as getWorkerState } from './chunk-typecheck-constants.4891f22f.js';
 import 'fs';
-import './chunk-utils-env.b1281522.js';
+import './chunk-utils-env.03f840f2.js';
 import 'tty';
 import 'path';
+import 'acorn';
 import 'module';
 import 'assert';
 import 'util';

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { c as VitestRunMode, U as UserConfig, t as Vitest, am as ModuleCacheMap, an as ViteNodeRunnerOptions, ao as MockMap, ap as ViteNodeRunner, aq as TestSequencer } from './global-58e8e951.js';
-export { aq as TestSequencer, as as TestSequencerConstructor, t as Vitest, ar as startVitest } from './global-58e8e951.js';
+import { j as VitestRunMode, U as UserConfig, N as Vitest, ax as ModuleCacheMap, ay as ViteNodeRunnerOptions, az as MockMap, aA as ViteNodeRunner, aB as TestSequencer } from './types-f302dae9.js';
+export { aB as TestSequencer, aD as TestSequencerConstructor, N as Vitest, aC as startVitest } from './types-f302dae9.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import 'tinybench';
 import 'fs';

package/dist/node.js

@@ -1,14 +1,14 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.d9033432.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.41b92ec9.js';
-import './chunk-utils-env.b1281522.js';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.477f36a4.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.503a4f67.js';
+import './chunk-utils-env.03f840f2.js';
 import 'tty';
 import 'url';
 import 'path';
-import './chunk-integrations-coverage.cca09977.js';
+import './chunk-integrations-coverage.befed097.js';
 import 'local-pkg';
-import './chunk-env-node.700b7e95.js';
+import './chunk-env-node.67948209.js';
 import 'console';
-import './chunk-mock-date.030959d3.js';
+import './chunk-typecheck-constants.4891f22f.js';
 import 'vite';
 import 'process';
 import 'fs';
@@ -17,20 +17,27 @@ import 'util';
 import 'stream';
 import 'events';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-vite-node-client.3868b3ba.js';
+import './chunk-vite-node-client.b2ab6dcf.js';
 import 'module';
 import 'vm';
-import './chunk-vite-node-utils.2144000e.js';
+import './chunk-vite-node-utils.8f0b4a12.js';
+import 'acorn';
 import 'assert';
 import 'debug';
 import 'perf_hooks';
+import 'fs/promises';
+import './vendor-index.737c3cff.js';
+import 'buffer';
+import 'child_process';
+import './vendor-index.e1d4cf84.js';
+import 'source-map';
+import 'acorn-walk';
 import 'worker_threads';
 import 'tinypool';
-import './chunk-utils-timers.8fca243e.js';
-import './chunk-utils-source-map.663e2952.js';
+import './chunk-utils-timers.06f993db.js';
+import './chunk-utils-source-map.c6dfbbc1.js';
 import 'crypto';
 import './vendor-index.9c919048.js';
-import './vendor-index.1a291e86.js';
 import './chunk-magic-string.ffe2b171.js';
 import 'strip-literal';
 import 'readline';