@vitest/browser 2.0.0-beta.9 → 2.0.0

package/dist/providers.js

@@ -1,111 +1,8 @@
-const playwrightBrowsers = ["firefox", "webkit", "chromium"];
-class PlaywrightBrowserProvider {
-  name = "playwright";
-  browser = null;
-  page = null;
-  browserName;
-  ctx;
-  options;
-  getSupportedBrowsers() {
-    return playwrightBrowsers;
-  }
-  initialize(project, { browser, options }) {
-    this.ctx = project;
-    this.browserName = browser;
-    this.options = options;
-  }
-  async openBrowserPage() {
-    if (this.page)
-      return this.page;
-    const options = this.ctx.config.browser;
-    const playwright = await import('playwright');
-    const browser = await playwright[this.browserName].launch({
-      ...this.options?.launch,
-      headless: options.headless
-    });
-    this.browser = browser;
-    this.page = await browser.newPage(this.options?.page);
-    return this.page;
-  }
-  async openPage(url) {
-    const browserPage = await this.openBrowserPage();
-    await browserPage.goto(url);
-  }
-  async close() {
-    const page = this.page;
-    this.page = null;
-    const browser = this.browser;
-    this.browser = null;
-    await page?.close();
-    await browser?.close();
-  }
-}
-
-const webdriverBrowsers = ["firefox", "chrome", "edge", "safari"];
-class WebdriverBrowserProvider {
-  name = "webdriverio";
-  browser = null;
-  browserName;
-  ctx;
-  options;
-  getSupportedBrowsers() {
-    return webdriverBrowsers;
-  }
-  async initialize(ctx, { browser, options }) {
-    this.ctx = ctx;
-    this.browserName = browser;
-    this.options = options;
-  }
-  async openBrowser() {
-    if (this.browser)
-      return this.browser;
-    const options = this.ctx.config.browser;
-    if (this.browserName === "safari") {
-      if (options.headless)
-        throw new Error("You've enabled headless mode for Safari but it doesn't currently support it.");
-    }
-    const { remote } = await import('webdriverio');
-    this.browser = await remote({
-      ...this.options,
-      logLevel: "error",
-      capabilities: this.buildCapabilities()
-    });
-    return this.browser;
-  }
-  buildCapabilities() {
-    const capabilities = {
-      ...this.options?.capabilities,
-      browserName: this.browserName
-    };
-    const headlessMap = {
-      chrome: ["goog:chromeOptions", ["headless", "disable-gpu"]],
-      firefox: ["moz:firefoxOptions", ["-headless"]],
-      edge: ["ms:edgeOptions", ["--headless"]]
-    };
-    const options = this.ctx.config.browser;
-    const browser = this.browserName;
-    if (browser !== "safari" && options.headless) {
-      const [key, args] = headlessMap[browser];
-      const currentValues = this.options?.capabilities?.[key] || {};
-      const newArgs = [...currentValues.args || [], ...args];
-      capabilities[key] = { ...currentValues, args: newArgs };
-    }
-    return capabilities;
-  }
-  async openPage(url) {
-    const browserInstance = await this.openBrowser();
-    await browserInstance.url(url);
-  }
-  async close() {
-    await Promise.all([
-      this.browser?.sessionId ? this.browser?.deleteSession?.() : null
-    ]);
-    process.exit();
-  }
-}
+import { W as WebdriverBrowserProvider, P as PlaywrightBrowserProvider } from './webdriver-BdVqnfdE.js';
 
 class PreviewBrowserProvider {
   name = "preview";
+  supportsParallelism = false;
   ctx;
   open = false;
   getSupportedBrowsers() {
@@ -114,20 +11,27 @@ class PreviewBrowserProvider {
   isOpen() {
     return this.open;
   }
+  getCommandsContext() {
+    return {};
+  }
   async initialize(ctx) {
     this.ctx = ctx;
     this.open = false;
-    if (ctx.config.browser.headless)
-      throw new Error(`You've enabled headless mode for "preview" provider but it doesn't support it. Use "playwright" or "webdriverio" instead: https://vitest.dev/guide/browser#configuration`);
+    if (ctx.config.browser.headless) {
+      throw new Error(
+        `You've enabled headless mode for "preview" provider but it doesn't support it. Use "playwright" or "webdriverio" instead: https://vitest.dev/guide/browser/#configuration`
+      );
+    }
   }
-  async openPage(_url) {
+  async openPage(_contextId, url) {
     this.open = true;
-    if (!this.ctx.browser)
+    if (!this.ctx.browser) {
       throw new Error("Browser is not initialized");
-    const options = this.ctx.browser.config.server;
+    }
+    const options = this.ctx.browser.vite.config.server;
     const _open = options.open;
-    options.open = _url;
-    this.ctx.browser.openBrowser();
+    options.open = url;
+    this.ctx.browser.vite.openBrowser();
     options.open = _open;
   }
   async close() {

package/dist/state.js

@@ -0,0 +1 @@
+const{parse:$parse,stringify:$stringify}=JSON;const{keys}=Object;const Primitive=String;const primitive="string";const ignore={};const object="object";const noop=(_,value)=>value;const primitives=value=>value instanceof Primitive?Primitive(value):value;const Primitives=(_,value)=>typeof value===primitive?new Primitive(value):value;const revive=(input,parsed,output,$)=>{const lazy=[];for(let ke=keys(output),{length}=ke,y=0;y<length;y++){const k=ke[y];const value=output[k];if(value instanceof Primitive){const tmp=input[value];if(typeof tmp===object&&!parsed.has(tmp)){parsed.add(tmp);output[k]=ignore;lazy.push({k,a:[input,parsed,tmp,$]})}else output[k]=$.call(output,k,tmp)}else if(output[k]!==ignore)output[k]=$.call(output,k,value)}for(let{length}=lazy,i=0;i<length;i++){const{k,a}=lazy[i];output[k]=$.call(output,k,revive.apply(null,a))}return output};const parse=(text,reviver)=>{const input=$parse(text,Primitives).map(primitives);const value=input[0];const $=noop;const tmp=typeof value===object&&value?revive(input,new Set,value,$):value;return $.call({"":tmp},"",tmp)};function getBrowserState(){return window.__vitest_browser_runner__}const config=getBrowserState().config;const contextId=getBrowserState().contextId;const providedContext=parse(getBrowserState().providedContext);const state={ctx:{pool:"browser",worker:"./browser.js",workerId:1,config,projectName:config.name||"",files:[],environment:{name:"browser",options:null},providedContext,invalidates:[]},onCancel:null,mockMap:new Map,config,environment:{name:"browser",transformMode:"web",setup(){throw new Error("Not called in the browser")}},moduleCache:getBrowserState().moduleCache,rpc:null,durations:{environment:0,prepare:performance.now()},providedContext};globalThis.__vitest_browser__=true;globalThis.__vitest_worker__=state;getBrowserState().cdp=createCdp();function rpc(){return state.rpc}function createCdp(){const listenersMap=new WeakMap;function getId(listener){const id=listenersMap.get(listener)||crypto.randomUUID();listenersMap.set(listener,id);return id}const listeners={};const error=err=>{window.dispatchEvent(new ErrorEvent("error",{error:err}))};const cdp={send(method,params){return rpc().sendCdpEvent(contextId,method,params)},on(event,listener){const listenerId=getId(listener);listeners[event]=listeners[event]||[];listeners[event].push(listener);rpc().trackCdpEvent(contextId,"on",event,listenerId).catch(error);return cdp},once(event,listener){const listenerId=getId(listener);const handler=data=>{listener(data);cdp.off(event,listener)};listeners[event]=listeners[event]||[];listeners[event].push(handler);rpc().trackCdpEvent(contextId,"once",event,listenerId).catch(error);return cdp},off(event,listener){const listenerId=getId(listener);if(listeners[event]){listeners[event]=listeners[event].filter(l=>l!==listener)}rpc().trackCdpEvent(contextId,"off",event,listenerId).catch(error);return cdp},emit(event,payload){if(listeners[event]){listeners[event].forEach(l=>{try{l(payload)}catch(err){error(err)}})}}};return cdp}

package/dist/webdriver-BdVqnfdE.js

@@ -0,0 +1,249 @@
+const playwrightBrowsers = ["firefox", "webkit", "chromium"];
+class PlaywrightBrowserProvider {
+  name = "playwright";
+  supportsParallelism = true;
+  browser = null;
+  browserName;
+  ctx;
+  options;
+  contexts = /* @__PURE__ */ new Map();
+  pages = /* @__PURE__ */ new Map();
+  browserPromise = null;
+  getSupportedBrowsers() {
+    return playwrightBrowsers;
+  }
+  initialize(project, { browser, options }) {
+    this.ctx = project;
+    this.browserName = browser;
+    this.options = options;
+  }
+  async openBrowser() {
+    if (this.browserPromise) {
+      return this.browserPromise;
+    }
+    if (this.browser) {
+      return this.browser;
+    }
+    this.browserPromise = (async () => {
+      const options = this.ctx.config.browser;
+      const playwright = await import('playwright');
+      const launchOptions = {
+        ...this.options?.launch,
+        headless: options.headless
+      };
+      if (this.ctx.config.browser.ui && this.browserName === "chromium") {
+        if (!launchOptions.args) {
+          launchOptions.args = [];
+        }
+        if (!launchOptions.args.includes("--start-maximized") && !launchOptions.args.includes("--start-fullscreen")) {
+          launchOptions.args.push("--start-maximized");
+        }
+      }
+      const browser = await playwright[this.browserName].launch(launchOptions);
+      this.browser = browser;
+      this.browserPromise = null;
+      return this.browser;
+    })();
+    return this.browserPromise;
+  }
+  async createContext(contextId) {
+    if (this.contexts.has(contextId)) {
+      return this.contexts.get(contextId);
+    }
+    const browser = await this.openBrowser();
+    const options = {
+      ...this.options?.context,
+      ignoreHTTPSErrors: true,
+      serviceWorkers: "allow"
+    };
+    if (this.ctx.config.browser.ui) {
+      options.viewport = null;
+    }
+    const context = await browser.newContext(options);
+    this.contexts.set(contextId, context);
+    return context;
+  }
+  getPage(contextId) {
+    const page = this.pages.get(contextId);
+    if (!page) {
+      throw new Error(`Page "${contextId}" not found`);
+    }
+    return page;
+  }
+  getCommandsContext(contextId) {
+    const page = this.getPage(contextId);
+    return {
+      page,
+      context: this.contexts.get(contextId),
+      frame() {
+        return new Promise((resolve, reject) => {
+          const frame = page.frame("vitest-iframe");
+          if (frame) {
+            return resolve(frame);
+          }
+          const timeout = setTimeout(() => {
+            const err = new Error(`Cannot find "vitest-iframe" on the page. This is a bug in Vitest, please report it.`);
+            reject(err);
+          }, 1e3);
+          page.on("frameattached", (frame2) => {
+            clearTimeout(timeout);
+            resolve(frame2);
+          });
+        });
+      },
+      get iframe() {
+        return page.frameLocator('[data-vitest="true"]');
+      }
+    };
+  }
+  async openBrowserPage(contextId) {
+    if (this.pages.has(contextId)) {
+      const page2 = this.pages.get(contextId);
+      await page2.close();
+      this.pages.delete(contextId);
+    }
+    const context = await this.createContext(contextId);
+    const page = await context.newPage();
+    this.pages.set(contextId, page);
+    if (process.env.VITEST_PW_DEBUG) {
+      page.on("requestfailed", (request) => {
+        console.error(
+          "[PW Error]",
+          request.resourceType(),
+          "request failed for",
+          request.url(),
+          "url:",
+          request.failure()?.errorText
+        );
+      });
+    }
+    return page;
+  }
+  async openPage(contextId, url) {
+    const browserPage = await this.openBrowserPage(contextId);
+    await browserPage.goto(url);
+  }
+  async getCDPSession(contextId) {
+    const page = this.getPage(contextId);
+    const cdp = await page.context().newCDPSession(page);
+    return {
+      async send(method, params) {
+        const result = await cdp.send(method, params);
+        return result;
+      },
+      on(event, listener) {
+        cdp.on(event, listener);
+      },
+      off(event, listener) {
+        cdp.off(event, listener);
+      },
+      once(event, listener) {
+        cdp.once(event, listener);
+      }
+    };
+  }
+  async close() {
+    const browser = this.browser;
+    this.browser = null;
+    await Promise.all([...this.pages.values()].map((p) => p.close()));
+    this.pages.clear();
+    await Promise.all([...this.contexts.values()].map((c) => c.close()));
+    this.contexts.clear();
+    await browser?.close();
+  }
+}
+
+const webdriverBrowsers = ["firefox", "chrome", "edge", "safari"];
+class WebdriverBrowserProvider {
+  name = "webdriverio";
+  supportsParallelism = false;
+  browser = null;
+  browserName;
+  ctx;
+  options;
+  getSupportedBrowsers() {
+    return webdriverBrowsers;
+  }
+  async initialize(ctx, { browser, options }) {
+    this.ctx = ctx;
+    this.browserName = browser;
+    this.options = options;
+  }
+  async beforeCommand() {
+    const page = this.browser;
+    const iframe = await page.findElement(
+      "css selector",
+      "iframe[data-vitest]"
+    );
+    await page.switchToFrame(iframe);
+  }
+  async afterCommand() {
+    await this.browser.switchToParentFrame();
+  }
+  getCommandsContext() {
+    return {
+      browser: this.browser
+    };
+  }
+  async openBrowser() {
+    if (this.browser) {
+      return this.browser;
+    }
+    const options = this.ctx.config.browser;
+    if (this.browserName === "safari") {
+      if (options.headless) {
+        throw new Error(
+          "You've enabled headless mode for Safari but it doesn't currently support it."
+        );
+      }
+    }
+    const { remote } = await import('webdriverio');
+    this.browser = await remote({
+      ...this.options,
+      logLevel: "error",
+      capabilities: this.buildCapabilities()
+    });
+    return this.browser;
+  }
+  buildCapabilities() {
+    const capabilities = {
+      ...this.options?.capabilities,
+      browserName: this.browserName
+    };
+    const headlessMap = {
+      chrome: ["goog:chromeOptions", ["headless", "disable-gpu"]],
+      firefox: ["moz:firefoxOptions", ["-headless"]],
+      edge: ["ms:edgeOptions", ["--headless"]]
+    };
+    const options = this.ctx.config.browser;
+    const browser = this.browserName;
+    if (browser !== "safari" && options.headless) {
+      const [key, args] = headlessMap[browser];
+      const currentValues = this.options?.capabilities?.[key] || {};
+      const newArgs = [...currentValues.args || [], ...args];
+      capabilities[key] = { ...currentValues, args: newArgs };
+    }
+    if (options.ui && (browser === "chrome" || browser === "edge")) {
+      const key = browser === "chrome" ? "goog:chromeOptions" : "ms:edgeOptions";
+      const args = capabilities[key]?.args || [];
+      if (!args.includes("--start-maximized") && !args.includes("--start-fullscreen")) {
+        args.push("--start-maximized");
+      }
+      capabilities[key] ??= {};
+      capabilities[key].args = args;
+    }
+    return capabilities;
+  }
+  async openPage(_contextId, url) {
+    const browserInstance = await this.openBrowser();
+    await browserInstance.url(url);
+  }
+  async close() {
+    await Promise.all([
+      this.browser?.sessionId ? this.browser?.deleteSession?.() : null
+    ]);
+    process.exit();
+  }
+}
+
+export { PlaywrightBrowserProvider as P, WebdriverBrowserProvider as W };