vitest 0.0.98 → 0.0.102

package/dist/{index-5cc247ff.js → index-825cb54c.js}

@@ -1,8 +1,7 @@
+import { c as commonjsGlobal } from './_commonjsHelpers-bdec4bbd.js';
 import assert$1 from 'assert';
 import require$$2 from 'events';
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
 var onetime$2 = {exports: {}};
 
 var mimicFn$2 = {exports: {}};
@@ -328,4 +327,4 @@ if (!processOk(process$1)) {
 
 var signalExit = signalExit$1.exports;
 
-export { signalExit$1 as a, onetime$2 as b, commonjsGlobal as c, onetime$1 as o, signalExit as s };
+export { signalExit$1 as a, onetime$2 as b, onetime$1 as o, signalExit as s };

package/dist/{index-368448f4.js → index-a190f5a1.js}

@@ -1,4 +1,4 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-b8c6cb53.js';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-64b3e636.js';
 import chai, { util, assert, should, expect } from 'chai';
 import * as tinyspy from 'tinyspy';
 import { spies } from 'tinyspy';

package/dist/index.d.ts

@@ -173,6 +173,12 @@ interface UserConsoleLog {
     taskId?: string;
 }
 
+declare type ChainableFunction<T extends string, Args extends any[], R = any> = {
+    (...args: Args): R;
+} & {
+    [x in T]: ChainableFunction<T, Args, R>;
+};
+
 declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 declare type TaskState = RunMode | 'pass' | 'fail';
 declare type ComputeMode = 'serial' | 'concurrent';
@@ -203,36 +209,16 @@ interface Test extends TaskBase {
     type: 'test';
     suite: Suite;
     result?: TaskResult;
+    fails?: boolean;
 }
 declare type Task = Test | Suite | File;
 declare type DoneCallback = (error?: any) => void;
 declare type TestFunction = (done: DoneCallback) => Awaitable<void>;
-declare type TestCollectorFn = (name: string, fn: TestFunction, timeout?: number) => void;
-interface ConcurrentCollector {
-    (name: string, fn: TestFunction, timeout?: number): void;
-    only: TestCollectorFn;
-    skip: TestCollectorFn;
-    todo: (name: string) => void;
-}
-interface OnlyCollector {
-    (name: string, fn: TestFunction, timeout?: number): void;
-    concurrent: TestCollectorFn;
-}
-interface SkipCollector {
-    (name: string, fn: TestFunction, timeout?: number): void;
-    concurrent: TestCollectorFn;
-}
-interface TodoCollector {
-    (name: string): void;
-    concurrent: (name: string) => void;
-}
-interface TestCollector {
-    (name: string, fn: TestFunction, timeout?: number): void;
-    concurrent: ConcurrentCollector;
-    only: OnlyCollector;
-    skip: SkipCollector;
-    todo: TodoCollector;
-}
+declare type TestCollector = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
+    name: string,
+    fn?: TestFunction,
+    timeout?: number
+], void>;
 declare type HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
 interface SuiteHooks {
     beforeAll: HookListener<[Suite]>[];
@@ -452,7 +438,14 @@ interface UserConfig extends InlineConfig {
      * - `vite.config.ts`
      */
     config?: string | undefined;
+    /**
+     * Use happy-dom
+     */
     dom?: boolean;
+    /**
+     * Do not watch
+     */
+    run?: boolean;
 }
 interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'> {
     config?: string;
@@ -485,90 +478,10 @@ declare type RpcPayload<T extends keyof RpcMap = keyof RpcMap> = {
     args: RpcMap[T][0];
 };
 
-declare const suite: {
-    (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-    concurrent: {
-        (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        skip(suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        only(suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        todo(suiteName: string): SuiteCollector;
-    };
-    skip: {
-        (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        concurrent: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
-    };
-    only: {
-        (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        concurrent: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
-    };
-    todo: {
-        (suiteName: string): SuiteCollector;
-        concurrent: (suiteName: string) => SuiteCollector;
-    };
-};
-declare const test: {
-    (name: string, fn: TestFunction, timeout?: number | undefined): void;
-    concurrent: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        skip(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        only(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        todo(name: string): void;
-    };
-    skip: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    only: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    todo: {
-        (name: string): void;
-        concurrent(name: string): void;
-    };
-};
-declare const describe: {
-    (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-    concurrent: {
-        (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        skip(suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        only(suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        todo(suiteName: string): SuiteCollector;
-    };
-    skip: {
-        (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        concurrent: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
-    };
-    only: {
-        (suiteName: string, factory?: TestFactory | undefined): SuiteCollector;
-        concurrent: (suiteName: string, factory?: TestFactory | undefined) => SuiteCollector;
-    };
-    todo: {
-        (suiteName: string): SuiteCollector;
-        concurrent: (suiteName: string) => SuiteCollector;
-    };
-};
-declare const it: {
-    (name: string, fn: TestFunction, timeout?: number | undefined): void;
-    concurrent: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        skip(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        only(name: string, fn: TestFunction, timeout?: number | undefined): void;
-        todo(name: string): void;
-    };
-    skip: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    only: {
-        (name: string, fn: TestFunction, timeout?: number | undefined): void;
-        concurrent(name: string, fn: TestFunction, timeout?: number | undefined): void;
-    };
-    todo: {
-        (name: string): void;
-        concurrent(name: string): void;
-    };
-};
+declare const suite: ChainableFunction<"skip" | "only" | "todo" | "concurrent", [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 it: TestCollector;
 declare global {
     namespace NodeJS {
         interface Process {
@@ -657,12 +570,14 @@ declare class VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
+declare type VitestInlineConfig = InlineConfig;
+
 declare module 'vite' {
     interface UserConfig {
         /**
          * Options for Vitest
          */
-        test?: InlineConfig;
+        test?: VitestInlineConfig;
     }
 }
 declare global {

package/dist/index.js

@@ -1,5 +1,9 @@
-export { d as describe, i as it, s as suite, t as test } from './suite-b8c6cb53.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-368448f4.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-64b3e636.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-a190f5a1.js';
 export { assert, default as chai, expect, should } from 'chai';
 import './index-9e71c815.js';
+import './utils-c8e62373.js';
+import 'tty';
+import 'local-pkg';
+import 'path';
 import 'tinyspy';

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

@@ -1,6 +1,8 @@
-import { A as API_PATH } from './constants-e78c749a.js';
+import { A as API_PATH } from './constants-a1417084.js';
 import 'url';
-import './index-1488b423.js';
+import './utils-c8e62373.js';
+import 'tty';
+import 'local-pkg';
 import 'path';
 
 /*! (c) 2020 Andrea Giammarchi */

package/dist/node.d.ts

@@ -0,0 +1,309 @@
+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.ts']
+     */
+    include?: string[];
+    /**
+     * Exclude globs for test files
+     * @default ['**\/node_modules\/**']
+     */
+    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;
+}
+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;
+}
+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,21 +1,21 @@
-export { c as createVitest } from './index-0697046c.js';
-import './index-1488b423.js';
+export { c as createVitest } from './index-37755855.js';
+import './utils-c8e62373.js';
+import 'tty';
+import 'local-pkg';
 import 'path';
 import 'vite';
 import 'process';
 import 'fs';
-import 'fast-glob';
+import 'os';
 import 'util';
-import './constants-e78c749a.js';
+import 'stream';
+import 'events';
+import './constants-a1417084.js';
 import 'url';
-import './utils-70b78878.js';
-import 'tty';
-import 'local-pkg';
 import 'perf_hooks';
-import './error-2437ee7f.js';
-import 'source-map';
-import './index-5cc247ff.js';
+import './error-d97062cd.js';
+import './index-825cb54c.js';
+import './_commonjsHelpers-bdec4bbd.js';
 import 'assert';
-import 'events';
 import 'worker_threads';
 import 'tinypool';