vitest 0.12.5 → 0.12.8

package/dist/cli.js

@@ -1,13 +1,14 @@
 import { EventEmitter } from 'events';
-import { p as picocolors } from './chunk-utils-global.03413604.js';
-import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.8560ca65.js';
+import { p as picocolors } from './chunk-utils-global.2fab7e5c.js';
+import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.fc385bba.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'buffer';
 import 'child_process';
 import 'process';
-import './vendor-index.4e550a2c.js';
+import './vendor-index.6c69a0a8.js';
+import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
 import 'assert';
 import 'stream';
@@ -15,17 +16,18 @@ import 'util';
 import 'url';
 import 'os';
 import 'vite';
-import './chunk-constants.153353ee.js';
+import './chunk-constants.3570739f.js';
 import 'readline';
-import './chunk-vite-node-utils.1064f66b.js';
+import './chunk-vite-node-utils.46e2a803.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.374342ed.js';
+import 'debug';
+import './chunk-defaults.7d81a6ca.js';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-timers.a0f0fe66.js';
-import './chunk-magic-string.d5e0e473.js';
+import './chunk-utils-timers.da6ac0a6.js';
+import './chunk-magic-string.41232190.js';
 import './vendor-index.405e58ef.js';
 
 function toArr(any) {
@@ -642,7 +644,7 @@ class CAC extends EventEmitter {
 const cac = (name = "") => new CAC(name);
 
 const cli = cac("vitest");
-cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-t, --testNamePattern <pattern>", "run tests with full names matching the specified pattern").option("--dir <path>", "base directory to scan for the test files").option("--ui", "enable UI").option("--open", "open UI automatically (default: !process.env.CI))").option("--api [api]", "serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "enabled threads (default: true)").option("--silent", "silent console output from tests").option("--isolate", "isolate environment for each test file (default: true)").option("--reporter <name>", "reporter").option("--outputTruncateLength <length>", "diff output length").option("--outputFile <filename/-s>", "write test results to a file when the --reporter=json or --reporter=junit option is also specified, use cac's dot notation for individual outputs of mutliple reporters").option("--coverage", "use c8 for coverage").option("--run", "do not watch").option("--mode <name>", "override Vite mode (default: test)").option("--globals", "inject apis globally").option("--global", "deprecated, use --globals").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment (default: node)").option("--passWithNoTests", "pass when no tests found").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").help();
+cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-t, --testNamePattern <pattern>", "run tests with full names matching the specified pattern").option("--dir <path>", "base directory to scan for the test files").option("--ui", "enable UI").option("--open", "open UI automatically (default: !process.env.CI))").option("--api [api]", "serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "enabled threads (default: true)").option("--silent", "silent console output from tests").option("--isolate", "isolate environment for each test file (default: true)").option("--reporter <name>", "reporter").option("--outputTruncateLength <length>", "diff output length").option("--outputFile <filename/-s>", "write test results to a file when the --reporter=json or --reporter=junit option is also specified, use cac's dot notation for individual outputs of mutliple reporters").option("--coverage", "use c8 for coverage").option("--run", "do not watch").option("--mode <name>", "override Vite mode (default: test)").option("--globals", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment (default: node)").option("--passWithNoTests", "pass when no tests found").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").help();
 cli.command("run [...filters]").action(run);
 cli.command("related [...filters]").action(runRelated);
 cli.command("watch [...filters]").action(start);

package/dist/config.d.ts

@@ -1,4 +1,5 @@
-import { UserConfig as UserConfig$2 } from 'vite';
+import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
+export { ConfigEnv } from 'vite';
 import { UserConfig as UserConfig$1, ResolvedC8Options } from 'vitest';
 
 // Type definitions for @sinonjs/fake-timers 8.1
@@ -98,6 +99,8 @@ interface UserConfig extends UserConfig$2 {
     test?: UserConfig$2['test'];
 }
 
-declare function defineConfig(config: UserConfig): UserConfig;
+declare type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
+declare type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFn;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
 
-export { UserConfig, configDefaults, defineConfig };
+export { UserConfig, UserConfigExport, UserConfigFn, configDefaults, defineConfig };

package/dist/entry.js

@@ -1,16 +1,17 @@
-export { r as run } from './vendor-entry.5b810598.js';
+export { r as run } from './vendor-entry.ca05c118.js';
 import 'fs';
-import './chunk-utils-global.03413604.js';
+import './chunk-utils-global.2fab7e5c.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './chunk-runtime-chain.eb563278.js';
+import './chunk-runtime-chain.5021a6b6.js';
 import 'chai';
-import './chunk-runtime-rpc.ef131645.js';
-import './chunk-utils-timers.a0f0fe66.js';
+import './vendor-_commonjsHelpers.addc3445.js';
+import './chunk-runtime-rpc.47bae3f9.js';
+import './chunk-utils-timers.da6ac0a6.js';
 import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.374342ed.js';
+import './chunk-defaults.7d81a6ca.js';
 import 'module';
 import 'url';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { ViteDevServer, TransformResult, CommonServerOptions } from 'vite';
-import { MessagePort } from 'worker_threads';
 import { SpyImpl } from 'tinyspy';
+import { MessagePort } from 'worker_threads';
 export { assert, default as chai, should } from 'chai';
 
 /**
@@ -90,112 +90,6 @@ declare type OldPlugin = {
 declare type Plugin = NewPlugin | OldPlugin;
 declare type Plugins = Array<Plugin>;
 
-declare type Formatter = (input: string | number | null | undefined) => string;
-
-declare const EXPECTED_COLOR: Formatter;
-declare const RECEIVED_COLOR: Formatter;
-declare const INVERTED_COLOR: Formatter;
-declare const BOLD_WEIGHT: Formatter;
-declare const DIM_COLOR: Formatter;
-interface MatcherHintOptions {
-    comment?: string;
-    expectedColor?: Formatter;
-    isDirectExpectCall?: boolean;
-    isNot?: boolean;
-    promise?: string;
-    receivedColor?: Formatter;
-    secondArgument?: string;
-    secondArgumentColor?: Formatter;
-}
-declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
-declare function stringify(object: unknown, maxDepth?: number, options?: PrettyFormatOptions): string;
-declare const printReceived: (object: unknown) => string;
-declare const printExpected: (value: unknown) => string;
-interface DiffOptions {
-    aAnnotation?: string;
-    aColor?: Formatter;
-    aIndicator?: string;
-    bAnnotation?: string;
-    bColor?: Formatter;
-    bIndicator?: string;
-    changeColor?: Formatter;
-    changeLineTrailingSpaceColor?: Formatter;
-    commonColor?: Formatter;
-    commonIndicator?: string;
-    commonLineTrailingSpaceColor?: Formatter;
-    contextLines?: number;
-    emptyFirstOrLastLinePlaceholder?: string;
-    expand?: boolean;
-    includeChangeCounts?: boolean;
-    omitAnnotationLines?: boolean;
-    patchColor?: Formatter;
-    compareKeys?: any;
-}
-declare function diff(a: any, b: any, options?: DiffOptions): string;
-
-declare const jestMatcherUtils_EXPECTED_COLOR: typeof EXPECTED_COLOR;
-declare const jestMatcherUtils_RECEIVED_COLOR: typeof RECEIVED_COLOR;
-declare const jestMatcherUtils_INVERTED_COLOR: typeof INVERTED_COLOR;
-declare const jestMatcherUtils_BOLD_WEIGHT: typeof BOLD_WEIGHT;
-declare const jestMatcherUtils_DIM_COLOR: typeof DIM_COLOR;
-type jestMatcherUtils_MatcherHintOptions = MatcherHintOptions;
-declare const jestMatcherUtils_matcherHint: typeof matcherHint;
-declare const jestMatcherUtils_stringify: typeof stringify;
-declare const jestMatcherUtils_printReceived: typeof printReceived;
-declare const jestMatcherUtils_printExpected: typeof printExpected;
-type jestMatcherUtils_DiffOptions = DiffOptions;
-declare const jestMatcherUtils_diff: typeof diff;
-declare namespace jestMatcherUtils {
-  export {
-    jestMatcherUtils_EXPECTED_COLOR as EXPECTED_COLOR,
-    jestMatcherUtils_RECEIVED_COLOR as RECEIVED_COLOR,
-    jestMatcherUtils_INVERTED_COLOR as INVERTED_COLOR,
-    jestMatcherUtils_BOLD_WEIGHT as BOLD_WEIGHT,
-    jestMatcherUtils_DIM_COLOR as DIM_COLOR,
-    jestMatcherUtils_MatcherHintOptions as MatcherHintOptions,
-    jestMatcherUtils_matcherHint as matcherHint,
-    jestMatcherUtils_stringify as stringify,
-    jestMatcherUtils_printReceived as printReceived,
-    jestMatcherUtils_printExpected as printExpected,
-    jestMatcherUtils_DiffOptions as DiffOptions,
-    jestMatcherUtils_diff as diff,
-  };
-}
-
-declare type Tester = (a: any, b: any) => boolean | undefined;
-interface MatcherState {
-    assertionCalls: number;
-    currentTestName?: string;
-    dontThrow?: () => void;
-    error?: Error;
-    equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
-    expand?: boolean;
-    expectedAssertionsNumber?: number | null;
-    expectedAssertionsNumberErrorGen?: (() => Error) | null;
-    isExpectingAssertions?: boolean;
-    isExpectingAssertionsError?: Error | null;
-    isNot: boolean;
-    promise: string;
-    suppressedErrors: Array<Error>;
-    testPath?: string;
-    utils: typeof jestMatcherUtils & {
-        iterableEquality: Tester;
-        subsetEquality: Tester;
-    };
-}
-interface SyncExpectationResult {
-    pass: boolean;
-    message: () => string;
-    actual?: any;
-    expected?: any;
-}
-declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
-declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
-interface RawMatcherFn<T extends MatcherState = MatcherState> {
-    (this: T, received: any, expected: any, options?: any): ExpectationResult;
-}
-declare type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
-
 // Type definitions for @sinonjs/fake-timers 8.1
 // Project: https://github.com/sinonjs/fake-timers
 // Definitions by: Wim Looman <https://github.com/Nemo157>
@@ -1292,6 +1186,218 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     api?: ApiConfig;
 }
 
+declare type VitestInlineConfig = InlineConfig;
+declare module 'vite' {
+    interface UserConfig {
+        /**
+         * Options for Vitest
+         */
+        test?: VitestInlineConfig;
+    }
+}
+
+declare type Formatter = (input: string | number | null | undefined) => string;
+
+interface MatcherHintOptions {
+    comment?: string;
+    expectedColor?: Formatter;
+    isDirectExpectCall?: boolean;
+    isNot?: boolean;
+    promise?: string;
+    receivedColor?: Formatter;
+    secondArgument?: string;
+    secondArgumentColor?: Formatter;
+}
+interface DiffOptions {
+    aAnnotation?: string;
+    aColor?: Formatter;
+    aIndicator?: string;
+    bAnnotation?: string;
+    bColor?: Formatter;
+    bIndicator?: string;
+    changeColor?: Formatter;
+    changeLineTrailingSpaceColor?: Formatter;
+    commonColor?: Formatter;
+    commonIndicator?: string;
+    commonLineTrailingSpaceColor?: Formatter;
+    contextLines?: number;
+    emptyFirstOrLastLinePlaceholder?: string;
+    expand?: boolean;
+    includeChangeCounts?: boolean;
+    omitAnnotationLines?: boolean;
+    patchColor?: Formatter;
+    compareKeys?: any;
+}
+
+declare const EXPECTED_COLOR: Formatter;
+declare const RECEIVED_COLOR: Formatter;
+declare const INVERTED_COLOR: Formatter;
+declare const BOLD_WEIGHT: Formatter;
+declare const DIM_COLOR: Formatter;
+declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
+declare function stringify(object: unknown, maxDepth?: number, options?: PrettyFormatOptions): string;
+declare const printReceived: (object: unknown) => string;
+declare const printExpected: (value: unknown) => string;
+declare function diff(a: any, b: any, options?: DiffOptions): string;
+
+declare const jestMatcherUtils_EXPECTED_COLOR: typeof EXPECTED_COLOR;
+declare const jestMatcherUtils_RECEIVED_COLOR: typeof RECEIVED_COLOR;
+declare const jestMatcherUtils_INVERTED_COLOR: typeof INVERTED_COLOR;
+declare const jestMatcherUtils_BOLD_WEIGHT: typeof BOLD_WEIGHT;
+declare const jestMatcherUtils_DIM_COLOR: typeof DIM_COLOR;
+declare const jestMatcherUtils_matcherHint: typeof matcherHint;
+declare const jestMatcherUtils_stringify: typeof stringify;
+declare const jestMatcherUtils_printReceived: typeof printReceived;
+declare const jestMatcherUtils_printExpected: typeof printExpected;
+declare const jestMatcherUtils_diff: typeof diff;
+declare namespace jestMatcherUtils {
+  export {
+    jestMatcherUtils_EXPECTED_COLOR as EXPECTED_COLOR,
+    jestMatcherUtils_RECEIVED_COLOR as RECEIVED_COLOR,
+    jestMatcherUtils_INVERTED_COLOR as INVERTED_COLOR,
+    jestMatcherUtils_BOLD_WEIGHT as BOLD_WEIGHT,
+    jestMatcherUtils_DIM_COLOR as DIM_COLOR,
+    jestMatcherUtils_matcherHint as matcherHint,
+    jestMatcherUtils_stringify as stringify,
+    jestMatcherUtils_printReceived as printReceived,
+    jestMatcherUtils_printExpected as printExpected,
+    jestMatcherUtils_diff as diff,
+  };
+}
+
+declare type Tester = (a: any, b: any) => boolean | undefined;
+interface MatcherState {
+    assertionCalls: number;
+    currentTestName?: string;
+    dontThrow?: () => void;
+    error?: Error;
+    equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
+    expand?: boolean;
+    expectedAssertionsNumber?: number | null;
+    expectedAssertionsNumberErrorGen?: (() => Error) | null;
+    isExpectingAssertions?: boolean;
+    isExpectingAssertionsError?: Error | null;
+    isNot: boolean;
+    promise: string;
+    suppressedErrors: Array<Error>;
+    testPath?: string;
+    utils: typeof jestMatcherUtils & {
+        iterableEquality: Tester;
+        subsetEquality: Tester;
+    };
+}
+interface SyncExpectationResult {
+    pass: boolean;
+    message: () => string;
+    actual?: any;
+    expected?: any;
+}
+declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
+declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+interface RawMatcherFn<T extends MatcherState = MatcherState> {
+    (this: T, received: any, expected: any, options?: any): ExpectationResult;
+}
+declare type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
+
+declare type Promisify<O> = {
+    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
+};
+declare global {
+    namespace jest {
+        interface Matchers<R, T = {}> {
+        }
+    }
+    namespace Vi {
+        interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {
+            <T>(actual: T, message?: string): Vi.Assertion<T>;
+            extend(expects: MatchersObject): void;
+            assertions(expected: number): void;
+            hasAssertions(): void;
+            anything(): any;
+            any(constructor: unknown): any;
+            addSnapshotSerializer(plugin: Plugin): void;
+            getState(): MatcherState;
+            setState(state: Partial<MatcherState>): void;
+            not: AsymmetricMatchersContaining;
+        }
+        interface AsymmetricMatchersContaining {
+            stringContaining(expected: string): any;
+            objectContaining(expected: any): any;
+            arrayContaining<T = unknown>(expected: Array<T>): any;
+            stringMatching(expected: string | RegExp): any;
+        }
+        interface JestAssertion<T = any> extends jest.Matchers<void, T> {
+            toMatchSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(snapshot: Partial<U>, message?: string): void;
+            toMatchSnapshot(message?: string): void;
+            matchSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(snapshot: Partial<U>, message?: string): void;
+            matchSnapshot(message?: string): void;
+            toMatchInlineSnapshot<U extends {
+                [P in keyof T]: any;
+            }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+            toMatchInlineSnapshot(snapshot?: string, message?: string): void;
+            toThrowErrorMatchingSnapshot(message?: string): void;
+            toThrowErrorMatchingInlineSnapshot(snapshot?: string, message?: string): void;
+            toEqual<E>(expected: E): void;
+            toStrictEqual<E>(expected: E): void;
+            toBe<E>(expected: E): void;
+            toMatch(expected: string | RegExp): void;
+            toMatchObject<E extends {} | any[]>(expected: E): void;
+            toContain<E>(item: E): void;
+            toContainEqual<E>(item: E): void;
+            toBeTruthy(): void;
+            toBeFalsy(): void;
+            toBeGreaterThan(num: number | bigint): void;
+            toBeGreaterThanOrEqual(num: number | bigint): void;
+            toBeLessThan(num: number | bigint): void;
+            toBeLessThanOrEqual(num: number | bigint): void;
+            toBeNaN(): void;
+            toBeUndefined(): void;
+            toBeNull(): void;
+            toBeDefined(): void;
+            toBeTypeOf(expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined'): void;
+            toBeInstanceOf<E>(expected: E): void;
+            toBeCalledTimes(times: number): void;
+            toHaveLength(length: number): void;
+            toHaveProperty<E>(property: string | string[], value?: E): void;
+            toBeCloseTo(number: number, numDigits?: number): void;
+            toHaveBeenCalledTimes(times: number): void;
+            toHaveBeenCalledOnce(): void;
+            toHaveBeenCalled(): void;
+            toBeCalled(): void;
+            toHaveBeenCalledWith<E extends any[]>(...args: E): void;
+            toBeCalledWith<E extends any[]>(...args: E): void;
+            toHaveBeenNthCalledWith<E extends any[]>(n: number, ...args: E): void;
+            nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void;
+            toHaveBeenLastCalledWith<E extends any[]>(...args: E): void;
+            lastCalledWith<E extends any[]>(...args: E): void;
+            toThrow(expected?: string | Constructable | RegExp | Error): void;
+            toThrowError(expected?: string | Constructable | RegExp | Error): void;
+            toReturn(): void;
+            toHaveReturned(): void;
+            toReturnTimes(times: number): void;
+            toHaveReturnedTimes(times: number): void;
+            toReturnWith<E>(value: E): void;
+            toHaveReturnedWith<E>(value: E): void;
+            toHaveLastReturnedWith<E>(value: E): void;
+            lastReturnedWith<E>(value: E): void;
+            toHaveNthReturnedWith<E>(nthCall: number, value: E): void;
+            nthReturnedWith<E>(nthCall: number, value: E): void;
+            toSatisfy<E>(matcher: (value: E) => boolean, message?: string): void;
+        }
+        type VitestAssertion<A, T> = {
+            [K in keyof A]: A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T>;
+        } & ((type: string, message?: string) => Assertion);
+        interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {
+            resolves: Promisify<Assertion<T>>;
+            rejects: Promisify<Assertion<T>>;
+        }
+    }
+}
+
 declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
 interface BirpcFn<T> {
@@ -1339,40 +1445,6 @@ interface WorkerGlobalState {
     mockMap: MockMap;
 }
 
-declare const suite: SuiteAPI<{}>;
-declare const test: TestAPI<{}>;
-declare const describe: SuiteAPI<{}>;
-declare const it: TestAPI<{}>;
-
-declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number | undefined) => void;
-declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undefined) => void;
-declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
-declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
-
-/**
- * A simple wrapper for converting callback style to promise
- */
-declare function withCallback(fn: (done: DoneCallback) => void): Promise<void>;
-
-/**
- * This utils allows computational intensive tasks to only be ran once
- * across test reruns to improve the watch mode performance.
- *
- * Currently only works with `isolate: false`
- *
- * @experimental
- */
-declare function runOnce<T>(fn: (() => T), key?: string): T;
-/**
- * Get a boolean indicates whether the task is running in the first time.
- * Could only be `false` in watch mode.
- *
- * Currently only works with `isolate: false`
- *
- * @experimental
- */
-declare function isFirstRun(): boolean;
-
 interface MockResultReturn<T> {
     type: 'return';
     value: T;
@@ -1453,6 +1525,40 @@ declare function spyOn<T, M extends (Methods<Required<T>> | Classes<Required<T>>
 declare function fn<TArgs extends any[] = any[], R = any>(): SpyInstanceFn<TArgs, R>;
 declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): SpyInstanceFn<TArgs, R>;
 
+declare const suite: SuiteAPI<{}>;
+declare const test: TestAPI<{}>;
+declare const describe: SuiteAPI<{}>;
+declare const it: TestAPI<{}>;
+
+declare const beforeAll: (fn: SuiteHooks['beforeAll'][0], timeout?: number | undefined) => void;
+declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undefined) => void;
+declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
+declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
+
+/**
+ * A simple wrapper for converting callback style to promise
+ */
+declare function withCallback(fn: (done: DoneCallback) => void): Promise<void>;
+
+/**
+ * This utils allows computational intensive tasks to only be ran once
+ * across test reruns to improve the watch mode performance.
+ *
+ * Currently only works with `isolate: false`
+ *
+ * @experimental
+ */
+declare function runOnce<T>(fn: (() => T), key?: string): T;
+/**
+ * Get a boolean indicates whether the task is running in the first time.
+ * Could only be `false` in watch mode.
+ *
+ * Currently only works with `isolate: false`
+ *
+ * @experimental
+ */
+declare function isFirstRun(): boolean;
+
 declare function createExpect(test?: Test): Vi.ExpectStatic;
 declare const expect: Vi.ExpectStatic;
 
@@ -1568,112 +1674,4 @@ interface WebSocketHandlers {
 interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog'> {
 }
 
-declare type VitestInlineConfig = InlineConfig;
-declare module 'vite' {
-    interface UserConfig {
-        /**
-         * Options for Vitest
-         */
-        test?: VitestInlineConfig;
-    }
-}
-declare type Promisify<O> = {
-    [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
-};
-declare global {
-    namespace jest {
-        interface Matchers<R, T = {}> {
-        }
-    }
-    namespace Vi {
-        interface ExpectStatic extends Chai.ExpectStatic, AsymmetricMatchersContaining {
-            <T>(actual: T, message?: string): Vi.Assertion<T>;
-            extend(expects: MatchersObject): void;
-            assertions(expected: number): void;
-            hasAssertions(): void;
-            anything(): any;
-            any(constructor: unknown): any;
-            addSnapshotSerializer(plugin: Plugin): void;
-            getState(): MatcherState;
-            setState(state: Partial<MatcherState>): void;
-            not: AsymmetricMatchersContaining;
-        }
-        interface AsymmetricMatchersContaining {
-            stringContaining(expected: string): any;
-            objectContaining(expected: any): any;
-            arrayContaining<T = unknown>(expected: Array<T>): any;
-            stringMatching(expected: string | RegExp): any;
-        }
-        interface JestAssertion<T = any> extends jest.Matchers<void, T> {
-            toMatchSnapshot<U extends {
-                [P in keyof T]: any;
-            }>(snapshot: Partial<U>, message?: string): void;
-            toMatchSnapshot(message?: string): void;
-            matchSnapshot<U extends {
-                [P in keyof T]: any;
-            }>(snapshot: Partial<U>, message?: string): void;
-            matchSnapshot(message?: string): void;
-            toMatchInlineSnapshot<U extends {
-                [P in keyof T]: any;
-            }>(properties: Partial<U>, snapshot?: string, message?: string): void;
-            toMatchInlineSnapshot(snapshot?: string, message?: string): void;
-            toThrowErrorMatchingSnapshot(message?: string): void;
-            toThrowErrorMatchingInlineSnapshot(snapshot?: string, message?: string): void;
-            toEqual<E>(expected: E): void;
-            toStrictEqual<E>(expected: E): void;
-            toBe<E>(expected: E): void;
-            toMatch(expected: string | RegExp): void;
-            toMatchObject<E extends {} | any[]>(expected: E): void;
-            toContain<E>(item: E): void;
-            toContainEqual<E>(item: E): void;
-            toBeTruthy(): void;
-            toBeFalsy(): void;
-            toBeGreaterThan(num: number | bigint): void;
-            toBeGreaterThanOrEqual(num: number | bigint): void;
-            toBeLessThan(num: number | bigint): void;
-            toBeLessThanOrEqual(num: number | bigint): void;
-            toBeNaN(): void;
-            toBeUndefined(): void;
-            toBeNull(): void;
-            toBeDefined(): void;
-            toBeTypeOf(expected: 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined'): void;
-            toBeInstanceOf<E>(expected: E): void;
-            toBeCalledTimes(times: number): void;
-            toHaveLength(length: number): void;
-            toHaveProperty<E>(property: string | string[], value?: E): void;
-            toBeCloseTo(number: number, numDigits?: number): void;
-            toHaveBeenCalledTimes(times: number): void;
-            toHaveBeenCalledOnce(): void;
-            toHaveBeenCalled(): void;
-            toBeCalled(): void;
-            toHaveBeenCalledWith<E extends any[]>(...args: E): void;
-            toBeCalledWith<E extends any[]>(...args: E): void;
-            toHaveBeenNthCalledWith<E extends any[]>(n: number, ...args: E): void;
-            nthCalledWith<E extends any[]>(nthCall: number, ...args: E): void;
-            toHaveBeenLastCalledWith<E extends any[]>(...args: E): void;
-            lastCalledWith<E extends any[]>(...args: E): void;
-            toThrow(expected?: string | Constructable | RegExp | Error): void;
-            toThrowError(expected?: string | Constructable | RegExp | Error): void;
-            toReturn(): void;
-            toHaveReturned(): void;
-            toReturnTimes(times: number): void;
-            toHaveReturnedTimes(times: number): void;
-            toReturnWith<E>(value: E): void;
-            toHaveReturnedWith<E>(value: E): void;
-            toHaveLastReturnedWith<E>(value: E): void;
-            lastReturnedWith<E>(value: E): void;
-            toHaveNthReturnedWith<E>(nthCall: number, value: E): void;
-            nthReturnedWith<E>(nthCall: number, value: E): void;
-            toSatisfy<E>(matcher: (value: E) => boolean, message?: string): void;
-        }
-        type VitestAssertion<A, T> = {
-            [K in keyof A]: A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T>;
-        } & ((type: string, message?: string) => Assertion);
-        interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T> {
-            resolves: Promisify<Assertion<T>>;
-            rejects: Promisify<Assertion<T>>;
-        }
-    }
-}
-
 export { ApiConfig, ArgumentsType$1 as ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, C8Options, Constructable, CoverageReporter, DeepMerge, DoneCallback, EnhancedSpy, Environment, EnvironmentOptions, EnvironmentReturn, ErrorWithDiff, File, HookCleanupCallback, HookListener, InlineConfig, JSDOMOptions, MergeInsertions, MockedFunction, MockedObject, ModuleCache, ModuleGraphData, MutableArray, Nullable, ParsedStack, Position, Reporter, ResolveIdFunction, ResolvedC8Options, ResolvedConfig, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, SpyContext, SpyInstance, SpyInstanceFn, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TransformResultWithSource, UncheckedSnapshot, UserConfig, UserConsoleLog, Vitest, WebSocketEvents, WebSocketHandlers, WorkerContext, WorkerGlobalState, WorkerRPC, afterAll, afterEach, beforeAll, beforeEach, createExpect, describe, expect, getRunningMode, isFirstRun, isWatchMode, it, runOnce, suite, test, vi, vitest, withCallback };

package/dist/index.js

@@ -1,12 +1,13 @@
-export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.eb563278.js';
+export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.5021a6b6.js';
 export { assert, default as chai, should } from 'chai';
-import './chunk-utils-global.03413604.js';
+import './vendor-_commonjsHelpers.addc3445.js';
+import './chunk-runtime-rpc.47bae3f9.js';
+import './chunk-utils-global.2fab7e5c.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './chunk-runtime-rpc.ef131645.js';
 import 'fs';
-import './chunk-utils-timers.a0f0fe66.js';
+import './chunk-utils-timers.da6ac0a6.js';
 import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';