vitest 4.1.5 → 5.0.0-beta.2

package/dist/chunks/{init-forks.UV3ZQGQH.js → init-forks.DMge3WTt.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.D98-gwRW.js';
+import { i as init } from './init.BVd7SaCA.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them

package/dist/chunks/{init-threads.D3eCsY76.js → init-threads.eIoyCTon.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.D98-gwRW.js';
+import { i as init } from './init.BVd7SaCA.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.D98-gwRW.js → init.BVd7SaCA.js}

@@ -3,16 +3,14 @@ import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
 import { ModuleRunner, EvaluatedModules } from 'vite/module-runner';
-import { b as VitestTransport } from './startVitestModuleRunner.bRl2_oI_.js';
-import { e as environments } from './index.DC7d2Pf8.js';
+import { e as environments, b as VitestTransport } from './index.CbgUM9E5.js';
 import { serializeValue } from '@vitest/utils/serialize';
 import { serializeError } from '@vitest/utils/error';
 import { disableDefaultColors } from 'tinyrainbow';
-import { T as Traces } from './traces.DT5aQ62U.js';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.MzXet3jl.js';
+import { Traces } from '../traces.js';
+import { o as onCancel, V as VitestEvaluatedModules, a as rpcDone, c as createRuntimeRpc } from './rpc.DFRWVnRh.js';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
-import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { E as EnvironmentTeardownError } from './utils.BX5Fg8C4.js';
 
 function isBuiltinEnvironment(env) {

package/dist/chunks/{nativeModuleMocker.BRN2oBJd.js → nativeModuleMocker.DKpFw0pk.js}

@@ -5,7 +5,7 @@ import { cleanUrl, createDefer } from '@vitest/utils/helpers';
 import { p as parse } from './acorn.B2iPLyUM.js';
 import { isAbsolute } from 'pathe';
 import { t as toBuiltin } from './modules.BJuCwlRJ.js';
-import { B as BareModuleMocker, n as normalizeModuleId } from './startVitestModuleRunner.bRl2_oI_.js';
+import { B as BareModuleMocker, n as normalizeModuleId } from './index.CbgUM9E5.js';
 import 'node:fs';
 import './utils.BX5Fg8C4.js';
 import '@vitest/utils/timers';
@@ -14,9 +14,10 @@ import 'node:path';
 import '../module-evaluator.js';
 import 'node:vm';
 import 'vite/module-runner';
-import './traces.DT5aQ62U.js';
+import '../traces.js';
 import '@vitest/mocker';
 import '@vitest/mocker/redirect';
+import 'node:console';
 
 class NativeModuleMocker extends BareModuleMocker {
 	wrapDynamicImport(moduleFactory) {

package/dist/chunks/{index.BCY_7LL2.js → nativeModuleRunner.BOeMnHl4.js}

@@ -1,13 +1,14 @@
-import fs, { statSync, realpathSync } from 'node:fs';
+import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
+import fs__default, { statSync, realpathSync } from 'node:fs';
 import { builtinModules, createRequire } from 'node:module';
 import path, { win32, dirname, join } from 'node:path';
 import process$1 from 'node:process';
-import fs$1 from 'node:fs/promises';
-import { fileURLToPath as fileURLToPath$1, pathToFileURL as pathToFileURL$1, URL as URL$1 } from 'node:url';
-import { isAbsolute } from 'pathe';
+import fs from 'node:fs/promises';
+import { isAbsolute, resolve } from 'pathe';
 import assert from 'node:assert';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
+import { ModuleRunner } from 'vite/module-runner';
 
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
 function withTrailingSlash(input = "", respectQueryAndFragment) {
@@ -561,7 +562,7 @@ function read(jsonPath, {base, specifier}) {
   let string;
 
   try {
-    string = fs.readFileSync(path.toNamespacedPath(jsonPath), 'utf8');
+    string = fs__default.readFileSync(path.toNamespacedPath(jsonPath), 'utf8');
   } catch (error) {
     const exception = /** @type {ErrnoException} */ (error);
 
@@ -2194,7 +2195,7 @@ async function findUp$1(name, {
 	while (directory) {
 		const filePath = isAbsoluteName ? name : path.join(directory, name);
 		try {
-			const stats = await fs$1.stat(filePath); // eslint-disable-line no-await-in-loop
+			const stats = await fs.stat(filePath); // eslint-disable-line no-await-in-loop
 			if ((type === 'file' && stats.isFile()) || (type === 'directory' && stats.isDirectory())) {
 				return filePath;
 			}
@@ -2222,7 +2223,7 @@ function findUpSync(name, {
 		const filePath = isAbsoluteName ? name : path.join(directory, name);
 
 		try {
-			const stats = fs.statSync(filePath, {throwIfNoEntry: false});
+			const stats = fs__default.statSync(filePath, {throwIfNoEntry: false});
 			if ((type === 'file' && stats?.isFile()) || (type === 'directory' && stats?.isDirectory())) {
 				return filePath;
 			}
@@ -2273,8 +2274,8 @@ function getPackageJsonPath(name, options = {}) {
   return searchPackageJSON(entry);
 }
 const readFile = quansync({
-  async: (id) => fs.promises.readFile(id, "utf8"),
-  sync: (id) => fs.readFileSync(id, "utf8")
+  async: (id) => fs__default.promises.readFile(id, "utf8"),
+  sync: (id) => fs__default.readFileSync(id, "utf8")
 });
 const getPackageInfo = quansync(function* (name, options = {}) {
   const packageJsonPath = getPackageJsonPath(name, options);
@@ -2313,7 +2314,7 @@ function searchPackageJSON(dir) {
       return;
     dir = newDir;
     packageJsonPath = join(dir, "package.json");
-    if (fs.existsSync(packageJsonPath))
+    if (fs__default.existsSync(packageJsonPath))
       break;
   }
   return packageJsonPath;
@@ -2324,7 +2325,7 @@ const findUp = quansync({
 });
 const loadPackageJSON = quansync(function* (cwd = process$1.cwd()) {
   const path = yield findUp("package.json", { cwd });
-  if (!path || !fs.existsSync(path))
+  if (!path || !fs__default.existsSync(path))
     return null;
   return JSON.parse(yield readFile(path));
 });
@@ -2335,4 +2336,34 @@ const isPackageListed = quansync(function* (name, cwd) {
 });
 isPackageListed.sync;
 
-export { isPackageExists as i, resolveModule as r };
+class NativeModuleRunner extends ModuleRunner {
+	/**
+	* @internal
+	*/
+	mocker;
+	constructor(root, mocker) {
+		super({
+			hmr: false,
+			sourcemapInterceptor: false,
+			transport: { invoke() {
+				throw new Error("Unexpected `invoke`");
+			} }
+		});
+		this.root = root;
+		this.mocker = mocker;
+		if (mocker) Object.defineProperty(globalThis, "__vitest_mocker__", {
+			configurable: true,
+			writable: true,
+			value: mocker
+		});
+	}
+	async import(moduleId) {
+		const path = resolveModule(moduleId, { paths: [this.root] }) ?? resolve(this.root, moduleId);
+		// resolveModule doesn't keep the query params, so we need to add them back
+		let queryParams = "";
+		if (moduleId.includes("?") && !path.includes("?")) queryParams = moduleId.slice(moduleId.indexOf("?"));
+		return import(pathToFileURL$1(path + queryParams).toString());
+	}
+}
+
+export { NativeModuleRunner as N, isPackageExists as i, resolveModule as r };

package/dist/chunks/node.CwFbQqI1.js

@@ -0,0 +1,47 @@
+import { g as getWorkerState } from './utils.BX5Fg8C4.js';
+import { promises, existsSync } from 'node:fs';
+import { isAbsolute, resolve, dirname, join, basename } from 'pathe';
+import '@vitest/utils/timers';
+
+class NodeSnapshotEnvironment {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	getVersion() {
+		return "1";
+	}
+	getHeader() {
+		return `// Snapshot v${this.getVersion()}`;
+	}
+	async resolveRawPath(testPath, rawPath) {
+		return isAbsolute(rawPath) ? rawPath : resolve(dirname(testPath), rawPath);
+	}
+	async resolvePath(filepath) {
+		return join(join(dirname(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${basename(filepath)}.snap`);
+	}
+	async prepareDirectory(dirPath) {
+		await promises.mkdir(dirPath, { recursive: true });
+	}
+	async saveSnapshotFile(filepath, snapshot) {
+		await promises.mkdir(dirname(filepath), { recursive: true });
+		await promises.writeFile(filepath, snapshot, "utf-8");
+	}
+	async readSnapshotFile(filepath) {
+		if (!existsSync(filepath)) return null;
+		return promises.readFile(filepath, "utf-8");
+	}
+	async removeSnapshotFile(filepath) {
+		if (existsSync(filepath)) await promises.unlink(filepath);
+	}
+}
+
+class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
+	getHeader() {
+		return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
+	}
+	resolvePath(filepath) {
+		return getWorkerState().rpc.resolveSnapshotPath(filepath);
+	}
+}
+
+export { VitestNodeSnapshotEnvironment };