npm - @vitest/browser - Versions diffs - 0.29.6 → 0.29.8 - Mend

@vitest/browser 0.29.6 → 0.29.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +6 -6
package/dist/client/__vitest__/assets/{index-d8f092a0.js → index-84967894.js} +22 -22
package/dist/client/__vitest__/index.html +1 -1
package/dist/client/assets/{index-25415511.js → index-a25c0b91.js} +218 -31
package/dist/client/index.html +1 -1
package/dist/index.js +12 -11
package/package.json +5 -4

package/dist/client/__vitest__/index.html CHANGED Viewed

@@ -17,7 +17,7 @@
       })()
     </script>
     <!-- !LOAD_METADATA! -->
-    <script type="module" crossorigin src="./assets/index-d8f092a0.js"></script>
+    <script type="module" crossorigin src="./assets/index-84967894.js"></script>
     <link rel="stylesheet" href="./assets/index-57d38fc4.css">
   </head>
   <body>

package/dist/client/assets/{index-25415511.js → index-a25c0b91.js} RENAMED Viewed

@@ -100,7 +100,7 @@ function createBirpc(functions, options) {
     timeout = DEFAULT_TIMEOUT
   } = options;
   const rpcPromiseMap = /* @__PURE__ */ new Map();
-  const rpc = new Proxy({}, {
+  const rpc2 = new Proxy({}, {
     get(_, method) {
       const sendEvent = (...args) => {
         post(serialize({ m: method, a: args, t: "q" }));
@@ -132,7 +132,7 @@ function createBirpc(functions, options) {
       const { m: method, a: args } = msg;
       let result, error;
       try {
-        result = await functions[method].apply(rpc, args);
+        result = await functions[method].apply(rpc2, args);
       } catch (e) {
         error = e;
       }
@@ -148,7 +148,7 @@ function createBirpc(functions, options) {
       rpcPromiseMap.delete(ack);
     }
   });
-  return rpc;
+  return rpc2;
 }
 const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
 function nanoid(size = 21) {
@@ -239,6 +239,7 @@ class StateManager {
     this.filesMap = /* @__PURE__ */ new Map();
     this.pathsSet = /* @__PURE__ */ new Set();
     this.collectingPromise = void 0;
+    this.browserTestPromises = /* @__PURE__ */ new Map();
     this.idMap = /* @__PURE__ */ new Map();
     this.taskFileMap = /* @__PURE__ */ new WeakMap();
     this.errorsSet = /* @__PURE__ */ new Set();
@@ -402,16 +403,72 @@ function createClient(url2, options = {}) {
   }
   return ctx;
 }
-function createBrowserRunner(original) {
+const { get } = Reflect;
+const safeRandom = Math.random;
+function withSafeTimers(getTimers, fn) {
+  const { setTimeout: setTimeout2, clearTimeout, nextTick, setImmediate, clearImmediate } = getTimers();
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentClearTimeout = globalThis.clearTimeout;
+  const currentRandom = globalThis.Math.random;
+  const currentNextTick = globalThis.process.nextTick;
+  const currentSetImmediate = globalThis.setImmediate;
+  const currentClearImmediate = globalThis.clearImmediate;
+  try {
+    globalThis.setTimeout = setTimeout2;
+    globalThis.clearTimeout = clearTimeout;
+    globalThis.Math.random = safeRandom;
+    globalThis.process.nextTick = nextTick;
+    globalThis.setImmediate = setImmediate;
+    globalThis.clearImmediate = clearImmediate;
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.clearTimeout = currentClearTimeout;
+    globalThis.Math.random = currentRandom;
+    globalThis.setImmediate = currentSetImmediate;
+    globalThis.clearImmediate = currentClearImmediate;
+    nextTick(() => {
+      globalThis.process.nextTick = currentNextTick;
+    });
+  }
+}
+const promises = /* @__PURE__ */ new Set();
+const rpcDone = async () => {
+  if (!promises.size)
+    return;
+  const awaitable = Array.from(promises);
+  return Promise.all(awaitable);
+};
+const createSafeRpc = (client2, getTimers) => {
+  return new Proxy(client2.rpc, {
+    get(target, p, handler) {
+      const sendCall = get(target, p, handler);
+      const safeSendCall = (...args) => withSafeTimers(getTimers, async () => {
+        const result = sendCall(...args);
+        promises.add(result);
+        try {
+          return await result;
+        } finally {
+          promises.delete(result);
+        }
+      });
+      safeSendCall.asEvent = sendCall.asEvent;
+      return safeSendCall;
+    }
+  });
+};
+const rpc = () => {
+  return globalThis.__vitest_worker__.safeRpc;
+};
+function createBrowserRunner(original, coverageModule) {
   return class BrowserTestRunner extends original {
     constructor(options) {
       super(options.config);
       __publicField(this, "config");
       __publicField(this, "hashMap", /* @__PURE__ */ new Map());
-      __publicField(this, "client");
       this.config = options.config;
       this.hashMap = options.browserHashMap;
-      this.client = options.client;
     }
     async onAfterRunTest(task) {
       var _a, _b, _c;
@@ -420,11 +477,17 @@ function createBrowserRunner(original) {
         console.error(error.message);
       });
     }
+    async onAfterRunSuite() {
+      var _a, _b;
+      await ((_a = super.onAfterRunSuite) == null ? void 0 : _a.call(this));
+      const coverage = await ((_b = coverageModule == null ? void 0 : coverageModule.takeCoverage) == null ? void 0 : _b.call(coverageModule));
+      await rpc().onAfterSuiteRun({ coverage });
+    }
     onCollected(files) {
-      return this.client.rpc.onCollected(files);
+      return rpc().onCollected(files);
     }
     onTaskUpdate(task) {
-      return this.client.rpc.onTaskUpdate(task);
+      return rpc().onTaskUpdate(task);
     }
     async importFile(filepath) {
       const match = filepath.match(/^(\w:\/)/);
@@ -439,25 +502,134 @@ function createBrowserRunner(original) {
   };
 }
 class BrowserSnapshotEnvironment {
-  constructor(client2) {
-    this.client = client2;
-  }
   readSnapshotFile(filepath) {
-    return this.client.rpc.readFile(filepath);
+    return rpc().readFile(filepath);
   }
   saveSnapshotFile(filepath, snapshot) {
-    return this.client.rpc.writeFile(filepath, snapshot);
+    return rpc().writeFile(filepath, snapshot);
   }
   resolvePath(filepath) {
-    return this.client.rpc.resolveSnapshotPath(filepath);
+    return rpc().resolveSnapshotPath(filepath);
   }
   removeSnapshotFile(filepath) {
-    return this.client.rpc.removeFile(filepath);
+    return rpc().removeFile(filepath);
   }
   async prepareDirectory(filepath) {
-    await this.client.rpc.createDirectory(filepath);
+    await rpc().createDirectory(filepath);
   }
 }
+const importId = (id) => {
+  const name = `/@id/${id}`;
+  return __vitePreload(() => import(name), true ? [] : void 0);
+};
+const { Date: Date$1, console: console$1 } = globalThis;
+const setupConsoleLogSpy = async () => {
+  const { stringify: stringify2, format, utilInspect } = await importId("vitest/utils");
+  const { log, info, error, dir, dirxml, trace, time, timeEnd, timeLog, warn, debug, count, countReset } = console$1;
+  const formatInput = (input) => {
+    if (input instanceof Node)
+      return stringify2(input);
+    return format(input);
+  };
+  const processLog = (args) => args.map(formatInput).join(" ");
+  const sendLog = (type, content) => {
+    var _a, _b;
+    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;
+    rpc().sendLog({
+      content,
+      time: Date$1.now(),
+      taskId,
+      type,
+      size: content.length
+    });
+  };
+  const stdout = (base) => (...args) => {
+    sendLog("stdout", processLog(args));
+    return base(...args);
+  };
+  const stderr = (base) => (...args) => {
+    sendLog("stderr", processLog(args));
+    return base(...args);
+  };
+  console$1.log = stdout(log);
+  console$1.debug = stdout(debug);
+  console$1.info = stdout(info);
+  console$1.error = stderr(error);
+  console$1.warn = stderr(warn);
+  console$1.dir = (item, options) => {
+    sendLog("stdout", utilInspect(item, options));
+    return dir(item, options);
+  };
+  console$1.dirxml = (...args) => {
+    sendLog("stdout", processLog(args));
+    return dirxml(...args);
+  };
+  console$1.trace = (...args) => {
+    const content = processLog(args);
+    const error2 = new Error("Trace");
+    const stack = (error2.stack || "").split("\n").slice(2).join("\n");
+    sendLog("stdout", `${content}
+${stack}`);
+    return trace(...args);
+  };
+  const timeLabels = {};
+  console$1.time = (label = "default") => {
+    const now = performance.now();
+    time(label);
+    timeLabels[label] = now;
+  };
+  console$1.timeLog = (label = "default") => {
+    timeLog(label);
+    if (!(label in timeLabels))
+      sendLog("stderr", `Timer "${label}" does not exist`);
+    else
+      sendLog("stdout", `${label}: ${timeLabels[label]} ms`);
+  };
+  console$1.timeEnd = (label = "default") => {
+    const end = performance.now();
+    timeEnd(label);
+    const start = timeLabels[label];
+    if (!(label in timeLabels)) {
+      sendLog("stderr", `Timer "${label}" does not exist`);
+    } else if (start) {
+      const duration = end - start;
+      sendLog("stdout", `${label}: ${duration} ms`);
+    }
+  };
+  const countLabels = {};
+  console$1.count = (label = "default") => {
+    const counter = (countLabels[label] ?? 0) + 1;
+    countLabels[label] = counter;
+    sendLog("stdout", `${label}: ${counter}`);
+    return count(label);
+  };
+  console$1.countReset = (label = "default") => {
+    countLabels[label] = 0;
+    return countReset(label);
+  };
+};
+const showPopupWarning = (name, value, defaultValue) => (...params) => {
+  const formatedParams = params.map((p) => JSON.stringify(p)).join(", ");
+  console.warn(`Vitest encountered a \`${name}(${formatedParams})\` call that it cannot handle by default, so it returned \`${value}\`. Read more in https://vitest.dev/guide/browser#thread-blocking-dialogs.
+If needed, mock the \`${name}\` call manually like:
+\`\`\`
+import { expect, vi } from "vitest"
+vi.spyOn(window, "${name}")${defaultValue ? `.mockReturnValue(${JSON.stringify(defaultValue)})` : ""}
+${name}(${formatedParams})
+expect(${name}).toHaveBeenCalledWith(${formatedParams})
+\`\`\``);
+  return value;
+};
+const setupDialogsSpy = () => {
+  globalThis.alert = showPopupWarning("alert", void 0);
+  globalThis.confirm = showPopupWarning("confirm", false, true);
+  globalThis.prompt = showPopupWarning("prompt", null, "your value");
+};
 globalThis.process = { env: {}, argv: [], cwd: () => "/", stdout: { write: () => {
 } }, nextTick: (cb) => cb() };
 globalThis.global = globalThis;
@@ -488,41 +660,56 @@ async function loadConfig() {
 }
 ws.addEventListener("open", async () => {
   await loadConfig();
+  const { getSafeTimers } = await importId("vitest/utils");
+  const safeRpc = createSafeRpc(client, getSafeTimers);
+  globalThis.__vitest_browser__ = true;
   globalThis.__vitest_worker__ = {
     config,
     browserHashMap,
     moduleCache: /* @__PURE__ */ new Map(),
-    rpc: client.rpc
+    rpc: client.rpc,
+    safeRpc
   };
-  globalThis.__vitest_mocker__ = {};
   const paths = getQueryPaths();
   const iFrame = document.getElementById("vitest-ui");
   iFrame.setAttribute("src", "/__vitest__/");
-  await runTests(paths, config, client);
+  await setupConsoleLogSpy();
+  setupDialogsSpy();
+  await runTests(paths, config);
 });
 let hasSnapshot = false;
-async function runTests(paths, config2, client2) {
-  const path = "/__vitest_index__";
-  const { startTests, setupCommonEnv, setupSnapshotEnvironment } = await __vitePreload(() => import(path), true ? [] : void 0);
+async function runTests(paths, config2) {
+  const viteClientPath = "/@vite/client";
+  await __vitePreload(() => import(viteClientPath), true ? [] : void 0);
+  const {
+    startTests,
+    setupCommonEnv,
+    setupSnapshotEnvironment,
+    takeCoverageInsideWorker
+  } = await importId("vitest/browser");
+  const executor = {
+    executeId: (id) => importId(id)
+  };
   if (!runner) {
-    const runnerPath = "/__vitest_runners__";
-    const { VitestTestRunner } = await __vitePreload(() => import(runnerPath), true ? [] : void 0);
-    const BrowserRunner = createBrowserRunner(VitestTestRunner);
-    runner = new BrowserRunner({ config: config2, client: client2, browserHashMap });
+    const { VitestTestRunner } = await importId("vitest/runners");
+    const BrowserRunner = createBrowserRunner(VitestTestRunner, { takeCoverage: () => takeCoverageInsideWorker(config2.coverage, executor) });
+    runner = new BrowserRunner({ config: config2, browserHashMap });
   }
   if (!hasSnapshot) {
-    setupSnapshotEnvironment(new BrowserSnapshotEnvironment(client2));
+    setupSnapshotEnvironment(new BrowserSnapshotEnvironment());
     hasSnapshot = true;
   }
   try {
     await setupCommonEnv(config2);
-    const files = paths.map((path2) => {
-      return `${config2.root}/${path2}`.replace(/\/+/g, "/");
+    const files = paths.map((path) => {
+      return `${config2.root}/${path}`.replace(/\/+/g, "/");
     });
     const now = `${new Date().getTime()}`;
     files.forEach((i) => browserHashMap.set(i, now));
-    await startTests(files, runner);
+    for (const file of files)
+      await startTests([file], runner);
   } finally {
-    await client2.rpc.onDone(testId);
+    await rpcDone();
+    await rpc().onDone(testId);
   }
 }

package/dist/client/index.html CHANGED Viewed

@@ -21,7 +21,7 @@
         border: none;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-25415511.js"></script>
+    <script type="module" crossorigin src="/assets/index-a25c0b91.js"></script>
   </head>
   <body>
     <iframe id="vitest-ui" src=""></iframe>

package/dist/index.js CHANGED Viewed

@@ -14,16 +14,9 @@ var index = (base = "/") => {
     {
       enforce: "pre",
       name: "vitest:browser",
-      async resolveId(id) {
-        if (id === "/__vitest_index__")
-          return this.resolve("vitest/browser");
-        if (id === "/__vitest_runners__")
-          return this.resolve("vitest/runners");
-        if (id.startsWith("node:"))
-          id = id.slice(5);
-        if (polyfills.includes(id))
-          return polyfillPath(normalizeId(id));
-        return null;
+      async config(viteConfig) {
+        viteConfig.esbuild || (viteConfig.esbuild = {});
+        viteConfig.esbuild.legalComments = "inline";
       },
       async configureServer(server) {
         server.middlewares.use(
@@ -37,8 +30,16 @@ var index = (base = "/") => {
     },
     {
       name: "modern-node-polyfills",
+      enforce: "pre",
+      config() {
+        return {
+          optimizeDeps: {
+            exclude: [...polyfills, ...builtinModules]
+          }
+        };
+      },
       async resolveId(id) {
-        if (!builtinModules.includes(id))
+        if (!builtinModules.includes(id) && !polyfills.includes(id) && !id.startsWith("node:"))
           return;
         id = normalizeId(id);
         return { id: await polyfillPath(id), moduleSideEffects: false };

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/browser",
   "type": "module",
-  "version": "0.29.6",
+  "version": "0.29.8",
   "description": "Browser running for Vitest",
   "repository": {
     "type": "git",
@@ -32,13 +32,14 @@
     "modern-node-polyfills": "0.1.0",
     "rollup-plugin-node-polyfills": "^0.2.1",
     "sirv": "^2.0.2",
-    "@vitest/runner": "0.29.6"
+    "@vitest/runner": "0.29.8"
   },
   "devDependencies": {
     "@types/ws": "^8.5.4",
     "rollup": "^2.79.1",
-    "@vitest/ws-client": "0.29.6",
-    "vitest": "0.29.6"
+    "@vitest/ui": "0.29.8",
+    "@vitest/ws-client": "0.29.8",
+    "vitest": "0.29.8"
   },
   "scripts": {
     "build": "rimraf dist && pnpm build:node && pnpm build:client && pnpm copy",