vitest 0.0.61 → 0.0.65

package/dist/{types-31dc4f04.d.ts → options-652352ad.d.ts}

@@ -1,7 +1,5 @@
-import { MessagePort } from 'worker_threads';
-import { Awaitable } from '@antfu/utils';
 import { TransformResult, ViteDevServer } from 'vite';
-import { SnapshotStateOptions } from 'jest-snapshot/build/State';
+import { OptionsReceived } from 'pretty-format';
 
 declare class StateManager {
     filesMap: Record<string, File>;
@@ -13,6 +11,142 @@ declare class StateManager {
     updateTasks(packs: TaskResultPack[]): void;
 }
 
+declare class SnapshotManager {
+    config: ResolvedConfig;
+    summary: SnapshotSummary;
+    constructor(config: ResolvedConfig);
+    clear(): void;
+    add(result: SnapshotResult): void;
+}
+
+declare type Awaitable<T> = T | PromiseLike<T>;
+declare type Nullable<T> = T | null | undefined;
+declare type Arrayable<T> = T | Array<T>;
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    transformResult?: TransformResult;
+}
+interface EnvironmentReturn {
+    teardown: (global: any) => Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    setup(global: any): Awaitable<EnvironmentReturn>;
+}
+interface VitestContext {
+    config: ResolvedConfig;
+    server: ViteDevServer;
+    state: StateManager;
+    snapshot: SnapshotManager;
+    reporter: Reporter;
+}
+
+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;
+}
+declare type Task = Test | Suite | File;
+declare type TestFunction = () => 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 HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
+interface SuiteHooks {
+    beforeAll: HookListener<[Suite]>[];
+    afterAll: HookListener<[Suite]>[];
+    beforeEach: HookListener<[Test, Suite]>[];
+    afterEach: HookListener<[Test, Suite]>[];
+}
+interface SuiteCollector {
+    readonly name: string;
+    readonly mode: RunMode;
+    type: 'collector';
+    test: TestCollector;
+    tasks: (Suite | Test | SuiteCollector)[];
+    collect: (file?: File) => Promise<Suite>;
+    clear: () => void;
+    on: <T extends keyof SuiteHooks>(name: T, ...fn: SuiteHooks[T]) => void;
+}
+declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
+interface GlobalContext {
+    tasks: (SuiteCollector | Test)[];
+    currentSuite: SuiteCollector | null;
+}
+
+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>;
+}
+
+declare type SnapshotData = Record<string, string>;
+declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type SnapshotStateOptions = {
+    updateSnapshot: SnapshotUpdateState;
+    expand?: boolean;
+    snapshotFormat?: OptionsReceived;
+};
+declare type SnapshotMatchOptions = {
+    testName: string;
+    received: unknown;
+    key?: string;
+    inlineSnapshot?: string;
+    isInline: boolean;
+    error?: Error;
+};
 interface SnapshotResult {
     filepath: string;
     added: number;
@@ -44,14 +178,6 @@ interface SnapshotSummary {
     updated: number;
 }
 
-declare class SnapshotManager {
-    config: ResolvedConfig;
-    summary: SnapshotSummary;
-    constructor(config: ResolvedConfig);
-    clear(): void;
-    add(result: SnapshotResult): void;
-}
-
 interface UserOptions {
     /**
      * Include globs for test files
@@ -91,11 +217,13 @@ interface UserOptions {
      */
     global?: boolean;
     /**
-     * Use `jsdom` or `happy-dom` to mock browser APIs
+     * Running environment
      *
-     * @default false
+     * Supports 'node', 'jsdom', 'happy-dom'
+     *
+     * @default 'node'
      */
-    dom?: boolean | 'jsdom' | 'happy-dom';
+    environment?: 'node' | 'jsdom' | 'happy-dom';
     /**
      * Update snapshot files
      *
@@ -117,10 +245,23 @@ interface UserOptions {
      */
     reporter?: Reporter;
     /**
-     * Interpret CJS module's default as named exports
+     * 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;
 }
 interface CliOptions extends UserOptions {
@@ -146,128 +287,5 @@ interface ResolvedConfig extends Omit<Required<CliOptions>, 'config' | 'filters'
     depsExternal: (string | RegExp)[];
     snapshotOptions: SnapshotStateOptions;
 }
-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;
-}
-declare type Task = Test | Suite | File;
-declare type TestFunction = () => 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 HookListener<T extends any[]> = (...args: T) => Awaitable<void>;
-interface SuiteHooks {
-    beforeAll: HookListener<[Suite]>[];
-    afterAll: HookListener<[Suite]>[];
-    beforeEach: HookListener<[Test, Suite]>[];
-    afterEach: HookListener<[Test, Suite]>[];
-}
-interface SuiteCollector {
-    readonly name: string;
-    readonly mode: RunMode;
-    type: 'collector';
-    test: TestCollector;
-    tasks: (Suite | Test | SuiteCollector)[];
-    collect: (file?: File) => Promise<Suite>;
-    clear: () => void;
-    on: <T extends keyof SuiteHooks>(name: T, ...fn: SuiteHooks[T]) => void;
-}
-declare type TestFactory = (test: (name: string, fn: TestFunction) => void) => Awaitable<void>;
-interface GlobalContext {
-    tasks: (SuiteCollector | Test)[];
-    currentSuite: SuiteCollector | null;
-}
-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>;
-}
-interface ModuleCache {
-    promise?: Promise<any>;
-    exports?: any;
-    transformResult?: TransformResult;
-}
-interface WorkerContext {
-    port: MessagePort;
-    config: ResolvedConfig;
-    files: string[];
-    invalidates?: string[];
-}
-interface RpcMap {
-    workerReady: [[], void];
-    fetch: [[id: string], TransformResult | null | undefined];
-    onCollected: [[files: File[]], void];
-    onFinished: [[], void];
-    onTaskUpdate: [[pack: TaskResultPack], void];
-    onWatcherStart: [[], void];
-    onWatcherRerun: [[files: string[], trigger: string], void];
-    snapshotSaved: [[snapshot: SnapshotResult], void];
-}
-declare type RpcCall = <T extends keyof RpcMap>(method: T, ...args: RpcMap[T][0]) => Promise<RpcMap[T][1]>;
-declare type RpcSend = <T extends keyof RpcMap>(method: T, ...args: RpcMap[T][0]) => void;
-declare type RpcPayload<T extends keyof RpcMap = keyof RpcMap> = {
-    id: string;
-    method: T;
-    args: RpcMap[T][0];
-};
-interface VitestContext {
-    config: ResolvedConfig;
-    server: ViteDevServer;
-    state: StateManager;
-    snapshot: SnapshotManager;
-    reporter: Reporter;
-}
 
-export { CliOptions as C, File as F, GlobalContext as G, HookListener as H, ModuleCache as M, ResolvedConfig as R, SuiteCollector as S, TestFactory as T, UserOptions as U, VitestContext as V, WorkerContext as W, TestFunction as a, SuiteHooks as b, RunMode as c, TaskState as d, ComputeMode as e, TaskBase as f, TaskResult as g, TaskResultPack as h, Suite as i, Test as j, Task as k, TestCollector as l, Reporter as m, RpcMap as n, RpcCall as o, RpcSend as p, RpcPayload as q };
+export { Awaitable as A, CliOptions as C, EnvironmentReturn as E, File as F, GlobalContext as G, HookListener as H, ModuleCache as M, Nullable as N, ResolvedConfig as R, SnapshotResult as S, TaskResultPack as T, UserOptions as U, VitestContext as V, TestFactory as a, SuiteCollector as b, TestFunction as c, SuiteHooks as d, RunMode as e, TaskState as f, ComputeMode as g, TaskBase as h, TaskResult as i, Suite as j, Test as k, Task as l, TestCollector as m, Reporter as n, SnapshotData as o, SnapshotUpdateState as p, SnapshotStateOptions as q, SnapshotMatchOptions as r, UncheckedSnapshot as s, SnapshotSummary as t, Arrayable as u, Environment as v };

package/dist/runtime/entry.d.ts

@@ -1,8 +1,6 @@
-import { R as ResolvedConfig } from '../types-31dc4f04';
-import 'worker_threads';
-import '@antfu/utils';
+import { R as ResolvedConfig } from '../options-652352ad';
 import 'vite';
-import 'jest-snapshot/build/State';
+import 'pretty-format';
 
 declare function run(files: string[], config: ResolvedConfig): Promise<void>;