vitest 0.34.6 → 1.0.0-beta.0

package/dist/vendor-benchmark.44931cfa.js

@@ -0,0 +1,41 @@
+import { getCurrentSuite } from '@vitest/runner';
+import { createChainable } from '@vitest/runner/utils';
+import { noop } from '@vitest/utils';
+import { i as isRunningInBenchmark } from './vendor-index.29282562.js';
+
+const benchFns = /* @__PURE__ */ new WeakMap();
+const benchOptsMap = /* @__PURE__ */ new WeakMap();
+function getBenchOptions(key) {
+  return benchOptsMap.get(key);
+}
+function getBenchFn(key) {
+  return benchFns.get(key);
+}
+const bench = createBenchmark(
+  function(name, fn = noop, options = {}) {
+    if (!isRunningInBenchmark())
+      throw new Error("`bench()` is only available in benchmark mode.");
+    const task = getCurrentSuite().task(formatName(name), {
+      ...this,
+      meta: {
+        benchmark: true
+      }
+    });
+    benchFns.set(task, fn);
+    benchOptsMap.set(task, options);
+  }
+);
+function createBenchmark(fn) {
+  const benchmark = createChainable(
+    ["skip", "only", "todo"],
+    fn
+  );
+  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+  return benchmark;
+}
+function formatName(name) {
+  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+}
+
+export { getBenchOptions as a, bench as b, getBenchFn as g };

package/dist/{vendor-environments.7aba93d9.js → vendor-environments.e73c5410.js}

@@ -472,8 +472,20 @@ var jsdom = {
     );
     const clearWindowErrors = catchWindowErrors(dom.window);
     dom.window.Buffer = Buffer;
-    if (typeof structuredClone !== "undefined" && !dom.window.structuredClone)
-      dom.window.structuredClone = structuredClone;
+    const globalNames = [
+      "structuredClone",
+      "fetch",
+      "Request",
+      "Response",
+      "BroadcastChannel",
+      "MessageChannel",
+      "MessagePort"
+    ];
+    for (const name of globalNames) {
+      const value = globalThis[name];
+      if (typeof value !== "undefined" && typeof dom.window[name] === "undefined")
+        dom.window[name] = value;
+    }
     return {
       getVmContext() {
         return dom.getInternalVMContext();

package/dist/{vendor-index.b271ebe4.js → vendor-index.1ca68bd5.js}

@@ -3,7 +3,7 @@ function defaultSerialize(i) {
   return i;
 }
 const defaultDeserialize = defaultSerialize;
-const { setTimeout } = globalThis;
+const { clearTimeout, setTimeout } = globalThis;
 const random = Math.random.bind(Math);
 function createBirpc(functions, options) {
   const {
@@ -32,14 +32,15 @@ function createBirpc(functions, options) {
         await _promise;
         return new Promise((resolve, reject) => {
           const id = nanoid();
-          rpcPromiseMap.set(id, { resolve, reject });
-          post(serialize({ m: method, a: args, i: id, t: "q" }));
+          let timeoutId;
           if (timeout >= 0) {
-            setTimeout(() => {
+            timeoutId = setTimeout(() => {
               reject(new Error(`[birpc] timeout on calling "${method}"`));
               rpcPromiseMap.delete(id);
-            }, timeout);
+            }, timeout).unref?.();
           }
+          rpcPromiseMap.set(id, { resolve, reject, timeoutId });
+          post(serialize({ m: method, a: args, i: id, t: "q" }));
         });
       };
       sendCall.asEvent = sendEvent;
@@ -70,6 +71,7 @@ function createBirpc(functions, options) {
       const { i: ack, r: result, e: error } = msg;
       const promise = rpcPromiseMap.get(ack);
       if (promise) {
+        clearTimeout(promise.timeoutId);
         if (error)
           promise.reject(error);
         else

package/dist/{vendor-index.3e351f42.js → vendor-index.d36f5516.js}

@@ -66,14 +66,14 @@ async function resolveTestRunner(config, executor) {
     rpc().onCollected(files);
     await (originalOnCollected == null ? void 0 : originalOnCollected.call(testRunner, files));
   };
-  const originalOnAfterRun = testRunner.onAfterRun;
-  testRunner.onAfterRun = async (files) => {
+  const originalOnAfterRun = testRunner.onAfterRunFiles;
+  testRunner.onAfterRunFiles = async (files) => {
     const coverage = await takeCoverageInsideWorker(config.coverage, executor);
     rpc().onAfterSuiteRun({ coverage });
     await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
   };
-  const originalOnAfterRunTest = testRunner.onAfterRunTest;
-  testRunner.onAfterRunTest = async (test) => {
+  const originalOnAfterRunTask = testRunner.onAfterRunTask;
+  testRunner.onAfterRunTask = async (test) => {
     var _a, _b;
     if (config.bail && ((_a = test.result) == null ? void 0 : _a.state) === "fail") {
       const previousFailures = await rpc().getCountOfFailedTests();
@@ -83,7 +83,7 @@ async function resolveTestRunner(config, executor) {
         (_b = testRunner.onCancel) == null ? void 0 : _b.call(testRunner, "test-failure");
       }
     }
-    await (originalOnAfterRunTest == null ? void 0 : originalOnAfterRunTest.call(testRunner, test));
+    await (originalOnAfterRunTask == null ? void 0 : originalOnAfterRunTask.call(testRunner, test));
   };
   return testRunner;
 }

package/dist/{vendor-index.7646b3af.js → vendor-index.f7fcd5e8.js}

@@ -1,6 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-import { e as bench, c as createExpect, d as globalExpect, v as vi, f as vitest } from './vendor-vi.6873a1c1.js';
+import { b as bench } from './vendor-benchmark.44931cfa.js';
 import { i as isFirstRun, r as runOnce } from './vendor-run-once.3e5ef7d7.js';
+import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vendor-vi.7f2b988f.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 

package/dist/vendor-inspector.209edf5a.js

@@ -0,0 +1,26 @@
+import { createRequire } from 'node:module';
+
+const __require = createRequire(import.meta.url);
+let inspector;
+function setupInspect(config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const isEnabled = config.inspect || config.inspectBrk;
+  if (isEnabled) {
+    inspector = __require("node:inspector");
+    const isOpen = inspector.url() !== void 0;
+    if (!isOpen) {
+      inspector.open();
+      if (config.inspectBrk)
+        inspector.waitForDebugger();
+    }
+  }
+  const isIsolatedSingleThread = config.pool === "threads" && ((_b = (_a = config.poolOptions) == null ? void 0 : _a.threads) == null ? void 0 : _b.isolate) === false && ((_d = (_c = config.poolOptions) == null ? void 0 : _c.threads) == null ? void 0 : _d.singleThread);
+  const isIsolatedSingleFork = config.pool === "forks" && ((_f = (_e = config.poolOptions) == null ? void 0 : _e.forks) == null ? void 0 : _f.isolate) === false && ((_h = (_g = config.poolOptions) == null ? void 0 : _g.forks) == null ? void 0 : _h.singleFork);
+  const keepOpen = config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
+  return function cleanup() {
+    if (isEnabled && !keepOpen && inspector)
+      inspector.close();
+  };
+}
+
+export { setupInspect as s };