vitest 0.0.100 → 0.0.104

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>;
@@ -555,17 +612,19 @@ 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;
     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 +648,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 +703,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,9 +1,9 @@
-export { b as assert, f as chai, d as describe, e as expect, i as it, c as should, s as suite, t as test } from './index-0b2be7f7.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-d57cd3f0.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-8d666d5a.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach } from './index-145f6f09.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-49e5008c.js';
 import './index-9e71c815.js';
-import './utils-b780070b.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './_commonjsHelpers-bdec4bbd.js';
 import 'tinyspy';

package/dist/{middleware-991dfa87.js → middleware-0627688d.js}

@@ -1,9 +1,11 @@
-import { A as API_PATH } from './constants-3cbd9066.js';
+import { A as API_PATH } from './constants-c4dc2ff5.js';
 import 'url';
-import './utils-b780070b.js';
+import './utils-49e5008c.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-113b8b23.js';
-import './utils-b780070b.js';
+export { c as createVitest } from './index-40564dba.js';
+import './utils-49e5008c.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
+import 'chai';
+import 'tinyspy';
 import 'vite';
 import 'process';
 import 'fs';
@@ -10,10 +12,10 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './constants-3cbd9066.js';
+import './constants-c4dc2ff5.js';
 import 'url';
 import 'perf_hooks';
-import './error-34c1d9e5.js';
+import './error-796962c6.js';
 import './index-825cb54c.js';
 import './_commonjsHelpers-bdec4bbd.js';
 import 'assert';