vitest 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/chunks/{config.d.D91DHYaD.d.ts → config.d.C0UMwus7.d.ts}

@@ -4,66 +4,88 @@ import { L as LabelColor, g as SnapshotUpdateState } from './general.d.DFAHgpC2.
 import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.d.DOJxxZV9.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 
-/**
- * Names of clock methods that may be faked by install.
- */
-type FakeMethod =
-    | "setTimeout"
-    | "clearTimeout"
-    | "setImmediate"
-    | "clearImmediate"
-    | "setInterval"
-    | "clearInterval"
-    | "Date"
-    | "nextTick"
-    | "hrtime"
-    | "requestAnimationFrame"
-    | "cancelAnimationFrame"
-    | "requestIdleCallback"
-    | "cancelIdleCallback"
-    | "performance"
-    | "queueMicrotask";
-
-interface FakeTimerInstallOpts {
-    /**
-     * Installs fake timers with the specified unix epoch (default: 0)
-     */
-    now?: number | Date | undefined;
-
-    /**
-     * An array with names of global methods and APIs to fake. By default, `@sinonjs/fake-timers` does not replace `nextTick()` and `queueMicrotask()`.
-     * For instance, `FakeTimers.install({ toFake: ['setTimeout', 'nextTick'] })` will fake only `setTimeout()` and `nextTick()`
-     */
-    toFake?: FakeMethod[] | undefined;
-
-    /**
-     * The maximum number of timers that will be run when calling runAll() (default: 1000)
-     */
-    loopLimit?: number | undefined;
-
-    /**
-     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
-     * 20ms for every 20ms change in the real system time) (default: false)
-     */
-    shouldAdvanceTime?: boolean | undefined;
-
-    /**
-     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
-     * in the real system time (default: 20)
-     */
-    advanceTimeDelta?: number | undefined;
-
-    /**
-     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by
-     * default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers. (default: false)
-     */
-    shouldClearNativeTimers?: boolean | undefined;
-
-    /**
-     * Tells FakeTimers to not throw an error when faking a timer that does not exist in the global object. (default: false)
-     */
-    ignoreMissingTimers?: boolean | undefined;
-}
+type VoidVarArgsFunc = (...args: unknown[]) => void;
+type SetImmediate = (callback: VoidVarArgsFunc, ...args: unknown[]) => NodeImmediate;
+type SetTimeout = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
+type ClearTimeout = (id?: TimerId) => void;
+type SetInterval = (callback: VoidVarArgsFunc, delay?: number, ...args: unknown[]) => TimerId;
+type ClearInterval = (id?: TimerId) => void;
+type QueueMicrotask = (callback: VoidVarArgsFunc) => void;
+type TimeRemaining = () => number;
+type IdleDeadline = {
+    didTimeout: boolean;
+    timeRemaining: TimeRemaining;
+};
+type RequestIdleCallbackCallback = (deadline: IdleDeadline) => any;
+type RequestIdleCallback = (callback: RequestIdleCallbackCallback, options?: {
+    timeout?: number;
+}) => number;
+type AnimationFrameCallback = (timestamp: number) => any;
+type RequestAnimationFrame = (callback: AnimationFrameCallback) => TimerId;
+type CancelAnimationFrame = (id: TimerId) => void;
+type CancelIdleCallback = (id: TimerId) => void;
+type ClearImmediate = (id: NodeImmediate) => void;
+type FakeMethod = "setTimeout" | "clearTimeout" | "setImmediate" | "clearImmediate" | "setInterval" | "clearInterval" | "Date" | "nextTick" | "hrtime" | "requestAnimationFrame" | "cancelAnimationFrame" | "requestIdleCallback" | "cancelIdleCallback" | "performance" | "queueMicrotask";
+type TimerId = number | NodeImmediate | Timer;
+type GlobalObject = Record<string, any> & {
+    setTimeout?: SetTimeout;
+    clearTimeout?: ClearTimeout;
+    setInterval?: SetInterval;
+    clearInterval?: ClearInterval;
+    setImmediate?: SetImmediate;
+    clearImmediate?: ClearImmediate;
+    queueMicrotask?: QueueMicrotask;
+    requestAnimationFrame?: RequestAnimationFrame;
+    cancelAnimationFrame?: CancelAnimationFrame;
+    requestIdleCallback?: RequestIdleCallback;
+    cancelIdleCallback?: CancelIdleCallback;
+    process?: any;
+    performance?: any;
+    Performance?: any;
+    Intl?: any;
+    Promise?: typeof Promise;
+    Date: typeof Date & {
+        isFake?: boolean;
+        toSource?: () => string;
+        clock?: any;
+    };
+};
+type TimerInitialProps = {
+    func: VoidVarArgsFunc;
+    args?: unknown[];
+    type?: 'Timeout' | 'Interval' | 'Immediate' | 'AnimationFrame' | 'IdleCallback';
+    delay?: number;
+    callAt?: number;
+    createdAt?: number;
+    immediate?: boolean;
+    id?: number;
+    error?: Error;
+    interval?: number;
+    animation?: boolean;
+    requestIdleCallback?: boolean;
+    order?: number;
+    heapIndex?: number;
+};
+type Config = {
+    now?: number | Date;
+    toFake?: FakeMethod[];
+    toNotFake?: FakeMethod[];
+    loopLimit?: number;
+    shouldAdvanceTime?: boolean;
+    advanceTimeDelta?: number;
+    shouldClearNativeTimers?: boolean;
+    ignoreMissingTimers?: boolean;
+    target?: GlobalObject;
+};
+type Timer = TimerInitialProps;
+type NodeImmediateHasRef = () => boolean;
+type NodeImmediateRef = () => NodeImmediate;
+type NodeImmediateUnref = () => NodeImmediate;
+type NodeImmediate = {
+    hasRef: NodeImmediateHasRef;
+    ref: NodeImmediateRef;
+    unref: NodeImmediateUnref;
+};
 
 /**
 * Config that tests have access to.
@@ -93,7 +115,7 @@ interface SerializedConfig {
 	restoreMocks: boolean;
 	unstubGlobals: boolean;
 	unstubEnvs: boolean;
-	fakeTimers: FakeTimerInstallOpts;
+	fakeTimers: Config;
 	maxConcurrency: number;
 	defines: Record<string, any>;
 	expect: {
@@ -170,6 +192,7 @@ interface SerializedConfig {
 		locators: {
 			testIdAttribute: string;
 			exact: boolean;
+			errorFormat: "html" | "aria" | "all";
 		};
 		screenshotFailures: boolean;
 		providerOptions: {
@@ -216,7 +239,7 @@ interface SerializedConfig {
 	strictTags: boolean;
 	mergeReportsLabel: string | undefined;
 	slowTestThreshold: number | undefined;
-	isAgent: boolean;
+	disableColors: boolean;
 }
 interface SerializedCoverageConfig {
 	provider: "istanbul" | "v8" | "custom" | undefined;
@@ -237,4 +260,4 @@ type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookT
 type RuntimeOptions = Partial<RuntimeConfig>;
 type BrowserTraceViewMode = "on" | "off" | "on-first-retry" | "on-all-retries" | "retain-on-failure";
 
-export type { BrowserTraceViewMode as B, FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedRootConfig as S, SerializedConfig as a, RuntimeConfig as b, SerializedCoverageConfig as c };
+export type { BrowserTraceViewMode as B, Config as C, RuntimeOptions as R, SerializedRootConfig as S, SerializedConfig as a, RuntimeConfig as b, SerializedCoverageConfig as c };

package/dist/chunks/{defaults.szbHWQun.js → defaults.DVfzlTkU.js}

@@ -1,5 +1,5 @@
 import nodeos__default from 'node:os';
-import './env.D4Lgay0q.js';
+import './env.BKKtU2WC.js';
 import { isCI, isAgent } from 'std-env';
 
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];

package/dist/chunks/{env.D4Lgay0q.js → env.BKKtU2WC.js}

@@ -4,5 +4,6 @@ const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.v
 const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 const isWindows = (isNode || isDeno) && process.platform === "win32";
 const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
+const isForceColor = () => "FORCE_COLOR" in process.env;
 
-export { isWindows as a, isTTY as i };
+export { isTTY as a, isWindows as b, isForceColor as i };

package/dist/chunks/{global.d.DhbKSQoV.d.ts → global.d.DZbA5YnY.d.ts}

@@ -1,4 +1,4 @@
-import { P as PromisifyAssertion, T as Tester, E as ExpectStatic, l as BenchmarkResult } from './browser.d.BUhkKcDl.js';
+import { P as PromisifyAssertion, T as Tester, E as ExpectStatic, l as BenchmarkResult } from './browser.d.DM1g8UNp.js';
 import { Plugin } from '@vitest/pretty-format';
 import { Test } from '@vitest/runner';
 import { i as SnapshotState, U as UserConsoleLog } from './general.d.DFAHgpC2.js';
@@ -26,7 +26,9 @@ declare module "vitest" {
 		assert: Chai.AssertStatic;
 		unreachable: (message?: string) => never;
 		soft: <T>(actual: T, message?: string) => Assertion<T>;
-		poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+		poll: <T>(actual: (options: {
+			signal: AbortSignal;
+		}) => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
 		addEqualityTesters: (testers: Array<Tester>) => void;
 		assertions: (expected: number) => void;
 		hasAssertions: () => void;

package/dist/chunks/{globals.EHmmu0nC.js → globals.8_qjZdeE.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants.-juJ8b_4.js';
-import { i as index } from './index.D_7-4CaB.js';
+import { i as index } from './index.ukHtlBbI.js';
 import '@vitest/runner';
 import './utils.BX5Fg8C4.js';
 import '@vitest/utils/timers';

package/dist/chunks/{index.CViWo__T.js → index.PuMGMNHF.js}

@@ -1,9 +1,9 @@
 import * as chai from 'chai';
 import { createHook } from 'node:async_hooks';
-import { l as loadDiffConfig, a as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Hpq30zVk.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.eQsbxe88.js';
 import { r as rpc } from './rpc.DFRWVnRh.js';
 import { g as getWorkerState } from './utils.BX5Fg8C4.js';
-import { T as TestRunner, N as NodeBenchmarkRunner } from './index.D_7-4CaB.js';
+import { T as TestRunner, N as NodeBenchmarkRunner } from './index.ukHtlBbI.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);