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

package/dist/@vitest/browser/types.d.ts

@@ -0,0 +1,69 @@
+import type { MockedModuleSerialized, ServerIdResolution, ServerMockResolution } from '../mocker/index.js';
+import type { TaskEventPack, TaskResultPack, TestArtifact } from '../runner/index.js';
+import type { BirpcReturn } from "birpc";
+import type { AfterSuiteRunMeta, BrowserTesterOptions, CancelReason, RunnerTestFile, SerializedTestSpecification, SnapshotResult, TestExecutionMethod, UserConsoleLog } from '../../index.js';
+export interface WebSocketBrowserHandlers {
+	resolveSnapshotPath: (testPath: string) => string;
+	resolveSnapshotRawPath: (testPath: string, rawPath: string) => string;
+	onUnhandledError: (error: unknown, type: string) => Promise<void>;
+	onQueued: (method: TestExecutionMethod, file: RunnerTestFile) => void;
+	onCollected: (method: TestExecutionMethod, files: RunnerTestFile[]) => Promise<void>;
+	onTaskArtifactRecord: <Artifact extends TestArtifact>(testId: string, artifact: Artifact) => Promise<Artifact>;
+	onTaskUpdate: (method: TestExecutionMethod, packs: TaskResultPack[], events: TaskEventPack[]) => void;
+	onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+	cancelCurrentRun: (reason: CancelReason) => void;
+	getCountOfFailedTests: () => number;
+	readSnapshotFile: (id: string) => Promise<string | null>;
+	saveSnapshotFile: (id: string, content: string) => Promise<void>;
+	removeSnapshotFile: (id: string) => Promise<void>;
+	sendLog: (method: TestExecutionMethod, log: UserConsoleLog) => void;
+	snapshotSaved: (snapshot: SnapshotResult) => void;
+	debug: (...args: string[]) => void;
+	resolveId: (id: string, importer?: string) => Promise<ServerIdResolution | null>;
+	triggerCommand: <T>(sessionId: string, command: string, testPath: string | undefined, payload: unknown[]) => Promise<T>;
+	resolveMock: (id: string, importer: string, options: {
+		mock: "spy" | "factory" | "auto";
+	}) => Promise<ServerMockResolution>;
+	invalidate: (ids: string[]) => void;
+	getBrowserFileSourceMap: (id: string) => SourceMap | null | {
+		mappings: "";
+	} | undefined;
+	wdioSwitchContext: (direction: "iframe" | "parent") => void;
+	registerMock: (sessionId: string, mock: MockedModuleSerialized) => void;
+	unregisterMock: (sessionId: string, id: string) => void;
+	clearMocks: (sessionId: string) => void;
+	sendCdpEvent: (sessionId: string, event: string, payload?: Record<string, unknown>) => unknown;
+	trackCdpEvent: (sessionId: string, type: "on" | "once" | "off", event: string, listenerId: string) => void;
+}
+export type Awaitable<T> = T | PromiseLike<T>;
+export interface WebSocketEvents {
+	onCollected?: (files: RunnerTestFile[]) => Awaitable<void>;
+	onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
+	onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
+	onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+	onSpecsCollected?: (specs?: SerializedTestSpecification[]) => Awaitable<void>;
+	onFinishedReportCoverage: () => void;
+}
+export interface WebSocketBrowserEvents {
+	onCancel: (reason: CancelReason) => void;
+	createTesters: (options: BrowserTesterOptions) => Promise<void>;
+	cleanupTesters: () => Promise<void>;
+	cdpEvent: (event: string, payload: unknown) => void;
+	resolveManualMock: (url: string) => Promise<{
+		url: string;
+		keys: string[];
+		responseId: string;
+	}>;
+}
+export type WebSocketBrowserRPC = BirpcReturn<WebSocketBrowserEvents, WebSocketBrowserHandlers>;
+interface SourceMap {
+	file: string;
+	mappings: string;
+	names: string[];
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+	toString: () => string;
+	toUrl: () => string;
+}
+export {};

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

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

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

@@ -0,0 +1,106 @@
+import { CustomComparatorsRegistry } from '../browser/index.js';
+export { defineBrowserCommand } from '../browser/index.js';
+import { Page, Frame, FrameLocator, BrowserContext, CDPSession, LaunchOptions, ConnectOptions, BrowserContextOptions, Browser } from 'playwright';
+import { ScreenshotMatcherOptions, ScreenshotComparatorRegistry, Locator } from '../browser/index.js';
+import { BrowserProviderOption, BrowserProvider, BrowserModuleMocker, TestProject, CDPSession as CDPSession$1 } from '../../node.js';
+
+declare const playwrightBrowsers: readonly ["firefox", "webkit", "chromium"];
+type PlaywrightBrowser = (typeof playwrightBrowsers)[number];
+interface PlaywrightProviderOptions {
+	/**
+	* The options passed down to [`playwright.connect`](https://playwright.dev/docs/api/class-browsertype#browser-type-launch) method.
+	* @see {@link https://playwright.dev/docs/api/class-browsertype#browser-type-launch}
+	*/
+	launchOptions?: Omit<LaunchOptions, "tracesDir">;
+	/**
+	* The options passed down to [`playwright.connect`](https://playwright.dev/docs/api/class-browsertype#browser-type-connect) method.
+	*
+	* This is used only if you connect remotely to the playwright instance via a WebSocket connection.
+	* @see {@link https://playwright.dev/docs/api/class-browsertype#browser-type-connect}
+	*/
+	connectOptions?: ConnectOptions & {
+		wsEndpoint: string;
+	};
+	/**
+	* The options passed down to [`browser.newContext`](https://playwright.dev/docs/api/class-browser#browser-new-context) method.
+	* @see {@link https://playwright.dev/docs/api/class-browser#browser-new-context}
+	*/
+	contextOptions?: Omit<BrowserContextOptions, "ignoreHTTPSErrors" | "serviceWorkers">;
+	/**
+	* The maximum time in milliseconds to wait for `userEvent` action to complete.
+	* @default 0 (no timeout)
+	*/
+	actionTimeout?: number;
+}
+declare function playwright(options?: PlaywrightProviderOptions): BrowserProviderOption<PlaywrightProviderOptions>;
+declare class PlaywrightBrowserProvider implements BrowserProvider {
+	private project;
+	private options;
+	name: "playwright";
+	supportsParallelism: boolean;
+	browser: Browser | null;
+	contexts: Map<string, BrowserContext>;
+	pages: Map<string, Page>;
+	mocker: BrowserModuleMocker;
+	browserName: PlaywrightBrowser;
+	private browserPromise;
+	private closing;
+	tracingContexts: Set<string>;
+	pendingTraces: Map<string, string>;
+	initScripts: string[];
+	constructor(project: TestProject, options: PlaywrightProviderOptions);
+	private openBrowser;
+	private createMocker;
+	private createContext;
+	getPage(sessionId: string): Page;
+	getCommandsContext(sessionId: string): {
+		page: Page;
+		context: BrowserContext;
+		frame: () => Promise<Frame>;
+		readonly iframe: FrameLocator;
+	};
+	private openBrowserPage;
+	openPage(sessionId: string, url: string): Promise<void>;
+	private _throwIfClosing;
+	getCDPSession(sessionid: string): Promise<CDPSession$1>;
+	close(): Promise<void>;
+}
+declare module "vitest/node" {
+	interface BrowserCommandContext {
+		page: Page;
+		frame(): Promise<Frame>;
+		iframe: FrameLocator;
+		context: BrowserContext;
+	}
+	interface _BrowserNames {
+		playwright: PlaywrightBrowser;
+	}
+	interface ToMatchScreenshotOptions extends Omit<ScreenshotMatcherOptions, "comparatorName" | "comparatorOptions">, CustomComparatorsRegistry {}
+	interface ToMatchScreenshotComparators extends ScreenshotComparatorRegistry {}
+}
+type PWHoverOptions = NonNullable<Parameters<Page["hover"]>[1]>;
+type PWClickOptions = NonNullable<Parameters<Page["click"]>[1]>;
+type PWDoubleClickOptions = NonNullable<Parameters<Page["dblclick"]>[1]>;
+type PWFillOptions = NonNullable<Parameters<Page["fill"]>[2]>;
+type PWScreenshotOptions = NonNullable<Parameters<Page["screenshot"]>[0]>;
+type PWSelectOptions = NonNullable<Parameters<Page["selectOption"]>[2]>;
+type PWDragAndDropOptions = NonNullable<Parameters<Page["dragAndDrop"]>[2]>;
+type PWSetInputFiles = NonNullable<Parameters<Page["setInputFiles"]>[2]>;
+type PWCDPSession = CDPSession;
+declare module "vitest/browser" {
+	interface UserEventHoverOptions extends PWHoverOptions {}
+	interface UserEventClickOptions extends PWClickOptions {}
+	interface UserEventDoubleClickOptions extends PWDoubleClickOptions {}
+	interface UserEventTripleClickOptions extends PWClickOptions {}
+	interface UserEventFillOptions extends PWFillOptions {}
+	interface UserEventSelectOptions extends PWSelectOptions {}
+	interface UserEventDragAndDropOptions extends PWDragAndDropOptions {}
+	interface UserEventUploadOptions extends PWSetInputFiles {}
+	interface ScreenshotOptions extends Omit<PWScreenshotOptions, "mask"> {
+		mask?: ReadonlyArray<Element | Locator> | undefined;
+	}
+	interface CDPSession extends PWCDPSession {}
+}
+
+export { PlaywrightBrowserProvider, playwright };
+export type { PlaywrightProviderOptions };