vitest 0.24.5 → 0.25.0

package/dist/{global-58e8e951.d.ts → types-b3ff5eea.d.ts}

@@ -1,4 +1,5 @@
 import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+import * as tinybench from 'tinybench';
 import { Task as Task$1, Options, TaskResult as TaskResult$1, Bench } from 'tinybench';
 import { Stats } from 'fs';
 import { MessagePort } from 'worker_threads';
@@ -202,6 +203,7 @@ interface ErrorPayload {
 
 interface CustomEventMap {
   'vite:beforeUpdate': UpdatePayload
+  'vite:afterUpdate': UpdatePayload
   'vite:beforePrune': PrunePayload
   'vite:beforeFullReload': FullReloadPayload
   'vite:error': ErrorPayload
@@ -263,6 +265,10 @@ declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
      * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
      */
     invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    /**
+     * Return parsed source map based on inlined source map of the module
+     */
+    getSourceMap(id: string): any;
 }
 declare class ViteNodeRunner {
     options: ViteNodeRunnerOptions;
@@ -276,6 +282,7 @@ declare class ViteNodeRunner {
     constructor(options: ViteNodeRunnerOptions);
     executeFile(file: string): Promise<any>;
     executeId(id: string): Promise<any>;
+    getSourceMap(id: string): any;
     /** @internal */
     cachedRequest(rawId: string, callstack: string[]): Promise<any>;
     /** @internal */
@@ -326,6 +333,7 @@ interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
+    map?: RawSourceMap;
     /**
      * Module ids that imports this module
      */
@@ -410,6 +418,7 @@ declare class ViteNodeServer {
     constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
     shouldExternalize(id: string): Promise<string | false>;
     resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
+    getSourceMap(source: string): RawSourceMap | null;
     fetchModule(id: string): Promise<FetchResult>;
     transformRequest(id: string): Promise<TransformResult$1 | null | undefined>;
     getTransformMode(id: string): "web" | "ssr";
@@ -427,6 +436,92 @@ declare class SnapshotManager {
     resolvePath(testPath: string): string;
 }
 
+interface ParsedFile extends File {
+    start: number;
+    end: number;
+}
+interface ParsedSuite extends Suite {
+    start: number;
+    end: number;
+}
+interface LocalCallDefinition {
+    start: number;
+    end: number;
+    name: string;
+    type: string;
+    mode: 'run' | 'skip' | 'only' | 'todo';
+    task: ParsedSuite | ParsedFile;
+}
+interface FileInformation {
+    file: ParsedFile;
+    filepath: string;
+    parsed: string;
+    map: RawSourceMap | null;
+    definitions: LocalCallDefinition[];
+}
+
+declare class TypeCheckError extends Error {
+    message: string;
+    stacks: ParsedStack[];
+    name: string;
+    constructor(message: string, stacks: ParsedStack[]);
+}
+interface ErrorsCache {
+    files: File[];
+    sourceErrors: TypeCheckError[];
+}
+declare type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
+declare class Typechecker {
+    protected ctx: Vitest;
+    protected files: string[];
+    private _onParseStart?;
+    private _onParseEnd?;
+    private _onWatcherRerun?;
+    private _result;
+    private _tests;
+    private tempConfigPath?;
+    private process;
+    constructor(ctx: Vitest, files: string[]);
+    onParseStart(fn: Callback): void;
+    onParseEnd(fn: Callback<[ErrorsCache]>): void;
+    onWatcherRerun(fn: Callback): void;
+    protected collectFileTests(filepath: string): Promise<FileInformation | null>;
+    collectTests(): Promise<Record<string, FileInformation>>;
+    protected prepareResults(output: string): Promise<{
+        files: File[];
+        sourceErrors: TypeCheckError[];
+    }>;
+    protected parseTscLikeOutput(output: string): Promise<Map<string, {
+        error: TypeCheckError;
+        originalError: TscErrorInfo;
+    }[]>>;
+    clear(): Promise<void>;
+    stop(): Promise<void>;
+    protected ensurePackageInstalled(root: string, checker: string): Promise<void>;
+    start(): Promise<void>;
+    getResult(): ErrorsCache;
+    getTestFiles(): {
+        result: undefined;
+        start: number;
+        end: number;
+        filepath: string;
+        collectDuration?: number | undefined;
+        setupDuration?: number | undefined;
+        type: "suite";
+        tasks: Task[];
+        benchmark?: tinybench.Bench | undefined;
+        id: string;
+        name: string;
+        mode: RunMode;
+        concurrent?: boolean | undefined;
+        shuffle?: boolean | undefined;
+        suite?: Suite | undefined;
+        file?: File | undefined;
+        retry?: number | undefined;
+        logs?: UserConsoleLog[] | undefined;
+    }[];
+}
+
 declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
 interface WorkerPool {
     runTests: RunWithFiles;
@@ -479,12 +574,14 @@ declare class Logger {
     log(...args: any[]): void;
     error(...args: any[]): void;
     warn(...args: any[]): void;
+    clearFullScreen(message: string): void;
     clearScreen(message: string, force?: boolean): void;
     private _clearScreen;
     printError(err: unknown, fullStack?: boolean, type?: string): Promise<void>;
     printNoTestFound(filters?: string[]): void;
     printBanner(): void;
     printUnhandledErrors(errors: unknown[]): Promise<void>;
+    printSourceTypeErrors(errors: TypeCheckError[]): Promise<void>;
 }
 
 interface SuiteResultCache {
@@ -511,7 +608,12 @@ interface CliOptions extends UserConfig {
      */
     run?: boolean;
 }
-declare function startVitest(mode: VitestRunMode, cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<boolean>;
+/**
+ * Start Vitest programmatically
+ *
+ * Returns a Vitest instance if initialized successfully.
+ */
+declare function startVitest(mode: VitestRunMode, cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<Vitest | undefined>;
 
 declare type FileStatsCache = Pick<Stats, 'size'>;
 declare class FilesStatsCache {
@@ -547,6 +649,7 @@ declare class Vitest {
     coverageProvider: CoverageProvider | null | undefined;
     logger: Logger;
     pool: WorkerPool | undefined;
+    typechecker: Typechecker | undefined;
     vitenode: ViteNodeServer;
     invalidates: Set<string>;
     changedTests: Set<string>;
@@ -560,6 +663,7 @@ declare class Vitest {
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
     initCoverageProvider(): Promise<CoverageProvider | null | undefined>;
     getSerializableConfig(): ResolvedConfig;
+    typecheck(filters?: string[]): Promise<void>;
     start(filters?: string[]): Promise<void>;
     private getTestDependencies;
     filterTestsBySource(tests: string[]): Promise<string[]>;
@@ -578,6 +682,9 @@ declare class Vitest {
      */
     private handleFileChanged;
     close(): Promise<void>;
+    /**
+     * Close the thread pool and exit the process
+     */
     exit(force?: boolean): Promise<void>;
     report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
     globTestFiles(filters?: string[]): Promise<string[]>;
@@ -617,7 +724,7 @@ declare abstract class BaseReporter implements Reporter {
     relative(path: string): string;
     onFinished(files?: File[], errors?: unknown[]): Promise<void>;
     onTaskUpdate(packs: TaskResultPack[]): void;
-    onWatcherStart(): Promise<void>;
+    onWatcherStart(files?: File[], errors?: unknown[]): Promise<void>;
     private resetLastRunLog;
     onWatcherRerun(files: string[], trigger?: string): Promise<void>;
     onUserConsoleLog(log: UserConsoleLog): void;
@@ -631,12 +738,13 @@ declare abstract class BaseReporter implements Reporter {
     registerUnhandledRejection(): void;
 }
 
-interface ListRendererOptions {
+interface ListRendererOptions$1 {
     renderSucceed?: boolean;
     logger: Logger;
     showHeap: boolean;
+    mode: VitestRunMode;
 }
-declare const createListRenderer: (_tasks: Task[], options: ListRendererOptions) => {
+declare const createListRenderer: (_tasks: Task[], options: ListRendererOptions$1) => {
     start(): any;
     update(_tasks: Task[]): any;
     stop(): Promise<any>;
@@ -645,11 +753,11 @@ declare const createListRenderer: (_tasks: Task[], options: ListRendererOptions)
 
 declare class DefaultReporter extends BaseReporter {
     renderer?: ReturnType<typeof createListRenderer>;
-    rendererOptions: ListRendererOptions;
+    rendererOptions: ListRendererOptions$1;
     onTestRemoved(trigger?: string): Promise<void>;
-    onCollected(): void;
+    onCollected(files?: File[]): void;
     onFinished(files?: File[], errors?: unknown[]): Promise<void>;
-    onWatcherStart(): Promise<void>;
+    onWatcherStart(files?: File[], errors?: unknown[]): Promise<void>;
     stopListRender(): Promise<void>;
     onWatcherRerun(files: string[], trigger?: string): Promise<void>;
     onUserConsoleLog(log: UserConsoleLog): void;
@@ -731,8 +839,33 @@ declare class JsonReporter implements Reporter {
     writeReport(report: string): Promise<void>;
 }
 
+interface ListRendererOptions {
+    renderSucceed?: boolean;
+    logger: Logger;
+    showHeap: boolean;
+}
+declare const createTableRenderer: (_tasks: Task[], options: ListRendererOptions) => {
+    start(): any;
+    update(_tasks: Task[]): any;
+    stop(): Promise<any>;
+    clear(): void;
+};
+
+declare class TableReporter extends BaseReporter {
+    renderer?: ReturnType<typeof createTableRenderer>;
+    rendererOptions: ListRendererOptions$1;
+    onTestRemoved(trigger?: string): Promise<void>;
+    onCollected(): void;
+    onFinished(files?: File[], errors?: unknown[]): Promise<void>;
+    onWatcherStart(): Promise<void>;
+    stopListRender(): Promise<void>;
+    onWatcherRerun(files: string[], trigger?: string): Promise<void>;
+    onUserConsoleLog(log: UserConsoleLog): void;
+}
+
 declare const BenchmarkReportsMap: {
-    default: typeof VerboseReporter;
+    default: typeof TableReporter;
+    verbose: typeof VerboseReporter;
     json: typeof JsonReporter;
 };
 declare type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
@@ -1011,6 +1144,7 @@ interface ErrorWithDiff extends Error {
     expected?: any;
     operator?: string;
     type?: string;
+    frame?: string;
 }
 interface ModuleGraphData {
     graph: Record<string, string[]>;
@@ -1134,8 +1268,12 @@ interface Test<ExtraContext = {}> extends TaskBase {
     result?: TaskResult;
     fails?: boolean;
     context: TestContext & ExtraContext;
+    onFailed?: OnTestFailedHandler[];
+}
+interface TypeCheck extends TaskBase {
+    type: 'typecheck';
 }
-declare type Task = Test | Suite | File | Benchmark;
+declare type Task = Test | Suite | File | Benchmark | TypeCheck;
 declare type DoneCallback = (error?: any) => void;
 declare type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
 declare type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
@@ -1233,7 +1371,12 @@ interface TestContext {
      * A expect instance bound to the test
      */
     expect: Vi.ExpectStatic;
+    /**
+     * Extract hooks on test failed
+     */
+    onTestFailed: (fn: OnTestFailedHandler) => void;
 }
+declare type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
 
 declare type SnapshotData = Record<string, string>;
 declare type SnapshotUpdateState = 'all' | 'new' | 'none';
@@ -1535,7 +1678,7 @@ interface Reporter {
     onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
     onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
     onTestRemoved?: (trigger?: string) => Awaitable<void>;
-    onWatcherStart?: () => Awaitable<void>;
+    onWatcherStart?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
     onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
     onServerRestart?: (reason?: string) => Awaitable<void>;
     onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
@@ -1553,7 +1696,7 @@ interface EnvironmentOptions {
     jsdom?: JSDOMOptions;
     [x: string]: unknown;
 }
-declare type VitestRunMode = 'test' | 'benchmark';
+declare type VitestRunMode = 'test' | 'benchmark' | 'typecheck';
 interface InlineConfig {
     /**
      * Benchmark options.
@@ -1914,16 +2057,43 @@ interface InlineConfig {
      * Ignore any unhandled errors that occur
      */
     dangerouslyIgnoreUnhandledErrors?: boolean;
+    /**
+     * Options for configuring typechecking test environment.
+     */
+    typecheck?: Partial<TypecheckConfig>;
+}
+interface TypecheckConfig {
+    /**
+     * What tools to use for type checking.
+     */
+    checker: 'tsc' | 'vue-tsc' | (string & Record<never, never>);
+    /**
+     * Pattern for files that should be treated as test files
+     */
+    include: string[];
+    /**
+     * Pattern for files that should not be treated as test files
+     */
+    exclude: string[];
+    /**
+     * Check JS files that have `@ts-check` comment.
+     * If you have it enabled in tsconfig, this will not overwrite it.
+     */
+    allowJs?: boolean;
+    /**
+     * Do not fail, if Vitest found errors outside the test files.
+     */
+    ignoreSourceErrors?: boolean;
+    /**
+     * Path to tsconfig, relative to the project root.
+     */
+    tsconfig?: string;
 }
 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`
+     * Default resolving to `vitest.config.*`, `vite.config.*`
      */
     config?: string | undefined;
     /**
@@ -1953,7 +2123,7 @@ interface UserConfig extends InlineConfig {
      */
     shard?: string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck'> {
     mode: VitestRunMode;
     base?: string;
     config?: string;
@@ -1980,6 +2150,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
         shuffle?: boolean;
         seed?: number;
     };
+    typecheck: TypecheckConfig;
 }
 
 declare type VitestInlineConfig = InlineConfig;
@@ -2243,4 +2414,30 @@ declare global {
     }
 }
 
-export { MutableArray as $, ApiConfig as A, BuiltinEnvironment as B, CSSModuleScopeStrategy as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SnapshotSummary as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, ResolveIdFunction as K, AfterSuiteRunMeta as L, ModuleGraphData as M, WorkerRPC as N, WorkerGlobalState as O, Awaitable as P, Nullable as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, WorkerContext as W, Arrayable as X, ArgumentsType$1 as Y, MergeInsertions as Z, DeepMerge as _, File as a, Constructable as a0, ModuleCache as a1, EnvironmentReturn as a2, Environment as a3, UserConsoleLog as a4, Position as a5, ParsedStack as a6, ErrorWithDiff as a7, OnServerRestartHandler as a8, CoverageProvider as a9, CoverageProviderModule as aa, CoverageReporter as ab, CoverageOptions as ac, ResolvedCoverageOptions as ad, BaseCoverageOptions as ae, CoverageIstanbulOptions as af, CoverageC8Options as ag, BenchmarkUserOptions as ah, Benchmark as ai, BenchmarkResult as aj, BenchFunction as ak, BenchmarkAPI as al, ModuleCacheMap as am, ViteNodeRunnerOptions as an, MockMap as ao, ViteNodeRunner as ap, TestSequencer as aq, startVitest as ar, TestSequencerConstructor as as, Reporter as b, VitestRunMode as c, RunMode as d, TaskState as e, TaskBase as f, TaskResult as g, Test as h, Task as i, TestFunction as j, TestOptions as k, TestAPI as l, SuiteAPI as m, HookCleanupCallback as n, SuiteHooks as o, SuiteCollector as p, SuiteFactory as q, RuntimeContext as r, TestContext as s, Vitest as t, SnapshotData as u, SnapshotUpdateState as v, SnapshotStateOptions as w, SnapshotMatchOptions as x, SnapshotResult as y, UncheckedSnapshot as z };
+declare type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+    filePath: string;
+    errCode: number;
+    errMsg: string;
+    line: number;
+    column: number;
+}
+interface CollectLineNumbers {
+    target: number;
+    next: number;
+    prev?: number;
+}
+declare type CollectLines = {
+    [key in keyof CollectLineNumbers]: string;
+};
+interface RootAndTarget {
+    root: string;
+    targetAbsPath: string;
+}
+declare type Context = RootAndTarget & {
+    rawErrsMap: RawErrsMap;
+    openedDirs: Set<string>;
+    lastActivePath?: string;
+};
+
+export { AfterSuiteRunMeta as $, ApiConfig as A, BuiltinEnvironment as B, CollectLineNumbers as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, TestContext as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, Vitest as K, SnapshotData as L, ModuleGraphData as M, SnapshotUpdateState as N, OnTestFailedHandler as O, SnapshotStateOptions as P, SnapshotMatchOptions as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, SnapshotResult as W, UncheckedSnapshot as X, SnapshotSummary as Y, WorkerContext as Z, ResolveIdFunction as _, File as a, WorkerRPC as a0, WorkerGlobalState as a1, Awaitable as a2, Nullable as a3, Arrayable as a4, ArgumentsType$1 as a5, MergeInsertions as a6, DeepMerge as a7, MutableArray as a8, Constructable as a9, startVitest as aA, TestSequencerConstructor as aB, ModuleCache as aa, EnvironmentReturn as ab, Environment as ac, UserConsoleLog as ad, Position as ae, ParsedStack as af, ErrorWithDiff as ag, OnServerRestartHandler as ah, CoverageProvider as ai, CoverageProviderModule as aj, CoverageReporter as ak, CoverageOptions as al, ResolvedCoverageOptions as am, BaseCoverageOptions as an, CoverageIstanbulOptions as ao, CoverageC8Options as ap, BenchmarkUserOptions as aq, Benchmark as ar, BenchmarkResult as as, BenchFunction as at, BenchmarkAPI as au, ModuleCacheMap as av, ViteNodeRunnerOptions as aw, MockMap as ax, ViteNodeRunner as ay, TestSequencer as az, Reporter as b, RawErrsMap as c, TscErrorInfo as d, CollectLines as e, RootAndTarget as f, Context as g, CSSModuleScopeStrategy as h, VitestRunMode as i, TypecheckConfig as j, RunMode as k, TaskState as l, TaskBase as m, TaskResult as n, Test as o, TypeCheck as p, Task as q, TestFunction as r, TestOptions as s, TestAPI as t, SuiteAPI as u, HookCleanupCallback as v, SuiteHooks as w, SuiteCollector as x, SuiteFactory as y, RuntimeContext as z };

package/dist/{vendor-index.cc8d244b.js → vendor-index.16d769d7.js}

@@ -2,10 +2,9 @@ import { Buffer } from 'buffer';
 import path from 'path';
 import childProcess from 'child_process';
 import process$1 from 'process';
-import { m as mergeStream, g as getStream, c as crossSpawn } from './vendor-index.12d51d29.js';
+import { s as signalExit, m as mergeStream, g as getStream, c as crossSpawn } from './vendor-index.22806ffb.js';
 import url from 'url';
 import require$$0, { constants } from 'os';
-import { s as signalExit } from './vendor-index.1a291e86.js';
 
 function stripFinalNewline(input) {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();