@vitest/browser 2.1.3 → 2.1.5

package/dist/client/__vitest_browser__/utils-Owv5OOOf.js

@@ -0,0 +1,195 @@
+(function polyfill() {
+  const relList = document.createElement("link").relList;
+  if (relList && relList.supports && relList.supports("modulepreload")) {
+    return;
+  }
+  for (const link of document.querySelectorAll('link[rel="modulepreload"]')) {
+    processPreload(link);
+  }
+  new MutationObserver((mutations) => {
+    for (const mutation of mutations) {
+      if (mutation.type !== "childList") {
+        continue;
+      }
+      for (const node of mutation.addedNodes) {
+        if (node.tagName === "LINK" && node.rel === "modulepreload")
+          processPreload(node);
+      }
+    }
+  }).observe(document, { childList: true, subtree: true });
+  function getFetchOpts(link) {
+    const fetchOpts = {};
+    if (link.integrity) fetchOpts.integrity = link.integrity;
+    if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
+    if (link.crossOrigin === "use-credentials")
+      fetchOpts.credentials = "include";
+    else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
+    else fetchOpts.credentials = "same-origin";
+    return fetchOpts;
+  }
+  function processPreload(link) {
+    if (link.ep)
+      return;
+    link.ep = true;
+    const fetchOpts = getFetchOpts(link);
+    fetch(link.href, fetchOpts);
+  }
+})();
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+const resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+async function importId(id) {
+  const name = `/@id/${id}`.replace(/\\/g, "/");
+  return (/* @__PURE__ */ getBrowserState()).wrapModule(() => import(
+    /* @vite-ignore */
+    name
+  ));
+}
+async function importFs(id) {
+  const name = `/@fs/${id}`.replace(/\\/g, "/");
+  return (/* @__PURE__ */ getBrowserState()).wrapModule(() => import(
+    /* @vite-ignore */
+    name
+  ));
+}
+const executor = {
+  isBrowser: true,
+  executeId: (id) => {
+    if (id[0] === "/" || id[1] === ":") {
+      return importFs(id);
+    }
+    return importId(id);
+  }
+};
+function getConfig() {
+  return (/* @__PURE__ */ getBrowserState()).config;
+}
+// @__NO_SIDE_EFFECTS__
+function getBrowserState() {
+  return window.__vitest_browser_runner__;
+}
+// @__NO_SIDE_EFFECTS__
+function getWorkerState() {
+  const state = window.__vitest_worker__;
+  if (!state) {
+    throw new Error("Worker state is not found. This is an issue with Vitest. Please, open an issue.");
+  }
+  return state;
+}
+export {
+  getConfig as a,
+  resolve as b,
+  getWorkerState as c,
+  executor as e,
+  getBrowserState as g,
+  relative as r
+};

package/dist/client/error-catcher.js

@@ -56,7 +56,9 @@ async function reportUnexpectedError(
   error,
 ) {
   const processedError = serializeError(error)
-  await client.rpc.onUnhandledError(processedError, type)
+  await client.waitForConnection().then(() => {
+    return client.rpc.onUnhandledError(processedError, type)
+  }).catch(console.error)
   const state = __vitest_browser_runner__
 
   if (state.type === 'orchestrator') {

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

@@ -1,50 +1,52 @@
-const moduleCache = new Map();
-
-function wrapModule(module) {
-  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);
+(() => {
+  const moduleCache = new Map();
+
+  function wrapModule(module) {
+    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));
+      moduleCache.set(promise, { promise, evaluated: false });
+      return promise.finally(() => moduleCache.delete(promise));
+    }
+    return module;
   }
-  return module;
-}
-
-window.__vitest_browser_runner__ = {
-  wrapModule,
-  wrapDynamicImport: wrapModule,
-  moduleCache,
-  config: { __VITEST_CONFIG__ },
-  viteConfig: { __VITEST_VITE_CONFIG__ },
-  files: { __VITEST_FILES__ },
-  type: { __VITEST_TYPE__ },
-  contextId: { __VITEST_CONTEXT_ID__ },
-  testerId: { __VITEST_TESTER_ID__ },
-  provider: { __VITEST_PROVIDER__ },
-  providedContext: { __VITEST_PROVIDED_CONTEXT__ },
-};
-
-const config = __vitest_browser_runner__.config;
-
-if (config.testNamePattern)
-  config.testNamePattern = parseRegexp(config.testNamePattern);
-
-function parseRegexp(input) {
-  // Parse input
-  const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
-
-  // match nothing
-  if (!m) return /$^/;
-
-  // Invalid flags
-  if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]))
-    return RegExp(input);
-
-  // Create the regular expression
-  return new RegExp(m[2], m[3]);
-}
+
+  window.__vitest_browser_runner__ = {
+    wrapModule,
+    wrapDynamicImport: wrapModule,
+    moduleCache,
+    config: { __VITEST_CONFIG__ },
+    viteConfig: { __VITEST_VITE_CONFIG__ },
+    files: { __VITEST_FILES__ },
+    type: { __VITEST_TYPE__ },
+    contextId: { __VITEST_CONTEXT_ID__ },
+    testerId: { __VITEST_TESTER_ID__ },
+    provider: { __VITEST_PROVIDER__ },
+    providedContext: { __VITEST_PROVIDED_CONTEXT__ },
+  };
+
+  const config = __vitest_browser_runner__.config;
+
+  if (config.testNamePattern)
+    config.testNamePattern = parseRegexp(config.testNamePattern);
+
+  function parseRegexp(input) {
+    // Parse input
+    const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
+
+    // match nothing
+    if (!m) return /$^/;
+
+    // Invalid flags
+    if (m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]))
+      return RegExp(input);
+
+    // Create the regular expression
+    return new RegExp(m[2], m[3]);
+  }
+})();

package/dist/client/orchestrator.html

@@ -26,8 +26,8 @@
     {__VITEST_INJECTOR__}
     {__VITEST_ERROR_CATCHER__}
     {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/orchestrator-BCPid0xo.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/preload-helper-D-WYp1PK.js">
+    <script type="module" crossorigin src="/__vitest_browser__/orchestrator-DnP17K36.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/utils-Owv5OOOf.js">
   </head>
   <body>
     <div id="vitest-tester"></div>

package/dist/client/tester/tester.html

@@ -4,26 +4,10 @@
     <meta charset="UTF-8" />
     <link rel="icon" href="{__VITEST_FAVICON__}" type="image/svg+xml">
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>{__VITEST_TITLE__}</title>
-    <style>
-      html {
-        padding: 0;
-        margin: 0;
-      }
-      body {
-        padding: 0;
-        margin: 0;
-        min-height: 100vh;
-      }
-    </style>
-    {__VITEST_INJECTOR__}
-    <script>{__VITEST_STATE__}</script>
-    {__VITEST_INTERNAL_SCRIPTS__}
-    {__VITEST_SCRIPTS__}
-    <script type="module" crossorigin src="/__vitest_browser__/tester-DZCtFstH.js"></script>
-    <link rel="modulepreload" crossorigin href="/__vitest_browser__/preload-helper-D-WYp1PK.js">
+    <title>Vitest Browser Tester</title>
+    <script type="module" crossorigin src="/__vitest_browser__/tester-BaiNqOPw.js"></script>
+    <link rel="modulepreload" crossorigin href="/__vitest_browser__/utils-Owv5OOOf.js">
   </head>
   <body>
-    {__VITEST_APPEND__}
   </body>
 </html>

package/dist/client.js

@@ -9,18 +9,24 @@ function createBirpc(functions, options) {
   const {
     post,
     on,
+    off = () => {
+    },
     eventNames = [],
     serialize = defaultSerialize,
     deserialize = defaultDeserialize,
     resolver,
+    bind = "rpc",
     timeout = DEFAULT_TIMEOUT
   } = options;
   const rpcPromiseMap = /* @__PURE__ */ new Map();
   let _promise;
+  let closed = false;
   const rpc = new Proxy({}, {
     get(_, method) {
       if (method === "$functions")
         return functions;
+      if (method === "$close")
+        return close;
       if (method === "then" && !eventNames.includes("then") && !("then" in functions))
         return void 0;
       const sendEvent = (...args) => {
@@ -31,7 +37,15 @@ function createBirpc(functions, options) {
         return sendEvent;
       }
       const sendCall = async (...args) => {
-        await _promise;
+        if (closed)
+          throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        if (_promise) {
+          try {
+            await _promise;
+          } finally {
+            _promise = void 0;
+          }
+        }
         return new Promise((resolve, reject) => {
           const id = nanoid();
           let timeoutId;
@@ -48,7 +62,7 @@ function createBirpc(functions, options) {
             if (typeof timeoutId === "object")
               timeoutId = timeoutId.unref?.();
           }
-          rpcPromiseMap.set(id, { resolve, reject, timeoutId });
+          rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
           post(serialize({ m: method, a: args, i: id, t: "q" }));
         });
       };
@@ -56,7 +70,15 @@ function createBirpc(functions, options) {
       return sendCall;
     }
   });
-  _promise = on(async (data, ...extra) => {
+  function close() {
+    closed = true;
+    rpcPromiseMap.forEach(({ reject, method }) => {
+      reject(new Error(`[birpc] rpc is closed, cannot call "${method}"`));
+    });
+    rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  async function onMessage(data, ...extra) {
     const msg = deserialize(data);
     if (msg.t === "q") {
       const { m: method, a: args } = msg;
@@ -66,7 +88,7 @@ function createBirpc(functions, options) {
         error = new Error(`[birpc] function "${method}" not found`);
       } else {
         try {
-          result = await fn.apply(rpc, args);
+          result = await fn.apply(bind === "rpc" ? rpc : functions, args);
         } catch (e) {
           error = e;
         }
@@ -88,7 +110,8 @@ function createBirpc(functions, options) {
       }
       rpcPromiseMap.delete(ack);
     }
-  });
+  }
+  _promise = on(onMessage);
   return rpc;
 }
 const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";

package/dist/context.js

@@ -1,3 +1,35 @@
+function ensureAwaited(promise) {
+  const test = (/* @__PURE__ */ getWorkerState()).current;
+  if (!test || test.type !== "test") {
+    return promise();
+  }
+  let awaited = false;
+  const sourceError = new Error("STACK_TRACE_ERROR");
+  test.onFinished ??= [];
+  test.onFinished.push(() => {
+    if (!awaited) {
+      const error = new Error(
+        `The call was not awaited. This method is asynchronous and must be awaited; otherwise, the call will not start to avoid unhandled rejections.`
+      );
+      error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+      throw error;
+    }
+  });
+  let promiseResult;
+  return {
+    then(onFulfilled, onRejected) {
+      awaited = true;
+      return (promiseResult ||= promise()).then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return (promiseResult ||= promise()).catch(onRejected);
+    },
+    finally(onFinally) {
+      return (promiseResult ||= promise()).finally(onFinally);
+    },
+    [Symbol.toStringTag]: "Promise"
+  };
+}
 // @__NO_SIDE_EFFECTS__
 function getBrowserState() {
   return window.__vitest_browser_runner__;
@@ -90,22 +122,33 @@ const channel = new BroadcastChannel(`vitest:${contextId}`);
 function triggerCommand(command, ...args) {
   return rpc().triggerCommand(contextId, command, filepath(), args);
 }
-function createUserEvent(__tl_user_event__) {
+function createUserEvent(__tl_user_event_base__, options) {
+  let __tl_user_event__ = __tl_user_event_base__?.setup(options ?? {});
   const keyboard = {
     unreleased: []
   };
   return {
-    setup(options) {
-      return createUserEvent(__tl_user_event__?.setup(options));
+    setup(options2) {
+      return createUserEvent(__tl_user_event_base__, options2);
+    },
+    async cleanup() {
+      return ensureAwaited(async () => {
+        if (typeof __tl_user_event_base__ !== "undefined") {
+          __tl_user_event__ = __tl_user_event_base__?.setup(options ?? {});
+          return;
+        }
+        await triggerCommand("__vitest_cleanup", keyboard);
+        keyboard.unreleased = [];
+      });
     },
-    click(element, options = {}) {
-      return convertToLocator(element).click(processClickOptions(options));
+    click(element, options2 = {}) {
+      return convertToLocator(element).click(processClickOptions(options2));
     },
-    dblClick(element, options = {}) {
-      return convertToLocator(element).dblClick(processClickOptions(options));
+    dblClick(element, options2 = {}) {
+      return convertToLocator(element).dblClick(processClickOptions(options2));
     },
-    tripleClick(element, options = {}) {
-      return convertToLocator(element).tripleClick(processClickOptions(options));
+    tripleClick(element, options2 = {}) {
+      return convertToLocator(element).tripleClick(processClickOptions(options2));
     },
     selectOptions(element, value) {
       return convertToLocator(element).selectOptions(value);
@@ -113,58 +156,64 @@ function createUserEvent(__tl_user_event__) {
     clear(element) {
       return convertToLocator(element).clear();
     },
-    hover(element, options = {}) {
-      return convertToLocator(element).hover(processHoverOptions(options));
+    hover(element, options2 = {}) {
+      return convertToLocator(element).hover(processHoverOptions(options2));
     },
-    unhover(element, options = {}) {
-      return convertToLocator(element).unhover(options);
+    unhover(element, options2 = {}) {
+      return convertToLocator(element).unhover(options2);
     },
     upload(element, files) {
       return convertToLocator(element).upload(files);
     },
     // non userEvent events, but still useful
-    fill(element, text, options) {
-      return convertToLocator(element).fill(text, options);
+    fill(element, text, options2) {
+      return convertToLocator(element).fill(text, options2);
     },
-    dragAndDrop(source, target, options = {}) {
+    dragAndDrop(source, target, options2 = {}) {
       const sourceLocator = convertToLocator(source);
       const targetLocator = convertToLocator(target);
-      return sourceLocator.dropTo(targetLocator, processDragAndDropOptions(options));
+      return sourceLocator.dropTo(targetLocator, processDragAndDropOptions(options2));
     },
     // testing-library user-event
-    async type(element, text, options = {}) {
-      if (typeof __tl_user_event__ !== "undefined") {
-        return __tl_user_event__.type(
-          element instanceof Element ? element : element.element(),
+    async type(element, text, options2 = {}) {
+      return ensureAwaited(async () => {
+        if (typeof __tl_user_event__ !== "undefined") {
+          return __tl_user_event__.type(
+            element instanceof Element ? element : element.element(),
+            text,
+            options2
+          );
+        }
+        const selector = convertToSelector(element);
+        const { unreleased } = await triggerCommand(
+          "__vitest_type",
+          selector,
           text,
-          options
+          { ...options2, unreleased: keyboard.unreleased }
         );
-      }
-      const selector = convertToSelector(element);
-      const { unreleased } = await triggerCommand(
-        "__vitest_type",
-        selector,
-        text,
-        { ...options, unreleased: keyboard.unreleased }
-      );
-      keyboard.unreleased = unreleased;
+        keyboard.unreleased = unreleased;
+      });
     },
-    tab(options = {}) {
-      if (typeof __tl_user_event__ !== "undefined") {
-        return __tl_user_event__.tab(options);
-      }
-      return triggerCommand("__vitest_tab", options);
+    tab(options2 = {}) {
+      return ensureAwaited(() => {
+        if (typeof __tl_user_event__ !== "undefined") {
+          return __tl_user_event__.tab(options2);
+        }
+        return triggerCommand("__vitest_tab", options2);
+      });
     },
     async keyboard(text) {
-      if (typeof __tl_user_event__ !== "undefined") {
-        return __tl_user_event__.keyboard(text);
-      }
-      const { unreleased } = await triggerCommand(
-        "__vitest_keyboard",
-        text,
-        keyboard
-      );
-      keyboard.unreleased = unreleased;
+      return ensureAwaited(async () => {
+        if (typeof __tl_user_event__ !== "undefined") {
+          return __tl_user_event__.keyboard(text);
+        }
+        const { unreleased } = await triggerCommand(
+          "__vitest_keyboard",
+          text,
+          keyboard
+        );
+        keyboard.unreleased = unreleased;
+      });
     }
   };
 }
@@ -205,10 +254,10 @@ const page = {
     screenshotIds[repeatCount] ??= {};
     screenshotIds[repeatCount][taskName] = number + 1;
     const name = options.path || `${taskName.replace(/[^a-z0-9]/gi, "-")}-${number}.png`;
-    return triggerCommand("__vitest_screenshot", name, {
+    return ensureAwaited(() => triggerCommand("__vitest_screenshot", name, {
       ...options,
       element: options.element ? convertToSelector(options.element) : void 0
-    });
+    }));
   },
   getByRole() {
     throw new Error('Method "getByRole" is not implemented in the current provider.');