@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/browser-playwright/locators.js

@@ -0,0 +1,114 @@
+import { selectorEngine, getByTitleSelector, getByTextSelector, getByPlaceholderSelector, getByAltTextSelector, getByTestIdSelector, getByRoleSelector, getByLabelSelector, Locator, processTimeoutOptions, getIframeScale } from '../browser/locators.js';
+import { page } from '../browser/context.js';
+import { __INTERNAL } from '../../browser.js';
+
+class PlaywrightLocator extends Locator {
+  constructor(selector, _container) {
+    super();
+    this.selector = selector;
+    this._container = _container;
+  }
+  click(options) {
+    return super.click(processTimeoutOptions(processClickOptions(options)));
+  }
+  dblClick(options) {
+    return super.dblClick(processTimeoutOptions(processClickOptions(options)));
+  }
+  tripleClick(options) {
+    return super.tripleClick(processTimeoutOptions(processClickOptions(options)));
+  }
+  selectOptions(value, options) {
+    return super.selectOptions(value, processTimeoutOptions(options));
+  }
+  clear(options) {
+    return super.clear(processTimeoutOptions(options));
+  }
+  hover(options) {
+    return super.hover(processTimeoutOptions(processHoverOptions(options)));
+  }
+  upload(files, options) {
+    return super.upload(files, processTimeoutOptions(options));
+  }
+  fill(text, options) {
+    return super.fill(text, processTimeoutOptions(options));
+  }
+  dropTo(target, options) {
+    return super.dropTo(target, processTimeoutOptions(processDragAndDropOptions(options)));
+  }
+  locator(selector) {
+    return new PlaywrightLocator(`${this.selector} >> ${selector}`, this._container);
+  }
+  elementLocator(element) {
+    return new PlaywrightLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+}
+page.extend({
+  getByLabelText(text, options) {
+    return new PlaywrightLocator(getByLabelSelector(text, options));
+  },
+  getByRole(role, options) {
+    return new PlaywrightLocator(getByRoleSelector(role, options));
+  },
+  getByTestId(testId) {
+    return new PlaywrightLocator(getByTestIdSelector(window.__vitest_worker__.config.browser.locators.testIdAttribute, testId));
+  },
+  getByAltText(text, options) {
+    return new PlaywrightLocator(getByAltTextSelector(text, options));
+  },
+  getByPlaceholder(text, options) {
+    return new PlaywrightLocator(getByPlaceholderSelector(text, options));
+  },
+  getByText(text, options) {
+    return new PlaywrightLocator(getByTextSelector(text, options));
+  },
+  getByTitle(title, options) {
+    return new PlaywrightLocator(getByTitleSelector(title, options));
+  },
+  elementLocator(element) {
+    return new PlaywrightLocator(selectorEngine.generateSelectorSimple(element), element);
+  },
+  frameLocator(locator) {
+    return new PlaywrightLocator(`${locator.selector} >> internal:control=enter-frame`);
+  }
+});
+__INTERNAL._createLocator = (selector) => new PlaywrightLocator(selector);
+function processDragAndDropOptions(options) {
+  if (!options) {
+    return options;
+  }
+  if (options.sourcePosition) {
+    options.sourcePosition = processPlaywrightPosition(options.sourcePosition);
+  }
+  if (options.targetPosition) {
+    options.targetPosition = processPlaywrightPosition(options.targetPosition);
+  }
+  return options;
+}
+function processHoverOptions(options) {
+  if (!options) {
+    return options;
+  }
+  if (options.position) {
+    options.position = processPlaywrightPosition(options.position);
+  }
+  return options;
+}
+function processClickOptions(options) {
+  if (!options) {
+    return options;
+  }
+  if (options.position) {
+    options.position = processPlaywrightPosition(options.position);
+  }
+  return options;
+}
+function processPlaywrightPosition(position) {
+  const scale = getIframeScale();
+  if (position.x != null) {
+    position.x *= scale;
+  }
+  if (position.y != null) {
+    position.y *= scale;
+  }
+  return position;
+}

package/dist/@vitest/browser-preview/context.d.ts

@@ -0,0 +1 @@
+export * from '../browser/context.js'

package/dist/@vitest/browser-preview/index.d.ts

@@ -0,0 +1,19 @@
+import { BrowserProviderOption, BrowserProvider, TestProject } from '../../node.js';
+export { defineBrowserCommand } from '../browser/index.js';
+
+declare function preview(): BrowserProviderOption;
+declare class PreviewBrowserProvider implements BrowserProvider {
+	name: "preview";
+	supportsParallelism: boolean;
+	private project;
+	private open;
+	distRoot: string;
+	initScripts: string[];
+	constructor(project: TestProject);
+	isOpen(): boolean;
+	getCommandsContext(): {};
+	openPage(_sessionId: string, url: string): Promise<void>;
+	close(): Promise<void>;
+}
+
+export { PreviewBrowserProvider, preview };

package/dist/@vitest/browser-preview/index.js

@@ -0,0 +1,148 @@
+import { nextTick } from 'node:process';
+import { defineBrowserProvider } from '../browser/index.js';
+export { defineBrowserCommand } from '../browser/index.js';
+import { fileURLToPath } from 'node:url';
+
+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]:[/\\]/;
+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 distRoot = dirname(fileURLToPath(import.meta.url));
+
+function preview() {
+  return defineBrowserProvider({
+    name: "preview",
+    providerFactory(project) {
+      return new PreviewBrowserProvider(project);
+    }
+  });
+}
+class PreviewBrowserProvider {
+  name = "preview";
+  supportsParallelism = false;
+  project;
+  open = false;
+  distRoot = distRoot;
+  initScripts = [resolve(distRoot, "locators.js")];
+  constructor(project) {
+    this.project = project;
+    this.open = false;
+    if (project.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");
+    }
+    nextTick(() => {
+      project.vitest.logger.printBrowserBanner(project);
+    });
+  }
+  isOpen() {
+    return this.open;
+  }
+  getCommandsContext() {
+    return {};
+  }
+  async openPage(_sessionId, url) {
+    this.open = true;
+    if (!this.project.browser) {
+      throw new Error("Browser is not initialized");
+    }
+    const options = this.project.browser.vite.config.server;
+    const _open = options.open;
+    options.open = url;
+    this.project.browser.vite.openBrowser();
+    options.open = _open;
+  }
+  async close() {}
+}
+
+export { PreviewBrowserProvider, preview };

package/dist/@vitest/browser-preview/locators.js

@@ -0,0 +1,79 @@
+import { selectorEngine, getByTitleSelector, getByTextSelector, getByPlaceholderSelector, getByAltTextSelector, getByTestIdSelector, getByRoleSelector, getByLabelSelector, Locator, convertElementToCssSelector } from '../browser/locators.js';
+import { page } from '../browser/context.js';
+import { utils, userEvent } from '../browser/index.js';
+import { __INTERNAL } from '../../browser.js';
+
+class PreviewLocator extends Locator {
+  constructor(_pwSelector, _container) {
+    super();
+    this._pwSelector = _pwSelector;
+    this._container = _container;
+  }
+  get selector() {
+    const selectors = this.elements().map((element) => convertElementToCssSelector(element));
+    if (!selectors.length) {
+      throw utils.getElementError(this._pwSelector, this._container || document.body);
+    }
+    return selectors.join(", ");
+  }
+  click() {
+    return userEvent.click(this.element());
+  }
+  dblClick() {
+    return userEvent.dblClick(this.element());
+  }
+  tripleClick() {
+    return userEvent.tripleClick(this.element());
+  }
+  hover() {
+    return userEvent.hover(this.element());
+  }
+  unhover() {
+    return userEvent.unhover(this.element());
+  }
+  async fill(text) {
+    return userEvent.fill(this.element(), text);
+  }
+  async upload(file) {
+    return userEvent.upload(this.element(), file);
+  }
+  selectOptions(options) {
+    return userEvent.selectOptions(this.element(), options);
+  }
+  clear() {
+    return userEvent.clear(this.element());
+  }
+  locator(selector) {
+    return new PreviewLocator(`${this._pwSelector} >> ${selector}`, this._container);
+  }
+  elementLocator(element) {
+    return new PreviewLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+}
+page.extend({
+  getByLabelText(text, options) {
+    return new PreviewLocator(getByLabelSelector(text, options));
+  },
+  getByRole(role, options) {
+    return new PreviewLocator(getByRoleSelector(role, options));
+  },
+  getByTestId(testId) {
+    return new PreviewLocator(getByTestIdSelector(window.__vitest_worker__.config.browser.locators.testIdAttribute, testId));
+  },
+  getByAltText(text, options) {
+    return new PreviewLocator(getByAltTextSelector(text, options));
+  },
+  getByPlaceholder(text, options) {
+    return new PreviewLocator(getByPlaceholderSelector(text, options));
+  },
+  getByText(text, options) {
+    return new PreviewLocator(getByTextSelector(text, options));
+  },
+  getByTitle(title, options) {
+    return new PreviewLocator(getByTitleSelector(title, options));
+  },
+  elementLocator(element) {
+    return new PreviewLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+});
+__INTERNAL._createLocator = (selector) => new PreviewLocator(selector);

package/dist/@vitest/browser-webdriverio/context.d.ts

@@ -0,0 +1 @@
+export * from '../browser/context.js'

package/dist/@vitest/browser-webdriverio/index.d.ts

@@ -0,0 +1,63 @@
+import { CustomComparatorsRegistry } from '../browser/index.js';
+export { defineBrowserCommand } from '../browser/index.js';
+import { ScreenshotMatcherOptions, ScreenshotComparatorRegistry } from '../browser/index.js';
+import { BrowserProvider, TestProject, CDPSession, BrowserProviderOption } from '../../node.js';
+import { ClickOptions, MoveToOptions, DragAndDropOptions, remote } from 'webdriverio';
+
+declare const webdriverBrowsers: readonly ["firefox", "chrome", "edge", "safari"];
+type WebdriverBrowser = (typeof webdriverBrowsers)[number];
+interface WebdriverProviderOptions extends Partial<Parameters<typeof remote>[0]> {}
+declare function webdriverio(options?: WebdriverProviderOptions): BrowserProviderOption<WebdriverProviderOptions>;
+declare class WebdriverBrowserProvider implements BrowserProvider {
+	name: "webdriverio";
+	supportsParallelism: boolean;
+	browser: WebdriverIO.Browser | null;
+	private browserName;
+	private project;
+	private options?;
+	private closing;
+	private iframeSwitched;
+	private topLevelContext;
+	initScripts: string[];
+	getSupportedBrowsers(): readonly string[];
+	constructor(project: TestProject, options: WebdriverProviderOptions);
+	isIframeSwitched(): boolean;
+	switchToTestFrame(): Promise<void>;
+	switchToMainFrame(): Promise<void>;
+	setViewport(options: {
+		width: number;
+		height: number;
+	}): Promise<void>;
+	getCommandsContext(): {
+		browser: WebdriverIO.Browser | null;
+	};
+	openBrowser(): Promise<WebdriverIO.Browser>;
+	private buildCapabilities;
+	openPage(sessionId: string, url: string): Promise<void>;
+	private _throwIfClosing;
+	close(): Promise<void>;
+	getCDPSession(_sessionId: string): Promise<CDPSession>;
+}
+declare module "vitest/browser" {
+	interface UserEventClickOptions extends Partial<ClickOptions> {}
+	interface UserEventHoverOptions extends MoveToOptions {}
+	interface UserEventDragAndDropOptions extends DragAndDropOptions {
+		sourceX?: number;
+		sourceY?: number;
+		targetX?: number;
+		targetY?: number;
+	}
+}
+declare module "vitest/node" {
+	interface BrowserCommandContext {
+		browser: WebdriverIO.Browser;
+	}
+	interface _BrowserNames {
+		webdriverio: WebdriverBrowser;
+	}
+	interface ToMatchScreenshotOptions extends Omit<ScreenshotMatcherOptions, "comparatorName" | "comparatorOptions">, CustomComparatorsRegistry {}
+	interface ToMatchScreenshotComparators extends ScreenshotComparatorRegistry {}
+}
+
+export { WebdriverBrowserProvider, webdriverio };
+export type { WebdriverProviderOptions };