@rstest/browser 0.11.5 → 0.11.7

package/src/client/locator.ts

@@ -1,448 +0,0 @@
-import type {
-  BrowserLocatorIR,
-  BrowserLocatorText,
-  BrowserRpcRequest,
-} from '../rpcProtocol';
-import { callBrowserRpc } from './browserRpc';
-
-export const serializeText = (value: string | RegExp): BrowserLocatorText => {
-  if (typeof value === 'string') {
-    return { type: 'string', value };
-  }
-  return { type: 'regexp', source: value.source, flags: value.flags };
-};
-
-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 class Locator {
-  readonly ir: BrowserLocatorIR;
-
-  constructor(ir: BrowserLocatorIR) {
-    this.ir = ir;
-  }
-
-  getByRole(role: string, options?: LocatorGetByRoleOptions): Locator {
-    const next = {
-      steps: [
-        ...this.ir.steps,
-        {
-          type: 'getByRole',
-          role,
-          options: options
-            ? {
-                ...options,
-                name:
-                  options.name === undefined
-                    ? undefined
-                    : serializeText(options.name),
-              }
-            : undefined,
-        },
-      ],
-    } satisfies BrowserLocatorIR;
-    return new Locator(next);
-  }
-
-  locator(selector: string): Locator {
-    return new Locator({
-      steps: [...this.ir.steps, { type: 'locator', selector }],
-    });
-  }
-
-  getByText(text: string | RegExp, options?: LocatorTextOptions): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        { type: 'getByText', text: serializeText(text), options },
-      ],
-    });
-  }
-
-  getByLabel(text: string | RegExp, options?: LocatorTextOptions): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        { type: 'getByLabel', text: serializeText(text), options },
-      ],
-    });
-  }
-
-  getByPlaceholder(
-    text: string | RegExp,
-    options?: LocatorTextOptions,
-  ): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        { type: 'getByPlaceholder', text: serializeText(text), options },
-      ],
-    });
-  }
-
-  getByAltText(text: string | RegExp, options?: LocatorTextOptions): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        { type: 'getByAltText', text: serializeText(text), options },
-      ],
-    });
-  }
-
-  getByTitle(text: string | RegExp, options?: LocatorTextOptions): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        { type: 'getByTitle', text: serializeText(text), options },
-      ],
-    });
-  }
-
-  getByTestId(text: string | RegExp): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        { type: 'getByTestId', text: serializeText(text) },
-      ],
-    });
-  }
-
-  filter(options: LocatorFilterOptions): Locator {
-    return new Locator({
-      steps: [
-        ...this.ir.steps,
-        {
-          type: 'filter',
-          options: {
-            hasText: options.hasText
-              ? serializeText(options.hasText)
-              : undefined,
-            hasNotText: options.hasNotText
-              ? serializeText(options.hasNotText)
-              : undefined,
-            has:
-              options.has === undefined
-                ? undefined
-                : isLocator(options.has)
-                  ? options.has.ir
-                  : (() => {
-                      throw new TypeError(
-                        'Locator.filter({ has }) expects a Locator returned from @rstest/browser page.getBy* APIs.',
-                      );
-                    })(),
-            hasNot:
-              options.hasNot === undefined
-                ? undefined
-                : isLocator(options.hasNot)
-                  ? options.hasNot.ir
-                  : (() => {
-                      throw new TypeError(
-                        'Locator.filter({ hasNot }) expects a Locator returned from @rstest/browser page.getBy* APIs.',
-                      );
-                    })(),
-          },
-        },
-      ],
-    });
-  }
-
-  and(other: Locator): Locator {
-    if (!isLocator(other)) {
-      throw new TypeError(
-        'Locator.and() expects a Locator returned from @rstest/browser page.getBy* APIs.',
-      );
-    }
-    return new Locator({
-      steps: [...this.ir.steps, { type: 'and', locator: other.ir }],
-    });
-  }
-
-  or(other: Locator): Locator {
-    if (!isLocator(other)) {
-      throw new TypeError(
-        'Locator.or() expects a Locator returned from @rstest/browser page.getBy* APIs.',
-      );
-    }
-    return new Locator({
-      steps: [...this.ir.steps, { type: 'or', locator: other.ir }],
-    });
-  }
-
-  nth(index: number): Locator {
-    return new Locator({ steps: [...this.ir.steps, { type: 'nth', index }] });
-  }
-
-  first(): Locator {
-    return new Locator({ steps: [...this.ir.steps, { type: 'first' }] });
-  }
-
-  last(): Locator {
-    return new Locator({ steps: [...this.ir.steps, { type: 'last' }] });
-  }
-
-  async click(options?: LocatorClickOptions): Promise<void> {
-    await this.callLocator('click', options === undefined ? [] : [options]);
-  }
-
-  async dblclick(options?: LocatorDblclickOptions): Promise<void> {
-    await this.callLocator('dblclick', options === undefined ? [] : [options]);
-  }
-
-  async fill(value: string, options?: LocatorFillOptions): Promise<void> {
-    await this.callLocator(
-      'fill',
-      options === undefined ? [value] : [value, options],
-    );
-  }
-
-  async hover(options?: LocatorHoverOptions): Promise<void> {
-    await this.callLocator('hover', options === undefined ? [] : [options]);
-  }
-
-  async press(key: string, options?: LocatorPressOptions): Promise<void> {
-    await this.callLocator(
-      'press',
-      options === undefined ? [key] : [key, options],
-    );
-  }
-
-  async clear(): Promise<void> {
-    await this.callLocator('clear', []);
-  }
-
-  async check(options?: LocatorCheckOptions): Promise<void> {
-    await this.callLocator('check', options === undefined ? [] : [options]);
-  }
-
-  async uncheck(options?: LocatorCheckOptions): Promise<void> {
-    await this.callLocator('uncheck', options === undefined ? [] : [options]);
-  }
-
-  async focus(options?: LocatorFocusOptions): Promise<void> {
-    await this.callLocator('focus', options === undefined ? [] : [options]);
-  }
-
-  async blur(options?: LocatorBlurOptions): Promise<void> {
-    await this.callLocator('blur', options === undefined ? [] : [options]);
-  }
-
-  async scrollIntoViewIfNeeded(
-    options?: LocatorScrollIntoViewIfNeededOptions,
-  ): Promise<void> {
-    await this.callLocator(
-      'scrollIntoViewIfNeeded',
-      options === undefined ? [] : [options],
-    );
-  }
-
-  async waitFor(options?: LocatorWaitForOptions): Promise<void> {
-    await this.callLocator('waitFor', options === undefined ? [] : [options]);
-  }
-
-  async dispatchEvent(
-    type: string,
-    eventInit?: LocatorDispatchEventInit,
-  ): Promise<void> {
-    if (typeof type !== 'string' || !type) {
-      throw new TypeError(
-        'Locator.dispatchEvent() expects a non-empty event type string.',
-      );
-    }
-    await this.callLocator(
-      'dispatchEvent',
-      eventInit === undefined ? [type] : [type, eventInit],
-    );
-  }
-
-  async selectOption(
-    value: string | string[],
-    options?: LocatorSelectOptionOptions,
-  ): Promise<void> {
-    if (
-      typeof value !== 'string' &&
-      !(Array.isArray(value) && value.every((v) => typeof v === 'string'))
-    ) {
-      throw new TypeError(
-        'Locator.selectOption() only supports string or string[] values in browser mode.',
-      );
-    }
-    await this.callLocator(
-      'selectOption',
-      options === undefined ? [value] : [value, options],
-    );
-  }
-
-  async setInputFiles(
-    files: string | string[],
-    options?: LocatorSetInputFilesOptions,
-  ): Promise<void> {
-    if (
-      typeof files !== 'string' &&
-      !(Array.isArray(files) && files.every((v) => typeof v === 'string'))
-    ) {
-      throw new TypeError(
-        'Locator.setInputFiles() only supports file path string or string[] in browser mode.',
-      );
-    }
-    await this.callLocator(
-      'setInputFiles',
-      options === undefined ? [files] : [files, options],
-    );
-  }
-
-  private async callLocator(method: string, args: unknown[]): Promise<void> {
-    await callBrowserRpc<void>({
-      kind: 'locator',
-      locator: this.ir,
-      method,
-      args,
-    } satisfies Omit<BrowserRpcRequest, 'id' | 'testPath' | 'runId'>);
-  }
-}
-
-const browserPageQueryMethods = [
-  'locator',
-  'getByRole',
-  'getByText',
-  'getByLabel',
-  'getByPlaceholder',
-  'getByAltText',
-  'getByTitle',
-  'getByTestId',
-] as const;
-
-type BrowserPageQueryMethod = (typeof browserPageQueryMethods)[number];
-
-export type BrowserPage = Pick<Locator, BrowserPageQueryMethod>;
-
-const rootLocator = new Locator({ steps: [] });
-
-const createBrowserPage = (): BrowserPage => {
-  return Object.fromEntries(
-    browserPageQueryMethods.map((methodName) => {
-      return [methodName, rootLocator[methodName].bind(rootLocator)];
-    }),
-  ) as BrowserPage;
-};
-
-export const page: BrowserPage = createBrowserPage();
-
-export const isLocator = (value: unknown): value is Locator => {
-  return value instanceof Locator;
-};
-
-/**
- * Configure the attribute used by `getByTestId()` queries.
- * Forwards to the host provider (e.g. Playwright `selectors.setTestIdAttribute()`).
- *
- * @default 'data-testid'
- */
-export const setTestIdAttribute = async (attribute: string): Promise<void> => {
-  await callBrowserRpc<void>({
-    kind: 'config',
-    locator: { steps: [] },
-    method: 'setTestIdAttribute',
-    args: [attribute],
-  } satisfies Omit<BrowserRpcRequest, 'id' | 'testPath' | 'runId'>);
-};

package/src/client/snapshot.ts

@@ -1,113 +0,0 @@
-import type { BrowserDispatchRequest, SnapshotRpcCall } from '../protocol';
-import { DISPATCH_NAMESPACE_SNAPSHOT } from '../protocol';
-import {
-  createRequestId,
-  dispatchRpc,
-  getRpcTimeout,
-} from './dispatchTransport';
-import { SNAPSHOT_HEADER } from '@rstest/core/internal/browser-runtime';
-import { mapStackFrame } from './sourceMapSupport';
-
-const createSnapshotDispatchRequest = (
-  requestId: string,
-  call: SnapshotRpcCall,
-): BrowserDispatchRequest => {
-  // Snapshot is just one namespace on the shared dispatch RPC channel.
-  // Keep this mapping explicit so new runner-side RPC clients can mirror it.
-  return {
-    requestId,
-    namespace: DISPATCH_NAMESPACE_SNAPSHOT,
-    method: call.method,
-    args: call.args,
-  };
-};
-
-/**
- * Send a snapshot RPC request to the container (parent window).
- * The container will forward it to the host via WebSocket RPC.
- *
- * `call` is a {@link SnapshotRpcCall}, so `method` and `args` are validated as a
- * pair — a mismatched argument shape fails to compile at the call site.
- */
-const sendRpcRequest = <T>(call: SnapshotRpcCall): Promise<T> => {
-  const requestId = createRequestId('snapshot-rpc');
-  const rpcTimeout = getRpcTimeout();
-  const dispatchRequest = createSnapshotDispatchRequest(requestId, call);
-
-  return dispatchRpc<T>({
-    requestId,
-    request: dispatchRequest,
-    timeoutMs: rpcTimeout,
-    staleMessage: 'Stale snapshot RPC request ignored.',
-    timeoutMessage: `Snapshot RPC timeout after ${rpcTimeout / 1000}s: ${call.method}`,
-  });
-};
-
-/**
- * Browser snapshot environment that proxies file operations to the host
- * via postMessage RPC through the container.
- */
-export class BrowserSnapshotEnvironment {
-  getVersion(): string {
-    return '1';
-  }
-
-  getHeader(): string {
-    return `${SNAPSHOT_HEADER} v${this.getVersion()}`;
-  }
-
-  async resolveRawPath(_testPath: string, rawPath: string): Promise<string> {
-    return rawPath;
-  }
-
-  async resolvePath(filepath: string): Promise<string> {
-    return sendRpcRequest<string>({
-      method: 'resolveSnapshotPath',
-      args: { testPath: filepath },
-    });
-  }
-
-  async prepareDirectory(): Promise<void> {
-    // Directory creation is handled by saveSnapshotFile on the host
-  }
-
-  async saveSnapshotFile(filepath: string, snapshot: string): Promise<void> {
-    await sendRpcRequest<void>({
-      method: 'saveSnapshotFile',
-      args: { filepath, content: snapshot },
-    });
-  }
-
-  async readSnapshotFile(filepath: string): Promise<string | null> {
-    return sendRpcRequest<string | null>({
-      method: 'readSnapshotFile',
-      args: { filepath },
-    });
-  }
-
-  async removeSnapshotFile(filepath: string): Promise<void> {
-    await sendRpcRequest<void>({
-      method: 'removeSnapshotFile',
-      args: { filepath },
-    });
-  }
-
-  /**
-   * Process stack trace for inline snapshots.
-   * Maps bundled URLs back to original source file paths.
-   */
-  processStackTrace(stack: {
-    file: string;
-    line: number;
-    column: number;
-    method: string;
-  }): { file: string; line: number; column: number; method: string } {
-    const mapped = mapStackFrame(stack);
-    return {
-      file: mapped.file,
-      line: mapped.line,
-      column: mapped.column,
-      method: mapped.method || stack.method,
-    };
-  }
-}

package/src/client/sourceMapSupport.ts

@@ -1,159 +0,0 @@
-import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping';
-import {
-  loadSourceMapWithCache,
-  normalizeJavaScriptUrl,
-  type SourceMapPayload,
-} from '../sourceMap/sourceMapLoader';
-
-// Source map cache: JS URL → TraceMap
-const sourceMapCache = new Map<string, TraceMap | null>();
-const sourceMapPayloadCache = new Map<string, SourceMapPayload | null>();
-
-/**
- * Get TraceMap for specified URL (sync cache lookup)
- */
-const getSourceMap = (url: string): TraceMap | null => {
-  return sourceMapCache.get(url) ?? null;
-};
-
-/**
- * Preload source map for specified JS URL.
- * First tries to extract inline source map from JS code,
- * then falls back to fetching external .map file.
- *
- * @param jsUrl - The URL of the JS file
- * @param force - If true, bypass cache and always fetch fresh source map
- */
-const preloadSourceMap = async (
-  jsUrl: string,
-  force = false,
-): Promise<void> => {
-  const normalizedUrl = normalizeJavaScriptUrl(jsUrl, {
-    origin: window.location.origin,
-  });
-  if (!normalizedUrl) {
-    return;
-  }
-
-  if (!force && sourceMapCache.has(normalizedUrl)) return;
-
-  const sourceMap = await loadSourceMapWithCache({
-    jsUrl: normalizedUrl,
-    cache: sourceMapPayloadCache,
-    force,
-    origin: window.location.origin,
-  });
-
-  sourceMapCache.set(normalizedUrl, sourceMap ? new TraceMap(sourceMap) : null);
-};
-
-/**
- * Get all script URLs currently on the page.
- * Used to detect newly loaded chunk scripts.
- */
-export const getScriptUrls = (): Set<string> => {
-  const scripts = document.querySelectorAll('script[src]');
-  const urls = new Set<string>();
-  for (const script of scripts) {
-    const src = script.getAttribute('src');
-    if (src) {
-      // Normalize to full URL
-      const fullUrl = src.startsWith('http')
-        ? src
-        : `${window.location.origin}${src.startsWith('/') ? '' : '/'}${src}`;
-      urls.add(fullUrl);
-    }
-  }
-  return urls;
-};
-
-/**
- * Find the newly added script URL by comparing script sets.
- * Returns the first new script URL found, or null if none.
- */
-export const findNewScriptUrl = (
-  beforeUrls: Set<string>,
-  afterUrls: Set<string>,
-): string | null => {
-  for (const url of afterUrls) {
-    if (!beforeUrls.has(url)) {
-      return url;
-    }
-  }
-  return null;
-};
-
-/**
- * Preload source map for a test file's chunk URL.
- *
- * Always fetches fresh source map to handle file changes during watch mode.
- *
- * @param chunkUrl - The full URL of the chunk JS file
- */
-export const preloadTestFileSourceMap = async (
-  chunkUrl: string,
-): Promise<void> => {
-  // Always force refresh to ensure we have the latest source map
-  // This handles the case where user saves file during test execution
-  await preloadSourceMap(chunkUrl, true);
-};
-
-/**
- * Preload source map for the runner.js file.
- *
- * This is essential for inline snapshot support because the snapshot code
- * runs in runner.js (which contains @rstest/core/internal/browser-runtime).
- * Without this, stack traces from inline snapshots cannot be mapped back
- * to the original source files.
- */
-export const preloadRunnerSourceMap = async (): Promise<void> => {
-  const runnerUrl = `${window.location.origin}/static/js/runner.js`;
-  await preloadSourceMap(runnerUrl);
-};
-
-/**
- * Stack frame interface matching @vitest/snapshot's format
- */
-interface StackFrame {
-  file: string;
-  line: number;
-  column: number;
-  method?: string;
-}
-
-/**
- * Map a stack frame from bundled URL to original source file.
- * This is used by BrowserSnapshotEnvironment.processStackTrace
- */
-export const mapStackFrame = (frame: StackFrame): StackFrame => {
-  const { file, line, column } = frame;
-
-  const fullUrl = normalizeJavaScriptUrl(file, {
-    origin: window.location.origin,
-  });
-  if (!fullUrl) {
-    return frame;
-  }
-
-  const traceMap = getSourceMap(fullUrl);
-  if (!traceMap) {
-    return frame;
-  }
-
-  const pos = originalPositionFor(traceMap, {
-    line,
-    column: column - 1, // source map uses 0-based column
-  });
-
-  if (pos.source && pos.line != null && pos.column != null) {
-    return {
-      ...frame,
-      file: pos.source,
-      line: pos.line,
-      column: pos.column + 1, // convert back to 1-based
-      method: pos.name || frame.method,
-    };
-  }
-
-  return frame;
-};