@vitest/browser 2.0.0-beta.2 → 2.0.0-beta.5

package/dist/client/__vitest_browser__/{tester-CrKhlp5g.js → tester-C3Mchfpf.js}

@@ -10,7 +10,10 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { i as importId, d as rpc$1, g as getConfig, _ as __vitePreload, b as channel, a as getBrowserState, c as client, l as loadSafeRpc, o as onCancel } from "./rpc-By4jD8av.js";
+import { i as importId, b as getConfig, e as rpc$1, _ as __vitePreload, f as extname, g as getBrowserState, a as channel, c as client, l as loadSafeRpc, o as onCancel } from "./rpc-DBukiZYG.js";
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
 function showPopupWarning(name, value, defaultValue) {
   return (...params) => {
     const formatedParams = params.map((p) => JSON.stringify(p)).join(", ");
@@ -42,14 +45,17 @@ async function setupConsoleLogSpy() {
     return format(input);
   };
   const processLog = (args) => args.map(formatInput).join(" ");
-  const sendLog = (type, content) => {
-    var _a, _b;
+  const sendLog = (type, content, disableStack) => {
+    var _a, _b, _c;
     if (content.startsWith("[vite]"))
       return;
     const unknownTestId = "__vitest__unknown_test__";
     const taskId = ((_b = (_a = globalThis.__vitest_worker__) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
+    const origin = getConfig().printConsoleTrace && !disableStack ? (_c = new Error("STACK_TRACE").stack) == null ? void 0 : _c.split("\n").slice(1).join("\n") : void 0;
     rpc$1().sendLog({
+      origin,
       content,
+      browser: true,
       time: Date$1.now(),
       taskId,
       type,
@@ -78,18 +84,19 @@ async function setupConsoleLogSpy() {
     return dirxml(...args);
   };
   console$1.trace = (...args) => {
+    var _a;
     const content = processLog(args);
-    const error2 = new Error("Trace");
-    const stack = (error2.stack || "").split("\n").slice(2).join("\n");
-    sendLog("stdout", `${content}
-${stack}`);
+    const error2 = new Error("$$Trace");
+    const stack = (error2.stack || "").split("\n").slice(((_a = error2.stack) == null ? void 0 : _a.includes("$$Trace")) ? 2 : 1).join("\n");
+    sendLog("stderr", `${content}
+${stack}`, true);
     return trace(...args);
   };
   const timeLabels = {};
   console$1.time = (label = "default") => {
-    const now = performance.now();
+    const now2 = performance.now();
     time(label);
-    timeLabels[label] = now;
+    timeLabels[label] = now2;
   };
   console$1.timeLog = (label = "default") => {
     timeLog(label);
@@ -168,6 +175,7 @@ function createBrowserRunner(runnerClass, coverageModule) {
       });
       __publicField(this, "onAfterRunFiles", async (files) => {
         var _a, _b;
+        await rpc$1().invalidateMocks();
         await ((_a = super.onAfterRunFiles) == null ? void 0 : _a.call(this, files));
         const coverage = await ((_b = coverageModule == null ? void 0 : coverageModule.takeCoverage) == null ? void 0 : _b.call(coverageModule));
         if (coverage) {
@@ -207,10 +215,9 @@ function createBrowserRunner(runnerClass, coverageModule) {
   };
 }
 let cachedRunner = null;
-async function initiateRunner() {
+async function initiateRunner(config) {
   if (cachedRunner)
     return cachedRunner;
-  const config = getConfig();
   const [
     { VitestTestRunner, NodeBenchmarkRunner },
     { takeCoverageInsideWorker, loadDiffConfig, loadSnapshotSerializers }
@@ -258,25 +265,219 @@ async function updateFilesLocations(files) {
   });
   await Promise.all(promises);
 }
-function throwNotImplemented(name) {
-  throw new Error(`[vitest] ${name} is not implemented in browser environment yet.`);
-}
+const now = Date.now;
 class VitestBrowserClientMocker {
-  importActual() {
-    throwNotImplemented("importActual");
+  constructor() {
+    __publicField(this, "queue", /* @__PURE__ */ new Set());
+    __publicField(this, "mocks", {});
+    __publicField(this, "factories", {});
+    __publicField(this, "spyModule");
+  }
+  setSpyModule(mod) {
+    this.spyModule = mod;
+  }
+  async importActual(id, importer) {
+    const resolved = await rpc$1().resolveId(id, importer);
+    if (resolved == null)
+      throw new Error(`[vitest] Cannot resolve ${id} imported from ${importer}`);
+    const ext = extname(resolved.id);
+    const base = getBrowserState().config.base || "/";
+    const url2 = new URL(`/@id${base}${resolved.id}`, location.href);
+    const query = `_vitest_original&ext.${ext}`;
+    const actualUrl = `${url2.pathname}${url2.search ? `${url2.search}&${query}` : `?${query}`}${url2.hash}`;
+    return getBrowserState().wrapModule(() => __vitePreload(() => import(actualUrl), true ? __vite__mapDeps([]) : void 0));
+  }
+  async importMock(rawId, importer) {
+    await this.prepare();
+    const { resolvedId, type, mockPath } = await rpc$1().resolveMock(rawId, importer);
+    const factoryReturn = this.get(resolvedId);
+    if (factoryReturn)
+      return factoryReturn;
+    if (this.factories[resolvedId])
+      return await this.resolve(resolvedId);
+    const base = getBrowserState().config.base || "/";
+    if (type === "redirect") {
+      const url22 = new URL(`/@id${base}${mockPath}`, location.href);
+      return __vitePreload(() => import(url22.toString()), true ? __vite__mapDeps([]) : void 0);
+    }
+    const url2 = new URL(`/@id${base}${resolvedId}`, location.href);
+    const query = url2.search ? `${url2.search}&t=${now()}` : `?t=${now()}`;
+    const moduleObject = await __vitePreload(() => import(`${url2.pathname}${query}${url2.hash}`), true ? __vite__mapDeps([]) : void 0);
+    return this.mockObject(moduleObject);
+  }
+  getMockContext() {
+    return { callstack: null };
+  }
+  get(id) {
+    return this.mocks[id];
+  }
+  async resolve(id) {
+    const factory = this.factories[id];
+    if (!factory)
+      throw new Error(`Cannot resolve ${id} mock: no factory provided`);
+    try {
+      this.mocks[id] = await factory();
+      return this.mocks[id];
+    } catch (err) {
+      const vitestError = new Error(
+        '[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock'
+      );
+      vitestError.cause = err;
+      throw vitestError;
+    }
+  }
+  queueMock(id, importer, factory) {
+    const promise = rpc$1().queueMock(id, importer, !!factory).then((id2) => {
+      this.factories[id2] = factory;
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  queueUnmock(id, importer) {
+    const promise = rpc$1().queueUnmock(id, importer).then((id2) => {
+      delete this.factories[id2];
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  async prepare() {
+    if (!this.queue.size)
+      return;
+    await Promise.all([...this.queue.values()]);
   }
-  importMock() {
-    throwNotImplemented("importMock");
+  // TODO: move this logic into a util(?)
+  mockObject(object, mockExports = {}) {
+    const finalizers = new Array();
+    const refs = new RefTracker();
+    const define = (container, key, value) => {
+      try {
+        container[key] = value;
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const mockPropertiesOf = (container, newContainer) => {
+      const containerType = /* @__PURE__ */ getType(container);
+      const isModule = containerType === "Module" || !!container.__esModule;
+      for (const { key: property, descriptor } of getAllMockableProperties(container, isModule)) {
+        if (!isModule && descriptor.get) {
+          try {
+            Object.defineProperty(newContainer, property, descriptor);
+          } catch (error) {
+          }
+          continue;
+        }
+        if (isSpecialProp(property, containerType))
+          continue;
+        const value = container[property];
+        const refId = refs.getId(value);
+        if (refId !== void 0) {
+          finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
+          continue;
+        }
+        const type = /* @__PURE__ */ getType(value);
+        if (Array.isArray(value)) {
+          define(newContainer, property, []);
+          continue;
+        }
+        const isFunction = type.includes("Function") && typeof value === "function";
+        if ((!isFunction || value.__isMockFunction) && type !== "Object" && type !== "Module") {
+          define(newContainer, property, value);
+          continue;
+        }
+        if (!define(newContainer, property, isFunction ? value : {}))
+          continue;
+        if (isFunction) {
+          let mockFunction = function() {
+            if (this instanceof newContainer[property]) {
+              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(this, false)) {
+                if (descriptor2.get)
+                  continue;
+                const value2 = this[key];
+                const type2 = /* @__PURE__ */ getType(value2);
+                const isFunction2 = type2.includes("Function") && typeof value2 === "function";
+                if (isFunction2) {
+                  const original = this[key];
+                  const mock2 = spyModule.vi.spyOn(this, key).mockImplementation(original);
+                  mock2.mockRestore = () => {
+                    mock2.mockReset();
+                    mock2.mockImplementation(original);
+                    return mock2;
+                  };
+                }
+              }
+            }
+          };
+          const spyModule = this.spyModule;
+          if (!spyModule)
+            throw new Error("[vitest] `spyModule` is not defined. This is Vitest error. Please open a new issue with reproduction.");
+          const mock = spyModule.vi.spyOn(newContainer, property).mockImplementation(mockFunction);
+          mock.mockRestore = () => {
+            mock.mockReset();
+            mock.mockImplementation(mockFunction);
+            return mock;
+          };
+          Object.defineProperty(newContainer[property], "length", { value: 0 });
+        }
+        refs.track(value, newContainer[property]);
+        mockPropertiesOf(value, newContainer[property]);
+      }
+    };
+    const mockedObject = mockExports;
+    mockPropertiesOf(object, mockedObject);
+    for (const finalizer of finalizers)
+      finalizer();
+    return mockedObject;
   }
-  queueMock() {
-    throwNotImplemented("queueMock");
+}
+function isSpecialProp(prop, parentType) {
+  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
+}
+class RefTracker {
+  constructor() {
+    __publicField(this, "idMap", /* @__PURE__ */ new Map());
+    __publicField(this, "mockedValueMap", /* @__PURE__ */ new Map());
+  }
+  getId(value) {
+    return this.idMap.get(value);
   }
-  queueUnmock() {
-    throwNotImplemented("queueUnmock");
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
   }
-  prepare() {
+  track(originalValue, mockedValue) {
+    const newId = this.idMap.size;
+    this.idMap.set(originalValue, newId);
+    this.mockedValueMap.set(newId, mockedValue);
+    return newId;
   }
 }
+function getAllMockableProperties(obj, isModule) {
+  const allProps = /* @__PURE__ */ new Map();
+  let curr = obj;
+  do {
+    if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype)
+      break;
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(curr, key);
+      if (descriptor)
+        allProps.set(key, { key, descriptor });
+    });
+  } while (curr = Object.getPrototypeOf(curr));
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor)
+      allProps.set("default", { key: "default", descriptor });
+  }
+  return Array.from(allProps.values());
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
 function on(event, listener) {
   window.addEventListener(event, listener);
   return () => window.removeEventListener(event, listener);
@@ -347,9 +548,16 @@ async function tryCall(fn) {
   try {
     return await fn();
   } catch (err) {
-    const now = Date.now();
-    const canTry = !reloadStart || now - Number(reloadStart) < 3e4;
-    debug("failed to resolve runner", err == null ? void 0 : err.message, "trying again:", canTry, "time is", now, "reloadStart is", reloadStart);
+    const now2 = Date.now();
+    const canTry = !reloadStart || now2 - Number(reloadStart) < 3e4;
+    const errorStack = (() => {
+      var _a;
+      if (!err)
+        return null;
+      return ((_a = err.stack) == null ? void 0 : _a.includes(err.message)) ? err.stack : `${err.message}
+${err.stack}`;
+    })();
+    debug("failed to resolve runner", "trying again:", canTry, "time is", now2, "reloadStart is", reloadStart, ":\n", errorStack);
     if (!canTry) {
       const error = serializeError(new Error("Vitest failed to load its runner after 30 seconds."));
       error.cause = serializeError(err);
@@ -358,7 +566,7 @@ async function tryCall(fn) {
     }
     if (!reloadStart) {
       const newUrl = new URL(location.href);
-      newUrl.searchParams.set("__reloadStart", now.toString());
+      newUrl.searchParams.set("__reloadStart", now2.toString());
       debug("set the new url because reload start is not set to", newUrl);
       location.href = newUrl.toString();
     } else {
@@ -382,7 +590,7 @@ async function prepareTestEnvironment(files) {
       worker: "./browser.js",
       workerId: 1,
       config,
-      projectName: config.name,
+      projectName: config.name || "",
       files,
       environment: {
         name: "browser",
@@ -405,23 +613,27 @@ async function prepareTestEnvironment(files) {
     rpc: rpc2,
     durations: {
       environment: 0,
-      prepare: 0
+      prepare: performance.now()
     },
     providedContext
   };
   globalThis.__vitest_browser__ = true;
   globalThis.__vitest_worker__ = state;
-  globalThis.__vitest_mocker__ = new VitestBrowserClientMocker();
+  const mocker = new VitestBrowserClientMocker();
+  globalThis.__vitest_mocker__ = mocker;
   await setupConsoleLogSpy();
   setupDialogsSpy();
-  const { startTests, setupCommonEnv } = await importId("vitest/browser");
-  const version = url.searchParams.get("browserv") || "0";
+  const version = url.searchParams.get("browserv") || "";
   files.forEach((filename) => {
     const currentVersion = browserHashMap.get(filename);
     if (!currentVersion || currentVersion[1] !== version)
       browserHashMap.set(filename, [true, version]);
   });
-  const runner = await initiateRunner();
+  const [runner, { startTests, setupCommonEnv, Vitest }] = await Promise.all([
+    initiateRunner(config),
+    importId("vitest/browser")
+  ]);
+  mocker.setSpyModule(Vitest);
   onCancel.then((reason) => {
     var _a;
     (_a = runner.onCancel) == null ? void 0 : _a.call(runner, reason);
@@ -460,6 +672,7 @@ async function runTests(files) {
   }
   debug("runner resolved successfully");
   const { config, runner, state, setupCommonEnv, startTests } = preparedData;
+  state.durations.prepare = performance.now() - state.durations.prepare;
   try {
     await setupCommonEnv(config);
     for (const file of files)

package/dist/client/esm-client-injector.js

@@ -1,42 +1,26 @@
 const moduleCache = new Map()
 
 function wrapModule(module) {
-  if (module instanceof Promise) {
-    moduleCache.set(module, { promise: module, evaluated: false })
-    return module
-      .then(m => '__vi_inject__' in m ? m.__vi_inject__ : m)
-      .finally(() => moduleCache.delete(module))
-  }
-  return '__vi_inject__' in module ? module.__vi_inject__ : module
-}
-
-function exportAll(exports, sourceModule) {
-  if (exports === sourceModule)
-    return
-
-  if (Object(sourceModule) !== sourceModule || Array.isArray(sourceModule))
-    return
-
-  for (const key in sourceModule) {
-    if (key !== 'default') {
-      try {
-        Object.defineProperty(exports, key, {
-          enumerable: true,
-          configurable: true,
-          get: () => sourceModule[key],
-        })
-      }
-      catch (_err) { }
-    }
+  if (typeof module === 'function') {
+    const promise = new Promise((resolve, reject) => {
+      if (typeof __vitest_mocker__ === 'undefined')
+        return module().then(resolve, reject)
+      __vitest_mocker__.prepare().finally(() => {
+        module().then(resolve, reject)
+      })
+    })
+    moduleCache.set(promise, { promise, evaluated: false })
+    return promise.finally(() => moduleCache.delete(promise))
   }
+  return module
 }
 
 window.__vitest_browser_runner__ = {
-  exportAll,
   wrapModule,
   moduleCache,
   config: { __VITEST_CONFIG__ },
   files: { __VITEST_FILES__ },
+  type: { __VITEST_TYPE__ },
 }
 
 const config = __vitest_browser_runner__.config

package/dist/client/{index.html → orchestrator.html}

@@ -15,19 +15,20 @@
         padding: 0;
         margin: 0;
       }
-      #vitest-ui {
-        width: 100vw;
-        height: 100vh;
-        border: none;
+      html,
+      body,
+      iframe[data-vitest],
+      #vitest-tester {
+        width: 100%;
+        height: 100%;
       }
     </style>
     <script>{__VITEST_INJECTOR__}</script>
     {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/main-DmAU-Uff.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-By4jD8av.js">
+    <script type="module" crossorigin src="/__vitest_browser__/orchestrator-CEB54dI4.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-DBukiZYG.js">
   </head>
   <body>
-    <iframe id="vitest-ui" src=""></iframe>
     <div id="vitest-tester"></div>
   </body>
 </html>

package/dist/client/tester.html

@@ -13,14 +13,15 @@
       body {
         padding: 0;
         margin: 0;
+        min-height: 100vh;
       }
     </style>
     <script>{__VITEST_INJECTOR__}</script>
     {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/tester-CrKhlp5g.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-By4jD8av.js">
+    <script type="module" crossorigin src="/__vitest_browser__/tester-C3Mchfpf.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/rpc-DBukiZYG.js">
   </head>
-  <body>
+  <body style="width: 100%; height: 100%; transform: scale(1); transform-origin: left top;">
     {__VITEST_APPEND__}
   </body>
 </html>

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { Plugin } from 'vite';
 import { WorkspaceProject } from 'vitest/node';
+export { BrowserCommand } from 'vitest/node';
+import { Plugin } from 'vitest/config';
 
 declare const _default: (project: WorkspaceProject, base?: string) => Plugin[];