@rstest/browser 0.11.6 → 0.11.8

package/src/client/api.ts

@@ -1,213 +0,0 @@
-import type { BrowserElementExpect } from '../augmentExpect';
-import type { BrowserLocatorText, BrowserRpcRequest } from '../rpcProtocol';
-import { callBrowserRpc } from './browserRpc';
-import {
-  isLocator,
-  Locator,
-  page,
-  serializeText,
-  setTestIdAttribute,
-} from './locator';
-
-const serializeMatcherText = (value: string | RegExp): BrowserLocatorText => {
-  return serializeText(value);
-};
-
-const createElementExpect = (
-  locator: Locator,
-  isNot: boolean,
-): BrowserElementExpect => {
-  const callExpect = async (
-    method: string,
-    args: unknown[],
-    timeout?: number,
-  ): Promise<void> => {
-    await callBrowserRpc<void>({
-      kind: 'expect',
-      locator: locator.ir,
-      method,
-      args,
-      isNot,
-      timeout,
-    } satisfies Omit<BrowserRpcRequest, 'id' | 'testPath' | 'runId'>);
-  };
-
-  const api: Omit<BrowserElementExpect, 'not'> = {
-    async toBeVisible(options) {
-      await callExpect('toBeVisible', [], options?.timeout);
-    },
-    async toBeHidden(options) {
-      await callExpect('toBeHidden', [], options?.timeout);
-    },
-    async toBeEnabled(options) {
-      await callExpect('toBeEnabled', [], options?.timeout);
-    },
-    async toBeDisabled(options) {
-      await callExpect('toBeDisabled', [], options?.timeout);
-    },
-    async toBeChecked(options) {
-      await callExpect('toBeChecked', [], options?.timeout);
-    },
-    async toBeUnchecked(options) {
-      await callExpect('toBeUnchecked', [], options?.timeout);
-    },
-    async toBeAttached(options) {
-      await callExpect('toBeAttached', [], options?.timeout);
-    },
-    async toBeDetached(options) {
-      await callExpect('toBeDetached', [], options?.timeout);
-    },
-    async toBeEditable(options) {
-      await callExpect('toBeEditable', [], options?.timeout);
-    },
-    async toBeFocused(options) {
-      await callExpect('toBeFocused', [], options?.timeout);
-    },
-    async toBeEmpty(options) {
-      await callExpect('toBeEmpty', [], options?.timeout);
-    },
-    async toBeInViewport(options) {
-      const ratio = options?.ratio;
-      await callExpect(
-        'toBeInViewport',
-        ratio === undefined ? [] : [ratio],
-        options?.timeout,
-      );
-    },
-    async toHaveText(text, options) {
-      await callExpect(
-        'toHaveText',
-        [serializeMatcherText(text)],
-        options?.timeout,
-      );
-    },
-    async toContainText(text, options) {
-      await callExpect(
-        'toContainText',
-        [serializeMatcherText(text)],
-        options?.timeout,
-      );
-    },
-    async toHaveValue(value, options) {
-      await callExpect(
-        'toHaveValue',
-        [serializeMatcherText(value)],
-        options?.timeout,
-      );
-    },
-    async toHaveId(value, options) {
-      await callExpect(
-        'toHaveId',
-        [serializeMatcherText(value)],
-        options?.timeout,
-      );
-    },
-    async toHaveAttribute(name, value, options) {
-      const args =
-        value === undefined ? [name] : [name, serializeMatcherText(value)];
-      await callExpect('toHaveAttribute', args, options?.timeout);
-    },
-    async toHaveClass(value, options) {
-      await callExpect(
-        'toHaveClass',
-        [serializeMatcherText(value)],
-        options?.timeout,
-      );
-    },
-    async toHaveCount(count, options) {
-      await callExpect('toHaveCount', [count], options?.timeout);
-    },
-    async toHaveCSS(name, value, options) {
-      if (typeof name !== 'string' || !name) {
-        throw new TypeError('toHaveCSS expects a non-empty CSS property name');
-      }
-      await callExpect(
-        'toHaveCSS',
-        [name, serializeMatcherText(value)],
-        options?.timeout,
-      );
-    },
-    async toHaveJSProperty(name, value, options) {
-      if (typeof name !== 'string' || !name) {
-        throw new TypeError(
-          'toHaveJSProperty expects a non-empty property name',
-        );
-      }
-      await callExpect('toHaveJSProperty', [name, value], options?.timeout);
-    },
-  };
-
-  const withNot = api as BrowserElementExpect;
-  Object.defineProperty(withNot, 'not', {
-    configurable: false,
-    enumerable: false,
-    get() {
-      return createElementExpect(locator, !isNot);
-    },
-  });
-  return withNot;
-};
-
-const element = (locator: unknown): BrowserElementExpect => {
-  if (!isLocator(locator)) {
-    throw new TypeError(
-      'expect.element() expects a Locator returned from @rstest/browser page.getBy* APIs.',
-    );
-  }
-
-  return createElementExpect(locator, false);
-};
-
-const markBrowserElement = (): void => {
-  Object.defineProperty(element, '__rstestBrowser', {
-    value: true,
-    configurable: false,
-    enumerable: false,
-    writable: false,
-  });
-};
-
-const installExpectElement = (): void => {
-  // In browser runtime, `@rstest/core` exports are proxies that forward property
-  // access to `globalThis.RSTEST_API`. Patch the underlying expect implementation.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const api = (globalThis as any).RSTEST_API as any;
-  const target = api?.expect;
-  if (!target) {
-    throw new Error(
-      'RSTEST_API.expect is not registered yet. This usually indicates @rstest/browser was imported too early.',
-    );
-  }
-
-  if (typeof target.element !== 'function' || !target.element.__rstestBrowser) {
-    markBrowserElement();
-    target.element = element;
-  }
-};
-
-installExpectElement();
-
-export type {
-  BrowserPage,
-  BrowserSerializable,
-  LocatorBlurOptions,
-  LocatorCheckOptions,
-  LocatorClickOptions,
-  LocatorDblclickOptions,
-  LocatorDispatchEventInit,
-  LocatorFillOptions,
-  LocatorFilterOptions,
-  LocatorFocusOptions,
-  LocatorGetByRoleOptions,
-  LocatorHoverOptions,
-  LocatorKeyboardModifier,
-  LocatorMouseButton,
-  LocatorPosition,
-  LocatorPressOptions,
-  LocatorScrollIntoViewIfNeededOptions,
-  LocatorSelectOptionOptions,
-  LocatorSetInputFilesOptions,
-  LocatorTextOptions,
-  LocatorWaitForOptions,
-} from './locator';
-export { Locator, page, setTestIdAttribute };

package/src/client/browserRpc.ts

@@ -1,86 +0,0 @@
-import type { BrowserDispatchRequest } from '../protocol';
-import { DISPATCH_METHOD_RPC, DISPATCH_NAMESPACE_BROWSER } from '../protocol';
-import type { BrowserRpcRequest } from '../rpcProtocol';
-import {
-  createRequestId,
-  dispatchRpc,
-  getRpcTimeout,
-} from './dispatchTransport';
-
-const getUrlSearchParam = (name: string): string | undefined => {
-  try {
-    const value = new URL(window.location.href).searchParams.get(name);
-    return value ?? undefined;
-  } catch {
-    return undefined;
-  }
-};
-
-const getCurrentTestPath = (): string => {
-  const testPath =
-    window.__RSTEST_BROWSER_OPTIONS__?.testFile ??
-    getUrlSearchParam('testFile');
-  if (!testPath) {
-    throw new Error(
-      'Browser RPC requires testFile in __RSTEST_BROWSER_OPTIONS__. ' +
-        'This usually indicates the runner iframe was not configured by the container or URL.',
-    );
-  }
-  return testPath;
-};
-
-const getCurrentRunId = (): string => {
-  const runId =
-    window.__RSTEST_BROWSER_OPTIONS__?.runId ?? getUrlSearchParam('runId');
-  if (!runId) {
-    throw new Error(
-      'Browser RPC requires runId in __RSTEST_BROWSER_OPTIONS__. ' +
-        'This usually indicates the runner iframe URL/config is stale or incomplete.',
-    );
-  }
-  return runId;
-};
-
-const createBrowserDispatchRequest = (
-  requestId: string,
-  request: BrowserRpcRequest,
-): BrowserDispatchRequest => {
-  return {
-    requestId,
-    namespace: DISPATCH_NAMESPACE_BROWSER,
-    method: DISPATCH_METHOD_RPC,
-    args: request,
-    target: {
-      testFile: request.testPath,
-    },
-  };
-};
-
-export const callBrowserRpc = async <T>(
-  payload: Omit<BrowserRpcRequest, 'id' | 'testPath' | 'runId'>,
-): Promise<T> => {
-  if (
-    payload.kind === 'config' &&
-    window.__RSTEST_BROWSER_OPTIONS__?.mode === 'collect'
-  ) {
-    return undefined as T;
-  }
-
-  const id = createRequestId('browser-rpc');
-  const rpcTimeout = getRpcTimeout();
-  const request: BrowserRpcRequest = {
-    id,
-    testPath: getCurrentTestPath(),
-    runId: getCurrentRunId(),
-    ...payload,
-  };
-  const dispatchRequest = createBrowserDispatchRequest(id, request);
-
-  return dispatchRpc<T>({
-    requestId: id,
-    request: dispatchRequest,
-    timeoutMs: rpcTimeout,
-    staleMessage: 'Stale browser RPC request ignored.',
-    timeoutMessage: `Browser RPC timeout after ${rpcTimeout / 1000}s: ${request.kind}.${request.method}`,
-  });
-};

package/src/client/dispatchTransport.ts

@@ -1,240 +0,0 @@
-import type {
-  BrowserDispatchRequest,
-  BrowserDispatchResponse,
-} from '../protocol';
-import {
-  DISPATCH_MESSAGE_TYPE,
-  DISPATCH_NAMESPACE_RUNNER,
-  DISPATCH_RESPONSE_TYPE,
-  DISPATCH_RPC_BRIDGE_NAME,
-  DISPATCH_RPC_REQUEST_TYPE,
-} from '../protocol';
-
-// Coincidentally equal to the host-side RUNNER_FRAMES_READY_TIMEOUT_MS and the
-// runner's CONFIG_WAIT_TIMEOUT_MS (entry.ts), but a semantically distinct
-// default in a different runtime, so deliberately not shared with them.
-const DEFAULT_RPC_TIMEOUT_MS = 30_000;
-
-export const getRpcTimeout = (): number => {
-  return (
-    window.__RSTEST_BROWSER_OPTIONS__?.rpcTimeout ?? DEFAULT_RPC_TIMEOUT_MS
-  );
-};
-
-const pendingRequests = new Map<
-  string,
-  {
-    resolve: (value: unknown) => void;
-    reject: (error: Error) => void;
-    staleMessage: string;
-  }
->();
-
-let requestIdCounter = 0;
-let messageListenerInitialized = false;
-
-export const createRequestId = (prefix: string): string => {
-  if (typeof globalThis.crypto?.randomUUID === 'function') {
-    return globalThis.crypto.randomUUID();
-  }
-
-  requestIdCounter += 1;
-  return `${prefix}-${Date.now().toString(36)}-${requestIdCounter.toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-};
-
-/**
- * Build a runner-lifecycle dispatch request.
- *
- * Lifecycle events (`file-ready`, `suite-start`, `suite-result`, `case-start`)
- * share the dispatch-rpc envelope but are delivered fire-and-forget via
- * {@link sendRunnerLifecycle}, so the request id only needs to be unique — it is
- * produced by the shared {@link createRequestId} factory rather than a bespoke
- * per-runner counter.
- */
-export const createRunnerLifecycleRequest = (
-  method: string,
-  args: unknown,
-): BrowserDispatchRequest => ({
-  requestId: createRequestId('runner-lifecycle'),
-  namespace: DISPATCH_NAMESPACE_RUNNER,
-  method,
-  args,
-});
-
-/**
- * Deliver a runner-lifecycle request fire-and-forget.
- *
- * Unlike {@link dispatchRpc}, this never awaits, unwraps, id-matches, or times
- * out: the host echoes a response but the runner ignores it. Failures surface
- * only through the optional `onError` hook (debug logging at the call site),
- * keeping the hot test loop non-blocking.
- */
-export const sendRunnerLifecycle = (
-  request: BrowserDispatchRequest,
-  onError?: (error: unknown) => void,
-): void => {
-  if (window.parent === window) {
-    const dispatchBridge = window[DISPATCH_RPC_BRIDGE_NAME];
-    if (!dispatchBridge) {
-      onError?.(
-        new Error('Dispatch RPC bridge is not available in top-level runner.'),
-      );
-      return;
-    }
-    void Promise.resolve(dispatchBridge(request)).catch((error: unknown) => {
-      onError?.(error);
-    });
-    return;
-  }
-
-  window.parent.postMessage(
-    {
-      type: DISPATCH_MESSAGE_TYPE,
-      payload: {
-        type: DISPATCH_RPC_REQUEST_TYPE,
-        payload: request,
-      },
-    },
-    '*',
-  );
-};
-
-const isDispatchResponse = (
-  value: unknown,
-): value is BrowserDispatchResponse => {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'requestId' in value &&
-    typeof (value as { requestId: unknown }).requestId === 'string'
-  );
-};
-
-const settlePendingRequest = (response: BrowserDispatchResponse): void => {
-  const pending = pendingRequests.get(response.requestId);
-  if (!pending) {
-    return;
-  }
-
-  pendingRequests.delete(response.requestId);
-  if (response.stale) {
-    pending.reject(new Error(pending.staleMessage));
-    return;
-  }
-  if (response.error) {
-    pending.reject(new Error(response.error));
-    return;
-  }
-  pending.resolve(response.result);
-};
-
-const initMessageListener = (): void => {
-  if (messageListenerInitialized) {
-    return;
-  }
-  messageListenerInitialized = true;
-
-  window.addEventListener('message', (event: MessageEvent) => {
-    if (event.data?.type === DISPATCH_RESPONSE_TYPE) {
-      settlePendingRequest(event.data.payload as BrowserDispatchResponse);
-    }
-  });
-};
-
-const unwrapDispatchBridgeResult = <T>(
-  requestId: string,
-  result: unknown,
-  staleMessage: string,
-): T => {
-  if (!isDispatchResponse(result)) {
-    throw new Error('Invalid dispatch bridge response payload.');
-  }
-
-  if (result.requestId !== requestId) {
-    throw new Error(
-      `Mismatched dispatch response id: expected ${requestId}, got ${result.requestId}`,
-    );
-  }
-  if (result.stale) {
-    throw new Error(staleMessage);
-  }
-  if (result.error) {
-    throw new Error(result.error);
-  }
-  return result.result as T;
-};
-
-export const dispatchRpc = <T>({
-  requestId,
-  request,
-  timeoutMs,
-  timeoutMessage,
-  staleMessage,
-}: {
-  requestId: string;
-  request: BrowserDispatchRequest;
-  timeoutMs: number;
-  timeoutMessage: string;
-  staleMessage: string;
-}): Promise<T> => {
-  if (window.parent === window) {
-    const dispatchBridge = window[DISPATCH_RPC_BRIDGE_NAME];
-    if (!dispatchBridge) {
-      throw new Error(
-        'Dispatch RPC bridge is not available in top-level runner.',
-      );
-    }
-
-    return new Promise<T>((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        reject(new Error(timeoutMessage));
-      }, timeoutMs);
-
-      const call = Promise.resolve(dispatchBridge(request)).then((result) =>
-        unwrapDispatchBridgeResult<T>(requestId, result, staleMessage),
-      );
-
-      call
-        .then((result) => {
-          clearTimeout(timeoutId);
-          resolve(result);
-        })
-        .catch((error) => {
-          clearTimeout(timeoutId);
-          reject(error instanceof Error ? error : new Error(String(error)));
-        });
-    });
-  }
-
-  initMessageListener();
-
-  return new Promise<T>((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      pendingRequests.delete(requestId);
-      reject(new Error(timeoutMessage));
-    }, timeoutMs);
-
-    pendingRequests.set(requestId, {
-      staleMessage,
-      resolve: (value) => {
-        clearTimeout(timeoutId);
-        resolve(value as T);
-      },
-      reject: (error) => {
-        clearTimeout(timeoutId);
-        reject(error);
-      },
-    });
-
-    window.parent.postMessage(
-      {
-        type: DISPATCH_MESSAGE_TYPE,
-        payload: {
-          type: DISPATCH_RPC_REQUEST_TYPE,
-          payload: request,
-        },
-      },
-      '*',
-    );
-  });
-};