vitest 0.27.3 → 0.28.0

package/dist/index.d.ts

@@ -1,23 +1,165 @@
-import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-2dd51af4.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-2dd51af4.js';
-import { D as DoneCallback, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, a as File, T as TaskResultPack, b as ResolvedConfig, c as ModuleGraphData, d as Reporter } from './types-c1386a7d.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, j as CSSModuleScopeStrategy, C as CollectLineNumbers, g as CollectLines, ab as Constructable, i as Context, ar as CoverageC8Options, aq as CoverageIstanbulOptions, an as CoverageOptions, aj as CoverageProvider, al as CoverageProviderModule, am as CoverageReporter, a9 as DeepMerge, D as DoneCallback, ae as Environment, E as EnvironmentOptions, ad as EnvironmentReturn, ah as ErrorWithDiff, a as File, x as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, a8 as MergeInsertions, ac as ModuleCache, c as ModuleGraphData, aa as MutableArray, a5 as Nullable, ai as OnServerRestartHandler, O as OnTestFailedHandler, ag as ParsedStack, e as RawErrsMap, ak as ReportContext, d as Reporter, a0 as ResolveIdFunction, b as ResolvedConfig, ao as ResolvedCoverageOptions, h as RootAndTarget, m 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, q as Suite, w as SuiteAPI, z as SuiteCollector, G as SuiteFactory, y as SuiteHooks, s as Task, o as TaskBase, p as TaskResult, T as TaskResultPack, n as TaskState, r as Test, v as TestAPI, L as TestContext, t as TestFunction, u as TestOptions, f as TscErrorInfo, l as TypecheckConfig, Z as UncheckedSnapshot, U as UserConfig, af as UserConsoleLog, N as Vitest, V as VitestEnvironment, k as VitestRunMode, $ as WorkerContext, a3 as WorkerGlobalState, a2 as WorkerRPC } from './types-c1386a7d.js';
+import { Test } from '@vitest/runner';
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
+import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, a as ResolvedConfig, b as ModuleGraphData, S as SnapshotResult, c as Reporter } from './types-c800444e.js';
+export { u as AfterSuiteRunMeta, A as ApiConfig, z as ArgumentsType, y as Arrayable, x as Awaitable, a2 as BaseCoverageOptions, a8 as BenchFunction, a6 as Benchmark, B as BenchmarkAPI, a7 as BenchmarkResult, a5 as BenchmarkUserOptions, h as BuiltinEnvironment, i as CSSModuleScopeStrategy, C as CollectLineNumbers, e as CollectLines, K as Constructable, g as Context, a4 as CoverageC8Options, a3 as CoverageIstanbulOptions, a0 as CoverageOptions, Y as CoverageProvider, _ as CoverageProviderModule, $ as CoverageReporter, G as DeepMerge, P as Environment, E as EnvironmentOptions, O as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, D as MergeInsertions, L as ModuleCache, b as ModuleGraphData, H as MutableArray, N as Nullable, X as OnServerRestartHandler, d as RawErrsMap, Z as ReportContext, c as Reporter, t as ResolveIdFunction, a as ResolvedConfig, a1 as ResolvedCoverageOptions, f as RootAndTarget, R as RuntimeConfig, j as SequenceHooks, n as SnapshotData, q as SnapshotMatchOptions, S as SnapshotResult, p as SnapshotStateOptions, s as SnapshotSummary, o as SnapshotUpdateState, T as TscErrorInfo, l as TypecheckConfig, r as UncheckedSnapshot, U as UserConfig, Q as UserConsoleLog, m as Vitest, V as VitestEnvironment, k as VitestRunMode, W as WorkerContext, w as WorkerGlobalState, v as WorkerRPC } from './types-c800444e.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';
+export { S as SnapshotEnvironment } from './env-afee91f0.js';
+import { File, TaskResultPack } from '@vitest/runner/types';
+export { DoneCallback, File, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, RuntimeContext, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TestOptions } from '@vitest/runner/types';
 import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
+export { ErrorWithDiff, ParsedStack } from '@vitest/runner/utils';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
-import 'tinyspy';
+import '@vitest/expect';
+import '@vitest/utils';
 import 'vite-node/client';
 import 'vite-node/server';
+import 'node:worker_threads';
 import 'vite-node';
 import 'node:fs';
-import 'node:worker_threads';
 
+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;
 /**
- * A simple wrapper for converting callback style to promise
+ * 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 function withCallback(fn: (done: DoneCallback) => void): Promise<void>;
+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;
+
+declare const bench: BenchmarkAPI;
 
 /**
  * This utils allows computational intensive tasks to only be ran once
@@ -38,6 +180,9 @@ declare function runOnce<T>(fn: (() => T), key?: string): T;
  */
 declare function isFirstRun(): boolean;
 
+declare function createExpect(test?: Test): Vi.ExpectStatic;
+declare const globalExpect: Vi.ExpectStatic;
+
 declare class VitestUtils {
     private _timers;
     private _mockedDate;
@@ -196,16 +341,20 @@ interface WebSocketHandlers {
     onCollected(files?: File[]): Promise<void>;
     onTaskUpdate(packs: TaskResultPack[]): void;
     getFiles(): File[];
-    getPaths(): Promise<string[]>;
+    getPaths(): string[];
     getConfig(): ResolvedConfig;
+    resolveSnapshotPath(testPath: string): string;
     getModuleGraph(id: string): Promise<ModuleGraphData>;
     getTransformResult(id: string): Promise<TransformResultWithSource | undefined>;
-    readFile(id: string): Promise<string>;
+    readFile(id: string): Promise<string | null>;
     writeFile(id: string, content: string): Promise<void>;
+    removeFile(id: string): Promise<void>;
+    createDirectory(id: string): Promise<string | undefined>;
+    snapshotSaved(snapshot: SnapshotResult): void;
     rerun(files: string[]): Promise<void>;
     updateSnapshot(file?: File): Promise<void>;
 }
 interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog' | 'onPathsCollected'> {
 }
 
-export { TransformResultWithSource, WebSocketEvents, WebSocketHandlers, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest, withCallback };
+export { AssertType, ExpectTypeOf, TransformResultWithSource, WebSocketEvents, WebSocketHandlers, assertType, bench, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest };

package/dist/index.js

@@ -1,26 +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.07d16eac.js';
-import { e as dist } from './chunk-utils-import.eb63557e.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-utils-import.eb63557e.js';
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
+export { b as bench, c as createExpect, g as expect, a as vi, v as vitest } from './chunk-utils-import.9911c99d.js';
+export { i as isFirstRun, r as runOnce } from './chunk-integrations-run-once.38756e30.js';
+import { d as dist } from './chunk-integrations-utils.f1f6f1ed.js';
+export { b as assertType, g as getRunningMode, a as isWatchMode } from './chunk-integrations-utils.f1f6f1ed.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
-import 'util';
-import './chunk-mock-date.91595ccd.js';
-import 'node:path';
-import 'picocolors';
-import 'local-pkg';
-import './chunk-utils-env.4ebb0106.js';
-import 'node:url';
-import 'path';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import './chunk-utils-global.442d1d33.js';
+import 'pathe';
+import './chunk-utils-env.860d90c2.js';
 import 'std-env';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-utils-timers.52534f96.js';
-import './vendor-index.723a074f.js';
-import 'tinyspy';
-import './chunk-utils-source-map.832515f7.js';
-import './chunk-runtime-rpc.e79efa9a.js';
-import 'node:fs';
-import 'fs';
+import '@vitest/expect';
+import './chunk-runtime-rpc.9c0386cc.js';
+import './chunk-snapshot-env.6457638e.js';
+import './chunk-utils-base.977ae74f.js';
+import './chunk-utils-tasks.1b603032.js';
+import 'util';
+import '@vitest/spy';
 
 
 

package/dist/loader.js

@@ -1,21 +1,21 @@
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { readFile } from 'node:fs/promises';
-import { i as isNodeBuiltin, h as hasCJSSyntax } from './vendor-index.b0346fe4.js';
+import { i as isNodeBuiltin, h as hasCJSSyntax } from './vendor-index.bdee400f.js';
 import { normalizeModuleId } from 'vite-node/utils';
-import { g as getWorkerState } from './chunk-mock-date.91595ccd.js';
+import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
 import 'acorn';
 import 'node:module';
 import 'node:fs';
+import 'pathe';
 import 'node:assert';
 import 'node:process';
 import 'node:path';
 import 'node:v8';
 import 'node:util';
-import 'picocolors';
-import 'local-pkg';
-import './chunk-utils-env.4ebb0106.js';
-import 'path';
+import './chunk-utils-env.860d90c2.js';
 import 'std-env';
+import '@vitest/runner/utils';
+import '@vitest/utils';
 
 var ModuleFormat = /* @__PURE__ */ ((ModuleFormat2) => {
   ModuleFormat2["Builtin"] = "builtin";

package/dist/node.d.ts

@@ -1,12 +1,17 @@
-import { k as VitestRunMode, U as UserConfig, N as Vitest, ax as MockFactory, ay as MockMap, az as TestSequencer } from './types-c1386a7d.js';
-export { az as TestSequencer, aB as TestSequencerConstructor, N as Vitest, aA as startVitest } from './types-c1386a7d.js';
+import { k as VitestRunMode, U as UserConfig, m as Vitest, a9 as MockFactory, aa as MockMap, ab as TestSequencer } from './types-c800444e.js';
+export { ab as TestSequencer, ad as TestSequencerConstructor, m as Vitest, ac as startVitest } from './types-c800444e.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeRunnerOptions } from 'vite-node';
+import '@vitest/expect';
+import '@vitest/runner/types';
+import '@vitest/runner';
+import '@vitest/runner/utils';
+import '@vitest/utils';
 import 'tinybench';
 import 'vite-node/server';
-import 'node:fs';
 import 'node:worker_threads';
+import 'node:fs';
 
 declare function createVitest(mode: VitestRunMode, options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
 
@@ -56,10 +61,7 @@ declare class VitestRunner extends ViteNodeRunner {
     shouldResolveId(id: string, _importee?: string | undefined): boolean;
     resolveUrl(id: string, importee?: string): Promise<[url: string, fsPath: string]>;
     dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
-    prepareContext(context: Record<string, any>): Record<string, any> & {
-        __vitest_mocker__: VitestMocker;
-    };
-    shouldInterop(path: string, mod: any): boolean;
+    prepareContext(context: Record<string, any>): Record<string, any>;
 }
 
 declare class BaseSequencer implements TestSequencer {

package/dist/node.js

@@ -1,37 +1,39 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-snapshot-manager.d16903ef.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.66533d65.js';
-import './chunk-utils-env.4ebb0106.js';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-node-pkg.dcdf4369.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.03017e8c.js';
+import 'pathe';
+import './chunk-constants.797d3ebf.js';
 import 'node:url';
-import 'path';
+import './chunk-utils-env.860d90c2.js';
 import 'std-env';
-import './chunk-integrations-coverage.18366936.js';
+import './chunk-integrations-coverage.48e6286b.js';
 import 'local-pkg';
+import 'util';
+import 'path';
 import './chunk-env-node.ffd1183b.js';
 import 'node:console';
-import './chunk-mock-date.91595ccd.js';
-import 'node:path';
 import 'picocolors';
 import 'vite';
+import 'node:path';
 import 'node:process';
 import 'node:fs';
 import 'os';
-import './vendor-index.57682f0c.js';
-import 'util';
 import 'stream';
 import 'events';
 import 'fs';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'vite-node/client';
 import 'vite-node/server';
+import './chunk-utils-global.442d1d33.js';
+import '@vitest/runner/utils';
+import '@vitest/utils';
 import 'node:fs/promises';
-import './vendor-index.451e37bc.js';
+import './vendor-index.618ca5a1.js';
 import 'node:buffer';
 import 'node:child_process';
-import './vendor-index.e6c27006.js';
 import 'child_process';
+import 'node:os';
 import 'assert';
 import 'buffer';
-import 'node:os';
 import 'source-map';
 import 'module';
 import 'acorn';
@@ -40,17 +42,16 @@ import 'node:worker_threads';
 import 'tinypool';
 import './vendor-index.783e7f3e.js';
 import 'perf_hooks';
-import './chunk-utils-source-map.832515f7.js';
-import './chunk-utils-timers.52534f96.js';
+import './chunk-utils-base.977ae74f.js';
+import './chunk-utils-tasks.1b603032.js';
 import 'crypto';
 import 'vite-node/utils';
-import './vendor-index.9c919048.js';
+import '@vitest/utils/diff';
 import 'node:crypto';
 import './chunk-magic-string.3a794426.js';
 import 'strip-literal';
 import 'readline';
-import './vendor-index.9f20a9be.js';
-import './vendor-index.b0346fe4.js';
+import './vendor-index.bdee400f.js';
 import 'node:module';
 import 'node:assert';
 import 'node:v8';

package/dist/runners-chunk.js

@@ -0,0 +1,215 @@
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { d as getSnapshotClient, c as createExpect, a as vi, e as getBenchOptions, f as getBenchFn } from './chunk-utils-import.9911c99d.js';
+import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
+import { g as getFullName } from './chunk-utils-tasks.1b603032.js';
+import { updateTask } from '@vitest/runner';
+import { createDefer, getSafeTimers } from '@vitest/utils';
+
+class VitestTestRunner {
+  constructor(config) {
+    this.config = config;
+    this.snapshotClient = getSnapshotClient();
+    this.workerState = getWorkerState();
+  }
+  importFile(filepath, source) {
+    if (source === "setup")
+      this.workerState.moduleCache.delete(filepath);
+    return import(filepath);
+  }
+  onBeforeRun() {
+    this.snapshotClient.clear();
+  }
+  async onAfterRun() {
+    await this.snapshotClient.saveCurrent();
+  }
+  onAfterRunSuite(suite) {
+    if (this.config.logHeapUsage && typeof process !== "undefined")
+      suite.result.heap = process.memoryUsage().heapUsed;
+  }
+  onAfterRunTest(test) {
+    this.snapshotClient.clearTest();
+    if (this.config.logHeapUsage && typeof process !== "undefined")
+      test.result.heap = process.memoryUsage().heapUsed;
+    this.workerState.current = void 0;
+  }
+  async onBeforeRunTest(test) {
+    if (test.mode !== "run") {
+      this.snapshotClient.skipTestSnapshots(test);
+      return;
+    }
+    clearModuleMocks(this.config);
+    await this.snapshotClient.setTest(test);
+    this.workerState.current = test;
+  }
+  onBeforeTryTest(test) {
+    var _a;
+    setState({
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberErrorGen: null,
+      testPath: (_a = test.suite.file) == null ? void 0 : _a.filepath,
+      currentTestName: getFullName(test),
+      snapshotState: this.snapshotClient.snapshotState
+    }, globalThis[GLOBAL_EXPECT]);
+  }
+  onAfterTryTest(test) {
+    const {
+      assertionCalls,
+      expectedAssertionsNumber,
+      expectedAssertionsNumberErrorGen,
+      isExpectingAssertions,
+      isExpectingAssertionsError
+    } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
+      throw expectedAssertionsNumberErrorGen();
+    if (isExpectingAssertions === true && assertionCalls === 0)
+      throw isExpectingAssertionsError;
+  }
+  extendTestContext(context) {
+    let _expect;
+    Object.defineProperty(context, "expect", {
+      get() {
+        if (!_expect)
+          _expect = createExpect(context.meta);
+        return _expect;
+      }
+    });
+    Object.defineProperty(context, "_local", {
+      get() {
+        return _expect != null;
+      }
+    });
+    return context;
+  }
+}
+function clearModuleMocks(config) {
+  const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+  if (restoreMocks)
+    vi.restoreAllMocks();
+  else if (mockReset)
+    vi.resetAllMocks();
+  else if (clearMocks)
+    vi.clearAllMocks();
+  if (unstubEnvs)
+    vi.unstubAllEnvs();
+  if (unstubGlobals)
+    vi.unstubAllGlobals();
+}
+
+async function importTinybench() {
+  if (!globalThis.EventTarget)
+    await import('./vendor-index.534e612c.js').then(function (n) { return n.i; });
+  return await import('tinybench');
+}
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+async function runBenchmarkSuite(suite, runner) {
+  var _a;
+  const { Task, Bench } = await importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run")
+      continue;
+    if ((_a = task.meta) == null ? void 0 : _a.benchmark)
+      benchmarkGroup.push(task);
+    else if (task.type === "suite")
+      benchmarkSuiteGroup.push(task);
+  }
+  if (benchmarkSuiteGroup.length)
+    await Promise.all(benchmarkSuiteGroup.map((subSuite) => runBenchmarkSuite(subSuite, runner)));
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    const benchmarkMap = {};
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1(suite);
+    benchmarkGroup.forEach((benchmark, idx) => {
+      const options = getBenchOptions(benchmark);
+      const benchmarkInstance = new Bench(options);
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const id = idx.toString();
+      benchmarkMap[id] = benchmark;
+      const task = new Task(benchmarkInstance, id, benchmarkFn);
+      benchmark.meta.task = task;
+      updateTask$1(benchmark);
+    });
+    benchmarkGroup.forEach((benchmark) => {
+      benchmark.meta.task.addEventListener("complete", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        if (_benchmark) {
+          const taskRes = task.result;
+          const result = _benchmark.result.benchmark;
+          Object.assign(result, taskRes);
+          updateTask$1(_benchmark);
+        }
+      });
+      benchmark.meta.task.addEventListener("error", (e) => {
+        const task = e.task;
+        const _benchmark = benchmarkMap[task.name || ""];
+        defer.reject(_benchmark ? task.result.error : e);
+      });
+    });
+    Promise.all(benchmarkGroup.map(async (benchmark) => {
+      await benchmark.meta.task.warmup();
+      const { setTimeout } = getSafeTimers();
+      return await new Promise((resolve) => setTimeout(async () => {
+        resolve(await benchmark.meta.task.run());
+      }));
+    })).then((tasks) => {
+      suite.result.duration = performance.now() - start;
+      suite.result.state = "pass";
+      tasks.sort((a, b) => a.result.mean - b.result.mean).forEach((cycle, idx) => {
+        const benchmark = benchmarkMap[cycle.name || ""];
+        benchmark.result.state = "pass";
+        if (benchmark) {
+          const result = benchmark.result.benchmark;
+          result.rank = Number(idx) + 1;
+          updateTask$1(benchmark);
+        }
+      });
+      updateTask$1(suite);
+      defer.resolve(null);
+    });
+    await defer;
+  }
+  function updateTask$1(task) {
+    updateTask(task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  importFile(filepath, source) {
+    if (source === "setup")
+      getWorkerState().moduleCache.delete(filepath);
+    return import(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTest() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
+
+export { NodeBenchmarkRunner as N, VitestTestRunner as V };

package/dist/runners.d.ts

@@ -0,0 +1,39 @@
+import { VitestRunner, VitestRunnerImportSource, Suite, Test, TestContext } from '@vitest/runner';
+import { a as ResolvedConfig } from './types-c800444e.js';
+import '@vitest/expect';
+import 'vite';
+import '@vitest/runner/types';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import 'tinybench';
+import 'vite-node/client';
+import 'vite-node/server';
+import 'node:worker_threads';
+import 'vite-node';
+import 'node:fs';
+
+declare class VitestTestRunner implements VitestRunner {
+    config: ResolvedConfig;
+    private snapshotClient;
+    private workerState;
+    constructor(config: ResolvedConfig);
+    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    onBeforeRun(): void;
+    onAfterRun(): Promise<void>;
+    onAfterRunSuite(suite: Suite): void;
+    onAfterRunTest(test: Test): void;
+    onBeforeRunTest(test: Test): Promise<void>;
+    onBeforeTryTest(test: Test): void;
+    onAfterTryTest(test: Test): void;
+    extendTestContext(context: TestContext): TestContext;
+}
+
+declare class NodeBenchmarkRunner implements VitestRunner {
+    config: ResolvedConfig;
+    constructor(config: ResolvedConfig);
+    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    runSuite(suite: Suite): Promise<void>;
+    runTest(): Promise<void>;
+}
+
+export { NodeBenchmarkRunner, VitestTestRunner };