vitest 0.24.5 → 0.25.1

package/dist/suite.js

@@ -1,16 +1,16 @@
 import 'util';
-import './chunk-mock-date.030959d3.js';
-export { b as bench, f as clearCollectorContext, p as createSuiteHooks, h as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.37ec5d73.js';
+import './chunk-typecheck-constants.4891f22f.js';
+export { b as bench, f as clearCollectorContext, q as createSuiteHooks, h as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.e387e274.js';
 import 'path';
-import './chunk-utils-env.b1281522.js';
+import './chunk-utils-env.03f840f2.js';
 import 'tty';
 import 'url';
 import 'local-pkg';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.b418c0ab.js';
-import './chunk-utils-timers.8fca243e.js';
+import './chunk-runtime-rpc.1e7530d3.js';
+import './chunk-utils-timers.06f993db.js';
 import 'fs';
-import './chunk-utils-source-map.663e2952.js';
+import './chunk-utils-source-map.c6dfbbc1.js';
 import './spy.js';
 import 'tinyspy';

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

@@ -1,5 +1,5 @@
 import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
-import { Task as Task$1, Options, TaskResult as TaskResult$1, Bench } from 'tinybench';
+import { Task as Task$1, TaskResult as TaskResult$1, Bench, Options } from 'tinybench';
 import { Stats } from 'fs';
 import { MessagePort } from 'worker_threads';
 
@@ -202,6 +202,7 @@ interface ErrorPayload {
 
 interface CustomEventMap {
   'vite:beforeUpdate': UpdatePayload
+  'vite:afterUpdate': UpdatePayload
   'vite:beforePrune': PrunePayload
   'vite:beforeFullReload': FullReloadPayload
   'vite:error': ErrorPayload
@@ -263,6 +264,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 +281,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 +332,7 @@ interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
+    map?: RawSourceMap;
     /**
      * Module ids that imports this module
      */
@@ -410,6 +417,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 +435,73 @@ 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: File;
+    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(): File[];
+}
+
 declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
 interface WorkerPool {
     runTests: RunWithFiles;
@@ -479,12 +554,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 +588,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 +629,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 +643,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 +662,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 +704,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 +718,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 +733,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;
     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 +819,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 +1124,7 @@ interface ErrorWithDiff extends Error {
     expected?: any;
     operator?: string;
     type?: string;
+    frame?: string;
 }
 interface ModuleGraphData {
     graph: Record<string, string[]>;
@@ -1075,7 +1189,6 @@ interface Benchmark extends TaskBase {
     result?: TaskResult;
     fails?: boolean;
     task?: Task$1;
-    options: Options;
 }
 interface BenchmarkResult extends TaskResult$1 {
     name: string;
@@ -1134,8 +1247,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 +1350,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 +1657,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>;
@@ -1544,6 +1666,7 @@ interface Reporter {
 declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 declare type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
 declare type CSSModuleScopeStrategy = 'stable' | 'scoped' | 'non-scoped';
+declare type SequenceHooks = 'stack' | 'list' | 'parallel';
 declare type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
 
 interface EnvironmentOptions {
@@ -1553,7 +1676,7 @@ interface EnvironmentOptions {
     jsdom?: JSDOMOptions;
     [x: string]: unknown;
 }
-declare type VitestRunMode = 'test' | 'benchmark';
+declare type VitestRunMode = 'test' | 'benchmark' | 'typecheck';
 interface InlineConfig {
     /**
      * Benchmark options.
@@ -1903,6 +2026,14 @@ interface InlineConfig {
          * @default Date.now()
          */
         seed?: number;
+        /**
+         * Defines how hooks should be ordered
+         * - `stack` will order "after" hooks in reverse order, "before" hooks will run sequentially
+         * - `list` will order hooks in the order they are defined
+         * - `parallel` will run hooks in a single group in parallel
+         * @default 'parallel'
+         */
+        hooks?: SequenceHooks;
     };
     /**
      * Specifies an `Object`, or an `Array` of `Object`,
@@ -1914,16 +2045,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 +2111,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;
@@ -1977,10 +2135,17 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     } | false;
     sequence: {
         sequencer: TestSequencerConstructor;
+        hooks: SequenceHooks;
         shuffle?: boolean;
         seed?: number;
     };
+    typecheck: TypecheckConfig;
 }
+declare type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency'> & {
+    sequence?: {
+        hooks?: SequenceHooks;
+    };
+};
 
 declare type VitestInlineConfig = InlineConfig;
 declare module 'vite' {
@@ -2243,4 +2408,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 { WorkerContext as $, ApiConfig as A, BuiltinEnvironment as B, CollectLineNumbers as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SuiteFactory as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, RuntimeContext as K, TestContext as L, ModuleGraphData as M, Vitest as N, OnTestFailedHandler as O, SnapshotData as P, SnapshotUpdateState as Q, RuntimeConfig as R, SequenceHooks as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, SnapshotStateOptions as W, SnapshotMatchOptions as X, SnapshotResult as Y, UncheckedSnapshot as Z, SnapshotSummary as _, File as a, ResolveIdFunction as a0, AfterSuiteRunMeta as a1, WorkerRPC as a2, WorkerGlobalState as a3, Awaitable as a4, Nullable as a5, Arrayable as a6, ArgumentsType$1 as a7, MergeInsertions as a8, DeepMerge as a9, ViteNodeRunner as aA, TestSequencer as aB, startVitest as aC, TestSequencerConstructor as aD, MutableArray as aa, Constructable as ab, ModuleCache as ac, EnvironmentReturn as ad, Environment as ae, UserConsoleLog as af, Position as ag, ParsedStack as ah, ErrorWithDiff as ai, OnServerRestartHandler as aj, CoverageProvider as ak, CoverageProviderModule as al, CoverageReporter as am, CoverageOptions as an, ResolvedCoverageOptions as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageC8Options as ar, BenchmarkUserOptions as as, Benchmark as at, BenchmarkResult as au, BenchFunction as av, BenchmarkAPI as aw, ModuleCacheMap as ax, ViteNodeRunnerOptions as ay, MockMap as az, ResolvedConfig as b, Reporter as c, RawErrsMap as d, TscErrorInfo as e, CollectLines as f, RootAndTarget as g, Context as h, CSSModuleScopeStrategy as i, VitestRunMode as j, TypecheckConfig as k, RunMode as l, TaskState as m, TaskBase as n, TaskResult as o, Suite as p, Test as q, TypeCheck as r, Task as s, TestFunction as t, TestOptions as u, TestAPI as v, SuiteAPI as w, HookCleanupCallback as x, SuiteHooks as y, SuiteCollector as z };

package/dist/{vendor-index.cc8d244b.js → vendor-index.737c3cff.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.e1d4cf84.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();