vitest 0.0.109 → 0.0.113

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { Formatter } from 'picocolors/types';
+import { ViteDevServer } from 'vite';
 import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
-export { assert, default as chai, expect, should } from 'chai';
+import { RawSourceMap } from 'source-map-js';
 export { Spy, SpyFn } from 'tinyspy';
+export { assert, default as chai, should } from 'chai';
 
 declare const EXPECTED_COLOR: Formatter;
 declare const RECEIVED_COLOR: Formatter;
@@ -117,6 +119,7 @@ interface AsymmetricMatcherInterface {
 declare abstract class AsymmetricMatcher<T, State extends MatcherState = MatcherState> implements AsymmetricMatcherInterface {
     protected sample: T;
     protected inverse: boolean;
+    $$typeof: symbol;
     constructor(sample: T, inverse?: boolean);
     protected getMatcherContext(): State;
     abstract asymmetricMatch(other: unknown): boolean;
@@ -158,6 +161,124 @@ declare class StringMatching extends AsymmetricMatcher<RegExp> {
     getExpectedType(): string;
 }
 
+declare class SnapshotManager {
+    config: ResolvedConfig;
+    summary: SnapshotSummary;
+    constructor(config: ResolvedConfig);
+    clear(): void;
+    add(result: SnapshotResult): void;
+}
+
+declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
+interface WorkerPool {
+    runTests: RunWithFiles;
+    collectTests: RunWithFiles;
+    close: () => Promise<void>;
+}
+
+declare class StateManager {
+    filesMap: Record<string, File>;
+    idMap: Record<string, Task>;
+    taskFileMap: WeakMap<Task, File>;
+    getFiles(keys?: string[]): File[];
+    collectFiles(files: File[]): void;
+    updateId(task: Task): void;
+    updateTasks(packs: TaskResultPack[]): void;
+}
+
+declare class Vitest {
+    config: ResolvedConfig;
+    server: ViteDevServer;
+    state: StateManager;
+    snapshot: SnapshotManager;
+    reporters: Reporter[];
+    console: Console;
+    pool: WorkerPool | undefined;
+    invalidates: Set<string>;
+    changedTests: Set<string>;
+    runningPromise?: Promise<void>;
+    isFirstRun: boolean;
+    restartsCount: number;
+    private _onRestartListeners;
+    constructor();
+    setServer(options: UserConfig, server: ViteDevServer): void;
+    start(filters?: string[]): Promise<void>;
+    runFiles(files: string[]): Promise<void>;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    private _rerunTimer;
+    private scheduleRerun;
+    private unregisterWatcher;
+    private registerWatcher;
+    private handleFileChanged;
+    close(): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
+    globTestFiles(filters?: string[]): Promise<string[]>;
+    isTargetFile(id: string): boolean;
+    onServerRestarted(fn: () => void): void;
+}
+
+declare abstract class BaseReporter implements Reporter {
+    ctx: Vitest;
+    start: number;
+    end: number;
+    watchFilters?: string[];
+    isTTY: boolean;
+    constructor(ctx: Vitest);
+    relative(path: string): string;
+    onFinished(files?: File[]): Promise<void>;
+    onTaskUpdate(pack: TaskResultPack): void;
+    isFirstWatchRun: boolean;
+    onWatcherStart(): Promise<void>;
+    onWatcherRerun(files: string[], trigger: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+    onServerRestart(): void;
+    reportSummary(files: File[]): Promise<void>;
+    private printTaskErrors;
+}
+
+interface ListRendererOptions {
+    renderSucceed?: boolean;
+}
+declare const createListRenderer: (_tasks: Task[], options?: ListRendererOptions) => {
+    start(): any;
+    update(_tasks: Task[]): any;
+    stop(): Promise<any>;
+    clear(): void;
+};
+
+declare class DefaultReporter extends BaseReporter {
+    renderer?: ReturnType<typeof createListRenderer>;
+    rendererOptions: ListRendererOptions;
+    onStart(): void;
+    onFinished(files?: File[]): Promise<void>;
+    onWatcherStart(): Promise<void>;
+    stopListRender(): Promise<void>;
+    onWatcherRerun(files: string[], trigger: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+}
+
+declare class DotReporter extends BaseReporter {
+    renderer?: ReturnType<typeof createListRenderer>;
+    onStart(): void;
+    onFinished(files?: File[]): Promise<void>;
+    onWatcherStart(): Promise<void>;
+    stopListRender(): Promise<void>;
+    onWatcherRerun(files: string[], trigger: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+}
+
+declare class VerboseReporter extends DefaultReporter {
+    constructor(ctx: Vitest);
+}
+
+declare const ReportersMap: {
+    default: typeof DefaultReporter;
+    verbose: typeof VerboseReporter;
+    dot: typeof DotReporter;
+};
+declare type BuiltinReporters = keyof typeof ReportersMap;
+
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
 declare type Arrayable<T> = T | Array<T>;
@@ -179,6 +300,16 @@ interface UserConsoleLog {
     type: 'stdout' | 'stderr';
     taskId?: string;
 }
+interface Position {
+    line: number;
+    column: number;
+}
+interface ParsedStack {
+    method: string;
+    file: string;
+    line: number;
+    column: number;
+}
 
 declare type ChainableFunction<T extends string, Args extends any[], R = any> = {
     (...args: Args): R;
@@ -371,7 +502,7 @@ interface InlineConfig {
     /**
      * Custom reporter for output
      */
-    reporters?: Reporter | Reporter[];
+    reporters?: Arrayable<BuiltinReporters | Reporter>;
     /**
      * Enable multi-threading
      *
@@ -489,6 +620,7 @@ interface WorkerContext {
 }
 interface RpcMap {
     fetch: [[id: string], string | undefined];
+    getSourceMap: [[id: string, force?: boolean], RawSourceMap | undefined];
     log: [[UserConsoleLog], void];
     processExit: [[code?: number], void];
     onCollected: [[files: File[]], void];
@@ -504,30 +636,18 @@ declare type RpcPayload<T extends keyof RpcMap = keyof RpcMap> = {
     args: RpcMap[T][0];
 };
 
-declare const suite: ChainableFunction<"skip" | "only" | "todo" | "concurrent", [name: string, factory?: TestFactory | undefined], SuiteCollector>;
+declare const suite: ChainableFunction<"concurrent" | "skip" | "only" | "todo", [name: string, factory?: TestFactory | undefined], SuiteCollector>;
 declare const test: TestCollector;
-declare const describe: ChainableFunction<"skip" | "only" | "todo" | "concurrent", [name: string, factory?: TestFactory | undefined], SuiteCollector>;
+declare const describe: ChainableFunction<"concurrent" | "skip" | "only" | "todo", [name: string, factory?: TestFactory | undefined], SuiteCollector>;
 declare const it: TestCollector;
-declare global {
-    namespace NodeJS {
-        interface Process {
-            __vitest_worker__: {
-                config: ResolvedConfig;
-                rpc: RpcCall;
-                send: RpcSend;
-                current?: Test;
-                filepath?: string;
-                moduleCache: Map<string, ModuleCache>;
-            };
-        }
-    }
-}
 
 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;
 
+declare const expect: Chai.ExpectStatic;
+
 interface MockResultReturn<T> {
     type: 'return';
     value: T;
@@ -620,10 +740,60 @@ declare class VitestUtils {
     getMockedDate(): string | number | Date | null;
     spyOn: typeof spyOn;
     fn: typeof fn;
-    mock(path: string): void;
+    /**
+     * 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 suppors it
+     * @param factory Factory for the mocked module. Has the highest priority.
+     */
+    mock(path: string, factory?: () => any): 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 suppors it
+     */
     unmock(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')
+     *
+     *  return { ...axios, get: vi.fn() }
+     * })
+     * @param path Path to the module. Can be aliased, if your config suppors it
+     * @returns Actual module without spies
+     */
     importActual<T>(path: string): Promise<T>;
-    importMock<T>(path: string): Promise<T>;
+    /**
+     * Imports a module with all of its properties and nested properties mocked.
+     * For the rules applied, see docs.
+     * @param path Path to the module. Can be aliased, if your config suppors it
+     * @returns Fully mocked module
+     */
+    importMock<T>(path: string): Promise<MaybeMockedDeep<T>>;
+    /**
+     * Type helpers for TypeScript. In reality just returns the object that was passed.
+     * @example
+     * import example from './example'
+     * vi.mock('./example')
+     *
+     * test('1+1 equals 2' async () => {
+     *  vi.mocked(example.calc).mockRestore()
+     *
+     *  const res = example.calc(1, '+', 1)
+     *
+     *  expect(res).toBe(2)
+     * })
+     * @param item Anything that can be mocked
+     * @param deep If the object is deeply mocked
+     */
     mocked<T>(item: T, deep?: false): MaybeMocked<T>;
     mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
     isMockFunction(fn: any): any;
@@ -654,6 +824,7 @@ declare global {
             any(constructor: unknown): Any;
             arrayContaining(expected: any): ArrayContaining;
             stringMatching(expected: RegExp): StringMatching;
+            assertions(expected: number): void;
         }
         interface Assertion {
             chaiEqual(expected: any): void;
@@ -708,4 +879,4 @@ declare global {
     }
 }
 
-export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, PropertyKeysOf, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, fn, it, spies, spyOn, suite, test, vi, vitest };
+export { ArgumentsOf, ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, ConstructorArgumentsOf, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, MaybeMocked, MaybeMockedConstructor, MaybeMockedDeep, MethodKeysOf, MockWithArgs, MockableFunction, MockedFunction, MockedFunctionDeep, MockedObject, MockedObjectDeep, ModuleCache, Nullable, ParsedStack, Position, PropertyKeysOf, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, expect, fn, it, spies, spyOn, suite, test, vi, vitest };

package/dist/index.js

@@ -1,10 +1,9 @@
-export { d as describe, i as it, s as suite, t as test, b as vi, v as vitest } from './vi-9754296d.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach } from './index-0961cf69.js';
-export { assert, default as chai, expect, should } from 'chai';
-export { f as fn, s as spies, a as spyOn } from './jest-mock-8498c46d.js';
-import './utils-d97bd6d9.js';
+export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-51946984.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-09437c50.js';
+export { f as fn, s as spies, a as spyOn } from './jest-mock-a57b745c.js';
+export { assert, default as chai, should } from 'chai';
+import './index-041e627e.js';
 import 'tty';
 import 'local-pkg';
-import 'path';
 import './_commonjsHelpers-c9e3b764.js';
 import 'tinyspy';

package/dist/{jest-mock-8498c46d.js → jest-mock-a57b745c.js}

@@ -44,10 +44,7 @@ function enhanceSpy(spy) {
     }
   };
   let onceImplementations = [];
-  let name = "";
-  Object.defineProperty(stub, "name", {
-    get: () => name
-  });
+  let name = stub.name;
   stub.getMockName = () => name || "vi.fn()";
   stub.mockName = (n) => {
     name = n;