vitest 2.0.4 → 2.0.5

package/dist/chunks/config.DCnyCTbs.d.ts

@@ -0,0 +1,203 @@
+import { PrettyFormatOptions } from '@vitest/pretty-format';
+import { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { SnapshotUpdateState } from '@vitest/snapshot';
+import { SnapshotEnvironment } from '@vitest/snapshot/environment';
+
+/**
+ * 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.
+     * For instance, `vi.useFakeTimer({ toFake: ['setTimeout', 'performance'] })` will fake only `setTimeout()` and `performance.now()`
+     * @default ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll()
+     * @default 10000
+     */
+    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.
+     * @default true
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+}
+
+/**
+ * Config that tests have access to.
+ */
+interface SerializedConfig {
+    name: string | undefined;
+    globals: boolean;
+    base: string | undefined;
+    snapshotEnvironment?: string;
+    disableConsoleIntercept: boolean | undefined;
+    runner: string | undefined;
+    isolate: boolean;
+    mode: 'test' | 'benchmark';
+    bail: number | undefined;
+    environmentOptions?: Record<string, any>;
+    root: string;
+    setupFiles: string[];
+    passWithNoTests: boolean;
+    testNamePattern: RegExp | undefined;
+    allowOnly: boolean;
+    testTimeout: number;
+    hookTimeout: number;
+    clearMocks: boolean;
+    mockReset: boolean;
+    restoreMocks: boolean;
+    unstubGlobals: boolean;
+    unstubEnvs: boolean;
+    fakeTimers: FakeTimerInstallOpts;
+    maxConcurrency: number;
+    defines: Record<string, any>;
+    expect: {
+        requireAssertions?: boolean;
+        poll?: {
+            timeout?: number;
+            interval?: number;
+        };
+    };
+    printConsoleTrace: boolean | undefined;
+    sequence: {
+        shuffle?: boolean;
+        concurrent?: boolean;
+        seed: number;
+        hooks: SequenceHooks;
+        setupFiles: SequenceSetupFiles;
+    };
+    poolOptions: {
+        forks: {
+            singleFork: boolean;
+            isolate: boolean;
+        };
+        threads: {
+            singleThread: boolean;
+            isolate: boolean;
+        };
+        vmThreads: {
+            singleThread: boolean;
+        };
+        vmForks: {
+            singleFork: boolean;
+        };
+    };
+    deps: {
+        web: {
+            transformAssets?: boolean;
+            transformCss?: boolean;
+            transformGlobPattern?: RegExp | RegExp[];
+        };
+        optimizer: {
+            web: {
+                enabled: boolean;
+            };
+            ssr: {
+                enabled: boolean;
+            };
+        };
+        interopDefault: boolean | undefined;
+        moduleDirectories: string[] | undefined;
+    };
+    snapshotOptions: {
+        updateSnapshot: SnapshotUpdateState;
+        expand: boolean | undefined;
+        snapshotFormat: PrettyFormatOptions | undefined;
+        /**
+         * only exists for tests, not available in the main process
+         */
+        snapshotEnvironment: SnapshotEnvironment;
+    };
+    pool: string;
+    snapshotSerializers: string[];
+    chaiConfig: {
+        includeStack?: boolean;
+        showDiff?: boolean;
+        truncateThreshold?: number;
+    } | undefined;
+    diff: string | undefined;
+    retry: number;
+    includeTaskLocation: boolean | undefined;
+    inspect: boolean | string | undefined;
+    inspectBrk: boolean | string | undefined;
+    inspector: {
+        enabled?: boolean;
+        port?: number;
+        host?: string;
+        waitForDebugger?: boolean;
+    };
+    watch: boolean;
+    env: Record<string, any>;
+    browser: {
+        name: string;
+        headless: boolean;
+        isolate: boolean;
+        fileParallelism: boolean;
+        ui: boolean;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        screenshotFailures: boolean;
+    };
+    standalone: boolean;
+    logHeapUsage: boolean | undefined;
+    coverage: SerializedCoverageConfig;
+}
+interface SerializedCoverageConfig {
+    provider: 'istanbul' | 'v8' | 'custom' | undefined;
+    reportsDirectory: string;
+    htmlReporter: {
+        subdir: string | undefined;
+    } | undefined;
+    enabled: boolean;
+    customProviderModule: string | undefined;
+}
+type RuntimeConfig = Pick<SerializedConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency' | 'expect' | 'printConsoleTrace'> & {
+    sequence?: {
+        concurrent?: boolean;
+        hooks?: SequenceHooks;
+    };
+};
+type RuntimeOptions = Partial<RuntimeConfig>;
+
+export type { FakeTimerInstallOpts as F, RuntimeOptions as R, SerializedConfig as S, SerializedCoverageConfig as a, RuntimeConfig as b };

package/dist/chunks/{runtime-console.C2L2zykk.js → console.Bgn7_A1x.js}

@@ -3,17 +3,16 @@ import { Console } from 'node:console';
 import { relative } from 'node:path';
 import { getSafeTimers } from '@vitest/utils';
 import c from 'tinyrainbow';
-import { R as RealDate } from '../vendor/date.W2xKR2qe.js';
+import { R as RealDate } from './date.W2xKR2qe.js';
 import 'pathe';
 import '@vitest/runner/utils';
-import { g as getWorkerState } from '../vendor/global.7bFbnyXl.js';
-import '../vendor/env.2ltrQNq0.js';
+import { g as getWorkerState } from './utils.Ck2hJTRs.js';
+import './env.BU041cs9.js';
 import 'std-env';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
 function getTaskIdByStack(root) {
-  var _a, _b;
-  const stack = (_a = new Error("STACK_TRACE_ERROR").stack) == null ? void 0 : _a.split("\n");
+  const stack = new Error("STACK_TRACE_ERROR").stack?.split("\n");
   if (!stack) {
     return UNKNOWN_TEST_ID;
   }
@@ -22,7 +21,7 @@ function getTaskIdByStack(root) {
   if (!line) {
     return UNKNOWN_TEST_ID;
   }
-  const filepath = (_b = line.match(/at\s(.*)\s?/)) == null ? void 0 : _b[1];
+  const filepath = line.match(/at\s(.*)\s?/)?.[1];
   if (filepath) {
     return relative(root, filepath);
   }
@@ -90,9 +89,8 @@ function createCustomConsole(defaultState) {
   }
   const stdout = new Writable({
     write(data, encoding, callback) {
-      var _a, _b, _c, _d;
       const s = state();
-      const id = ((_a = s == null ? void 0 : s.current) == null ? void 0 : _a.id) || ((_c = (_b = s == null ? void 0 : s.current) == null ? void 0 : _b.suite) == null ? void 0 : _c.id) || ((_d = s.current) == null ? void 0 : _d.file.id) || getTaskIdByStack(s.config.root);
+      const id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
       let timer = timers.get(id);
       if (timer) {
         timer.stdoutTime = timer.stdoutTime || RealDate.now();
@@ -113,7 +111,7 @@ function createCustomConsole(defaultState) {
         const limit = Error.stackTraceLimit;
         Error.stackTraceLimit = limit + 6;
         const stack = new Error("STACK_TRACE").stack;
-        const trace = stack == null ? void 0 : stack.split("\n").slice(7).join("\n");
+        const trace = stack?.split("\n").slice(7).join("\n");
         Error.stackTraceLimit = limit;
         buffer.push([data, trace]);
       } else {
@@ -125,9 +123,8 @@ function createCustomConsole(defaultState) {
   });
   const stderr = new Writable({
     write(data, encoding, callback) {
-      var _a, _b, _c, _d, _e;
       const s = state();
-      const id = ((_a = s == null ? void 0 : s.current) == null ? void 0 : _a.id) || ((_c = (_b = s == null ? void 0 : s.current) == null ? void 0 : _b.suite) == null ? void 0 : _c.id) || ((_d = s.current) == null ? void 0 : _d.file.id) || getTaskIdByStack(s.config.root);
+      const id = s?.current?.id || s?.current?.suite?.id || s.current?.file.id || getTaskIdByStack(s.config.root);
       let timer = timers.get(id);
       if (timer) {
         timer.stderrTime = timer.stderrTime || RealDate.now();
@@ -147,15 +144,15 @@ function createCustomConsole(defaultState) {
       if (state().config.printConsoleTrace) {
         const limit = Error.stackTraceLimit;
         Error.stackTraceLimit = limit + 6;
-        const stack = (_e = new Error("STACK_TRACE").stack) == null ? void 0 : _e.split("\n");
+        const stack = new Error("STACK_TRACE").stack?.split("\n");
         Error.stackTraceLimit = limit;
-        const isTrace = stack == null ? void 0 : stack.some(
+        const isTrace = stack?.some(
           (line) => line.includes("at Console.trace")
         );
         if (isTrace) {
           buffer.push([data, void 0]);
         } else {
-          const trace = stack == null ? void 0 : stack.slice(7).join("\n");
+          const trace = stack?.slice(7).join("\n");
           Error.stackTraceLimit = limit;
           buffer.push([data, trace]);
         }

package/dist/{vendor/constants.CsnA4eRy.js → chunks/constants.CaAN7icJ.js}

@@ -6,9 +6,7 @@ const extraInlineDeps = [
   /^(?!.*node_modules).*\.mjs$/,
   /^(?!.*node_modules).*\.cjs\.js$/,
   // Vite client
-  /vite\w*\/dist\/client\/env.mjs/,
-  // Nuxt
-  "@nuxt/test-utils"
+  /vite\w*\/dist\/client\/env.mjs/
 ];
 const CONFIG_NAMES = ["vitest.config", "vite.config"];
 const WORKSPACES_NAMES = ["vitest.workspace", "vitest.projects"];

package/dist/{vendor/coverage.BhYSDdTT.js → chunks/coverage.CqfT4xaf.js}

@@ -3,7 +3,7 @@ const CoverageProviderMap = {
   istanbul: "@vitest/coverage-istanbul"
 };
 async function resolveCoverageProviderModule(options, loader) {
-  if (!(options == null ? void 0 : options.enabled) || !options.provider) {
+  if (!options?.enabled || !options.provider) {
     return null;
   }
   const provider = options.provider;
@@ -42,26 +42,23 @@ async function getCoverageProvider(options, loader) {
   return null;
 }
 async function startCoverageInsideWorker(options, loader) {
-  var _a;
   const coverageModule = await resolveCoverageProviderModule(options, loader);
   if (coverageModule) {
-    return (_a = coverageModule.startCoverage) == null ? void 0 : _a.call(coverageModule);
+    return coverageModule.startCoverage?.();
   }
   return null;
 }
 async function takeCoverageInsideWorker(options, loader) {
-  var _a;
   const coverageModule = await resolveCoverageProviderModule(options, loader);
   if (coverageModule) {
-    return (_a = coverageModule.takeCoverage) == null ? void 0 : _a.call(coverageModule);
+    return coverageModule.takeCoverage?.();
   }
   return null;
 }
 async function stopCoverageInsideWorker(options, loader) {
-  var _a;
   const coverageModule = await resolveCoverageProviderModule(options, loader);
   if (coverageModule) {
-    return (_a = coverageModule.stopCoverage) == null ? void 0 : _a.call(coverageModule);
+    return coverageModule.stopCoverage?.();
   }
   return null;
 }

package/dist/chunks/{browser-creator.CyaOd8pl.js → creator.a3OfuIEW.js}

@@ -1,14 +1,14 @@
 import { resolve, dirname, relative } from 'node:path';
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { p as prompt, f as findUp } from '../vendor/index.D6GZqexG.js';
+import { p as prompt, f as findUp } from './index.CM5UI-4O.js';
 import c from 'tinyrainbow';
-import { detectPackageManager, installPackage } from './install-pkg.DNUmWFkO.js';
+import { detectPackageManager, installPackage } from './index.DNUmWFkO.js';
 import { execa } from 'execa';
-import { c as configFiles } from '../vendor/constants.CsnA4eRy.js';
+import { c as configFiles } from './constants.CaAN7icJ.js';
 import 'node:url';
 import 'node:process';
-import '../vendor/_commonjsHelpers.BFTU3MAI.js';
+import './_commonjsHelpers.BFTU3MAI.js';
 import 'readline';
 import 'events';
 import 'fs';
@@ -552,7 +552,7 @@ async function create() {
     type: "select",
     name: "lang",
     message: "Choose a language for your tests",
-    choices: sort(getLanguageOptions(), defaults == null ? void 0 : defaults.lang)
+    choices: sort(getLanguageOptions(), defaults?.lang)
   });
   if (!lang) {
     return fail();
@@ -561,7 +561,7 @@ async function create() {
     type: "select",
     name: "provider",
     message: "Choose a browser provider. Vitest will use its API to control the testing environment",
-    choices: sort(getProviderOptions(), defaults == null ? void 0 : defaults.provider)
+    choices: sort(getProviderOptions(), defaults?.provider)
   });
   if (!provider) {
     return fail();
@@ -582,7 +582,7 @@ async function create() {
     type: "select",
     name: "framework",
     message: "Choose your framework",
-    choices: sort(getFramework(), defaults == null ? void 0 : defaults.framework)
+    choices: sort(getFramework(), defaults?.framework)
   });
   if (!framework) {
     return fail();
@@ -660,7 +660,7 @@ async function create() {
     });
   }
   if (lang === "ts") {
-    await updateTsConfig(providerPkg == null ? void 0 : providerPkg.types);
+    await updateTsConfig(providerPkg?.types);
   }
   log();
   const exampleTestFile = await generateExampleFiles(framework, lang);

package/dist/{vendor/env.2ltrQNq0.js → chunks/env.BU041cs9.js}

@@ -1,8 +1,7 @@
 import 'std-env';
 
-var _a, _b;
-const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
-const isDeno = typeof process < "u" && typeof process.stdout < "u" && ((_b = process.versions) == null ? void 0 : _b.deno) !== void 0;
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 const isWindows = (isNode || isDeno) && process.platform === "win32";
 
 export { isDeno as a, isWindows as b, isNode as i };

package/dist/chunks/environment.0M5R1SX_.d.ts

@@ -0,0 +1,173 @@
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type MutableArray<T extends readonly any[]> = {
+    -readonly [k in keyof T]: T[k];
+};
+interface Constructable {
+    new (...args: any[]): any;
+}
+type TransformMode = 'web' | 'ssr';
+/** @deprecated not used */
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface AfterSuiteRunMeta {
+    coverage?: unknown;
+    transformMode: TransformMode;
+    projectName?: string;
+}
+interface UserConsoleLog {
+    content: string;
+    origin?: string;
+    browser?: boolean;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+    time: number;
+    size: number;
+}
+interface ModuleGraphData {
+    graph: Record<string, string[]>;
+    externalized: string[];
+    inlined: string[];
+}
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+interface ProvidedContext {
+}
+
+interface JSDOMOptions {
+    /**
+     * The html content for the test.
+     *
+     * @default '<!DOCTYPE html>'
+     */
+    html?: string | ArrayBufferLike;
+    /**
+     * referrer just affects the value read from document.referrer.
+     * It defaults to no referrer (which reflects as the empty string).
+     */
+    referrer?: string;
+    /**
+     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
+     *
+     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
+     */
+    userAgent?: string;
+    /**
+     * url sets the value returned by window.location, document.URL, and document.documentURI,
+     * and affects things like resolution of relative URLs within the document
+     * and the same-origin restrictions and referrer used while fetching subresources.
+     *
+     * @default 'http://localhost:3000'.
+     */
+    url?: string;
+    /**
+     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
+     * Values that are not "text/html" or an XML mime type will throw.
+     *
+     * @default 'text/html'.
+     */
+    contentType?: string;
+    /**
+     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
+     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
+     * to 5,000,000 code units per origin, as inspired by the HTML specification.
+     *
+     * @default 5_000_000
+     */
+    storageQuota?: number;
+    /**
+     * Enable console?
+     *
+     * @default false
+     */
+    console?: boolean;
+    /**
+     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
+     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
+     *
+     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
+     * content.
+     *
+     * @default true
+     */
+    pretendToBeVisual?: boolean;
+    /**
+     * `includeNodeLocations` preserves the location info produced by the HTML parser,
+     * allowing you to retrieve it with the nodeLocation() method (described below).
+     *
+     * It defaults to false to give the best performance,
+     * and cannot be used with an XML content type since our XML parser does not support location info.
+     *
+     * @default false
+     */
+    includeNodeLocations?: boolean | undefined;
+    /**
+     * @default 'dangerously'
+     */
+    runScripts?: 'dangerously' | 'outside-only';
+    /**
+     * Enable CookieJar
+     *
+     * @default false
+     */
+    cookieJar?: boolean;
+    resources?: 'usable';
+}
+
+/**
+ * Happy DOM options.
+ */
+interface HappyDOMOptions {
+    width?: number;
+    height?: number;
+    url?: string;
+    settings?: {
+        disableJavaScriptEvaluation?: boolean;
+        disableJavaScriptFileLoading?: boolean;
+        disableCSSFileLoading?: boolean;
+        disableIframePageLoading?: boolean;
+        disableComputedStyleRendering?: boolean;
+        enableFileSystemHttpRequests?: boolean;
+        navigator?: {
+            userAgent?: string;
+        };
+        device?: {
+            prefersColorScheme?: string;
+            mediaType?: string;
+        };
+    };
+}
+
+interface EnvironmentReturn {
+    teardown: (global: any) => Awaitable<void>;
+}
+interface VmEnvironmentReturn {
+    getVmContext: () => {
+        [key: string]: any;
+    };
+    teardown: () => Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    transformMode: 'web' | 'ssr';
+    setupVM?: (options: Record<string, any>) => Awaitable<VmEnvironmentReturn>;
+    setup: (global: any, options: Record<string, any>) => Awaitable<EnvironmentReturn>;
+}
+interface EnvironmentOptions {
+    /**
+     * jsdom options.
+     */
+    jsdom?: JSDOMOptions;
+    happyDOM?: HappyDOMOptions;
+    [x: string]: unknown;
+}
+interface ResolvedTestEnvironment {
+    environment: Environment;
+    options: Record<string, any> | null;
+}
+
+export type { AfterSuiteRunMeta as A, Constructable as C, Environment as E, HappyDOMOptions as H, JSDOMOptions as J, ModuleGraphData as M, Nullable as N, OnServerRestartHandler as O, ProvidedContext as P, ResolvedTestEnvironment as R, TransformMode as T, UserConsoleLog as U, VmEnvironmentReturn as V, EnvironmentReturn as a, Awaitable as b, Arrayable as c, ArgumentsType as d, MutableArray as e, EnvironmentOptions as f, ModuleCache as g };