@rstest/browser 0.8.5 → 0.9.0

package/dist/client/entry.d.ts

@@ -1,8 +1,4 @@
-import type { BrowserClientMessage, BrowserHostConfig } from '../protocol';
 declare global {
-    interface Window {
-        __RSTEST_BROWSER_OPTIONS__?: BrowserHostConfig;
-        __rstest_dispatch__?: (message: BrowserClientMessage) => void;
-    }
     var __coverage__: Record<string, unknown> | undefined;
 }
+export {};

package/dist/client/locator.d.ts

@@ -0,0 +1,125 @@
+import type { BrowserLocatorIR, BrowserLocatorText } from '../rpcProtocol';
+export declare const serializeText: (value: string | RegExp) => BrowserLocatorText;
+export type LocatorGetByRoleOptions = {
+    name?: string | RegExp;
+    exact?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+    expanded?: boolean;
+    selected?: boolean;
+    pressed?: boolean;
+    includeHidden?: boolean;
+    level?: number;
+};
+export type LocatorTextOptions = {
+    exact?: boolean;
+};
+export type LocatorKeyboardModifier = 'Alt' | 'Control' | 'ControlOrMeta' | 'Meta' | 'Shift';
+export type LocatorMouseButton = 'left' | 'right' | 'middle';
+export type LocatorPosition = {
+    x: number;
+    y: number;
+};
+export type LocatorClickOptions = {
+    button?: LocatorMouseButton;
+    clickCount?: number;
+    delay?: number;
+    force?: boolean;
+    modifiers?: LocatorKeyboardModifier[];
+    position?: LocatorPosition;
+    timeout?: number;
+    trial?: boolean;
+};
+export type LocatorDblclickOptions = Omit<LocatorClickOptions, 'clickCount'>;
+export type LocatorHoverOptions = Pick<LocatorClickOptions, 'force' | 'modifiers' | 'position' | 'timeout' | 'trial'>;
+export type LocatorPressOptions = {
+    delay?: number;
+    timeout?: number;
+};
+export type LocatorFillOptions = {
+    force?: boolean;
+    timeout?: number;
+};
+export type LocatorCheckOptions = {
+    force?: boolean;
+    position?: LocatorPosition;
+    timeout?: number;
+    trial?: boolean;
+};
+export type LocatorFocusOptions = {
+    timeout?: number;
+};
+export type LocatorBlurOptions = {
+    timeout?: number;
+};
+export type LocatorScrollIntoViewIfNeededOptions = {
+    timeout?: number;
+};
+export type LocatorWaitForOptions = {
+    state?: 'attached' | 'detached' | 'visible' | 'hidden';
+    timeout?: number;
+};
+export type BrowserSerializable = null | boolean | number | string | BrowserSerializable[] | {
+    [key: string]: BrowserSerializable;
+};
+export type LocatorDispatchEventInit = BrowserSerializable;
+export type LocatorSelectOptionOptions = {
+    force?: boolean;
+    timeout?: number;
+};
+export type LocatorSetInputFilesOptions = {
+    timeout?: number;
+};
+export type LocatorFilterOptions = {
+    hasText?: string | RegExp;
+    hasNotText?: string | RegExp;
+    has?: Locator;
+    hasNot?: Locator;
+};
+export declare class Locator {
+    readonly ir: BrowserLocatorIR;
+    constructor(ir: BrowserLocatorIR);
+    getByRole(role: string, options?: LocatorGetByRoleOptions): Locator;
+    locator(selector: string): Locator;
+    getByText(text: string | RegExp, options?: LocatorTextOptions): Locator;
+    getByLabel(text: string | RegExp, options?: LocatorTextOptions): Locator;
+    getByPlaceholder(text: string | RegExp, options?: LocatorTextOptions): Locator;
+    getByAltText(text: string | RegExp, options?: LocatorTextOptions): Locator;
+    getByTitle(text: string | RegExp, options?: LocatorTextOptions): Locator;
+    getByTestId(text: string | RegExp): Locator;
+    filter(options: LocatorFilterOptions): Locator;
+    and(other: Locator): Locator;
+    or(other: Locator): Locator;
+    nth(index: number): Locator;
+    first(): Locator;
+    last(): Locator;
+    click(options?: LocatorClickOptions): Promise<void>;
+    dblclick(options?: LocatorDblclickOptions): Promise<void>;
+    fill(value: string, options?: LocatorFillOptions): Promise<void>;
+    hover(options?: LocatorHoverOptions): Promise<void>;
+    press(key: string, options?: LocatorPressOptions): Promise<void>;
+    clear(): Promise<void>;
+    check(options?: LocatorCheckOptions): Promise<void>;
+    uncheck(options?: LocatorCheckOptions): Promise<void>;
+    focus(options?: LocatorFocusOptions): Promise<void>;
+    blur(options?: LocatorBlurOptions): Promise<void>;
+    scrollIntoViewIfNeeded(options?: LocatorScrollIntoViewIfNeededOptions): Promise<void>;
+    waitFor(options?: LocatorWaitForOptions): Promise<void>;
+    dispatchEvent(type: string, eventInit?: LocatorDispatchEventInit): Promise<void>;
+    selectOption(value: string | string[], options?: LocatorSelectOptionOptions): Promise<void>;
+    setInputFiles(files: string | string[], options?: LocatorSetInputFilesOptions): Promise<void>;
+    private callLocator;
+}
+declare const browserPageQueryMethods: readonly ["locator", "getByRole", "getByText", "getByLabel", "getByPlaceholder", "getByAltText", "getByTitle", "getByTestId"];
+type BrowserPageQueryMethod = (typeof browserPageQueryMethods)[number];
+export type BrowserPage = Pick<Locator, BrowserPageQueryMethod>;
+export declare const page: BrowserPage;
+export declare const isLocator: (value: unknown) => value is Locator;
+/**
+ * Configure the attribute used by `getByTestId()` queries.
+ * Forwards to the host provider (e.g. Playwright `selectors.setTestIdAttribute()`).
+ *
+ * @default 'data-testid'
+ */
+export declare const setTestIdAttribute: (attribute: string) => Promise<void>;
+export {};

package/dist/client/snapshot.d.ts

@@ -1,9 +1,3 @@
-import type { BrowserHostConfig } from '../protocol';
-declare global {
-    interface Window {
-        __RSTEST_BROWSER_OPTIONS__?: BrowserHostConfig;
-    }
-}
 /**
  * Browser snapshot environment that proxies file operations to the host
  * via postMessage RPC through the container.

package/dist/concurrency.d.ts

@@ -0,0 +1,12 @@
+import type { Rstest } from '@rstest/core/browser';
+export type HeadlessConcurrencyContext = Pick<Rstest, 'command'> & {
+    normalizedConfig: {
+        pool: {
+            maxWorkers?: string | number;
+        };
+    };
+};
+export declare const getNumCpus: () => number;
+export declare const parseWorkers: (maxWorkers: string | number, numCpus?: number) => number;
+export declare const resolveDefaultHeadlessWorkers: (command: HeadlessConcurrencyContext["command"], numCpus?: number) => number;
+export declare const getHeadlessConcurrency: (context: HeadlessConcurrencyContext, totalTests: number) => number;

package/dist/dispatchCapabilities.d.ts

@@ -0,0 +1,34 @@
+import type { Reporter } from '@rstest/core/browser';
+import { HostDispatchRouter } from './dispatchRouter';
+import type { BrowserClientMessage, BrowserDispatchHandler, SnapshotRpcRequest } from './protocol';
+export type HostDispatchRouterOptions = ConstructorParameters<typeof HostDispatchRouter>[0];
+type RunnerPayload<TType extends BrowserClientMessage['type']> = Extract<BrowserClientMessage, {
+    type: TType;
+}> extends {
+    payload: infer TPayload;
+} ? TPayload : never;
+type ReporterHookArg<THook extends keyof Reporter> = Parameters<NonNullable<Reporter[THook]>>[0];
+type RunnerDispatchFileReadyPayload = ReporterHookArg<'onTestFileReady'>;
+type RunnerDispatchSuiteStartPayload = ReporterHookArg<'onTestSuiteStart'>;
+type RunnerDispatchSuiteResultPayload = ReporterHookArg<'onTestSuiteResult'>;
+type RunnerDispatchCaseStartPayload = ReporterHookArg<'onTestCaseStart'>;
+export type RunnerDispatchCallbacks = {
+    onTestFileStart: (payload: RunnerPayload<'file-start'>) => Promise<void>;
+    onTestFileReady: (payload: RunnerDispatchFileReadyPayload) => Promise<void>;
+    onTestSuiteStart: (payload: RunnerDispatchSuiteStartPayload) => Promise<void>;
+    onTestSuiteResult: (payload: RunnerDispatchSuiteResultPayload) => Promise<void>;
+    onTestCaseStart: (payload: RunnerDispatchCaseStartPayload) => Promise<void>;
+    onTestCaseResult: (payload: RunnerPayload<'case-result'>) => Promise<void>;
+    onTestFileComplete: (payload: RunnerPayload<'file-complete'>) => Promise<void>;
+    onLog: (payload: RunnerPayload<'log'>) => Promise<void>;
+    onFatal: (payload: RunnerPayload<'fatal'>) => Promise<void>;
+};
+type CreateHostDispatchRouterOptions = {
+    routerOptions?: HostDispatchRouterOptions;
+    runnerCallbacks: RunnerDispatchCallbacks;
+    runSnapshotRpc: (request: SnapshotRpcRequest) => Promise<unknown>;
+    extensionHandlers?: Map<string, BrowserDispatchHandler>;
+    onDuplicateNamespace?: (namespace: string) => void;
+};
+export declare const createHostDispatchRouter: ({ routerOptions, runnerCallbacks, runSnapshotRpc, extensionHandlers, onDuplicateNamespace, }: CreateHostDispatchRouterOptions) => HostDispatchRouter;
+export {};

package/dist/dispatchRouter.d.ts

@@ -0,0 +1,20 @@
+import type { BrowserDispatchRequest, BrowserDispatchResponse } from './protocol';
+type DispatchHandler = (request: BrowserDispatchRequest) => Promise<unknown>;
+type HostDispatchRouterOptions = {
+    isRunTokenStale?: (runToken: number) => boolean;
+    onStale?: (request: BrowserDispatchRequest) => void;
+};
+/**
+ * Host-side routing layer for dispatch envelopes.
+ * Capabilities are registered by namespace, while routing stays transport-agnostic.
+ */
+export declare class HostDispatchRouter {
+    private handlers;
+    private options;
+    constructor(options?: HostDispatchRouterOptions);
+    register(namespace: string, handler: DispatchHandler): void;
+    unregister(namespace: string): void;
+    has(namespace: string): boolean;
+    dispatch(request: BrowserDispatchRequest): Promise<BrowserDispatchResponse>;
+}
+export {};

package/dist/headlessLatestRerunScheduler.d.ts

@@ -0,0 +1,19 @@
+export type HeadlessLatestRerunScheduler<TFile> = {
+    enqueueLatest: (files: TFile[]) => Promise<void>;
+    whenIdle: () => Promise<void>;
+};
+type HeadlessLatestRerunSchedulerOptions<TFile, TRun> = {
+    getActiveRun: () => TRun | null;
+    isRunCancelled: (run: TRun) => boolean;
+    invalidateActiveRun: () => void;
+    interruptActiveRun: (run: TRun) => Promise<void>;
+    runFiles: (files: TFile[]) => Promise<void>;
+    onError?: (error: unknown) => Promise<void> | void;
+    onInterrupt?: (run: TRun) => void;
+};
+/**
+ * Latest-only rerun scheduler for headless watch mode.
+ * Keeps only the newest pending payload and interrupts active run generations.
+ */
+export declare const createHeadlessLatestRerunScheduler: <TFile, TRun>(options: HeadlessLatestRerunSchedulerOptions<TFile, TRun>) => HeadlessLatestRerunScheduler<TFile>;
+export {};

package/dist/headlessTransport.d.ts

@@ -0,0 +1,12 @@
+import type { BrowserClientMessage, BrowserDispatchRequest, BrowserDispatchResponse } from './protocol';
+import type { BrowserProviderPage } from './providers';
+type HeadlessRunnerTransportHandlers = {
+    onDispatchMessage: (message: BrowserClientMessage) => Promise<void>;
+    onDispatchRpc: (request: BrowserDispatchRequest) => Promise<BrowserDispatchResponse>;
+};
+/**
+ * Headless transport adapter.
+ * This only binds page bridge functions and delegates all scheduling decisions upstream.
+ */
+export declare const attachHeadlessRunnerTransport: (page: BrowserProviderPage, handlers: HeadlessRunnerTransportHandlers) => Promise<void>;
+export {};