vitest 0.0.101 → 0.0.105

package/dist/{index-825cb54c.js → index-4cf13e25.js}

@@ -1,4 +1,4 @@
-import { c as commonjsGlobal } from './_commonjsHelpers-bdec4bbd.js';
+import { q as commonjsGlobal } from './utils-5307e690.js';
 import assert$1 from 'assert';
 import require$$2 from 'events';
 

package/dist/{index-0c3a317d.js → index-5d224425.js}

@@ -2,11 +2,15 @@ import path$5 from 'path';
 import fs$5 from 'fs';
 import require$$0 from 'util';
 import require$$0$1 from 'child_process';
-import { c as commonjsGlobal } from './_commonjsHelpers-bdec4bbd.js';
-import { a as signalExit, b as onetime$1 } from './index-825cb54c.js';
+import { q as commonjsGlobal } from './utils-5307e690.js';
+import { a as signalExit, b as onetime$1 } from './index-4cf13e25.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-a76b4291.js

@@ -0,0 +1,31 @@
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-101bab76.js';
+import chai, { assert, should, expect } from 'chai';
+import { s as spies, a as spyOn, f as fn, v as vitest, b as vi } from './utils-5307e690.js';
+
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  suite: suite,
+  test: test,
+  describe: describe,
+  it: it,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  assert: assert,
+  should: should,
+  expect: expect,
+  chai: chai,
+  spies: spies,
+  spyOn: spyOn,
+  fn: fn,
+  vitest: vitest,
+  vi: vi
+});
+
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, index as i };

package/dist/index.d.ts

@@ -150,6 +150,12 @@ declare class Any extends AsymmetricMatcher<any> {
     getExpectedType(): string;
     toAsymmetricMatcher(): string;
 }
+declare class StringMatching extends AsymmetricMatcher<RegExp> {
+    constructor(sample: string | RegExp, inverse?: boolean);
+    asymmetricMatch(other: string): boolean;
+    toString(): string;
+    getExpectedType(): string;
+}
 
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
@@ -303,12 +309,12 @@ interface InlineConfig {
     /**
      * Include globs for test files
      *
-     * @default ['**\/*.test.ts']
+     * @default ['**\/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
      */
     include?: string[];
     /**
      * Exclude globs for test files
-     * @default ['**\/node_modules\/**']
+     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
      */
     exclude?: string[];
     /**
@@ -426,6 +432,21 @@ interface InlineConfig {
      * @default false
      */
     api?: boolean | number;
+    /**
+     * Will call `.mockClear()` on all spies before each test
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Will call `.mockReset()` on all spies before each test
+     * @default false
+     */
+    mockReset?: boolean;
+    /**
+     * Will call `.mockRestore()` on all spies before each test
+     * @default false
+     */
+    restoreMocks?: boolean;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -446,6 +467,10 @@ interface UserConfig extends InlineConfig {
      * Do not watch
      */
     run?: boolean;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
 }
 interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'> {
     config?: string;
@@ -490,6 +515,7 @@ declare global {
                 rpc: RpcCall;
                 send: RpcSend;
                 current?: Test;
+                filepath?: string;
                 moduleCache: Map<string, ModuleCache>;
             };
         }
@@ -541,6 +567,37 @@ interface JestMockCompat<TArgs extends any[] = any[], TReturns = any> {
 interface JestMockCompatFn<TArgs extends any[] = any, TReturns = any> extends JestMockCompat<TArgs, TReturns> {
     (...args: TArgs): TReturns;
 }
+declare type MockableFunction = (...args: Array<any>) => any;
+declare type MethodKeysOf<T> = {
+    [K in keyof T]: T[K] extends MockableFunction ? K : never;
+}[keyof T];
+declare type PropertyKeysOf<T> = {
+    [K in keyof T]: T[K] extends MockableFunction ? never : K;
+}[keyof T];
+declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
+declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
+declare type MaybeMockedConstructor<T> = T extends new (...args: Array<any>) => infer R ? JestMockCompatFn<ConstructorArgumentsOf<T>, R> : T;
+declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> & {
+    [K in keyof T]: T[K];
+};
+declare type MockedFunctionDeep<T extends MockableFunction> = MockWithArgs<T> & MockedObjectDeep<T>;
+declare type MockedObject<T> = MaybeMockedConstructor<T> & {
+    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
+} & {
+    [K in PropertyKeysOf<T>]: T[K];
+};
+declare type MockedObjectDeep<T> = MaybeMockedConstructor<T> & {
+    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunctionDeep<T[K]> : T[K];
+} & {
+    [K in PropertyKeysOf<T>]: MaybeMockedDeep<T[K]>;
+};
+declare type MaybeMockedDeep<T> = T extends MockableFunction ? MockedFunctionDeep<T> : T extends object ? MockedObjectDeep<T> : T;
+declare type MaybeMocked<T> = T extends MockableFunction ? MockedFunction<T> : T extends object ? MockedObject<T> : T;
+interface MockWithArgs<T extends MockableFunction> extends JestMockCompatFn<ArgumentsOf<T>, ReturnType<T>> {
+    new (...args: ConstructorArgumentsOf<T>): T;
+    (...args: ArgumentsOf<T>): ReturnType<T>;
+}
+declare const spies: Set<JestMockCompat<any[], any>>;
 declare function spyOn<T, K extends keyof T>(obj: T, method: K, accessType?: 'get' | 'set'): T[K] extends (...args: infer TArgs) => infer TReturnValue ? JestMockCompat<TArgs, TReturnValue> : JestMockCompat;
 declare type Awaited<T> = T extends Promise<infer R> ? R : never;
 declare function fn<TArgs extends any[] = any[], R = any>(): JestMockCompatFn<TArgs, R>;
@@ -548,6 +605,7 @@ declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...ar
 
 declare class VitestUtils {
     private _timers;
+    private _systemDate;
     constructor();
     useFakeTimers(): void;
     useRealTimers(): void;
@@ -555,17 +613,22 @@ declare class VitestUtils {
     runAllTimers(): void | Promise<void>;
     advanceTimersByTime(ms: number): void | Promise<void>;
     advanceTimersToNextTimer(): void | Promise<void>;
-    runAllTicks(): void | Promise<void>;
-    setSystemTime(time?: number | Date): void;
-    getRealSystemTime(): number;
     getTimerCount(): number;
+    setSystemDate(date: string | number | Date): void;
+    resetSystemDate(): void;
+    getSystemDate(): string | number | Date;
     spyOn: typeof spyOn;
     fn: typeof fn;
-    mock: (path: string) => string;
+    mock(path: string): void;
+    unmock(path: string): void;
+    importActual<T>(path: string): Promise<T>;
+    importMock<T>(path: string): Promise<T>;
+    mocked<T>(item: T, deep?: false): MaybeMocked<T>;
+    mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
     isMockFunction(fn: any): any;
-    clearAllMocks(): void;
-    resetAllMocks(): void;
-    restoreAllMocks(): void;
+    clearAllMocks(): this;
+    resetAllMocks(): this;
+    restoreAllMocks(): this;
 }
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
@@ -589,6 +652,7 @@ declare global {
             objectContaining(expected: any): ObjectContaining;
             any(constructor: unknown): Any;
             arrayContaining(expected: any): ArrayContaining;
+            stringMatching(expected: RegExp): StringMatching;
         }
         interface Assertion {
             chaiEqual(expected: any): void;
@@ -643,4 +707,4 @@ declare global {
     }
 }
 
-export { ArgumentsType, Arrayable, Awaitable, BuiltinEnvironment, ComputeMode, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, JestMockCompat, JestMockCompatContext, JestMockCompatFn, ModuleCache, Nullable, 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, 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, fn, it, spies, spyOn, suite, test, vi, vitest };

package/dist/index.js

@@ -1,8 +1,8 @@
-export { d as describe, i as it, s as suite, t as test } from './suite-4f3fb0b5.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, f as fn, s as spyOn, e as vi, v as vitest } from './index-f580d714.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-101bab76.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach } from './index-a76b4291.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-5307e690.js';
 import './index-9e71c815.js';
-import './utils-c8e62373.js';
 import 'tty';
 import 'local-pkg';
 import 'path';

package/dist/{middleware-05e03d95.js → middleware-c66abe08.js}

@@ -1,9 +1,11 @@
-import { A as API_PATH } from './constants-a1417084.js';
+import { A as API_PATH } from './constants-9320a46c.js';
 import 'url';
-import './utils-c8e62373.js';
+import './utils-5307e690.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import 'chai';
+import 'tinyspy';
 
 /*! (c) 2020 Andrea Giammarchi */
 

package/dist/node.d.ts

@@ -0,0 +1,328 @@
+import { ViteDevServer, UserConfig as UserConfig$1 } from 'vite';
+import { OptionsReceived } from 'pretty-format';
+
+declare type Awaitable<T> = T | PromiseLike<T>;
+declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+interface UserConsoleLog {
+    content: string;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+}
+
+declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
+declare type TaskState = RunMode | 'pass' | 'fail';
+declare type ComputeMode = 'serial' | 'concurrent';
+interface TaskBase {
+    id: string;
+    name: string;
+    mode: RunMode;
+    computeMode: ComputeMode;
+    suite?: Suite;
+    file?: File;
+    result?: TaskResult;
+}
+interface TaskResult {
+    state: TaskState;
+    start: number;
+    end?: number;
+    error?: unknown;
+}
+declare type TaskResultPack = [id: string, result: TaskResult | undefined];
+interface Suite extends TaskBase {
+    type: 'suite';
+    tasks: Task[];
+}
+interface File extends Suite {
+    filepath: string;
+}
+interface Test extends TaskBase {
+    type: 'test';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+}
+declare type Task = Test | Suite | File;
+
+interface Reporter {
+    onStart?: (files?: string[]) => Awaitable<void>;
+    onFinished?: (files?: File[]) => Awaitable<void>;
+    onTaskUpdate?: (pack: TaskResultPack) => Awaitable<void>;
+    onWatcherStart?: () => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string) => Awaitable<void>;
+    onServerRestart?: () => Awaitable<void>;
+    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
+}
+
+declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type SnapshotStateOptions = {
+    updateSnapshot: SnapshotUpdateState;
+    expand?: boolean;
+    snapshotFormat?: OptionsReceived;
+};
+interface SnapshotResult {
+    filepath: string;
+    added: number;
+    fileDeleted: boolean;
+    matched: number;
+    unchecked: number;
+    uncheckedKeys: Array<string>;
+    unmatched: number;
+    updated: number;
+}
+interface UncheckedSnapshot {
+    filePath: string;
+    keys: Array<string>;
+}
+interface SnapshotSummary {
+    added: number;
+    didUpdate: boolean;
+    failure: boolean;
+    filesAdded: number;
+    filesRemoved: number;
+    filesRemovedList: Array<string>;
+    filesUnmatched: number;
+    filesUpdated: number;
+    matched: number;
+    total: number;
+    unchecked: number;
+    uncheckedKeysByFile: Array<UncheckedSnapshot>;
+    unmatched: number;
+    updated: number;
+}
+
+declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom';
+interface InlineConfig {
+    /**
+     * Include globs for test files
+     *
+     * @default ['**\/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
+     */
+    include?: string[];
+    /**
+     * Exclude globs for test files
+     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
+     */
+    exclude?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     */
+    deps?: {
+        /**
+         * Externalize means that Vite will bypass the package to native Node.
+         *
+         * Externalized dependencies will not be applied Vite's transformers and resolvers.
+         * And does not support HMR on reload.
+         *
+         * Typically, packages under `node_modules` are externalized.
+         */
+        external?: (string | RegExp)[];
+        /**
+         * Vite will process inlined modules.
+         *
+         * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+         */
+        inline?: (string | RegExp)[];
+    };
+    /**
+     * Register apis globally
+     *
+     * @default false
+     */
+    global?: boolean;
+    /**
+     * Running environment
+     *
+     * Supports 'node', 'jsdom', 'happy-dom'
+     *
+     * @default 'node'
+     */
+    environment?: BuiltinEnvironment;
+    /**
+     * Update snapshot files
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default false
+     */
+    watch?: boolean;
+    /**
+     * Project root
+     */
+    root?: string;
+    /**
+     * Custom reporter for output
+     */
+    reporters?: Reporter | Reporter[];
+    /**
+     * Enable multi-threading
+     *
+     * @default true
+     */
+    threads?: boolean;
+    /**
+     * Maximum number of threads
+     *
+     * @default available CPUs
+     */
+    maxThreads?: number;
+    /**
+     * Minimum number of threads
+     *
+     * @default available CPUs
+     */
+    minThreads?: number;
+    interpretDefault?: boolean;
+    /**
+     * Default timeout of a test in milliseconds
+     *
+     * @default 5000
+     */
+    testTimeout?: number;
+    /**
+     * Default timeout of a hook in milliseconds
+     *
+     * @default 5000
+     */
+    hookTimeout?: number;
+    /**
+     * Silent mode
+     *
+     * @default false
+     */
+    silent?: boolean;
+    /**
+     * Path to setup files
+     */
+    setupFiles?: string | string[];
+    /**
+     * Pattern of file paths to be ignore from triggering watch rerun
+     *
+     * @default ['**\/node_modules\/**', '**\/dist/**']
+     */
+    watchIgnore?: (string | RegExp)[];
+    /**
+     * Open Vitest UI
+     * @internal WIP
+     */
+    open?: boolean;
+    /**
+     * Listen to port and serve API
+     *
+     * When set to true, the default port is 55555
+     *
+     * @internal WIP
+     * @default false
+     */
+    api?: boolean | number;
+    /**
+     * Will call `.mockClear()` on all spies before each test
+     * @default false
+     */
+    clearMocks?: boolean;
+    /**
+     * Will call `.mockReset()` on all spies before each test
+     * @default false
+     */
+    mockReset?: boolean;
+    /**
+     * Will call `.mockRestore()` on all spies before each test
+     * @default false
+     */
+    restoreMocks?: boolean;
+}
+interface UserConfig extends InlineConfig {
+    /**
+     * Path to the config file.
+     *
+     * Default resolving to one of:
+     * - `vitest.config.js`
+     * - `vitest.config.ts`
+     * - `vite.config.js`
+     * - `vite.config.ts`
+     */
+    config?: string | undefined;
+    /**
+     * Use happy-dom
+     */
+    dom?: boolean;
+    /**
+     * Do not watch
+     */
+    run?: boolean;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
+}
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'> {
+    config?: string;
+    filters?: string[];
+    depsInline: (string | RegExp)[];
+    depsExternal: (string | RegExp)[];
+    snapshotOptions: SnapshotStateOptions;
+}
+
+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 function createVitest(options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
+
+export { Vitest, createVitest };

package/dist/node.js

@@ -1,8 +1,10 @@
-export { c as createVitest } from './index-37755855.js';
-import './utils-c8e62373.js';
+export { c as createVitest } from './index-1da01554.js';
+import './utils-5307e690.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import 'chai';
+import 'tinyspy';
 import 'vite';
 import 'process';
 import 'fs';
@@ -10,12 +12,11 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './constants-a1417084.js';
+import './constants-9320a46c.js';
 import 'url';
 import 'perf_hooks';
-import './error-d97062cd.js';
-import './index-825cb54c.js';
-import './_commonjsHelpers-bdec4bbd.js';
+import './error-4e165107.js';
+import './index-4cf13e25.js';
 import 'assert';
 import 'worker_threads';
 import 'tinypool';

package/dist/{suite-4f3fb0b5.js → suite-101bab76.js}

@@ -1,5 +1,5 @@
 import { n as nanoid } from './index-9e71c815.js';
-import { n as noop } from './utils-c8e62373.js';
+import { n as noop } from './utils-5307e690.js';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -198,4 +198,4 @@ function createSuite() {
   });
 }
 
-export { getDefaultHookTimeout as a, setHooks as b, createSuiteHooks as c, describe as d, clearContext as e, defaultSuite as f, getCurrentSuite as g, context as h, it as i, getHooks as j, getFn as k, suite as s, test as t, withTimeout as w };
+export { getDefaultHookTimeout as a, defaultSuite as b, clearContext as c, describe as d, setHooks as e, getHooks as f, getCurrentSuite as g, context as h, it as i, getFn as j, suite as s, test as t, withTimeout as w };