vitest 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/runners.js

@@ -1,5 +1,5 @@
 import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
-import { g as getSnapshotClient, c as createExpect, v as vi } from './vendor-vi.7f2b988f.js';
+import { g as getSnapshotClient, c as createExpect, v as vi } from './vendor-vi.d30b47ae.js';
 import './vendor-index.29282562.js';
 import { a as rpc } from './vendor-rpc.cbd8e972.js';
 import { g as getFullName } from './vendor-tasks.f9d75aed.js';
@@ -14,7 +14,6 @@ import './vendor-_commonjsHelpers.7d1333e8.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/utils/source-map';
-import 'util';
 import './vendor-date.6e993429.js';
 import '@vitest/spy';
 import 'pathe';
@@ -128,11 +127,6 @@ function clearModuleMocks(config) {
     vi.unstubAllGlobals();
 }
 
-async function importTinybench() {
-  if (!globalThis.EventTarget)
-    await import('./vendor-index.98139333.js').then(function (n) { return n.i; });
-  return await import('tinybench');
-}
 function createBenchmarkResult(name) {
   return {
     name,
@@ -144,7 +138,7 @@ function createBenchmarkResult(name) {
 const benchmarkTasks = /* @__PURE__ */ new WeakMap();
 async function runBenchmarkSuite(suite, runner) {
   var _a;
-  const { Task, Bench } = await importTinybench();
+  const { Task, Bench } = await runner.importTinybench();
   const start = performance.now();
   const benchmarkGroup = [];
   const benchmarkSuiteGroup = [];
@@ -160,14 +154,30 @@ async function runBenchmarkSuite(suite, runner) {
     await Promise.all(benchmarkSuiteGroup.map((subSuite) => runBenchmarkSuite(subSuite, runner)));
   if (benchmarkGroup.length) {
     const defer = createDefer();
-    const benchmarkMap = {};
     suite.result = {
       state: "run",
       startTime: start,
       benchmark: createBenchmarkResult(suite.name)
     };
     updateTask$1(suite);
-    benchmarkGroup.forEach((benchmark, idx) => {
+    const addBenchTaskListener = (task, benchmark) => {
+      task.addEventListener("complete", (e) => {
+        const task2 = e.task;
+        const taskRes = task2.result;
+        const result = benchmark.result.benchmark;
+        Object.assign(result, taskRes);
+        updateTask$1(benchmark);
+      }, {
+        once: true
+      });
+      task.addEventListener("error", (e) => {
+        const task2 = e.task;
+        defer.reject(benchmark ? task2.result.error : e);
+      }, {
+        once: true
+      });
+    };
+    benchmarkGroup.forEach((benchmark) => {
       const options = getBenchOptions(benchmark);
       const benchmarkInstance = new Bench(options);
       const benchmarkFn = getBenchFn(benchmark);
@@ -176,43 +186,26 @@ async function runBenchmarkSuite(suite, runner) {
         startTime: start,
         benchmark: createBenchmarkResult(benchmark.name)
       };
-      const id = idx.toString();
-      benchmarkMap[id] = benchmark;
-      const task = new Task(benchmarkInstance, id, benchmarkFn);
+      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
       benchmarkTasks.set(benchmark, task);
+      addBenchTaskListener(task, benchmark);
       updateTask$1(benchmark);
     });
-    benchmarkGroup.forEach((benchmark) => {
-      const task = benchmarkTasks.get(benchmark);
-      task.addEventListener("complete", (e) => {
-        const task2 = e.task;
-        const _benchmark = benchmarkMap[task2.name || ""];
-        if (_benchmark) {
-          const taskRes = task2.result;
-          const result = _benchmark.result.benchmark;
-          Object.assign(result, taskRes);
-          updateTask$1(_benchmark);
-        }
-      });
-      task.addEventListener("error", (e) => {
-        const task2 = e.task;
-        const _benchmark = benchmarkMap[task2.name || ""];
-        defer.reject(_benchmark ? task2.result.error : e);
-      });
-    });
+    const { setTimeout } = getSafeTimers();
     const tasks = [];
     for (const benchmark of benchmarkGroup) {
       const task = benchmarkTasks.get(benchmark);
       await task.warmup();
-      const { setTimeout } = getSafeTimers();
-      tasks.push(await new Promise((resolve) => setTimeout(async () => {
-        resolve(await task.run());
-      })));
+      tasks.push([
+        await new Promise((resolve) => setTimeout(async () => {
+          resolve(await task.run());
+        })),
+        benchmark
+      ]);
     }
     suite.result.duration = performance.now() - start;
     suite.result.state = "pass";
-    tasks.sort((a, b) => a.result.mean - b.result.mean).forEach((cycle, idx) => {
-      const benchmark = benchmarkMap[cycle.name || ""];
+    tasks.sort(([taskA], [taskB]) => taskA.result.mean - taskB.result.mean).forEach(([, benchmark], idx) => {
       benchmark.result.state = "pass";
       if (benchmark) {
         const result = benchmark.result.benchmark;
@@ -233,6 +226,9 @@ class NodeBenchmarkRunner {
     this.config = config;
   }
   __vitest_executor;
+  async importTinybench() {
+    return await import('tinybench');
+  }
   importFile(filepath, source) {
     if (source === "setup")
       getWorkerState().moduleCache.delete(filepath);

package/dist/{suite-543d56bd.d.ts → suite-0579b50d.d.ts}

@@ -1,6 +1,6 @@
 import { Custom } from '@vitest/runner';
 import '@vitest/runner/utils';
-import { af as BenchFunction, ag as BenchmarkAPI } from './reporters-7bd09217.js';
+import { ai as BenchFunction, aj as BenchmarkAPI } from './reporters-1678fe04.js';
 import { Options } from 'tinybench';
 
 declare function getBenchOptions(key: Custom): Options;

package/dist/suite.d.ts

@@ -1,7 +1,7 @@
 export { createTaskCollector, getCurrentSuite, getFn, setFn } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-export { g as getBenchFn, a as getBenchOptions } from './suite-543d56bd.js';
-import './reporters-7bd09217.js';
+export { g as getBenchFn, a as getBenchOptions } from './suite-0579b50d.js';
+import './reporters-1678fe04.js';
 import 'vite';
 import 'vite-node';
 import '@vitest/snapshot';

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

@@ -1,6 +1,3 @@
-import { resolve, normalize } from 'pathe';
-import { r as resolvePath } from './vendor-index.0b5b3600.js';
-import { ViteNodeRunner } from 'vite-node/client';
 import { Console } from 'node:console';
 import { importModule } from 'local-pkg';
 
@@ -479,7 +476,9 @@ var jsdom = {
       "Response",
       "BroadcastChannel",
       "MessageChannel",
-      "MessagePort"
+      "MessagePort",
+      "TextEncoder",
+      "TextDecoder"
     ];
     for (const name of globalNames) {
       const value = globalThis[name];
@@ -646,44 +645,14 @@ const envPackageNames = {
   "happy-dom": "happy-dom",
   "edge-runtime": "@edge-runtime/vm"
 };
-function isBuiltinEnvironment(env) {
-  return env in environments;
-}
 function getEnvPackageName(env) {
   if (env === "node")
     return null;
   if (env in envPackageNames)
     return envPackageNames[env];
+  if (env[0] === "." || env[0] === "/")
+    return null;
   return `vitest-environment-${env}`;
 }
-const _loaders = /* @__PURE__ */ new Map();
-async function createEnvironmentLoader(options) {
-  if (!_loaders.has(options.root)) {
-    const loader = new ViteNodeRunner(options);
-    await loader.executeId("/@vite/env");
-    _loaders.set(options.root, loader);
-  }
-  return _loaders.get(options.root);
-}
-async function loadEnvironment(name, options) {
-  if (isBuiltinEnvironment(name))
-    return environments[name];
-  const loader = await createEnvironmentLoader(options);
-  const root = loader.root;
-  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : await resolvePath(`vitest-environment-${name}`, { url: [root] }) ?? resolve(root, name);
-  const pkg = await loader.executeId(normalize(packageId));
-  if (!pkg || !pkg.default || typeof pkg.default !== "object") {
-    throw new TypeError(
-      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`
-    );
-  }
-  const environment = pkg.default;
-  if (environment.transformMode !== "web" && environment.transformMode !== "ssr") {
-    throw new TypeError(
-      `Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web".`
-    );
-  }
-  return environment;
-}
 
-export { environments as e, getEnvPackageName as g, loadEnvironment as l, populateGlobal as p };
+export { environments as e, getEnvPackageName as g, populateGlobal as p };

package/dist/{vendor-execute.07d1a420.js → vendor-execute.e6e4e89b.js}

@@ -1009,6 +1009,7 @@ async function startVitestExecutor(options) {
     }
     rpc().onUnhandledError(error, type);
   }
+  process.setMaxListeners(25);
   process.on("uncaughtException", (e) => catchError(e, "Uncaught Exception"));
   process.on("unhandledRejection", (e) => catchError(e, "Unhandled Rejection"));
   const getTransformMode = () => {

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

@@ -68,8 +68,13 @@ async function resolveTestRunner(config, executor) {
   };
   const originalOnAfterRun = testRunner.onAfterRunFiles;
   testRunner.onAfterRunFiles = async (files) => {
+    const state = getWorkerState();
     const coverage = await takeCoverageInsideWorker(config.coverage, executor);
-    rpc().onAfterSuiteRun({ coverage });
+    rpc().onAfterSuiteRun({
+      coverage,
+      transformMode: state.environment.transformMode,
+      projectName: state.ctx.projectName
+    });
     await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
   };
   const originalOnAfterRunTask = testRunner.onAfterRunTask;

package/dist/{vendor-index.f7fcd5e8.js → vendor-index.68ecee35.js}

@@ -1,7 +1,7 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
 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 { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vendor-vi.d30b47ae.js';
 import * as chai from 'chai';
 import { assert, should } from 'chai';