@vitest/browser 3.1.0-beta.1 → 3.1.0-beta.2

package/dist/webdriver-BP2w_ajA.js

@@ -0,0 +1,271 @@
+const playwrightBrowsers = [
+	"firefox",
+	"webkit",
+	"chromium"
+];
+class PlaywrightBrowserProvider {
+	name = "playwright";
+	supportsParallelism = true;
+	browser = null;
+	browserName;
+	project;
+	options;
+	contexts = new Map();
+	pages = new Map();
+	browserPromise = null;
+	getSupportedBrowsers() {
+		return playwrightBrowsers;
+	}
+	initialize(project, { browser, options }) {
+		this.project = 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.project.config.browser;
+			const playwright = await import('playwright');
+			const launchOptions = {
+				...this.options?.launch,
+				headless: options.headless
+			};
+			if (this.project.config.inspector.enabled) {
+				const port = this.project.config.inspector.port || 9229;
+				const host = this.project.config.inspector.host || "127.0.0.1";
+				launchOptions.args ||= [];
+				launchOptions.args.push(`--remote-debugging-port=${port}`);
+				launchOptions.args.push(`--remote-debugging-address=${host}`);
+				this.project.vitest.logger.log(`Debugger listening on ws://${host}:${port}`);
+			}
+			if (this.project.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(sessionId) {
+		if (this.contexts.has(sessionId)) {
+			return this.contexts.get(sessionId);
+		}
+		const browser = await this.openBrowser();
+		const { actionTimeout,...contextOptions } = this.options?.context ?? {};
+		const options = {
+			...contextOptions,
+			ignoreHTTPSErrors: true,
+			serviceWorkers: "allow"
+		};
+		if (this.project.config.browser.ui) {
+			options.viewport = null;
+		}
+		const context = await browser.newContext(options);
+		if (actionTimeout) {
+			context.setDefaultTimeout(actionTimeout);
+		}
+		this.contexts.set(sessionId, context);
+		return context;
+	}
+	getPage(sessionId) {
+		const page = this.pages.get(sessionId);
+		if (!page) {
+			throw new Error(`Page "${sessionId}" not found in ${this.browserName} browser.`);
+		}
+		return page;
+	}
+	getCommandsContext(sessionId) {
+		const page = this.getPage(sessionId);
+		return {
+			page,
+			context: this.contexts.get(sessionId),
+			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", (frame) => {
+						clearTimeout(timeout);
+						resolve(frame);
+					});
+				});
+			},
+			get iframe() {
+				return page.frameLocator("[data-vitest=\"true\"]");
+			}
+		};
+	}
+	async openBrowserPage(sessionId) {
+		if (this.pages.has(sessionId)) {
+			const page = this.pages.get(sessionId);
+			await page.close();
+			this.pages.delete(sessionId);
+		}
+		const context = await this.createContext(sessionId);
+		const page = await context.newPage();
+		this.pages.set(sessionId, 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);
+			});
+		}
+		page.on("crash", () => {
+			const session = this.project.vitest._browserSessions.getSession(sessionId);
+			session?.reject(new Error("Page crashed when executing tests"));
+		});
+		return page;
+	}
+	async openPage(sessionId, url, beforeNavigate) {
+		const browserPage = await this.openBrowserPage(sessionId);
+		await beforeNavigate?.();
+		await browserPage.goto(url, { timeout: 0 });
+	}
+	async getCDPSession(sessionid) {
+		const page = this.getPage(sessionid);
+		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;
+	project;
+	options;
+	getSupportedBrowsers() {
+		return webdriverBrowsers;
+	}
+	async initialize(ctx, { browser, options }) {
+		this.project = ctx;
+		this.browserName = browser;
+		this.options = options;
+	}
+	async switchToTestFrame() {
+		const page = this.browser;
+		if (page.switchFrame) {
+			await page.switchFrame(page.$("iframe[data-vitest]"));
+		} else {
+			const iframe = await page.findElement("css selector", "iframe[data-vitest]");
+			await page.switchToFrame(iframe);
+		}
+	}
+	async switchToMainFrame() {
+		const page = this.browser;
+		if (page.switchFrame) {
+			await page.switchFrame(null);
+		} else {
+			await page.switchToParentFrame();
+		}
+	}
+	getCommandsContext() {
+		return { browser: this.browser };
+	}
+	async openBrowser() {
+		if (this.browser) {
+			return this.browser;
+		}
+		const options = this.project.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.project.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(_sessionId, 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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/browser",
   "type": "module",
-  "version": "3.1.0-beta.1",
+  "version": "3.1.0-beta.2",
   "description": "Browser running for Vitest",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -66,7 +66,7 @@
   "peerDependencies": {
     "playwright": "*",
     "webdriverio": "^7.0.0 || ^8.0.0 || ^9.0.0",
-    "vitest": "3.1.0-beta.1"
+    "vitest": "3.1.0-beta.2"
   },
   "peerDependenciesMeta": {
     "playwright": {
@@ -87,8 +87,8 @@
     "sirv": "^3.0.1",
     "tinyrainbow": "^2.0.0",
     "ws": "^8.18.1",
-    "@vitest/mocker": "3.1.0-beta.1",
-    "@vitest/utils": "3.1.0-beta.1"
+    "@vitest/mocker": "3.1.0-beta.2",
+    "@vitest/utils": "3.1.0-beta.2"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.3",
@@ -105,10 +105,10 @@
     "playwright-core": "^1.50.1",
     "safaridriver": "^1.0.0",
     "webdriverio": "^9.10.0",
-    "@vitest/runner": "3.1.0-beta.1",
-    "@vitest/ws-client": "3.1.0-beta.1",
-    "@vitest/ui": "3.1.0-beta.1",
-    "vitest": "3.1.0-beta.1"
+    "@vitest/runner": "3.1.0-beta.2",
+    "@vitest/ui": "3.1.0-beta.2",
+    "vitest": "3.1.0-beta.2",
+    "@vitest/ws-client": "3.1.0-beta.2"
   },
   "scripts": {
     "build": "rimraf dist && pnpm build:node && pnpm build:client",

package/dist/index-DrTP5i7N.js

@@ -1,195 +0,0 @@
-import { server, page } from '@vitest/browser/context';
-import { I as Ivya, e as getByRoleSelector, c as getByAltTextSelector, f as getByLabelSelector, b as getByPlaceholderSelector, d as getByTestIdSelector, a as getByTextSelector, g as getByTitleSelector, h as getElementError } from './public-utils-J4vwTaki.js';
-
-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(sourceError)).then(onFulfilled, onRejected);
-    },
-    catch(onRejected) {
-      return (promiseResult ||= promise(sourceError)).catch(onRejected);
-    },
-    finally(onFinally) {
-      return (promiseResult ||= promise(sourceError)).finally(onFinally);
-    },
-    [Symbol.toStringTag]: "Promise"
-  };
-}
-// @__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;
-}
-
-const selectorEngine = Ivya.create({
-  browser: ((name) => {
-    switch (name) {
-      case "edge":
-      case "chrome":
-        return "chromium";
-      case "safari":
-        return "webkit";
-      default:
-        return name;
-    }
-  })(server.config.browser.name),
-  testIdAttribute: server.config.browser.locators.testIdAttribute
-});
-class Locator {
-  _parsedSelector;
-  _container;
-  _pwSelector;
-  click(options = {}) {
-    return this.triggerCommand("__vitest_click", this.selector, options);
-  }
-  dblClick(options = {}) {
-    return this.triggerCommand("__vitest_dblClick", this.selector, options);
-  }
-  tripleClick(options = {}) {
-    return this.triggerCommand("__vitest_tripleClick", this.selector, options);
-  }
-  clear(options) {
-    return this.triggerCommand("__vitest_clear", this.selector, options);
-  }
-  hover(options) {
-    return this.triggerCommand("__vitest_hover", this.selector, options);
-  }
-  unhover(options) {
-    return this.triggerCommand("__vitest_hover", "html > body", options);
-  }
-  fill(text, options) {
-    return this.triggerCommand("__vitest_fill", this.selector, text, options);
-  }
-  async upload(files, options) {
-    const filesPromise = (Array.isArray(files) ? files : [files]).map(async (file) => {
-      if (typeof file === "string") {
-        return file;
-      }
-      const bas64String = await new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = () => reject(new Error(`Failed to read file: ${file.name}`));
-        reader.readAsDataURL(file);
-      });
-      return {
-        name: file.name,
-        mimeType: file.type,
-        base64: bas64String
-      };
-    });
-    return this.triggerCommand("__vitest_upload", this.selector, await Promise.all(filesPromise), options);
-  }
-  dropTo(target, options = {}) {
-    return this.triggerCommand(
-      "__vitest_dragAndDrop",
-      this.selector,
-      target.selector,
-      options
-    );
-  }
-  selectOptions(value, options) {
-    const values = (Array.isArray(value) ? value : [value]).map((v) => {
-      if (typeof v !== "string") {
-        const selector = "element" in v ? v.selector : selectorEngine.generateSelectorSimple(v);
-        return { element: selector };
-      }
-      return v;
-    });
-    return this.triggerCommand("__vitest_selectOptions", this.selector, values, options);
-  }
-  screenshot(options) {
-    return page.screenshot({
-      ...options,
-      element: this
-    });
-  }
-  getByRole(role, options) {
-    return this.locator(getByRoleSelector(role, options));
-  }
-  getByAltText(text, options) {
-    return this.locator(getByAltTextSelector(text, options));
-  }
-  getByLabelText(text, options) {
-    return this.locator(getByLabelSelector(text, options));
-  }
-  getByPlaceholder(text, options) {
-    return this.locator(getByPlaceholderSelector(text, options));
-  }
-  getByTestId(testId) {
-    return this.locator(getByTestIdSelector(server.config.browser.locators.testIdAttribute, testId));
-  }
-  getByText(text, options) {
-    return this.locator(getByTextSelector(text, options));
-  }
-  getByTitle(title, options) {
-    return this.locator(getByTitleSelector(title, options));
-  }
-  query() {
-    const parsedSelector = this._parsedSelector || (this._parsedSelector = selectorEngine.parseSelector(this._pwSelector || this.selector));
-    return selectorEngine.querySelector(parsedSelector, document.documentElement, true);
-  }
-  element() {
-    const element = this.query();
-    if (!element) {
-      throw getElementError(this._pwSelector || this.selector, this._container || document.body);
-    }
-    return element;
-  }
-  elements() {
-    const parsedSelector = this._parsedSelector || (this._parsedSelector = selectorEngine.parseSelector(this._pwSelector || this.selector));
-    return selectorEngine.querySelectorAll(parsedSelector, document.documentElement);
-  }
-  all() {
-    return this.elements().map((element) => this.elementLocator(element));
-  }
-  nth(index) {
-    return this.locator(`nth=${index}`);
-  }
-  first() {
-    return this.nth(0);
-  }
-  last() {
-    return this.nth(-1);
-  }
-  toString() {
-    return this.selector;
-  }
-  toJSON() {
-    return this.selector;
-  }
-  triggerCommand(command, ...args) {
-    const commands = getBrowserState().commands;
-    return ensureAwaited((error) => commands.triggerCommand(
-      command,
-      args,
-      error
-    ));
-  }
-}
-
-export { Locator as L, getWorkerState as a, getBrowserState as g, selectorEngine as s };

package/dist/utils-VCysLhWp.js

@@ -1,115 +0,0 @@
-import { g as getBrowserState, a as getWorkerState } from './index-DrTP5i7N.js';
-
-const provider = getBrowserState().provider;
-// @__NO_SIDE_EFFECTS__
-function convertElementToCssSelector(element) {
-  if (!element || !(element instanceof Element)) {
-    throw new Error(
-      `Expected DOM element to be an instance of Element, received ${typeof element}`
-    );
-  }
-  return getUniqueCssSelector(element);
-}
-function escapeIdForCSSSelector(id) {
-  return id.split("").map((char) => {
-    const code = char.charCodeAt(0);
-    if (char === " " || char === "#" || char === "." || char === ":" || char === "[" || char === "]" || char === ">" || char === "+" || char === "~" || char === "\\") {
-      return `\\${char}`;
-    } else if (code >= 65536) {
-      return `\\${code.toString(16).toUpperCase().padStart(6, "0")} `;
-    } else if (code < 32 || code === 127) {
-      return `\\${code.toString(16).toUpperCase().padStart(2, "0")} `;
-    } else if (code >= 128) {
-      return `\\${code.toString(16).toUpperCase().padStart(2, "0")} `;
-    } else {
-      return char;
-    }
-  }).join("");
-}
-function getUniqueCssSelector(el) {
-  const path = [];
-  let parent;
-  let hasShadowRoot = false;
-  while (parent = getParent(el)) {
-    if (parent.shadowRoot) {
-      hasShadowRoot = true;
-    }
-    const tag = el.tagName;
-    if (el.id) {
-      path.push(`#${escapeIdForCSSSelector(el.id)}`);
-    } else if (!el.nextElementSibling && !el.previousElementSibling) {
-      path.push(tag.toLowerCase());
-    } else {
-      let index = 0;
-      let sameTagSiblings = 0;
-      let elementIndex = 0;
-      for (const sibling of parent.children) {
-        index++;
-        if (sibling.tagName === tag) {
-          sameTagSiblings++;
-        }
-        if (sibling === el) {
-          elementIndex = index;
-        }
-      }
-      if (sameTagSiblings > 1) {
-        path.push(`${tag.toLowerCase()}:nth-child(${elementIndex})`);
-      } else {
-        path.push(tag.toLowerCase());
-      }
-    }
-    el = parent;
-  }
-  return `${getBrowserState().provider === "webdriverio" && hasShadowRoot ? ">>>" : ""}${path.reverse().join(" > ")}`;
-}
-function getParent(el) {
-  const parent = el.parentNode;
-  if (parent instanceof ShadowRoot) {
-    return parent.host;
-  }
-  return parent;
-}
-const now = Date.now;
-function processTimeoutOptions(options_) {
-  if (
-    // if timeout is set, keep it
-    options_ && options_.timeout != null || provider !== "playwright"
-  ) {
-    return options_;
-  }
-  if (getWorkerState().config.browser.providerOptions.actionTimeout != null) {
-    return options_;
-  }
-  const currentTest = getWorkerState().current;
-  const startTime = currentTest?.result?.startTime;
-  if (!currentTest || currentTest.type === "suite" || !startTime) {
-    return options_;
-  }
-  const timeout = currentTest.timeout;
-  if (timeout === 0 || timeout === Number.POSITIVE_INFINITY) {
-    return options_;
-  }
-  options_ = options_ || {};
-  const currentTime = now();
-  const endTime = startTime + timeout;
-  const remainingTime = endTime - currentTime;
-  if (remainingTime <= 0) {
-    return options_;
-  }
-  options_.timeout = remainingTime - 100;
-  return options_;
-}
-function getIframeScale() {
-  const testerUi = window.parent.document.querySelector("#tester-ui");
-  if (!testerUi) {
-    throw new Error(`Cannot find Tester element. This is a bug in Vitest. Please, open a new issue with reproduction.`);
-  }
-  const scaleAttribute = testerUi.getAttribute("data-scale");
-  const scale = Number(scaleAttribute);
-  if (Number.isNaN(scale)) {
-    throw new TypeError(`Cannot parse scale value from Tester element (${scaleAttribute}). This is a bug in Vitest. Please, open a new issue with reproduction.`);
-  }
-  return scale;
-}
-
-export { convertElementToCssSelector as c, getIframeScale as g, processTimeoutOptions as p };