vitest 0.17.1 → 0.19.0

package/dist/node.d.ts

@@ -1,4 +1,4 @@
-import { ViteDevServer, TransformResult, CommonServerOptions, UserConfig as UserConfig$1, Plugin as Plugin$1 } from 'vite';
+import { ViteDevServer, TransformResult, AliasOptions, CommonServerOptions, UserConfig as UserConfig$1, Plugin as Plugin$1 } from 'vite';
 import { Stats } from 'fs';
 
 interface UpdatePayload {
@@ -51,26 +51,18 @@ interface CustomEventMap {
 type InferCustomEventPayload<T extends string> =
   T extends keyof CustomEventMap ? CustomEventMap[T] : any
 
-type ModuleNamespace = Record<string, any> & {
-  [Symbol.toStringTag]: 'Module'
-}
-
 interface ViteHotContext {
   readonly data: any
 
   accept(): void
-  accept(cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(
-    deps: readonly string[],
-    cb: (mods: Array<ModuleNamespace | undefined>) => void
-  ): void
+  accept(cb: (mod: any) => void): void
+  accept(dep: string, cb: (mod: any) => void): void
+  accept(deps: readonly string[], cb: (mods: any[]) => void): void
 
-  acceptExports(exportNames: string | readonly string[]): void
-  acceptExports(
-    exportNames: string | readonly string[],
-    cb: (mod: ModuleNamespace | undefined) => void
-  ): void
+  /**
+   * @deprecated
+   */
+  acceptDeps(): never
 
   dispose(cb: (data: any) => void): void
   decline(): void
@@ -365,14 +357,19 @@ declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
     watchFilters?: string[];
-    isTTY: boolean;
+    isTTY: false;
     ctx: Vitest;
+    private _filesInWatchMode;
+    private _lastRunTimeout;
+    private _lastRunTimer;
+    private _lastRunCount;
     constructor();
     onInit(ctx: Vitest): void;
     relative(path: string): string;
     onFinished(files?: File[], errors?: unknown[]): Promise<void>;
     onTaskUpdate(packs: TaskResultPack[]): void;
     onWatcherStart(): Promise<void>;
+    private resetLastRunLog;
     onWatcherRerun(files: string[], trigger?: string): Promise<void>;
     onUserConsoleLog(log: UserConsoleLog): void;
     shouldLog(log: UserConsoleLog): boolean;
@@ -382,9 +379,35 @@ declare abstract class BaseReporter implements Reporter {
     registerUnhandledRejection(): void;
 }
 
+declare class Logger {
+    ctx: Vitest;
+    console: Console;
+    outputStream: NodeJS.WriteStream & {
+        fd: 1;
+    };
+    errorStream: NodeJS.WriteStream & {
+        fd: 2;
+    };
+    logUpdate: ((...text: string[]) => void) & {
+        clear(): void;
+        done(): void;
+    };
+    private _clearScreenPending;
+    constructor(ctx: Vitest, console?: Console);
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    warn(...args: any[]): 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>;
+}
+
 interface ListRendererOptions {
     renderSucceed?: boolean;
-    outputStream: NodeJS.WritableStream;
+    logger: Logger;
     showHeap: boolean;
 }
 declare const createListRenderer: (_tasks: Task[], options: ListRendererOptions) => {
@@ -416,6 +439,10 @@ declare class DotReporter extends BaseReporter {
     onUserConsoleLog(log: UserConsoleLog): void;
 }
 
+interface Callsite {
+    line: number;
+    column: number;
+}
 declare class JsonReporter implements Reporter {
     start: number;
     ctx: Vitest;
@@ -428,6 +455,7 @@ declare class JsonReporter implements Reporter {
      * @param report
      */
     writeReport(report: string): Promise<void>;
+    protected getFailureLocation(test: Test): Callsite | undefined;
 }
 
 declare class VerboseReporter extends DefaultReporter {
@@ -482,7 +510,7 @@ interface TestSequencer {
     shard(files: string[]): Awaitable<string[]>;
     sort(files: string[]): Awaitable<string[]>;
 }
-interface TestSequencerContructor {
+interface TestSequencerConstructor {
     new (ctx: Vitest): TestSequencer;
 }
 
@@ -727,6 +755,7 @@ interface TestContext {
 
 interface Reporter {
     onInit?(ctx: Vitest): void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
     onCollected?: (files?: File[]) => Awaitable<void>;
     onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
     onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
@@ -936,6 +965,12 @@ interface InlineConfig {
      * @default 10000
      */
     hookTimeout?: number;
+    /**
+     * Default timeout to wait for close when Vitest shuts down, in milliseconds
+     *
+     * @default 1000
+     */
+    teardownTimeout?: number;
     /**
      * Silent mode
      *
@@ -1004,6 +1039,11 @@ interface InlineConfig {
      * @internal WIP
      */
     ui?: boolean;
+    /**
+     * Use in browser environment
+     * @experimental
+     */
+    browser?: boolean;
     /**
      * Open UI automatically.
      *
@@ -1103,7 +1143,7 @@ interface InlineConfig {
          * your custom sequencer from `BaseSequencer` from `vitest/node`.
          * @default BaseSequencer
          */
-        sequencer?: TestSequencerContructor;
+        sequencer?: TestSequencerConstructor;
         /**
          * Should tests run in random order.
          * @default false
@@ -1115,6 +1155,12 @@ interface InlineConfig {
          */
         seed?: number;
     };
+    /**
+     * Specifies an `Object`, or an `Array` of `Object`,
+     * which defines aliases used to replace values in `import` or `require` statements.
+     * Will be merged with the default aliases inside `resolve.alias`.
+     */
+    alias?: AliasOptions;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -1173,7 +1219,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
         dir: string;
     } | false;
     sequence: {
-        sequencer: TestSequencerContructor;
+        sequencer: TestSequencerConstructor;
         shuffle?: boolean;
         seed?: number;
     };
@@ -1457,6 +1503,27 @@ interface WorkerPool {
     close: () => Promise<void>;
 }
 
+declare class StateManager {
+    filesMap: Map<string, File>;
+    pathsSet: Set<string>;
+    idMap: Map<string, Task>;
+    taskFileMap: WeakMap<Task, File>;
+    errorsSet: Set<unknown>;
+    catchError(err: unknown, type: string): void;
+    clearErrors(): void;
+    getUnhandledErrors(): unknown[];
+    getPaths(): string[];
+    getFiles(keys?: string[]): File[];
+    getFilepaths(): string[];
+    getFailedFilepaths(): string[];
+    collectPaths(paths?: string[]): void;
+    collectFiles(files?: File[]): void;
+    clearFiles(paths?: string[]): void;
+    updateId(task: Task): void;
+    updateTasks(packs: TaskResultPack[]): void;
+    updateUserLog(log: UserConsoleLog): void;
+}
+
 interface SuiteResultCache {
     failed: boolean;
     duration: number;
@@ -1466,6 +1533,7 @@ declare class ResultsCache {
     private cachePath;
     private version;
     private root;
+    getCachePath(): string | null;
     setConfig(root: string, config: ResolvedConfig['cache']): void;
     getResults(fsPath: string): SuiteResultCache | undefined;
     readFromCache(): Promise<void>;
@@ -1474,6 +1542,14 @@ declare class ResultsCache {
     writeToCache(): Promise<void>;
 }
 
+interface CliOptions extends UserConfig {
+    /**
+     * Override the watch mode
+     */
+    run?: boolean;
+}
+declare function startVitest(cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<boolean>;
+
 declare type FileStatsCache = Pick<Stats, 'size'>;
 declare class FilesStatsCache {
     cache: Map<string, FileStatsCache>;
@@ -1482,27 +1558,18 @@ declare class FilesStatsCache {
     removeStats(fsPath: string): void;
 }
 
-declare class StateManager {
-    filesMap: Map<string, File>;
-    idMap: Map<string, Task>;
-    taskFileMap: WeakMap<Task, File>;
-    errorsSet: Set<unknown>;
+declare class VitestCache {
     results: ResultsCache;
     stats: FilesStatsCache;
     getFileTestResults(id: string): SuiteResultCache | undefined;
     getFileStats(id: string): {
         size: number;
     } | undefined;
-    catchError(err: unknown, type: string): void;
-    clearErrors(): void;
-    getUnhandledErrors(): unknown[];
-    getFiles(keys?: string[]): File[];
-    getFilepaths(): string[];
-    getFailedFilepaths(): string[];
-    collectFiles(files?: File[]): void;
-    updateId(task: Task): void;
-    updateTasks(packs: TaskResultPack[]): void;
-    updateUserLog(log: UserConsoleLog): void;
+    static resolveCacheDir(root: string, dir: string | undefined): string;
+    static clearCache(options: CliOptions): Promise<{
+        dir: string;
+        cleared: boolean;
+    }>;
 }
 
 declare class Vitest {
@@ -1511,15 +1578,10 @@ declare class Vitest {
     server: ViteDevServer;
     state: StateManager;
     snapshot: SnapshotManager;
+    cache: VitestCache;
     reporters: Reporter[];
-    console: Console;
+    logger: Logger;
     pool: WorkerPool | undefined;
-    outputStream: NodeJS.WriteStream & {
-        fd: 1;
-    };
-    errorStream: NodeJS.WriteStream & {
-        fd: 2;
-    };
     vitenode: ViteNodeServer;
     invalidates: Set<string>;
     changedTests: Set<string>;
@@ -1528,8 +1590,8 @@ declare class Vitest {
     isFirstRun: boolean;
     restartsCount: number;
     runner: ViteNodeRunner;
-    private _onRestartListeners;
     constructor();
+    private _onRestartListeners;
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
     getSerializableConfig(): ResolvedConfig;
     start(filters?: string[]): Promise<void>;
@@ -1540,9 +1602,6 @@ declare class Vitest {
     changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
     rerunFailed(): Promise<void>;
     updateSnapshot(files?: string[]): Promise<void>;
-    log(...args: any[]): void;
-    error(...args: any[]): void;
-    clearScreen(): void;
     private _rerunTimer;
     private scheduleRerun;
     private unregisterWatcher;
@@ -1557,7 +1616,6 @@ declare class Vitest {
     globTestFiles(filters?: string[]): Promise<string[]>;
     isTargetFile(id: string, source?: string): Promise<boolean>;
     isInSourceTestFile(code: string): boolean;
-    printError(err: unknown, fullStack?: boolean, type?: string): Promise<void>;
     onServerRestarted(fn: () => void): void;
 }
 
@@ -1565,14 +1623,7 @@ declare function createVitest(options: UserConfig, viteOverrides?: UserConfig$1)
 
 declare function VitestPlugin(options?: UserConfig, ctx?: Vitest): Promise<Plugin$1[]>;
 
-interface CliOptions extends UserConfig {
-    /**
-     * Override the watch mode
-     */
-    run?: boolean;
-}
-declare function startVitest(cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<boolean>;
-
+declare type Key = string | symbol;
 interface ViteRunnerRequest {
     (dep: string): any;
     callstack: string[];
@@ -1598,7 +1649,7 @@ declare class VitestMocker {
     normalizePath(path: string): string;
     getFsPath(path: string, external: string | null): string;
     resolveMockPath(mockPath: string, external: string | null): string | null;
-    mockValue(value: any): any;
+    mockObject(object: Record<string | symbol, any>): Record<Key, any>;
     unmockPath(path: string): void;
     mockPath(path: string, external: string | null, factory?: () => any): void;
     importActual<T>(id: string, importer: string): Promise<T>;
@@ -1629,4 +1680,4 @@ declare class BaseSequencer implements TestSequencer {
     sort(files: string[]): Promise<string[]>;
 }
 
-export { BaseSequencer, ExecuteOptions, TestSequencer, TestSequencerContructor, Vitest, VitestPlugin, VitestRunner, createVitest, startVitest };
+export { BaseSequencer, ExecuteOptions, TestSequencer, TestSequencerConstructor, Vitest, VitestPlugin, VitestRunner, createVitest, startVitest };

package/dist/node.mjs

@@ -1,33 +1,31 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.0fc8ed68.mjs';
-export { V as VitestRunner } from './chunk-runtime-mocker.34b9d585.mjs';
-import './chunk-env-node.aa51c4cc.mjs';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.a2813ad7.mjs';
+export { V as VitestRunner } from './chunk-runtime-mocker.dfdfd57b.mjs';
+import './chunk-utils-global.2aa95025.mjs';
+import 'path';
+import 'tty';
 import 'local-pkg';
+import './chunk-defaults.408a0cfe.mjs';
 import 'fs';
 import 'module';
 import 'url';
-import './chunk-utils-global.4828c2e2.mjs';
-import 'tty';
-import 'path';
 import 'vite';
 import 'process';
-import './chunk-constants.27550afb.mjs';
-import 'readline';
+import './chunk-constants.38b43a44.mjs';
 import 'os';
 import 'util';
 import 'stream';
 import 'events';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-vite-node-utils.0f776286.mjs';
+import './chunk-vite-node-utils.ad73f2ab.mjs';
 import 'vm';
 import 'assert';
 import 'debug';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-source-map.a9047343.mjs';
-import './vendor-index.a2a385d8.mjs';
-import 'child_process';
-import 'buffer';
+import './chunk-utils-source-map.8b066ce2.mjs';
 import 'crypto';
+import './vendor-index.61438b77.mjs';
 import './chunk-magic-string.efe26975.mjs';
-import './vendor-index.98e769c1.mjs';
+import 'readline';
+import './vendor-index.de788b6a.mjs';

package/dist/spy.mjs

@@ -1,2 +1,102 @@
-export { f as fn, i as isMockFunction, a as spies, s as spyOn } from './chunk-integrations-spy.674b628e.mjs';
-import 'tinyspy';
+import * as tinyspy from 'tinyspy';
+
+const spies = /* @__PURE__ */ new Set();
+function isMockFunction(fn2) {
+  return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
+}
+function spyOn(obj, method, accessType) {
+  const dictionary = {
+    get: "getter",
+    set: "setter"
+  };
+  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
+  const stub = tinyspy.spyOn(obj, objMethod);
+  return enhanceSpy(stub);
+}
+let callOrder = 0;
+function enhanceSpy(spy) {
+  const stub = spy;
+  let implementation;
+  let instances = [];
+  let invocations = [];
+  const mockContext = {
+    get calls() {
+      return stub.calls;
+    },
+    get instances() {
+      return instances;
+    },
+    get invocationCallOrder() {
+      return invocations;
+    },
+    get results() {
+      return stub.results.map(([callType, value]) => {
+        const type = callType === "error" ? "throw" : "return";
+        return { type, value };
+      });
+    },
+    get lastCall() {
+      return stub.calls[stub.calls.length - 1];
+    }
+  };
+  let onceImplementations = [];
+  let name = stub.name;
+  stub.getMockName = () => name || "vi.fn()";
+  stub.mockName = (n) => {
+    name = n;
+    return stub;
+  };
+  stub.mockClear = () => {
+    stub.reset();
+    instances = [];
+    invocations = [];
+    return stub;
+  };
+  stub.mockReset = () => {
+    stub.mockClear();
+    implementation = () => void 0;
+    onceImplementations = [];
+    return stub;
+  };
+  stub.mockRestore = () => {
+    stub.mockReset();
+    implementation = void 0;
+    return stub;
+  };
+  stub.getMockImplementation = () => implementation;
+  stub.mockImplementation = (fn2) => {
+    implementation = fn2;
+    return stub;
+  };
+  stub.mockImplementationOnce = (fn2) => {
+    onceImplementations.push(fn2);
+    return stub;
+  };
+  stub.mockReturnThis = () => stub.mockImplementation(function() {
+    return this;
+  });
+  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+  stub.mockRejectedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.reject(val));
+  Object.defineProperty(stub, "mock", {
+    get: () => mockContext
+  });
+  stub.willCall(function(...args) {
+    instances.push(this);
+    invocations.push(++callOrder);
+    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
+    });
+    return impl.apply(this, args);
+  });
+  spies.add(stub);
+  return stub;
+}
+function fn(implementation) {
+  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
+  }) }, "fn"));
+}
+
+export { fn, isMockFunction, spies, spyOn };

package/dist/suite.mjs

@@ -0,0 +1,13 @@
+import 'util';
+import './chunk-utils-global.2aa95025.mjs';
+export { e as clearCollectorContext, o as createSuiteHooks, f as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.1e1aabb3.mjs';
+import 'path';
+import 'tty';
+import 'local-pkg';
+import 'chai';
+import './vendor-_commonjsHelpers.4da45ef5.mjs';
+import './chunk-runtime-rpc.45d8ee19.mjs';
+import 'fs';
+import './chunk-utils-source-map.8b066ce2.mjs';
+import './spy.mjs';
+import 'tinyspy';