@vitest/browser 2.1.0-beta.5 → 2.1.0-beta.7

package/dist/client/__vitest_browser__/preload-helper-D-WYp1PK.js

@@ -0,0 +1,317 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+(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);
+  }
+})();
+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;
+}
+class MockerRegistry {
+  constructor() {
+    __publicField(this, "registry", /* @__PURE__ */ new Map());
+  }
+  clear() {
+    this.registry.clear();
+  }
+  keys() {
+    return this.registry.keys();
+  }
+  add(mock) {
+    this.registry.set(mock.url, mock);
+  }
+  register(typeOrEvent, raw, url, factoryOrRedirect) {
+    const type = typeof typeOrEvent === "object" ? typeOrEvent.type : typeOrEvent;
+    if (typeof typeOrEvent === "object") {
+      const event = typeOrEvent;
+      if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule) {
+        throw new TypeError(
+          `[vitest] Cannot register a mock that is already defined. Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". Use "registry.add()" to update a mock instead.`
+        );
+      }
+      if (event.type === "automock") {
+        const module = AutomockedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "autospy") {
+        const module = AutospiedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "redirect") {
+        const module = RedirectedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "manual") {
+        throw new Error(`Cannot set serialized manual mock. Define a factory function manually with \`ManualMockedModule.fromJSON()\`.`);
+      } else {
+        throw new Error(`Unknown mock type: ${event.type}`);
+      }
+    }
+    if (typeof raw !== "string") {
+      throw new TypeError("[vitest] Mocks require a raw string.");
+    }
+    if (typeof url !== "string") {
+      throw new TypeError("[vitest] Mocks require a url string.");
+    }
+    if (type === "manual") {
+      if (typeof factoryOrRedirect !== "function") {
+        throw new TypeError("[vitest] Manual mocks require a factory function.");
+      }
+      const mock = new ManualMockedModule(raw, url, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else if (type === "automock" || type === "autospy") {
+      const mock = type === "automock" ? new AutomockedModule(raw, url) : new AutospiedModule(raw, url);
+      this.add(mock);
+      return mock;
+    } else if (type === "redirect") {
+      if (typeof factoryOrRedirect !== "string") {
+        throw new TypeError("[vitest] Redirect mocks require a redirect string.");
+      }
+      const mock = new RedirectedModule(raw, url, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else {
+      throw new Error(`[vitest] Unknown mock type: ${type}`);
+    }
+  }
+  delete(id) {
+    this.registry.delete(id);
+  }
+  get(id) {
+    return this.registry.get(id);
+  }
+  has(id) {
+    return this.registry.has(id);
+  }
+}
+class AutomockedModule {
+  constructor(raw, url) {
+    __publicField(this, "type", "automock");
+    this.raw = raw;
+    this.url = url;
+  }
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw
+    };
+  }
+}
+class AutospiedModule {
+  constructor(raw, url) {
+    __publicField(this, "type", "autospy");
+    this.raw = raw;
+    this.url = url;
+  }
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw
+    };
+  }
+}
+class RedirectedModule {
+  constructor(raw, url, redirect) {
+    __publicField(this, "type", "redirect");
+    this.raw = raw;
+    this.url = url;
+    this.redirect = redirect;
+  }
+  static fromJSON(data) {
+    return new RedirectedModule(data.raw, data.url, data.redirect);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw,
+      redirect: this.redirect
+    };
+  }
+}
+class ManualMockedModule {
+  constructor(raw, url, factory) {
+    __publicField(this, "cache");
+    __publicField(this, "type", "manual");
+    this.raw = raw;
+    this.url = url;
+    this.factory = factory;
+  }
+  async resolve() {
+    if (this.cache) {
+      return this.cache;
+    }
+    let exports;
+    try {
+      exports = await this.factory();
+    } 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;
+    }
+    if (exports === null || typeof exports !== "object" || Array.isArray(exports)) {
+      throw new TypeError(
+        `[vitest] vi.mock("${this.raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`
+      );
+    }
+    return this.cache = exports;
+  }
+  static fromJSON(data, factory) {
+    return new ManualMockedModule(data.raw, data.url, factory);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw
+    };
+  }
+}
+const scriptRel = "modulepreload";
+const assetsURL = function(dep) {
+  return "/" + dep;
+};
+const seen = {};
+const __vitePreload = function preload(baseModule, deps, importerUrl) {
+  let promise = Promise.resolve();
+  if (deps && deps.length > 0) {
+    document.getElementsByTagName("link");
+    const cspNonceMeta = document.querySelector(
+      "meta[property=csp-nonce]"
+    );
+    const cspNonce = (cspNonceMeta == null ? void 0 : cspNonceMeta.nonce) || (cspNonceMeta == null ? void 0 : cspNonceMeta.getAttribute("nonce"));
+    promise = Promise.all(
+      deps.map((dep) => {
+        dep = assetsURL(dep);
+        if (dep in seen) return;
+        seen[dep] = true;
+        const isCss = dep.endsWith(".css");
+        const cssSelector = isCss ? '[rel="stylesheet"]' : "";
+        if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) {
+          return;
+        }
+        const link = document.createElement("link");
+        link.rel = isCss ? "stylesheet" : scriptRel;
+        if (!isCss) {
+          link.as = "script";
+          link.crossOrigin = "";
+        }
+        link.href = dep;
+        if (cspNonce) {
+          link.setAttribute("nonce", cspNonce);
+        }
+        document.head.appendChild(link);
+        if (isCss) {
+          return new Promise((res, rej) => {
+            link.addEventListener("load", res);
+            link.addEventListener(
+              "error",
+              () => rej(new Error(`Unable to preload CSS for ${dep}`))
+            );
+          });
+        }
+      })
+    );
+  }
+  return promise.then(() => baseModule()).catch((err) => {
+    const e = new Event("vite:preloadError", {
+      cancelable: true
+    });
+    e.payload = err;
+    window.dispatchEvent(e);
+    if (!e.defaultPrevented) {
+      throw err;
+    }
+  });
+};
+export {
+  AutomockedModule as A,
+  MockerRegistry as M,
+  RedirectedModule as R,
+  __vitePreload as _,
+  ManualMockedModule as a,
+  getConfig as b,
+  getWorkerState as c,
+  executor as e,
+  getBrowserState as g
+};