vitest 3.0.0-beta.3 → 3.0.0

package/dist/chunks/{config.BTPBhmK5.d.ts → config.BRtC-JeT.d.ts}

@@ -60,6 +60,12 @@ interface FakeTimerInstallOpts {
      * @default true
      */
     shouldClearNativeTimers?: boolean | undefined;
+
+    /**
+     * Don't throw error when asked to fake timers that are not present.
+     * @default false
+     */
+    ignoreMissingTimers?: boolean | undefined;
 }
 
 /**

package/dist/chunks/{console.BYGVloWk.js → console.CN7AiMGV.js}

@@ -27,13 +27,24 @@ function createCustomConsole(defaultState) {
   const stdoutBuffer = /* @__PURE__ */ new Map();
   const stderrBuffer = /* @__PURE__ */ new Map();
   const timers = /* @__PURE__ */ new Map();
-  const { setTimeout, clearTimeout } = getSafeTimers();
+  const { queueMicrotask } = getSafeTimers();
+  function queueCancelableMicrotask(callback) {
+    let canceled = false;
+    queueMicrotask(() => {
+      if (!canceled) {
+        callback();
+      }
+    });
+    return () => {
+      canceled = true;
+    };
+  }
   const state = () => defaultState || getWorkerState();
   function schedule(taskId) {
     const timer = timers.get(taskId);
     const { stdoutTime, stderrTime } = timer;
-    clearTimeout(timer.timer);
-    timer.timer = setTimeout(() => {
+    timer.cancel?.();
+    timer.cancel = queueCancelableMicrotask(() => {
       if (stderrTime < stdoutTime) {
         sendStderr(taskId);
         sendStdout(taskId);
@@ -93,8 +104,7 @@ function createCustomConsole(defaultState) {
       } else {
         timer = {
           stdoutTime: RealDate.now(),
-          stderrTime: RealDate.now(),
-          timer: 0
+          stderrTime: RealDate.now()
         };
         timers.set(id, timer);
       }
@@ -127,8 +137,7 @@ function createCustomConsole(defaultState) {
       } else {
         timer = {
           stderrTime: RealDate.now(),
-          stdoutTime: RealDate.now(),
-          timer: 0
+          stdoutTime: RealDate.now()
         };
         timers.set(id, timer);
       }

package/dist/chunks/{creator.Ot9GlSGw.js → creator.DztqrnyH.js}

@@ -1,7 +1,7 @@
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
-import { detectPackageManager, installPackage } from './index.DQboAxJm.js';
+import { detectPackageManager, installPackage } from './index.D9C26wCk.js';
 import { p as prompt, f as findUp } from './index.BJDntFik.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';

package/dist/chunks/{execute.2pr0rHgK.js → execute.BMOaRArH.js}

@@ -21,6 +21,8 @@ function normalizeWindowsPath(input = "") {
 const _UNC_REGEX = /^[/\\]{2}/;
 const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _EXTNAME_RE = /.(\.[^./]+)$/;
+globalThis.process?.platform === "win32" ? ";" : ":";
 const normalize = function(path) {
   if (path.length === 0) {
     return ".";
@@ -50,24 +52,26 @@ const normalize = function(path) {
   }
   return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
 };
-const join = function(...arguments_) {
-  if (arguments_.length === 0) {
-    return ".";
-  }
-  let joined;
-  for (const argument of arguments_) {
-    if (argument && argument.length > 0) {
-      if (joined === void 0) {
-        joined = argument;
+const join = function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
       } else {
-        joined += `/${argument}`;
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
       }
+    } else {
+      path += seg;
     }
   }
-  if (joined === void 0) {
-    return ".";
-  }
-  return normalize(joined.replace(/\/\/+/g, "/"));
+  return normalize(path);
 };
 function cwd() {
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
@@ -156,7 +160,6 @@ function normalizeString(path, allowAboveRoot) {
 const isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
-const _EXTNAME_RE = /.(\.[^./]+)$/;
 const extname = function(p) {
   const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
   return match && match[1] || "";
@@ -169,7 +172,15 @@ const dirname = function(p) {
   return segments.join("/") || (isAbsolute(p) ? "/" : ".");
 };
 const basename = function(p, extension) {
-  const lastSegment = normalizeWindowsPath(p).split("/").pop();
+  const segments = normalizeWindowsPath(p).split("/");
+  let lastSegment = "";
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const val = segments[i];
+    if (val) {
+      lastSegment = val;
+      break;
+    }
+  }
   return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
 

package/dist/chunks/global.CnI8_G5V.d.ts

@@ -0,0 +1,133 @@
+import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
+import { Plugin } from '@vitest/pretty-format';
+import { SnapshotState } from '@vitest/snapshot';
+import { B as BenchmarkResult } from './benchmark.CFFwLv-O.js';
+import { U as UserConsoleLog } from './environment.d8YfPkTm.js';
+
+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;
+}
+type CollectLines = {
+    [key in keyof CollectLineNumbers]: string;
+};
+interface RootAndTarget {
+    root: string;
+    targetAbsPath: string;
+}
+type Context = RootAndTarget & {
+    rawErrsMap: RawErrsMap;
+    openedDirs: Set<string>;
+    lastActivePath?: string;
+};
+
+declare global {
+    namespace Chai {
+        interface Assertion {
+            containSubset: (expected: any) => Assertion;
+        }
+        interface Assert {
+            containSubset: (val: any, exp: any, msg?: string) => void;
+        }
+    }
+}
+interface SnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(snapshot: Partial<U>, message?: string): void;
+    (message?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+    (message?: string): void;
+}
+declare module '@vitest/expect' {
+    interface MatcherState {
+        environment: string;
+        snapshotState: SnapshotState;
+    }
+    interface ExpectPollOptions {
+        interval?: number;
+        timeout?: number;
+        message?: string;
+    }
+    interface ExpectStatic {
+        unreachable: (message?: string) => never;
+        soft: <T>(actual: T, message?: string) => Assertion<T>;
+        poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+        addEqualityTesters: (testers: Array<Tester>) => void;
+        assertions: (expected: number) => void;
+        hasAssertions: () => void;
+        addSnapshotSerializer: (plugin: Plugin) => void;
+    }
+    interface Assertion<T> {
+        matchSnapshot: SnapshotMatcher<T>;
+        toMatchSnapshot: SnapshotMatcher<T>;
+        toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+        /**
+         * Checks that an error thrown by a function matches a previously recorded snapshot.
+         *
+         * @param message - Optional custom error message.
+         *
+         * @example
+         * expect(functionWithError).toThrowErrorMatchingSnapshot();
+         */
+        toThrowErrorMatchingSnapshot: (message?: string) => void;
+        /**
+         * Checks that an error thrown by a function matches an inline snapshot within the test file.
+         * Useful for keeping snapshots close to the test code.
+         *
+         * @param snapshot - Optional inline snapshot string to match.
+         * @param message - Optional custom error message.
+         *
+         * @example
+         * const throwError = () => { throw new Error('Error occurred') };
+         * expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+         */
+        toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+        /**
+         * Compares the received value to a snapshot saved in a specified file.
+         * Useful for cases where snapshot content is large or needs to be shared across tests.
+         *
+         * @param filepath - Path to the snapshot file.
+         * @param message - Optional custom error message.
+         *
+         * @example
+         * await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+         */
+        toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+    }
+}
+declare module '@vitest/runner' {
+    interface TestContext {
+        expect: ExpectStatic;
+    }
+    interface TaskMeta {
+        typecheck?: boolean;
+        benchmark?: boolean;
+        failScreenshotPath?: string;
+    }
+    interface File {
+        prepareDuration?: number;
+        environmentLoad?: number;
+    }
+    interface TaskBase {
+        logs?: UserConsoleLog[];
+    }
+    interface TaskResult {
+        benchmark?: BenchmarkResult;
+    }
+}
+
+export type { CollectLineNumbers as C, RawErrsMap as R, TscErrorInfo as T, CollectLines as a, RootAndTarget as b, Context as c };

package/dist/chunks/{globals.BFncSRNA.js → globals.C5RQxaV3.js}

@@ -1,6 +1,6 @@
 import { g as globalApis } from './constants.fzPh7AOq.js';
-import { V as VitestIndex } from './index.CkWmZCXU.js';
-import './vi.S4Fq8wSo.js';
+import { V as VitestIndex } from './index.BQbxGbG9.js';
+import './vi.Da_PT3Vw.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/utils';

package/dist/chunks/{index.CkWmZCXU.js → index.BQbxGbG9.js}

@@ -1,4 +1,4 @@
-import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.S4Fq8wSo.js';
+import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.Da_PT3Vw.js';
 import { i as isFirstRun, a as runOnce } from './run-once.2ogXb3JV.js';
 import { b as bench } from './benchmark.Cdu9hjj4.js';
 import { expectTypeOf } from 'expect-type';

package/dist/chunks/{index.BBoOXW-l.js → index.CUcwvygK.js}

@@ -2,8 +2,8 @@ import * as chai from 'chai';
 import { resolve } from 'node:path';
 import { t as takeCoverageInsideWorker } from './coverage.BWeNbfBa.js';
 import { distDir } from '../path.js';
-import { r as rpc } from './rpc.C3q9uwRX.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.Cp_bu5q3.js';
+import { r as rpc } from './rpc.TVf73xOu.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.D0zLenuv.js';
 import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 function setupChaiConfig(config) {
@@ -58,9 +58,9 @@ async function resolveTestRunner(config, executor) {
   ]);
   testRunner.config.diffOptions = diffOptions;
   const originalOnTaskUpdate = testRunner.onTaskUpdate;
-  testRunner.onTaskUpdate = async (task) => {
-    const p = rpc().onTaskUpdate(task);
-    await originalOnTaskUpdate?.call(testRunner, task);
+  testRunner.onTaskUpdate = async (task, events) => {
+    const p = rpc().onTaskUpdate(task, events);
+    await originalOnTaskUpdate?.call(testRunner, task, events);
     return p;
   };
   const originalOnCollectStart = testRunner.onCollectStart;

package/dist/chunks/{index.DQboAxJm.js → index.D9C26wCk.js}

@@ -14,6 +14,7 @@ const AGENTS = [
   "deno"
 ];
 const LOCKS = {
+  "bun.lock": "bun",
   "bun.lockb": "bun",
   "deno.lock": "deno",
   "pnpm-lock.yaml": "pnpm",