vitest 0.0.107 → 0.0.111

package/dist/{index-1ede1cc5.js → index-9f4b9905.js}

@@ -2,15 +2,11 @@ import path$5 from 'path';
 import fs$5 from 'fs';
 import require$$0 from 'util';
 import require$$0$1 from 'child_process';
-import { q as commonjsGlobal } from './utils-92ec89d1.js';
-import { a as signalExit, b as onetime$1 } from './index-84978a77.js';
+import { c as commonjsGlobal } from './_commonjsHelpers-c9e3b764.js';
+import { a as signalExit, b as onetime$1 } from './index-61c8686f.js';
 import require$$0$2 from 'os';
 import require$$0$4 from 'buffer';
 import require$$0$3 from 'stream';
-import 'tty';
-import 'local-pkg';
-import 'chai';
-import 'tinyspy';
 import 'assert';
 import 'events';
 

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 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';
+export { Spy, SpyFn } from 'tinyspy';
+export { assert, default as chai, should } from 'chai';
 
 declare const EXPECTED_COLOR: Formatter;
 declare const RECEIVED_COLOR: Formatter;
@@ -116,6 +118,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;
@@ -157,6 +160,123 @@ 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>;
+}
+
+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>;
@@ -370,7 +490,7 @@ interface InlineConfig {
     /**
      * Custom reporter for output
      */
-    reporters?: Reporter | Reporter[];
+    reporters?: Arrayable<BuiltinReporters | Reporter>;
     /**
      * Enable multi-threading
      *
@@ -507,26 +627,14 @@ declare const suite: ChainableFunction<"skip" | "only" | "todo" | "concurrent",
 declare const test: TestCollector;
 declare const describe: ChainableFunction<"skip" | "only" | "todo" | "concurrent", [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: (value: any, message?: string | undefined) => Chai.Assertion;
+
 interface MockResultReturn<T> {
     type: 'return';
     value: T;
@@ -619,10 +727,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;
@@ -653,6 +811,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;
@@ -707,4 +866,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, 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,9 +1,10 @@
-export { d as describe, i as it, s as suite, t as test } from './suite-ff89a82e.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach } from './index-77f19d39.js';
-export { assert, default as chai, expect, should } from 'chai';
-export { f as fn, s as spies, a as spyOn, b as vi, v as vitest } from './utils-92ec89d1.js';
-import './index-9e71c815.js';
+export { d as describe, i as it, c as suite, t as test, e as vi, v as vitest } from './vi-cb9e4e4e.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as expect } from './index-2bb9fd4d.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 './utils-cb6b1266.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import './_commonjsHelpers-c9e3b764.js';
 import 'tinyspy';

package/dist/jest-mock-a57b745c.js

@@ -0,0 +1,101 @@
+import { util } from 'chai';
+import * as tinyspy from 'tinyspy';
+
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+let nanoid = (size = 21) => {
+  let id = '';
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0];
+  }
+  return id
+};
+
+const spies = /* @__PURE__ */ new Set();
+function spyOn(obj, method, accessType) {
+  const dictionary = {
+    get: "getter",
+    set: "setter"
+  };
+  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
+  const stub = tinyspy.spyOn(obj, objMethod);
+  return enhanceSpy(stub);
+}
+function enhanceSpy(spy) {
+  const stub = spy;
+  let implementation;
+  const instances = [];
+  const mockContext = {
+    get calls() {
+      return stub.calls;
+    },
+    get instances() {
+      return instances;
+    },
+    get invocationCallOrder() {
+      return [];
+    },
+    get results() {
+      return stub.results.map(([callType, value]) => {
+        const type = callType === "error" ? "throw" : "return";
+        return { type, value };
+      });
+    }
+  };
+  let onceImplementations = [];
+  let name = stub.name;
+  stub.getMockName = () => name || "vi.fn()";
+  stub.mockName = (n) => {
+    name = n;
+    return stub;
+  };
+  stub.mockClear = () => {
+    stub.reset();
+    return stub;
+  };
+  stub.mockReset = () => {
+    stub.reset();
+    implementation = () => void 0;
+    onceImplementations = [];
+    return stub;
+  };
+  stub.mockRestore = () => {
+    stub.mockReset();
+    implementation = void 0;
+    return stub;
+  };
+  stub.getMockImplementation = () => implementation;
+  stub.mockImplementation = (fn2) => {
+    implementation = fn2;
+    return stub;
+  };
+  stub.mockImplementationOnce = (fn2) => {
+    onceImplementations.push(fn2);
+    return stub;
+  };
+  stub.mockReturnThis = () => stub.mockImplementation(function() {
+    return this;
+  });
+  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+  stub.mockRejectedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.reject(val));
+  util.addProperty(stub, "mock", () => mockContext);
+  stub.willCall(function(...args) {
+    instances.push(this);
+    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
+    });
+    return impl.apply(this, args);
+  });
+  spies.add(stub);
+  return stub;
+}
+function fn(implementation) {
+  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
+  }) }, "fn"));
+}
+
+export { spyOn as a, fn as f, nanoid as n, spies as s };

package/dist/{middleware-0c8d46aa.js → middleware-2028dfa0.js}

@@ -1,11 +1,9 @@
-import { A as API_PATH } from './constants-82dad049.js';
+import { A as API_PATH } from './constants-2b0310b7.js';
 import 'url';
-import './utils-92ec89d1.js';
+import './utils-cb6b1266.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import 'chai';
-import 'tinyspy';
 
 /*! (c) 2020 Andrea Giammarchi */
 

package/dist/node.d.ts

@@ -1,7 +1,68 @@
 import { ViteDevServer, UserConfig as UserConfig$1 } from 'vite';
 import { OptionsReceived } from 'pretty-format';
 
+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>;
+}
+
+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 Arrayable<T> = T | Array<T>;
 declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
 interface UserConsoleLog {
     content: string;
@@ -156,7 +217,7 @@ interface InlineConfig {
     /**
      * Custom reporter for output
      */
-    reporters?: Reporter | Reporter[];
+    reporters?: Arrayable<BuiltinReporters | Reporter>;
     /**
      * Enable multi-threading
      *

package/dist/node.js

@@ -1,10 +1,8 @@
-export { c as createVitest } from './index-8cc284f9.js';
-import './utils-92ec89d1.js';
+export { c as createVitest } from './index-8ab26d25.js';
+import './utils-cb6b1266.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import 'chai';
-import 'tinyspy';
 import 'vite';
 import 'process';
 import 'fs';
@@ -12,11 +10,12 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './constants-82dad049.js';
+import './constants-2b0310b7.js';
 import 'url';
 import 'perf_hooks';
-import './error-e81aa23d.js';
-import './index-84978a77.js';
+import './diff-66d6bb83.js';
+import './index-61c8686f.js';
+import './_commonjsHelpers-c9e3b764.js';
 import 'assert';
 import 'worker_threads';
 import 'tinypool';