vitest 2.1.3 → 2.1.5

package/dist/chunks/{index.lVXYBqEP.js → index.K90BXFOx.js}

@@ -1,102 +1,5 @@
 import { Console } from 'node:console';
 
-const denyList = /* @__PURE__ */ new Set([
-  "GLOBAL",
-  "root",
-  "global",
-  "Buffer",
-  "ArrayBuffer",
-  "Uint8Array"
-]);
-const nodeGlobals = new Map(
-  Object.getOwnPropertyNames(globalThis).filter((global) => !denyList.has(global)).map((nodeGlobalsKey) => {
-    const descriptor = Object.getOwnPropertyDescriptor(
-      globalThis,
-      nodeGlobalsKey
-    );
-    if (!descriptor) {
-      throw new Error(
-        `No property descriptor for ${nodeGlobalsKey}, this is a bug in Vitest.`
-      );
-    }
-    return [nodeGlobalsKey, descriptor];
-  })
-);
-var node = {
-  name: "node",
-  transformMode: "ssr",
-  // this is largely copied from jest's node environment
-  async setupVM() {
-    const vm = await import('node:vm');
-    let context = vm.createContext();
-    let global = vm.runInContext("this", context);
-    const contextGlobals = new Set(Object.getOwnPropertyNames(global));
-    for (const [nodeGlobalsKey, descriptor] of nodeGlobals) {
-      if (!contextGlobals.has(nodeGlobalsKey)) {
-        if (descriptor.configurable) {
-          Object.defineProperty(global, nodeGlobalsKey, {
-            configurable: true,
-            enumerable: descriptor.enumerable,
-            get() {
-              const val = globalThis[nodeGlobalsKey];
-              Object.defineProperty(global, nodeGlobalsKey, {
-                configurable: true,
-                enumerable: descriptor.enumerable,
-                value: val,
-                writable: descriptor.writable === true || nodeGlobalsKey === "performance"
-              });
-              return val;
-            },
-            set(val) {
-              Object.defineProperty(global, nodeGlobalsKey, {
-                configurable: true,
-                enumerable: descriptor.enumerable,
-                value: val,
-                writable: true
-              });
-            }
-          });
-        } else if ("value" in descriptor) {
-          Object.defineProperty(global, nodeGlobalsKey, {
-            configurable: false,
-            enumerable: descriptor.enumerable,
-            value: descriptor.value,
-            writable: descriptor.writable
-          });
-        } else {
-          Object.defineProperty(global, nodeGlobalsKey, {
-            configurable: false,
-            enumerable: descriptor.enumerable,
-            get: descriptor.get,
-            set: descriptor.set
-          });
-        }
-      }
-    }
-    global.global = global;
-    global.Buffer = Buffer;
-    global.ArrayBuffer = ArrayBuffer;
-    global.Uint8Array = Uint8Array;
-    return {
-      getVmContext() {
-        return context;
-      },
-      teardown() {
-        context = void 0;
-        global = void 0;
-      }
-    };
-  },
-  async setup(global) {
-    global.console.Console = Console;
-    return {
-      teardown(global2) {
-        delete global2.console.Console;
-      }
-    };
-  }
-};
-
 const LIVING_KEYS = [
   "DOMException",
   "URL",
@@ -409,6 +312,114 @@ function populateGlobal(global, win, options = {}) {
   };
 }
 
+var edge = {
+  name: "edge-runtime",
+  transformMode: "ssr",
+  async setupVM() {
+    const { EdgeVM } = await import('@edge-runtime/vm');
+    const vm = new EdgeVM({
+      extend: (context) => {
+        context.global = context;
+        context.Buffer = Buffer;
+        return context;
+      }
+    });
+    return {
+      getVmContext() {
+        return vm.context;
+      },
+      teardown() {
+      }
+    };
+  },
+  async setup(global) {
+    const { EdgeVM } = await import('@edge-runtime/vm');
+    const vm = new EdgeVM({
+      extend: (context) => {
+        context.global = context;
+        context.Buffer = Buffer;
+        KEYS.forEach((key) => {
+          if (key in global) {
+            context[key] = global[key];
+          }
+        });
+        return context;
+      }
+    });
+    const { keys, originals } = populateGlobal(global, vm.context, {
+      bindFunctions: true
+    });
+    return {
+      teardown(global2) {
+        keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
+      }
+    };
+  }
+};
+
+async function teardownWindow(win) {
+  if (win.close && win.happyDOM.abort) {
+    await win.happyDOM.abort();
+    win.close();
+  } else {
+    win.happyDOM.cancelAsync();
+  }
+}
+var happy = {
+  name: "happy-dom",
+  transformMode: "web",
+  async setupVM({ happyDOM = {} }) {
+    const { Window } = await import('happy-dom');
+    let win = new Window({
+      ...happyDOM,
+      console: console && globalThis.console ? globalThis.console : void 0,
+      url: happyDOM.url || "http://localhost:3000",
+      settings: {
+        ...happyDOM.settings,
+        disableErrorCapturing: true
+      }
+    });
+    win.Buffer = Buffer;
+    if (typeof structuredClone !== "undefined" && !win.structuredClone) {
+      win.structuredClone = structuredClone;
+    }
+    return {
+      getVmContext() {
+        return win;
+      },
+      async teardown() {
+        await teardownWindow(win);
+        win = void 0;
+      }
+    };
+  },
+  async setup(global, { happyDOM = {} }) {
+    const { Window, GlobalWindow } = await import('happy-dom');
+    const win = new (GlobalWindow || Window)({
+      ...happyDOM,
+      console: console && global.console ? global.console : void 0,
+      url: happyDOM.url || "http://localhost:3000",
+      settings: {
+        ...happyDOM.settings,
+        disableErrorCapturing: true
+      }
+    });
+    const { keys, originals } = populateGlobal(global, win, {
+      bindFunctions: true,
+      // jsdom doesn't support Request and Response, but happy-dom does
+      additionalKeys: ["Request", "Response", "MessagePort", "fetch"]
+    });
+    return {
+      async teardown(global2) {
+        await teardownWindow(win);
+        keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
+      }
+    };
+  }
+};
+
 function catchWindowErrors(window) {
   let userErrorListenerCount = 0;
   function throwUnhandlerError(e) {
@@ -540,109 +551,98 @@ var jsdom = {
   }
 };
 
-async function teardownWindow(win) {
-  if (win.close && win.happyDOM.abort) {
-    await win.happyDOM.abort();
-    win.close();
-  } else {
-    win.happyDOM.cancelAsync();
-  }
-}
-var happy = {
-  name: "happy-dom",
-  transformMode: "web",
-  async setupVM({ happyDOM = {} }) {
-    const { Window } = await import('happy-dom');
-    let win = new Window({
-      ...happyDOM,
-      console: console && globalThis.console ? globalThis.console : void 0,
-      url: happyDOM.url || "http://localhost:3000",
-      settings: {
-        ...happyDOM.settings,
-        disableErrorCapturing: true
-      }
-    });
-    win.Buffer = Buffer;
-    if (typeof structuredClone !== "undefined" && !win.structuredClone) {
-      win.structuredClone = structuredClone;
+const denyList = /* @__PURE__ */ new Set([
+  "GLOBAL",
+  "root",
+  "global",
+  "Buffer",
+  "ArrayBuffer",
+  "Uint8Array"
+]);
+const nodeGlobals = new Map(
+  Object.getOwnPropertyNames(globalThis).filter((global) => !denyList.has(global)).map((nodeGlobalsKey) => {
+    const descriptor = Object.getOwnPropertyDescriptor(
+      globalThis,
+      nodeGlobalsKey
+    );
+    if (!descriptor) {
+      throw new Error(
+        `No property descriptor for ${nodeGlobalsKey}, this is a bug in Vitest.`
+      );
     }
-    return {
-      getVmContext() {
-        return win;
-      },
-      async teardown() {
-        await teardownWindow(win);
-        win = void 0;
-      }
-    };
-  },
-  async setup(global, { happyDOM = {} }) {
-    const { Window, GlobalWindow } = await import('happy-dom');
-    const win = new (GlobalWindow || Window)({
-      ...happyDOM,
-      console: console && global.console ? global.console : void 0,
-      url: happyDOM.url || "http://localhost:3000",
-      settings: {
-        ...happyDOM.settings,
-        disableErrorCapturing: true
-      }
-    });
-    const { keys, originals } = populateGlobal(global, win, {
-      bindFunctions: true,
-      // jsdom doesn't support Request and Response, but happy-dom does
-      additionalKeys: ["Request", "Response"]
-    });
-    return {
-      async teardown(global2) {
-        await teardownWindow(win);
-        keys.forEach((key) => delete global2[key]);
-        originals.forEach((v, k) => global2[k] = v);
-      }
-    };
-  }
-};
-
-var edge = {
-  name: "edge-runtime",
+    return [nodeGlobalsKey, descriptor];
+  })
+);
+var node = {
+  name: "node",
   transformMode: "ssr",
+  // this is largely copied from jest's node environment
   async setupVM() {
-    const { EdgeVM } = await import('@edge-runtime/vm');
-    const vm = new EdgeVM({
-      extend: (context) => {
-        context.global = context;
-        context.Buffer = Buffer;
-        return context;
+    const vm = await import('node:vm');
+    let context = vm.createContext();
+    let global = vm.runInContext("this", context);
+    const contextGlobals = new Set(Object.getOwnPropertyNames(global));
+    for (const [nodeGlobalsKey, descriptor] of nodeGlobals) {
+      if (!contextGlobals.has(nodeGlobalsKey)) {
+        if (descriptor.configurable) {
+          Object.defineProperty(global, nodeGlobalsKey, {
+            configurable: true,
+            enumerable: descriptor.enumerable,
+            get() {
+              const val = globalThis[nodeGlobalsKey];
+              Object.defineProperty(global, nodeGlobalsKey, {
+                configurable: true,
+                enumerable: descriptor.enumerable,
+                value: val,
+                writable: descriptor.writable === true || nodeGlobalsKey === "performance"
+              });
+              return val;
+            },
+            set(val) {
+              Object.defineProperty(global, nodeGlobalsKey, {
+                configurable: true,
+                enumerable: descriptor.enumerable,
+                value: val,
+                writable: true
+              });
+            }
+          });
+        } else if ("value" in descriptor) {
+          Object.defineProperty(global, nodeGlobalsKey, {
+            configurable: false,
+            enumerable: descriptor.enumerable,
+            value: descriptor.value,
+            writable: descriptor.writable
+          });
+        } else {
+          Object.defineProperty(global, nodeGlobalsKey, {
+            configurable: false,
+            enumerable: descriptor.enumerable,
+            get: descriptor.get,
+            set: descriptor.set
+          });
+        }
       }
-    });
+    }
+    global.global = global;
+    global.Buffer = Buffer;
+    global.ArrayBuffer = ArrayBuffer;
+    global.Uint8Array = Uint8Array;
     return {
       getVmContext() {
-        return vm.context;
+        return context;
       },
       teardown() {
+        context = void 0;
+        global = void 0;
       }
     };
   },
   async setup(global) {
-    const { EdgeVM } = await import('@edge-runtime/vm');
-    const vm = new EdgeVM({
-      extend: (context) => {
-        context.global = context;
-        context.Buffer = Buffer;
-        KEYS.forEach((key) => {
-          if (key in global) {
-            context[key] = global[key];
-          }
-        });
-        return context;
-      }
-    });
-    const { keys, originals } = populateGlobal(global, vm.context, {
-      bindFunctions: true
-    });
+    global.console.Console = Console;
     return {
       teardown(global2) {
-        keys.forEach((key) => delete global2[key]);
-        originals.forEach((v, k) => global2[k] = v);
+        delete global2.console.Console;
       }
     };
   }

package/dist/chunks/index.ckWaX2gY.js

@@ -0,0 +1,54 @@
+import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.DgezovHB.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.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';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import * as chai from 'chai';
+import { assert, should } from 'chai';
+
+function inject(key) {
+  const workerState = getWorkerState();
+  return workerState.providedContext[key];
+}
+
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+function isWatchMode() {
+  return getRunningMode() === "watch";
+}
+
+const assertType = function assertType2() {
+};
+
+var VitestIndex = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  afterAll: afterAll,
+  afterEach: afterEach,
+  assert: assert,
+  assertType: assertType,
+  beforeAll: beforeAll,
+  beforeEach: beforeEach,
+  bench: bench,
+  chai: chai,
+  createExpect: createExpect,
+  describe: describe,
+  expect: globalExpect,
+  expectTypeOf: expectTypeOf,
+  getRunningMode: getRunningMode,
+  inject: inject,
+  isFirstRun: isFirstRun,
+  isWatchMode: isWatchMode,
+  it: it,
+  onTestFailed: onTestFailed,
+  onTestFinished: onTestFinished,
+  runOnce: runOnce,
+  should: should,
+  suite: suite,
+  test: test,
+  vi: vi,
+  vitest: vitest
+});
+
+export { VitestIndex as V, isWatchMode as a, assertType as b, getRunningMode as g, inject as i };

package/dist/chunks/{index.4GFF2h22.js → index.nEwtF0bu.js}

@@ -1,10 +1,10 @@
 import * as chai from 'chai';
-import { resolve } from 'pathe';
+import { resolve } from 'node:path';
+import { t as takeCoverageInsideWorker } from './coverage.BoMDb1ip.js';
 import { distDir } from '../path.js';
-import { g as getWorkerState } from './utils.Ck2hJTRs.js';
-import { r as rpc } from './rpc.B7Mfb-Yf.js';
-import { t as takeCoverageInsideWorker } from './coverage.zlNdAMHK.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.BKyF15v_.js';
+import { r as rpc } from './rpc.C3q9uwRX.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.Dj6BZI3u.js';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 function setupChaiConfig(config) {
   Object.assign(chai.config, config);
@@ -12,7 +12,7 @@ function setupChaiConfig(config) {
 
 async function resolveSnapshotEnvironment(config, executor) {
   if (!config.snapshotEnvironment) {
-    const { VitestNodeSnapshotEnvironment } = await import('./node.Bx4JZjMG.js');
+    const { VitestNodeSnapshotEnvironment } = await import('./node.AKq966Jp.js');
     return new VitestNodeSnapshotEnvironment();
   }
   const mod = await executor.executeId(config.snapshotEnvironment);

package/dist/chunks/{node.Bx4JZjMG.js → node.AKq966Jp.js}

@@ -1,10 +1,6 @@
 import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import 'pathe';
-import '@vitest/runner/utils';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
 import '@vitest/utils';
-import { g as getWorkerState } from './utils.Ck2hJTRs.js';
-import './env.CmHVDJnw.js';
-import 'std-env';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
   getHeader() {