vitest 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { TaskPopulated, File, TaskResultPack, CancelReason } from '@vitest/runner';
 export { Custom, DoneCallback, ExtendedContext, File, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, RuntimeContext, SequenceHooks, SequenceSetupFiles, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskContext, TaskCustomOptions, TaskMeta, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench } from './suite-0579b50d.js';
+export { b as bench } from './suite-ad69b7cd.js';
 import { ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, ExpectStatic, JestAssertion } from '@vitest/expect';
-import { F as FakeTimerInstallOpts, M as MockFactoryWithHelper, k as RuntimeConfig, A as AfterSuiteRunMeta, l as UserConsoleLog, R as ResolvedConfig, m as ModuleGraphData, n as Reporter } from './reporters-1678fe04.js';
-export { D as ApiConfig, a4 as ArgumentsType, a3 as Arrayable, a1 as Awaitable, B as BaseCoverageOptions, ai as BenchFunction, ag as Benchmark, aj as BenchmarkAPI, ah as BenchmarkResult, af as BenchmarkUserOptions, x as BuiltinEnvironment, z as CSSModuleScopeStrategy, q as CollectLineNumbers, r as CollectLines, a6 as Constructable, u as Context, Y as ContextRPC, S as ContextTestEnvironment, ad as CoverageIstanbulOptions, b as CoverageOptions, c as CoverageProvider, d as CoverageProviderModule, ac as CoverageReporter, C as CoverageV8Options, ae as CustomProviderOptions, I as DepsOptimizationOptions, E as Environment, G as EnvironmentOptions, a8 as EnvironmentReturn, H as HappyDOMOptions, L as InlineConfig, J as JSDOMOptions, a7 as ModuleCache, a5 as MutableArray, a2 as Nullable, aa as OnServerRestartHandler, v as Pool, w as PoolOptions, P as ProjectConfig, o as RawErrsMap, ab as ReportContext, _ as ResolveIdFunction, a as ResolvedCoverageOptions, X as ResolvedTestEnvironment, t as RootAndTarget, Q as RunnerRPC, O as RuntimeRPC, K as TransformModePatterns, p as TscErrorInfo, N as TypecheckConfig, U as UserConfig, e as Vitest, y as VitestEnvironment, V as VitestRunMode, a9 as VmEnvironmentReturn, Z as WorkerContext, a0 as WorkerGlobalState, $ as WorkerRPC } from './reporters-1678fe04.js';
-import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, EnhancedSpy } from '@vitest/spy';
-export { EnhancedSpy, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
+import { F as FakeTimerInstallOpts, M as MockFactoryWithHelper, l as RuntimeConfig, f as ProvidedContext, A as AfterSuiteRunMeta, m as UserConsoleLog, R as ResolvedConfig, n as ModuleGraphData, o as Reporter } from './reporters-50c2bd49.js';
+export { G as ApiConfig, a5 as ArgumentsType, a4 as Arrayable, a2 as Awaitable, B as BaseCoverageOptions, aj as BenchFunction, ah as Benchmark, ak as BenchmarkAPI, ai as BenchmarkResult, ag as BenchmarkUserOptions, y as BuiltinEnvironment, D as CSSModuleScopeStrategy, r as CollectLineNumbers, t as CollectLines, a7 as Constructable, v as Context, Z as ContextRPC, X as ContextTestEnvironment, ae as CoverageIstanbulOptions, b as CoverageOptions, c as CoverageProvider, d as CoverageProviderModule, ad as CoverageReporter, C as CoverageV8Options, af as CustomProviderOptions, K as DepsOptimizationOptions, E as Environment, I as EnvironmentOptions, a9 as EnvironmentReturn, H as HappyDOMOptions, N as InlineConfig, J as JSDOMOptions, a8 as ModuleCache, a6 as MutableArray, a3 as Nullable, ab as OnServerRestartHandler, w as Pool, x as PoolOptions, P as ProjectConfig, p as RawErrsMap, ac as ReportContext, $ as ResolveIdFunction, a as ResolvedCoverageOptions, Y as ResolvedTestEnvironment, u as RootAndTarget, S as RunnerRPC, Q as RuntimeRPC, L as TransformModePatterns, q as TscErrorInfo, O as TypecheckConfig, U as UserConfig, e as Vitest, z as VitestEnvironment, V as VitestRunMode, aa as VmEnvironmentReturn, _ as WorkerContext, a1 as WorkerGlobalState, a0 as WorkerRPC } from './reporters-50c2bd49.js';
+import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
+export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
 export { SnapshotEnvironment } from '@vitest/snapshot/environment';
 import { SnapshotResult } from '@vitest/snapshot';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
@@ -24,7 +24,6 @@ import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'rollup';
 import 'node:fs';
 
 declare type Not<T extends boolean> = T extends true ? false : true;
@@ -226,87 +225,232 @@ interface WaitUntilOptions extends Pick<WaitForOptions, 'interval' | 'timeout'>
 }
 declare function waitUntil<T>(callback: WaitUntilCallback<T>, options?: number | WaitUntilOptions): Promise<T>;
 
+type ESModuleExports = Record<string, unknown>;
 interface VitestUtils {
+    /**
+     * Checks if fake timers are enabled.
+     */
     isFakeTimers(): boolean;
-    useFakeTimers(config?: FakeTimerInstallOpts): this;
-    useRealTimers(): this;
-    runOnlyPendingTimers(): this;
-    runOnlyPendingTimersAsync(): Promise<this>;
-    runAllTimers(): this;
-    runAllTimersAsync(): Promise<this>;
-    runAllTicks(): this;
-    advanceTimersByTime(ms: number): this;
-    advanceTimersByTimeAsync(ms: number): Promise<this>;
-    advanceTimersToNextTimer(): this;
-    advanceTimersToNextTimerAsync(): Promise<this>;
+    /**
+     * This method wraps all further calls to timers until [`vi.useRealTimers()`](https://vitest.dev/api/vi#vi-userealtimers) is called.
+     */
+    useFakeTimers(config?: FakeTimerInstallOpts): VitestUtils;
+    /**
+     * Restores mocked timers to their original implementations. All timers that were scheduled before will be discarded.
+     */
+    useRealTimers(): VitestUtils;
+    /**
+     * This method will call every timer that was initiated after [`vi.useFakeTimers`](https://vitest.dev/api/vi#vi-usefaketimers) call.
+     * It will not fire any timer that was initiated during its call.
+     */
+    runOnlyPendingTimers(): VitestUtils;
+    /**
+     * This method will asynchronously call every timer that was initiated after [`vi.useFakeTimers`](https://vitest.dev/api/vi#vi-usefaketimers) call, even asynchronous ones.
+     * It will not fire any timer that was initiated during its call.
+     */
+    runOnlyPendingTimersAsync(): Promise<VitestUtils>;
+    /**
+     * This method will invoke every initiated timer until the timer queue is empty. It means that every timer called during `runAllTimers` will be fired.
+     * If you have an infinite interval, it will throw after 10,000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/#faketimers-looplimit)).
+     */
+    runAllTimers(): VitestUtils;
+    /**
+     * This method will asynchronously invoke every initiated timer until the timer queue is empty. It means that every timer called during `runAllTimersAsync` will be fired even asynchronous timers.
+     * If you have an infinite interval, it will throw after 10 000 tries (can be configured with [`fakeTimers.loopLimit`](https://vitest.dev/config/#faketimers-looplimit)).
+     */
+    runAllTimersAsync(): Promise<VitestUtils>;
+    /**
+     * Calls every microtask that was queued by `process.nextTick`. This will also run all microtasks scheduled by themselves.
+     */
+    runAllTicks(): VitestUtils;
+    /**
+     * This method will invoke every initiated timer until the specified number of milliseconds is passed or the queue is empty - whatever comes first.
+     */
+    advanceTimersByTime(ms: number): VitestUtils;
+    /**
+     * This method will invoke every initiated timer until the specified number of milliseconds is passed or the queue is empty - whatever comes first. This will include and await asynchronously set timers.
+     */
+    advanceTimersByTimeAsync(ms: number): Promise<VitestUtils>;
+    /**
+     * Will call next available timer. Useful to make assertions between each timer call. You can chain call it to manage timers by yourself.
+     */
+    advanceTimersToNextTimer(): VitestUtils;
+    /**
+     * Will call next available timer and wait until it's resolved if it was set asynchronously. Useful to make assertions between each timer call.
+     */
+    advanceTimersToNextTimerAsync(): Promise<VitestUtils>;
+    /**
+     * Get the number of waiting timers.
+     */
     getTimerCount(): number;
-    setSystemTime(time: number | string | Date): this;
+    /**
+     * If fake timers are enabled, this method simulates a user changing the system clock (will affect date related API like `hrtime`, `performance.now` or `new Date()`) - however, it will not fire any timers.
+     * If fake timers are not enabled, this method will only mock `Date.*` and `new Date()` calls.
+     */
+    setSystemTime(time: number | string | Date): VitestUtils;
+    /**
+     * Returns mocked current date that was set using `setSystemTime`. If date is not mocked the method will return `null`.
+     */
     getMockedSystemTime(): Date | null;
+    /**
+     * When using `vi.useFakeTimers`, `Date.now` calls are mocked. If you need to get real time in milliseconds, you can call this function.
+     */
     getRealSystemTime(): number;
-    clearAllTimers(): this;
+    /**
+     * Removes all timers that are scheduled to run. These timers will never run in the future.
+     */
+    clearAllTimers(): VitestUtils;
+    /**
+     * Creates a spy on a method or getter/setter of an object similar to [`vi.fn()`](https://vitest.dev/api/vi#vi-fn). It returns a [mock function](https://vitest.dev/api/mock).
+     *
+     * @example
+     * const cart = {
+     *   getApples: () => 42
+     * }
+     *
+     * const spy = vi.spyOn(cart, 'getApples').mockReturnValue(10)
+     *
+     * expect(cart.getApples()).toBe(10)
+     * expect(spy).toHaveBeenCalled()
+     * expect(spy).toHaveReturnedWith(10)
+     */
     spyOn: typeof spyOn;
+    /**
+     * Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).
+     *
+     * If no function is given, mock will return `undefined`, when invoked.
+     *
+     * @example
+     * const getApples = vi.fn(() => 0)
+     *
+     * getApples()
+     *
+     * expect(getApples).toHaveBeenCalled()
+     * expect(getApples).toHaveReturnedWith(0)
+     *
+     * getApples.mockReturnValueOnce(5)
+     *
+     * expect(getApples()).toBe(5)
+     * expect(getApples).toHaveNthReturnedWith(2, 5)
+     */
     fn: typeof fn;
+    /**
+     * Wait for the callback to execute successfully. If the callback throws an error or returns a rejected promise it will continue to wait until it succeeds or times out.
+     *
+     * This is very useful when you need to wait for some asynchronous action to complete, for example, when you start a server and need to wait for it to start.
+     *
+     * @example
+     * const server = createServer()
+     *
+     * await vi.waitFor(
+     *   () => {
+     *     if (!server.isReady)
+     *       throw new Error('Server not started')
+     *
+     *     console.log('Server started')
+     *   }, {
+     *     timeout: 500, // default is 1000
+     *     interval: 20, // default is 50
+     *   }
+     * )
+     */
     waitFor: typeof waitFor;
+    /**
+     * This is similar to [`vi.waitFor`](https://vitest.dev/api/vi#vi-waitfor), but if the callback throws any errors, execution is immediately interrupted and an error message is received.
+     *
+     * If the callback returns a falsy value, the next check will continue until a truthy value is returned. This is useful when you need to wait for something to exist before taking the next step.
+     *
+     * @example
+     * const element = await vi.waitUntil(
+     *   () => document.querySelector('.element'),
+     *   {
+     *     timeout: 500, // default is 1000
+     *     interval: 20, // default is 50
+     *   }
+     * )
+     *
+     * // do something with the element
+     * expect(element.querySelector('.element-child')).toBeTruthy()
+     */
     waitUntil: typeof waitUntil;
     /**
      * Run the factory before imports are evaluated. You can return a value from the factory
-     * to reuse it inside your `vi.mock` factory and tests.
+     * to reuse it inside your [`vi.mock`](https://vitest.dev/api/vi#vi-mock) factory and tests.
+     *
+     * If used with [`vi.mock`](https://vitest.dev/api/vi#vi-mock), both will be hoisted in the order they are defined in.
      */
     hoisted<T>(factory: () => T): T;
     /**
-     * Makes all `imports` to passed module to be mocked.
-     * - If there is a factory, will return it's result. The call to `vi.mock` is hoisted to the top of the file,
-     * so you don't have access to variables declared in the global file scope, if you didn't put them before imports!
-     * - If `__mocks__` folder with file of the same name exist, all imports will
-     * return it.
-     * - If there is no `__mocks__` folder or a file with the same name inside, will call original
-     * module and mock it.
-     * @param path Path to the module. Can be aliased, if your config supports it
-     * @param factory Factory for the mocked module. Has the highest priority.
+     * Mocks every import call to the module even if it was already statically imported.
+     *
+     * The call to `vi.mock` is hoisted to the top of the file, so you don't have access to variables declared in the global file scope
+     * unless they are defined with [`vi.hoisted`](https://vitest.dev/api/vi#vi-hoisted) before this call.
+     *
+     * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     * @param factory Mocked module factory. The result of this function will be an exports object
      */
     mock(path: string, factory?: MockFactoryWithHelper): void;
     /**
-     * Removes module from mocked registry. All subsequent calls to import will
-     * return original module even if it was mocked.
-     * @param path Path to the module. Can be aliased, if your config supports it
+     * Removes module from mocked registry. All calls to import will return the original module even if it was mocked before.
+     *
+     * This call is hoisted to the top of the file, so it will only unmock modules that were defined in `setupFiles`, for example.
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
      */
     unmock(path: string): void;
-    doMock(path: string, factory?: () => any): void;
+    /**
+     * Mocks every subsequent [dynamic import](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) call.
+     *
+     * Unlike [`vi.mock`](https://vitest.dev/api/vi#vi-mock), this method will not mock statically imported modules because it is not hoisted to the top of the file.
+     *
+     * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     * @param factory Mocked module factory. The result of this function will be an exports object
+     */
+    doMock(path: string, factory?: MockFactoryWithHelper): void;
+    /**
+     * Removes module from mocked registry. All subsequent calls to import will return original module.
+     *
+     * Unlike [`vi.unmock`](https://vitest.dev/api/vi#vi-unmock), this method is not hoisted to the top of the file.
+     * @param path Path to the module. Can be aliased, if your Vitest config supports it
+     */
     doUnmock(path: string): void;
     /**
      * Imports module, bypassing all checks if it should be mocked.
      * Can be useful if you want to mock module partially.
      * @example
-     * vi.mock('./example', async () => {
-     *  const axios = await vi.importActual('./example')
+     * vi.mock('./example.js', async () => {
+     *  const axios = await vi.importActual<typeof import('./example.js')>('./example.js')
      *
      *  return { ...axios, get: vi.fn() }
      * })
      * @param path Path to the module. Can be aliased, if your config supports it
-     * @returns Actual module without spies
      */
-    importActual<T = unknown>(path: string): Promise<T>;
+    importActual<T = ESModuleExports>(path: string): Promise<T>;
     /**
      * Imports a module with all of its properties and nested properties mocked.
-     * For the rules applied, see docs.
+     *
+     * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+     * @example
+     * const example = await vi.importMock<typeof import('./example.js')>('./example.js')
+     * example.calc.mockReturnValue(10)
+     * expect(example.calc()).toBe(10)
      * @param path Path to the module. Can be aliased, if your config supports it
      * @returns Fully mocked module
      */
-    importMock<T>(path: string): Promise<MaybeMockedDeep<T>>;
+    importMock<T = ESModuleExports>(path: string): Promise<MaybeMockedDeep<T>>;
     /**
-     * Type helpers for TypeScript. In reality just returns the object that was passed.
+     * Type helper for TypeScript. Just returns the object that was passed.
      *
-     * When `partial` is `true` it will expect a `Partial<T>` as a return value.
+     * When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will only make TypeScript believe that
+     * the first level values are mocked. You can pass down `{ deep: true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually is.
      * @example
-     * import example from './example'
-     * vi.mock('./example')
-     *
-     * test('1+1 equals 2' async () => {
-     *  vi.mocked(example.calc).mockRestore()
+     * import example from './example.js'
+     * vi.mock('./example.js')
      *
-     *  const res = example.calc(1, '+', 1)
-     *
-     *  expect(res).toBe(2)
+     * test('1 + 1 equals 10' async () => {
+     *  vi.mocked(example.calc).mockReturnValue(10)
+     *  expect(example.calc(1, '+', 1)).toBe(10)
      * })
      * @param item Anything that can be mocked
      * @param deep If the object is deeply mocked
@@ -331,30 +475,52 @@ interface VitestUtils {
         deep: true;
     }): MaybePartiallyMockedDeep<T>;
     mocked<T>(item: T): MaybeMocked<T>;
-    isMockFunction(fn: any): fn is EnhancedSpy;
-    clearAllMocks(): this;
-    resetAllMocks(): this;
-    restoreAllMocks(): this;
+    /**
+     * Checks that a given parameter is a mock function. If you are using TypeScript, it will also narrow down its type.
+     */
+    isMockFunction(fn: any): fn is MockInstance;
+    /**
+     * Calls [`.mockClear()`](https://vitest.dev/api/mock#mockclear) on every mocked function. This will only empty `.mock` state, it will not reset implementation.
+     *
+     * It is useful if you need to clean up mock between different assertions.
+     */
+    clearAllMocks(): VitestUtils;
+    /**
+     * Calls [`.mockReset()`](https://vitest.dev/api/mock#mockreset) on every mocked function. This will empty `.mock` state, reset "once" implementations and force the base implementation to return `undefined` when invoked.
+     *
+     * This is useful when you want to completely reset a mock to the default state.
+     */
+    resetAllMocks(): VitestUtils;
+    /**
+     * Calls [`.mockRestore()`](https://vitest.dev/api/mock#mockrestore) on every mocked function. This will restore all original implementations.
+     */
+    restoreAllMocks(): VitestUtils;
     /**
      * Makes value available on global namespace.
      * Useful, if you want to have global variables available, like `IntersectionObserver`.
      * You can return it back to original value with `vi.unstubAllGlobals`, or by enabling `unstubGlobals` config option.
      */
-    stubGlobal(name: string | symbol | number, value: unknown): this;
+    stubGlobal(name: string | symbol | number, value: unknown): VitestUtils;
     /**
      * Changes the value of `import.meta.env` and `process.env`.
      * You can return it back to original value with `vi.unstubAllEnvs`, or by enabling `unstubEnvs` config option.
      */
-    stubEnv(name: string, value: string): this;
+    stubEnv(name: string, value: string): VitestUtils;
     /**
      * Reset the value to original value that was available before first `vi.stubGlobal` was called.
      */
-    unstubAllGlobals(): this;
+    unstubAllGlobals(): VitestUtils;
     /**
      * Reset environmental variables to the ones that were available before first `vi.stubEnv` was called.
      */
-    unstubAllEnvs(): this;
-    resetModules(): this;
+    unstubAllEnvs(): VitestUtils;
+    /**
+     * Resets modules registry by clearing the cache of all modules. This allows modules to be reevaluated when reimported.
+     * Top-level imports cannot be re-evaluated. Might be useful to isolate modules where local state conflicts between tests.
+     *
+     * This method does not reset mocks registry. To clear mocks registry, use [`vi.unmock`](https://vitest.dev/api/vi#vi-unmock) or [`vi.doUnmock`](https://vitest.dev/api/vi#vi-dounmock).
+     */
+    resetModules(): VitestUtils;
     /**
      * Wait for all imports to load. Useful, if you have a synchronous call that starts
      * importing a module that you cannot await otherwise.
@@ -373,9 +539,15 @@ interface VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
-declare function getRunningMode(): "watch" | "run";
+declare function getRunningMode(): "run" | "watch";
 declare function isWatchMode(): boolean;
 
+/**
+ * Gives access to injected context provided from the main thread.
+ * This usually returns a value provided by `globalSetup` or an external library.
+ */
+declare function inject<T extends keyof ProvidedContext>(key: T): ProvidedContext[T];
+
 interface TransformResultWithSource extends TransformResult {
     source?: string;
 }
@@ -403,9 +575,10 @@ interface WebSocketHandlers {
     snapshotSaved(snapshot: SnapshotResult): void;
     rerun(files: string[]): Promise<void>;
     updateSnapshot(file?: File): Promise<void>;
+    getProvidedContext(): ProvidedContext;
 }
 interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog' | 'onPathsCollected'> {
     onCancel(reason: CancelReason): void;
 }
 
-export { AfterSuiteRunMeta, type AssertType, type ExpectTypeOf, ModuleGraphData, Reporter, ResolvedConfig, RuntimeConfig, type TransformResultWithSource, UserConsoleLog, type VitestUtils, type WebSocketEvents, type WebSocketHandlers, assertType, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest };
+export { AfterSuiteRunMeta, type AssertType, type ExpectTypeOf, ModuleGraphData, ProvidedContext, Reporter, ResolvedConfig, RuntimeConfig, type TransformResultWithSource, UserConsoleLog, type VitestUtils, type WebSocketEvents, type WebSocketHandlers, assertType, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, inject, isFirstRun, isWatchMode, runOnce, vi, vitest };

package/dist/index.js

@@ -1,18 +1,18 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench } from './vendor-benchmark.44931cfa.js';
-export { i as isFirstRun, r as runOnce } from './vendor-run-once.3e5ef7d7.js';
-export { c as createExpect, a as expect, v as vi, b as vitest } from './vendor-vi.d30b47ae.js';
-import { d as dist } from './vendor-index.68ecee35.js';
-export { b as assertType, g as getRunningMode, a as isWatchMode } from './vendor-index.68ecee35.js';
+export { b as bench } from './vendor-benchmark.b6befc50.js';
+export { i as isFirstRun, r as runOnce } from './vendor-run-once.fb836747.js';
+export { c as createExpect, a as expect, v as vi, b as vitest } from './vendor-vi.3baa7c4a.js';
+import { d as dist } from './vendor-index.72df742e.js';
+export { c as assertType, g as getRunningMode, a as inject, b as isWatchMode } from './vendor-index.72df742e.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './vendor-index.29282562.js';
+import './vendor-index.2b92937b.js';
 import 'pathe';
 import 'std-env';
-import './vendor-global.97e4527c.js';
+import './vendor-global.c3664e75.js';
 import './vendor-_commonjsHelpers.7d1333e8.js';
 import '@vitest/expect';
 import '@vitest/snapshot';

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { V as VitestRunMode, U as UserConfig, e as Vitest, T as TestSequencer, W as WorkspaceSpec } from './reporters-1678fe04.js';
-export { i as BrowserProvider, h as BrowserProviderInitializationOptions, j as BrowserProviderOptions, g as TestSequencerConstructor, f as WorkspaceProject, s as startVitest } from './reporters-1678fe04.js';
+import { V as VitestRunMode, U as UserConfig, e as Vitest, R as ResolvedConfig, f as ProvidedContext, T as TestSequencer, W as WorkspaceSpec } from './reporters-50c2bd49.js';
+export { j as BrowserProvider, i as BrowserProviderInitializationOptions, k as BrowserProviderOptions, h as TestSequencerConstructor, g as WorkspaceProject, s as startVitest } from './reporters-50c2bd49.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import '@vitest/runner';
 import 'vite-node';
@@ -12,7 +12,6 @@ import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'rollup';
 import 'node:fs';
 import 'chai';
 
@@ -22,6 +21,11 @@ declare function VitestPlugin(options?: UserConfig, ctx?: Vitest): Promise<Plugi
 
 declare function registerConsoleShortcuts(ctx: Vitest): () => void;
 
+interface GlobalSetupContext {
+    config: ResolvedConfig;
+    provide<T extends keyof ProvidedContext>(key: T, value: ProvidedContext[T]): void;
+}
+
 declare class BaseSequencer implements TestSequencer {
     protected ctx: Vitest;
     constructor(ctx: Vitest);
@@ -31,4 +35,4 @@ declare class BaseSequencer implements TestSequencer {
 
 declare function ensurePackageInstalled(dependency: string, root: string): Promise<boolean>;
 
-export { BaseSequencer, TestSequencer, Vitest, VitestPlugin, WorkspaceSpec, createVitest, ensurePackageInstalled, registerConsoleShortcuts };
+export { BaseSequencer, type GlobalSetupContext, TestSequencer, Vitest, VitestPlugin, WorkspaceSpec, createVitest, ensurePackageInstalled, registerConsoleShortcuts };

package/dist/node.js

@@ -1,4 +1,4 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, e as ensurePackageInstalled, r as registerConsoleShortcuts, s as startVitest } from './vendor-node.327f8f1f.js';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, e as ensurePackageInstalled, r as registerConsoleShortcuts, s as startVitest } from './vendor-node.65461b16.js';
 import 'pathe';
 import 'vite';
 import 'node:path';
@@ -18,11 +18,11 @@ import 'vite-node/utils';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
-import './vendor-index.29282562.js';
+import './vendor-index.2b92937b.js';
 import 'std-env';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './vendor-global.97e4527c.js';
+import './vendor-global.c3664e75.js';
 import './vendor-coverage.78040316.js';
 import './vendor-paths.84fc7a99.js';
 import 'node:v8';
@@ -46,7 +46,7 @@ import 'local-pkg';
 import 'module';
 import 'acorn';
 import 'acorn-walk';
-import './vendor-reporters.b9600369.js';
+import './vendor-reporters.d24d80a4.js';
 import './chunk-runtime-console.f3263f87.js';
 import 'node:stream';
 import 'node:console';

package/dist/{reporters-1678fe04.d.ts → reporters-50c2bd49.d.ts}

@@ -12,7 +12,6 @@ import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
 import { MessagePort } from 'node:worker_threads';
-import * as rollup from 'rollup';
 import { Stats } from 'node:fs';
 import * as chai from 'chai';
 
@@ -497,18 +496,20 @@ declare class WorkspaceProject {
     closingPromise: Promise<unknown> | undefined;
     browserProvider: BrowserProvider | undefined;
     testFilesList: string[];
-    private _globalSetupInit;
     private _globalSetups;
+    private _provided;
     constructor(path: string | number, ctx: Vitest);
     getName(): string;
     isCore(): boolean;
+    provide: (key: string, value: unknown) => void;
+    getProvidedContext(): ProvidedContext;
     initializeGlobalSetup(): Promise<void>;
     teardownGlobalSetup(): Promise<void>;
     get logger(): Logger;
     getModulesByFilepath(file: string): Set<vite.ModuleNode>;
     getModuleById(id: string): vite.ModuleNode | undefined;
-    getSourceMapModuleById(id: string): rollup.SourceMap | null | undefined;
-    getBrowserSourceMapModuleById(id: string): rollup.SourceMap | null | undefined;
+    getSourceMapModuleById(id: string): RawSourceMap | null | undefined;
+    getBrowserSourceMapModuleById(id: string): RawSourceMap | null | undefined;
     get reporters(): Reporter[];
     globTestFiles(filters?: string[]): Promise<string[]>;
     globAllTestFiles(config: ResolvedConfig, cwd: string): Promise<string[]>;
@@ -558,7 +559,7 @@ interface BrowserConfigOptions {
      *
      * @default 'webdriverio'
      */
-    provider?: 'webdriverio' | 'playwright' | (string & {});
+    provider?: 'webdriverio' | 'playwright' | 'none' | (string & {});
     /**
      * Options that are passed down to a browser provider.
      * To support type hinting, add one of the types to your tsconfig.json "compilerOptions.types" field:
@@ -654,6 +655,8 @@ interface ModuleGraphData {
     inlined: string[];
 }
 type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+interface ProvidedContext {
+}
 
 declare class StateManager {
     filesMap: Map<string, File[]>;
@@ -1199,6 +1202,7 @@ interface ContextRPC {
     files: string[];
     invalidates?: string[];
     environment: ContextTestEnvironment;
+    providedContext: Record<string, any>;
 }
 
 interface WorkerContext extends ContextRPC {
@@ -1223,6 +1227,7 @@ interface WorkerGlobalState {
     onCancel: Promise<CancelReason>;
     moduleCache: ModuleCacheMap;
     mockMap: MockMap;
+    providedContext: Record<string, any>;
     durations: {
         environment: number;
         prepare: number;
@@ -1635,6 +1640,18 @@ interface WorkerContextOptions {
      * @default true
      */
     isolate?: boolean;
+    /**
+    * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
+    *
+    * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
+    *
+    * Set to `process.execArgv` to pass all arguments of the current process.
+    *
+    * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+    *
+    * @default [] // no execution arguments are passed
+    */
+    execArgv?: string[];
 }
 interface VmOptions {
     /**
@@ -1644,6 +1661,18 @@ interface VmOptions {
     memoryLimit?: string | number;
     /** Isolation is always enabled */
     isolate?: true;
+    /**
+    * Pass additional arguments to `node` process when spawning `worker_threads` or `child_process`.
+    *
+    * See [Command-line API | Node.js](https://nodejs.org/docs/latest/api/cli.html) for more information.
+    *
+    * Set to `process.execArgv` to pass all arguments of the current process.
+    *
+    * Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103
+    *
+    * @default [] // no execution arguments are passed
+    */
+    execArgv?: string[];
 }
 
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
@@ -2184,6 +2213,10 @@ interface InlineConfig {
      * @default 0
     */
     retry?: number;
+    /**
+     * Show full diff when snapshot fails instead of a patch.
+     */
+    expandSnapshotDiff?: boolean;
 }
 interface TypecheckConfig {
     /**
@@ -2394,4 +2427,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { type WorkerRPC as $, type AfterSuiteRunMeta as A, type BaseCoverageOptions as B, type CoverageV8Options as C, type ApiConfig as D, type Environment as E, type FakeTimerInstallOpts as F, type EnvironmentOptions as G, type HappyDOMOptions as H, type DepsOptimizationOptions as I, type JSDOMOptions as J, type TransformModePatterns as K, type InlineConfig as L, type MockFactoryWithHelper as M, type TypecheckConfig as N, type RuntimeRPC as O, type ProjectConfig as P, type RunnerRPC as Q, type ResolvedConfig as R, type ContextTestEnvironment as S, type TestSequencer as T, type UserConfig as U, type VitestRunMode as V, type WorkspaceSpec as W, type ResolvedTestEnvironment as X, type ContextRPC as Y, type WorkerContext as Z, type ResolveIdFunction as _, type ResolvedCoverageOptions as a, type WorkerGlobalState as a0, type Awaitable as a1, type Nullable as a2, type Arrayable as a3, type ArgumentsType$1 as a4, type MutableArray as a5, type Constructable as a6, type ModuleCache as a7, type EnvironmentReturn as a8, type VmEnvironmentReturn as a9, type BenchmarkBuiltinReporters as aA, type OnServerRestartHandler as aa, type ReportContext as ab, type CoverageReporter as ac, type CoverageIstanbulOptions as ad, type CustomProviderOptions as ae, type BenchmarkUserOptions as af, type Benchmark as ag, type BenchmarkResult as ah, type BenchFunction as ai, type BenchmarkAPI as aj, type PendingSuiteMock as ak, type MockFactory as al, type MockMap as am, DefaultReporter as an, BasicReporter as ao, DotReporter as ap, JsonReporter$1 as aq, VerboseReporter as ar, TapReporter as as, JUnitReporter as at, TapFlatReporter as au, HangingProcessReporter as av, BaseReporter as aw, ReportersMap as ax, type BuiltinReporters as ay, BenchmarkReportsMap as az, type CoverageOptions as b, type CoverageProvider as c, type CoverageProviderModule as d, Vitest as e, WorkspaceProject as f, type TestSequencerConstructor as g, type BrowserProviderInitializationOptions as h, type BrowserProvider as i, type BrowserProviderOptions as j, type RuntimeConfig as k, type UserConsoleLog as l, type ModuleGraphData as m, type Reporter as n, type RawErrsMap as o, type TscErrorInfo as p, type CollectLineNumbers as q, type CollectLines as r, startVitest as s, type RootAndTarget as t, type Context as u, type Pool as v, type PoolOptions as w, type BuiltinEnvironment as x, type VitestEnvironment as y, type CSSModuleScopeStrategy as z };
+export { type ResolveIdFunction as $, type AfterSuiteRunMeta as A, type BaseCoverageOptions as B, type CoverageV8Options as C, type CSSModuleScopeStrategy as D, type Environment as E, type FakeTimerInstallOpts as F, type ApiConfig as G, type HappyDOMOptions as H, type EnvironmentOptions as I, type JSDOMOptions as J, type DepsOptimizationOptions as K, type TransformModePatterns as L, type MockFactoryWithHelper as M, type InlineConfig as N, type TypecheckConfig as O, type ProjectConfig as P, type RuntimeRPC as Q, type ResolvedConfig as R, type RunnerRPC as S, type TestSequencer as T, type UserConfig as U, type VitestRunMode as V, type WorkspaceSpec as W, type ContextTestEnvironment as X, type ResolvedTestEnvironment as Y, type ContextRPC as Z, type WorkerContext as _, type ResolvedCoverageOptions as a, type WorkerRPC as a0, type WorkerGlobalState as a1, type Awaitable as a2, type Nullable as a3, type Arrayable as a4, type ArgumentsType$1 as a5, type MutableArray as a6, type Constructable as a7, type ModuleCache as a8, type EnvironmentReturn as a9, BenchmarkReportsMap as aA, type BenchmarkBuiltinReporters as aB, type VmEnvironmentReturn as aa, type OnServerRestartHandler as ab, type ReportContext as ac, type CoverageReporter as ad, type CoverageIstanbulOptions as ae, type CustomProviderOptions as af, type BenchmarkUserOptions as ag, type Benchmark as ah, type BenchmarkResult as ai, type BenchFunction as aj, type BenchmarkAPI as ak, type PendingSuiteMock as al, type MockFactory as am, type MockMap as an, DefaultReporter as ao, BasicReporter as ap, DotReporter as aq, JsonReporter$1 as ar, VerboseReporter as as, TapReporter as at, JUnitReporter as au, TapFlatReporter as av, HangingProcessReporter as aw, BaseReporter as ax, ReportersMap as ay, type BuiltinReporters as az, type CoverageOptions as b, type CoverageProvider as c, type CoverageProviderModule as d, Vitest as e, type ProvidedContext as f, WorkspaceProject as g, type TestSequencerConstructor as h, type BrowserProviderInitializationOptions as i, type BrowserProvider as j, type BrowserProviderOptions as k, type RuntimeConfig as l, type UserConsoleLog as m, type ModuleGraphData as n, type Reporter as o, type RawErrsMap as p, type TscErrorInfo as q, type CollectLineNumbers as r, startVitest as s, type CollectLines as t, type RootAndTarget as u, type Context as v, type Pool as w, type PoolOptions as x, type BuiltinEnvironment as y, type VitestEnvironment as z };

package/dist/reporters.d.ts

@@ -1,4 +1,4 @@
-export { aw as BaseReporter, ao as BasicReporter, aA as BenchmarkBuiltinReporters, az as BenchmarkReportsMap, ay as BuiltinReporters, an as DefaultReporter, ap as DotReporter, av as HangingProcessReporter, at as JUnitReporter, aq as JsonReporter, n as Reporter, ax as ReportersMap, au as TapFlatReporter, as as TapReporter, ar as VerboseReporter } from './reporters-1678fe04.js';
+export { ax as BaseReporter, ap as BasicReporter, aB as BenchmarkBuiltinReporters, aA as BenchmarkReportsMap, az as BuiltinReporters, ao as DefaultReporter, aq as DotReporter, aw as HangingProcessReporter, au as JUnitReporter, ar as JsonReporter, o as Reporter, ay as ReportersMap, av as TapFlatReporter, at as TapReporter, as as VerboseReporter } from './reporters-50c2bd49.js';
 import 'vite';
 import '@vitest/runner';
 import 'vite-node';
@@ -11,6 +11,5 @@ import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'rollup';
 import 'node:fs';
 import 'chai';