vitest 0.34.3 → 0.34.5

package/dist/{vendor-vi.597d9e06.js → vendor-vi.6873a1c1.js}

@@ -3168,6 +3168,9 @@ class FakeTimers {
   configure(config) {
     this._userConfig = config;
   }
+  isFakeTimers() {
+    return this._fakingTime;
+  }
   _checkFakeTimers() {
     if (!this._fakingTime) {
       throw new Error(
@@ -3178,6 +3181,124 @@ class FakeTimers {
   }
 }
 
+function copyStackTrace(target, source) {
+  if (source.stack !== void 0)
+    target.stack = source.stack.replace(source.message, target.message);
+  return target;
+}
+function waitFor(callback, options = {}) {
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+  return new Promise((resolve, reject) => {
+    let lastError;
+    let promiseStatus = "idle";
+    let timeoutId;
+    let intervalId;
+    const onResolve = (result) => {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      if (intervalId)
+        clearInterval(intervalId);
+      resolve(result);
+    };
+    const handleTimeout = () => {
+      let error = lastError;
+      if (!error)
+        error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+      reject(error);
+    };
+    const checkCallback = () => {
+      if (vi.isFakeTimers())
+        vi.advanceTimersByTime(interval);
+      if (promiseStatus === "pending")
+        return;
+      try {
+        const result = callback();
+        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+          const thenable = result;
+          promiseStatus = "pending";
+          thenable.then(
+            (resolvedValue) => {
+              promiseStatus = "resolved";
+              onResolve(resolvedValue);
+            },
+            (rejectedValue) => {
+              promiseStatus = "rejected";
+              lastError = rejectedValue;
+            }
+          );
+        } else {
+          onResolve(result);
+          return true;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    };
+    if (checkCallback() === true)
+      return;
+    timeoutId = setTimeout(handleTimeout, timeout);
+    intervalId = setInterval(checkCallback, interval);
+  });
+}
+function waitUntil(callback, options = {}) {
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+  return new Promise((resolve, reject) => {
+    let promiseStatus = "idle";
+    let timeoutId;
+    let intervalId;
+    const onReject = (error) => {
+      if (!error)
+        error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+      reject(error);
+    };
+    const onResolve = (result) => {
+      if (!result)
+        return;
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      if (intervalId)
+        clearInterval(intervalId);
+      resolve(result);
+      return true;
+    };
+    const checkCallback = () => {
+      if (vi.isFakeTimers())
+        vi.advanceTimersByTime(interval);
+      if (promiseStatus === "pending")
+        return;
+      try {
+        const result = callback();
+        if (result !== null && typeof result === "object" && typeof result.then === "function") {
+          const thenable = result;
+          promiseStatus = "pending";
+          thenable.then(
+            (resolvedValue) => {
+              promiseStatus = "resolved";
+              onResolve(resolvedValue);
+            },
+            (rejectedValue) => {
+              promiseStatus = "rejected";
+              onReject(rejectedValue);
+            }
+          );
+        } else {
+          return onResolve(result);
+        }
+      } catch (error) {
+        onReject(error);
+      }
+    };
+    if (checkCallback() === true)
+      return;
+    timeoutId = setTimeout(onReject, timeout);
+    intervalId = setInterval(checkCallback, interval);
+  });
+}
+
 function createVitest() {
   const _mocker = typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, {
     get(_, name) {
@@ -3205,7 +3326,7 @@ function createVitest() {
     const stack = parseSingleStack(importerStack);
     return (stack == null ? void 0 : stack.file) || "";
   };
-  return {
+  const utils = {
     useFakeTimers(config) {
       if (config) {
         _timers.configure(config);
@@ -3214,48 +3335,51 @@ function createVitest() {
         _timers.configure(workerState2.config.fakeTimers);
       }
       _timers.useFakeTimers();
-      return this;
+      return utils;
+    },
+    isFakeTimers() {
+      return _timers.isFakeTimers();
     },
     useRealTimers() {
       _timers.useRealTimers();
       _mockedDate = null;
-      return this;
+      return utils;
     },
     runOnlyPendingTimers() {
       _timers.runOnlyPendingTimers();
-      return this;
+      return utils;
     },
     async runOnlyPendingTimersAsync() {
       await _timers.runOnlyPendingTimersAsync();
-      return this;
+      return utils;
     },
     runAllTimers() {
       _timers.runAllTimers();
-      return this;
+      return utils;
     },
     async runAllTimersAsync() {
       await _timers.runAllTimersAsync();
-      return this;
+      return utils;
     },
     runAllTicks() {
       _timers.runAllTicks();
-      return this;
+      return utils;
     },
     advanceTimersByTime(ms) {
       _timers.advanceTimersByTime(ms);
-      return this;
+      return utils;
     },
     async advanceTimersByTimeAsync(ms) {
       await _timers.advanceTimersByTimeAsync(ms);
-      return this;
+      return utils;
     },
     advanceTimersToNextTimer() {
       _timers.advanceTimersToNextTimer();
-      return this;
+      return utils;
     },
     async advanceTimersToNextTimerAsync() {
       await _timers.advanceTimersToNextTimerAsync();
-      return this;
+      return utils;
     },
     getTimerCount() {
       return _timers.getTimerCount();
@@ -3264,7 +3388,7 @@ function createVitest() {
       const date = time instanceof Date ? time : new Date(time);
       _mockedDate = date;
       _timers.setSystemTime(date);
-      return this;
+      return utils;
     },
     getMockedSystemTime() {
       return _mockedDate;
@@ -3274,11 +3398,13 @@ function createVitest() {
     },
     clearAllTimers() {
       _timers.clearAllTimers();
-      return this;
+      return utils;
     },
     // mocks
     spyOn,
     fn,
+    waitFor,
+    waitUntil,
     hoisted(factory) {
       assertTypes(factory, '"vi.hoisted" factory', ["function"]);
       return factory();
@@ -3314,15 +3440,15 @@ function createVitest() {
     },
     clearAllMocks() {
       spies.forEach((spy) => spy.mockClear());
-      return this;
+      return utils;
     },
     resetAllMocks() {
       spies.forEach((spy) => spy.mockReset());
-      return this;
+      return utils;
     },
     restoreAllMocks() {
       spies.forEach((spy) => spy.mockRestore());
-      return this;
+      return utils;
     },
     stubGlobal(name, value) {
       if (!_stubsGlobal.has(name))
@@ -3333,13 +3459,13 @@ function createVitest() {
         configurable: true,
         enumerable: true
       });
-      return this;
+      return utils;
     },
     stubEnv(name, value) {
       if (!_stubsEnv.has(name))
         _stubsEnv.set(name, process.env[name]);
       process.env[name] = value;
-      return this;
+      return utils;
     },
     unstubAllGlobals() {
       _stubsGlobal.forEach((original, name) => {
@@ -3349,7 +3475,7 @@ function createVitest() {
           Object.defineProperty(globalThis, name, original);
       });
       _stubsGlobal.clear();
-      return this;
+      return utils;
     },
     unstubAllEnvs() {
       _stubsEnv.forEach((original, name) => {
@@ -3359,12 +3485,12 @@ function createVitest() {
           process.env[name] = original;
       });
       _stubsEnv.clear();
-      return this;
+      return utils;
     },
     resetModules() {
       const state = getWorkerState();
       resetModules(state.moduleCache);
-      return this;
+      return utils;
     },
     async dynamicImportSettled() {
       return waitForImportsToResolve();
@@ -3382,6 +3508,7 @@ function createVitest() {
       }
     }
   };
+  return utils;
 }
 const vitest = createVitest();
 const vi = vitest;

package/dist/vm.js

@@ -7,8 +7,8 @@ import { c as createBirpc } from './vendor-index.b271ebe4.js';
 import { resolve } from 'pathe';
 import { installSourcemapsSupport } from 'vite-node/source-map';
 import { d as distDir } from './vendor-paths.84fc7a99.js';
-import { l as loadEnvironment } from './vendor-environments.8eb4d407.js';
-import { b as startVitestExecutor } from './vendor-execute.a63e187f.js';
+import { l as loadEnvironment } from './vendor-environments.b9b2f624.js';
+import { b as startVitestExecutor } from './vendor-execute.07d1a420.js';
 import { createCustomConsole } from './chunk-runtime-console.ea222ffb.js';
 import { c as createSafeRpc } from './vendor-rpc.cbd8e972.js';
 import './vendor-index.0b5b3600.js';
@@ -42,7 +42,7 @@ async function run(ctx) {
   const onCancel = new Promise((resolve2) => {
     setCancel = resolve2;
   });
-  const rpc = createBirpc(
+  const rpc = createSafeRpc(createBirpc(
     {
       onCancel: setCancel
     },
@@ -55,8 +55,13 @@ async function run(ctx) {
         port.addListener("message", fn);
       }
     }
-  );
-  const environment = await loadEnvironment(ctx.environment.name, ctx.config.root);
+  ));
+  const environment = await loadEnvironment(ctx.environment.name, {
+    root: ctx.config.root,
+    fetchModule(id) {
+      return rpc.fetch(id, "ssr");
+    }
+  });
   if (!environment.setupVM) {
     const envName = ctx.environment.name;
     const packageId = envName[0] === "." ? envName : `vitest-environment-${envName}`;
@@ -75,7 +80,7 @@ async function run(ctx) {
       environment: performance.now(),
       prepare: performance.now()
     },
-    rpc: createSafeRpc(rpc)
+    rpc
   };
   installSourcemapsSupport({
     getSourceMap: (source) => moduleCache.getSourceMap(source)

package/dist/worker.js

@@ -2,25 +2,25 @@ import { performance } from 'node:perf_hooks';
 import { c as createBirpc } from './vendor-index.b271ebe4.js';
 import { workerId } from 'tinypool';
 import { g as getWorkerState } from './vendor-global.97e4527c.js';
-import { l as loadEnvironment } from './vendor-environments.8eb4d407.js';
-import { s as startViteNode, m as moduleCache, a as mockMap } from './vendor-execute.a63e187f.js';
+import { l as loadEnvironment } from './vendor-environments.b9b2f624.js';
+import { s as startViteNode, m as moduleCache, a as mockMap } from './vendor-execute.07d1a420.js';
 import { s as setupInspect } from './vendor-inspector.47fc8cbb.js';
 import { r as rpcDone, c as createSafeRpc } from './vendor-rpc.cbd8e972.js';
-import 'node:url';
 import 'pathe';
 import './vendor-index.0b5b3600.js';
 import 'acorn';
 import 'node:module';
 import 'node:fs';
+import 'node:url';
 import 'node:assert';
 import 'node:process';
 import 'node:path';
 import 'node:v8';
 import 'node:util';
+import 'vite-node/client';
 import 'node:console';
 import 'local-pkg';
 import 'node:vm';
-import 'vite-node/client';
 import 'vite-node/utils';
 import '@vitest/utils/error';
 import './vendor-paths.84fc7a99.js';
@@ -39,7 +39,7 @@ async function init(ctx) {
   const onCancel = new Promise((resolve) => {
     setCancel = resolve;
   });
-  const rpc = createBirpc(
+  const rpc = createSafeRpc(createBirpc(
     {
       onCancel: setCancel
     },
@@ -52,8 +52,13 @@ async function init(ctx) {
         port.addListener("message", fn);
       }
     }
-  );
-  const environment = await loadEnvironment(ctx.environment.name, ctx.config.root);
+  ));
+  const environment = await loadEnvironment(ctx.environment.name, {
+    root: ctx.config.root,
+    fetchModule(id) {
+      return rpc.fetch(id, "ssr");
+    }
+  });
   if (ctx.environment.transformMode)
     environment.transformMode = ctx.environment.transformMode;
   const state = {
@@ -67,7 +72,7 @@ async function init(ctx) {
       environment: 0,
       prepare: performance.now()
     },
-    rpc: createSafeRpc(rpc)
+    rpc
   };
   globalThis.__vitest_worker__ = state;
   if (ctx.invalidates) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.34.3",
+  "version": "0.34.5",
   "description": "A blazing fast unit test framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -153,14 +153,14 @@
     "strip-literal": "^1.0.1",
     "tinybench": "^2.5.0",
     "tinypool": "^0.7.0",
-    "vite": "^3.0.0 || ^4.0.0",
+    "vite": "^3.1.0 || ^4.0.0 || ^5.0.0-0",
     "why-is-node-running": "^2.2.2",
-    "@vitest/runner": "0.34.3",
-    "@vitest/utils": "0.34.3",
-    "vite-node": "0.34.3",
-    "@vitest/expect": "0.34.3",
-    "@vitest/snapshot": "0.34.3",
-    "@vitest/spy": "0.34.3"
+    "@vitest/runner": "0.34.5",
+    "@vitest/snapshot": "0.34.5",
+    "vite-node": "0.34.5",
+    "@vitest/spy": "0.34.5",
+    "@vitest/utils": "0.34.5",
+    "@vitest/expect": "0.34.5"
   },
   "devDependencies": {
     "@ampproject/remapping": "^2.2.1",