@rstest/browser 0.11.5 → 0.11.7

package/src/concurrency.ts

@@ -1,65 +0,0 @@
-import {
-  getNumCpus,
-  parseWorkers,
-  resolveWorkerCount,
-} from '@rstest/core/internal/browser';
-import type { Rstest } from '@rstest/core/internal/browser';
-
-// Re-export the shared worker primitives so existing consumers (and unit tests
-// importing from `../src/concurrency`) keep a stable import surface.
-export { getNumCpus, parseWorkers };
-
-// The browser headless path caps CPU-derived workers at 12 and halves that
-// capped base in watch; the shared `resolveWorkerCount` helper owns the
-// `maxWorkers` override and workload clamp.
-const DEFAULT_MAX_HEADLESS_WORKERS = 12;
-
-type HeadlessConcurrencyContext = Pick<Rstest, 'command'> & {
-  normalizedConfig: {
-    pool: {
-      maxWorkers?: string | number;
-    };
-  };
-};
-
-const resolveHeadlessWorkerCount = ({
-  command,
-  maxWorkers,
-  totalTasks,
-  numCpus = getNumCpus(),
-}: {
-  command: HeadlessConcurrencyContext['command'];
-  maxWorkers?: string | number;
-  totalTasks: number;
-  numCpus?: number;
-}): number => {
-  const base = Math.max(Math.min(DEFAULT_MAX_HEADLESS_WORKERS, numCpus - 1), 1);
-  return resolveWorkerCount({
-    command,
-    maxWorkers,
-    totalTasks,
-    recommended: base,
-    watchRecommended: Math.max(Math.floor(base / 2), 1),
-    numCpus,
-  });
-};
-
-export const resolveDefaultHeadlessWorkers = (
-  command: HeadlessConcurrencyContext['command'],
-  numCpus: number = getNumCpus(),
-): number =>
-  resolveHeadlessWorkerCount({
-    command,
-    totalTasks: Number.POSITIVE_INFINITY,
-    numCpus,
-  });
-
-export const getHeadlessConcurrency = (
-  context: HeadlessConcurrencyContext,
-  totalTests: number,
-): number =>
-  resolveHeadlessWorkerCount({
-    command: context.command,
-    maxWorkers: context.normalizedConfig.pool.maxWorkers,
-    totalTasks: totalTests,
-  });

package/src/configValidation.ts

@@ -1,263 +0,0 @@
-import {
-  browserIgnoredRuntimeConfigKeys,
-  color,
-  logger,
-  type RstestContext,
-  type RuntimeConfig,
-} from '@rstest/core/internal/browser';
-import { resolveBrowserViewportPreset } from './viewportPresets';
-
-type BrowserProjectConfig =
-  RstestContext['projects'][number]['normalizedConfig'];
-
-/**
- * Per-key warning for a browser-ignored RuntimeConfig field, keyed by the exact
- * RuntimeConfig keys the `executorCapabilities` table marks 'ignored-warn' /
- * 'stripped'. {@link reportUnsupportedBrowserOptions} iterates the table's
- * {@link browserIgnoredRuntimeConfigKeys} and looks each key up here, so the
- * warnings are genuinely table-driven.
- */
-const ignoredKeyWarnings: Partial<
-  Record<
-    keyof RuntimeConfig,
-    {
-      /** True when the project's value is non-default (worth warning about). */
-      isNonDefault: (config: BrowserProjectConfig) => boolean;
-      message: (config: BrowserProjectConfig) => string;
-      /**
-       * Warn only on browser-only runs. Global-only config (copied onto every
-       * project) that a mixed repo may legitimately set for its node projects.
-       */
-      browserOnly?: boolean;
-    }
-  >
-> = {
-  testEnvironment: {
-    isNonDefault: (config) => config.testEnvironment.name !== 'node',
-    message: (config) =>
-      `Ignoring testEnvironment '${config.testEnvironment.name}' in browser ` +
-      'mode: the browser itself is the test environment.',
-  },
-  isolate: {
-    isNonDefault: (config) => config.isolate === false,
-    message: () =>
-      'Ignoring isolate: false in browser mode: each test file still runs in ' +
-      'a fresh context.',
-    browserOnly: true,
-  },
-  federation: {
-    isNonDefault: (config) => config.federation === true,
-    message: () =>
-      'Ignoring federation in browser mode: it only applies to the Node runner.',
-    browserOnly: true,
-  },
-  detectAsyncLeaks: {
-    isNonDefault: (config) => config.detectAsyncLeaks === true,
-    message: () =>
-      'Ignoring detectAsyncLeaks in browser mode: it relies on node ' +
-      'async_hooks.',
-  },
-  logHeapUsage: {
-    isNonDefault: (config) => config.logHeapUsage === true,
-    message: () => 'Ignoring logHeapUsage in browser mode.',
-  },
-};
-
-/**
- * Browser-ignored keys handled outside the generic warn loop: `coverage` is
- * 'stripped' but gets the dedicated provider check in
- * {@link reportUnsupportedBrowserOptions} (a v8 hard error on browser-only
- * runs, a warning in mixed runs), not a plain "set → warn".
- */
-const speciallyHandledIgnoredKeys: (keyof RuntimeConfig)[] = ['coverage'];
-
-/**
- * Every browser-ignored RuntimeConfig key this module checks — the union of the
- * warn descriptors and the specially-handled keys. Exported for the lockstep
- * test that asserts it covers {@link browserIgnoredRuntimeConfigKeys}.
- */
-export const browserValidatedIgnoredKeys: (keyof RuntimeConfig)[] = [
-  ...(Object.keys(ignoredKeyWarnings) as (keyof RuntimeConfig)[]),
-  ...speciallyHandledIgnoredKeys,
-];
-
-// Anti-#1389 lockstep (runs at module load): fail loudly if the
-// `executorCapabilities` table gains an 'ignored-warn' / 'stripped' browser key
-// that this validation does not cover, instead of it becoming a silent no-op.
-const assertIgnoredKeysCovered = (): void => {
-  const covered = new Set<string>(browserValidatedIgnoredKeys);
-  const uncovered = browserIgnoredRuntimeConfigKeys.filter(
-    (key) => !covered.has(key),
-  );
-  if (uncovered.length > 0) {
-    throw new Error(
-      'Browser config validation is out of sync with executorCapabilities: ' +
-        `no check for ignored RuntimeConfig field(s): ${uncovered.join(', ')}. ` +
-        'Add a descriptor to `ignoredKeyWarnings` or `speciallyHandledIgnoredKeys`.',
-    );
-  }
-};
-assertIgnoredKeysCovered();
-
-const SUPPORTED_PROVIDERS = ['playwright'] as const;
-
-const isPlainObject = (value: unknown): value is Record<string, unknown> => {
-  return Object.prototype.toString.call(value) === '[object Object]';
-};
-
-const validateViewport = (viewport: unknown): void => {
-  if (viewport == null) {
-    return;
-  }
-
-  if (typeof viewport === 'string') {
-    const presetId = viewport.trim();
-    if (!presetId) {
-      throw new Error('browser.viewport must be a non-empty preset id.');
-    }
-    if (!resolveBrowserViewportPreset(presetId)) {
-      throw new Error(
-        `browser.viewport must be a valid preset id. Received: ${viewport}`,
-      );
-    }
-    return;
-  }
-
-  if (isPlainObject(viewport)) {
-    const width = (viewport as any).width;
-    const height = (viewport as any).height;
-    if (!Number.isFinite(width) || width <= 0) {
-      throw new Error('browser.viewport.width must be a positive number.');
-    }
-    if (!Number.isFinite(height) || height <= 0) {
-      throw new Error('browser.viewport.height must be a positive number.');
-    }
-    return;
-  }
-
-  throw new Error(
-    'browser.viewport must be either a preset id or { width, height }.',
-  );
-};
-
-/**
- * Warn (or hard-error) on node-only config that is silently ignored under
- * `browser.enabled`. Prevents the #1389 class of silent no-ops. The per-key
- * warnings are driven by the `executorCapabilities` table: the loop iterates
- * {@link browserIgnoredRuntimeConfigKeys} and looks each key up in
- * {@link ignoredKeyWarnings}; `coverage` (and `pool`, which is not a
- * RuntimeConfig field) keep bespoke handling below.
- *
- * Scoping rules: `coverage` and `isolate` are global-only config copied onto
- * every project, so a v8 hard-error / isolate warning is gated to browser-only
- * runs — a mixed repo legitimately sets them for its node projects and must not
- * get unsilenceable noise on a correct configuration.
- */
-const reportUnsupportedBrowserOptions = (context: RstestContext): void => {
-  const browserProjects = context.projects.filter(
-    (project) => project.normalizedConfig.browser.enabled,
-  );
-  if (browserProjects.length === 0) {
-    return;
-  }
-  const isBrowserOnlyRun = browserProjects.length === context.projects.length;
-
-  // `coverage`, `pool` and `isolate` are global-only config (not settable per
-  // project), read from the root normalized config.
-  const globalConfig = context.normalizedConfig;
-
-  const { coverage } = globalConfig;
-  // `list` never collects coverage, so the v8 guard must not block listing.
-  if (
-    context.command !== 'list' &&
-    coverage.enabled &&
-    coverage.provider === 'v8'
-  ) {
-    if (isBrowserOnlyRun) {
-      throw new Error(
-        "Coverage provider 'v8' is not supported in browser mode: browser " +
-          'projects produce no v8 coverage. Use the default istanbul provider ' +
-          "(coverage.provider: 'istanbul') for browser coverage.",
-      );
-    }
-    logger.warn(
-      color.yellow(
-        "Coverage provider 'v8' produces no coverage for browser project " +
-          "files; use the 'istanbul' provider to collect browser coverage. " +
-          'Node projects will still use v8.',
-      ),
-    );
-  }
-
-  // Node-only options silently ignored under browser.enabled. Collected into a
-  // Set so each distinct warning is emitted once, not per project.
-  const warnings = new Set<string>();
-
-  if (globalConfig.pool.type !== 'forks') {
-    warnings.add(
-      `Ignoring pool.type '${globalConfig.pool.type}' in browser mode.`,
-    );
-  }
-  if (globalConfig.pool.execArgv && globalConfig.pool.execArgv.length > 0) {
-    warnings.add('Ignoring pool.execArgv in browser mode.');
-  }
-  // Table-driven warnings: for every browser-ignored RuntimeConfig key, warn
-  // when a browser project sets it to a non-default value. `isolate` (and any
-  // other global-only key) is copied onto every project, so reading it per
-  // project matches the old global read; the Set dedupes the repeats.
-  for (const project of browserProjects) {
-    const config = project.normalizedConfig;
-    for (const key of browserIgnoredRuntimeConfigKeys) {
-      const descriptor = ignoredKeyWarnings[key];
-      if (!descriptor) {
-        // Specially handled elsewhere (e.g. `coverage`).
-        continue;
-      }
-      if (descriptor.browserOnly && !isBrowserOnlyRun) {
-        continue;
-      }
-      if (descriptor.isNonDefault(config)) {
-        warnings.add(descriptor.message(config));
-      }
-    }
-  }
-
-  for (const message of warnings) {
-    logger.warn(color.yellow(message));
-  }
-};
-
-export const validateBrowserConfig = (context: RstestContext): void => {
-  for (const project of context.projects) {
-    const { browser, output } = project.normalizedConfig;
-    if (!browser.enabled) {
-      continue;
-    }
-
-    if (!browser.provider) {
-      throw new Error(
-        'browser.provider is required when browser.enabled is true.',
-      );
-    }
-
-    if (!SUPPORTED_PROVIDERS.includes(browser.provider)) {
-      throw new Error(
-        `browser.provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}.`,
-      );
-    }
-
-    validateViewport(browser.viewport);
-
-    if (!isPlainObject(browser.providerOptions)) {
-      throw new Error('browser.providerOptions must be a plain object.');
-    }
-
-    if (output?.bundleDependencies === false) {
-      throw new Error(
-        'output.bundleDependencies false is not supported in browser mode.',
-      );
-    }
-  }
-
-  reportUnsupportedBrowserOptions(context);
-};

package/src/dispatchCapabilities.ts

@@ -1,182 +0,0 @@
-import type { Reporter } from '@rstest/core/internal/browser';
-import { HostDispatchRouter } from './dispatchRouter';
-import {
-  DISPATCH_NAMESPACE_RUNNER,
-  DISPATCH_NAMESPACE_SNAPSHOT,
-} from './protocol';
-import type {
-  BrowserClientMessage,
-  BrowserDispatchHandler,
-  BrowserDispatchRequest,
-  RunnerDispatchMethod,
-  SnapshotRpcMethod,
-  SnapshotRpcMethodArgs,
-  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> =
-  NonNullable<Reporter[THook]> extends (...args: infer TArgs) => unknown
-    ? TArgs[0]
-    : never;
-
-type RunnerDispatchFileReadyPayload = ReporterHookArg<'onTestFileReady'>;
-type RunnerDispatchSuiteStartPayload = ReporterHookArg<'onTestSuiteStart'>;
-type RunnerDispatchSuiteResultPayload = ReporterHookArg<'onTestSuiteResult'>;
-type RunnerDispatchCaseStartPayload = ReporterHookArg<'onTestCaseStart'>;
-
-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;
-};
-
-/**
- * Builds a typed {@link SnapshotRpcRequest} from the untrusted wire envelope,
- * one builder per method. Keyed by {@link SnapshotRpcMethod}, so adding or
- * renaming a method in the union forces a matching entry here — a stale name
- * becomes a compile error instead of silently falling through to `null`. The
- * `args` casts are the unavoidable trust boundary for inbound wire data.
- */
-const snapshotRequestBuilders: {
-  [M in SnapshotRpcMethod]: (
-    id: string,
-    args: BrowserDispatchRequest['args'],
-  ) => Extract<SnapshotRpcRequest, { method: M }>;
-} = {
-  resolveSnapshotPath: (id, args) => ({
-    id,
-    method: 'resolveSnapshotPath',
-    args: args as SnapshotRpcMethodArgs['resolveSnapshotPath'],
-  }),
-  readSnapshotFile: (id, args) => ({
-    id,
-    method: 'readSnapshotFile',
-    args: args as SnapshotRpcMethodArgs['readSnapshotFile'],
-  }),
-  saveSnapshotFile: (id, args) => ({
-    id,
-    method: 'saveSnapshotFile',
-    args: args as SnapshotRpcMethodArgs['saveSnapshotFile'],
-  }),
-  removeSnapshotFile: (id, args) => ({
-    id,
-    method: 'removeSnapshotFile',
-    args: args as SnapshotRpcMethodArgs['removeSnapshotFile'],
-  }),
-};
-
-const toSnapshotRpcRequest = (
-  request: BrowserDispatchRequest,
-): SnapshotRpcRequest | null => {
-  const builder = snapshotRequestBuilders[
-    request.method as SnapshotRpcMethod
-  ] as
-    | ((id: string, args: BrowserDispatchRequest['args']) => SnapshotRpcRequest)
-    | undefined;
-  return builder ? builder(request.requestId, request.args) : null;
-};
-
-export const createHostDispatchRouter = ({
-  routerOptions,
-  runnerCallbacks,
-  runSnapshotRpc,
-  extensionHandlers,
-  onDuplicateNamespace,
-}: CreateHostDispatchRouterOptions): HostDispatchRouter => {
-  const router = new HostDispatchRouter(routerOptions);
-
-  // Keyed by RunnerDispatchMethod so adding a runner method to that union forces
-  // a handler entry here (a missing key is a compile error) — the previous
-  // `switch` with `default: break` silently dropped unhandled methods. The
-  // `args` casts are checked against each callback's parameter type, so a wrong
-  // payload type also fails to compile.
-  const runnerMethodHandlers: {
-    [M in RunnerDispatchMethod]: (
-      args: BrowserDispatchRequest['args'],
-    ) => Promise<void>;
-  } = {
-    'file-start': (args) =>
-      runnerCallbacks.onTestFileStart(args as RunnerPayload<'file-start'>),
-    'file-ready': (args) =>
-      runnerCallbacks.onTestFileReady(args as RunnerDispatchFileReadyPayload),
-    'suite-start': (args) =>
-      runnerCallbacks.onTestSuiteStart(args as RunnerDispatchSuiteStartPayload),
-    'suite-result': (args) =>
-      runnerCallbacks.onTestSuiteResult(
-        args as RunnerDispatchSuiteResultPayload,
-      ),
-    'case-start': (args) =>
-      runnerCallbacks.onTestCaseStart(args as RunnerDispatchCaseStartPayload),
-    'case-result': (args) =>
-      runnerCallbacks.onTestCaseResult(args as RunnerPayload<'case-result'>),
-    'file-complete': (args) =>
-      runnerCallbacks.onTestFileComplete(
-        args as RunnerPayload<'file-complete'>,
-      ),
-    log: (args) => runnerCallbacks.onLog(args as RunnerPayload<'log'>),
-    fatal: (args) => runnerCallbacks.onFatal(args as RunnerPayload<'fatal'>),
-  };
-
-  router.register(
-    DISPATCH_NAMESPACE_RUNNER,
-    async (request: BrowserDispatchRequest) => {
-      // `request.method` is untrusted wire data, so the lookup may miss. Unknown
-      // methods are ignored for forward-compatibility with newer runners,
-      // matching the previous `default: break`.
-      await runnerMethodHandlers[request.method as RunnerDispatchMethod]?.(
-        request.args,
-      );
-    },
-  );
-
-  router.register(
-    DISPATCH_NAMESPACE_SNAPSHOT,
-    async (request: BrowserDispatchRequest) => {
-      const snapshotRequest = toSnapshotRpcRequest(request);
-      if (!snapshotRequest) {
-        return undefined;
-      }
-      return runSnapshotRpc(snapshotRequest);
-    },
-  );
-
-  for (const [namespace, handler] of extensionHandlers ?? []) {
-    if (router.has(namespace)) {
-      onDuplicateNamespace?.(namespace);
-      continue;
-    }
-
-    router.register(namespace, handler);
-  }
-
-  return router;
-};

package/src/dispatchRouter.ts

@@ -1,82 +0,0 @@
-import type {
-  BrowserDispatchRequest,
-  BrowserDispatchResponse,
-} from './protocol';
-
-type DispatchHandler = (request: BrowserDispatchRequest) => Promise<unknown>;
-
-type HostDispatchRouterOptions = {
-  isRunTokenStale?: (runToken: number) => boolean;
-  onStale?: (request: BrowserDispatchRequest) => void;
-};
-
-const toErrorMessage = (error: unknown): string => {
-  return error instanceof Error ? error.message : String(error);
-};
-
-/**
- * Host-side routing layer for dispatch envelopes.
- * Capabilities are registered by namespace, while routing stays transport-agnostic.
- */
-export class HostDispatchRouter {
-  private handlers = new Map<string, DispatchHandler>();
-  private options: HostDispatchRouterOptions;
-
-  constructor(options?: HostDispatchRouterOptions) {
-    this.options = options ?? {};
-  }
-
-  register(namespace: string, handler: DispatchHandler): void {
-    this.handlers.set(namespace, handler);
-  }
-
-  unregister(namespace: string): void {
-    this.handlers.delete(namespace);
-  }
-
-  has(namespace: string): boolean {
-    return this.handlers.has(namespace);
-  }
-
-  async dispatch(
-    request: BrowserDispatchRequest,
-  ): Promise<BrowserDispatchResponse> {
-    const runToken = request.runToken;
-    if (
-      typeof runToken === 'number' &&
-      this.options.isRunTokenStale?.(runToken)
-    ) {
-      // Return a stale marker so callers can drop old-run writes safely.
-      this.options.onStale?.(request);
-      return {
-        requestId: request.requestId,
-        runToken,
-        stale: true,
-      };
-    }
-
-    const handler = this.handlers.get(request.namespace);
-    if (!handler) {
-      return {
-        requestId: request.requestId,
-        runToken,
-        error: `No dispatch handler registered for namespace "${request.namespace}"`,
-      };
-    }
-
-    try {
-      const result = await handler(request);
-      return {
-        requestId: request.requestId,
-        runToken,
-        result,
-      };
-    } catch (error) {
-      return {
-        requestId: request.requestId,
-        runToken,
-        error: toErrorMessage(error),
-      };
-    }
-  }
-}

package/src/env.d.ts

@@ -1,54 +0,0 @@
-import { DISPATCH_MESSAGE_TYPE, DISPATCH_RPC_BRIDGE_NAME } from './protocol';
-import type {
-  BrowserClientMessage,
-  BrowserDispatchRequest,
-  BrowserHostConfig,
-} from './protocol';
-
-declare module '@rstest/browser-manifest' {
-  export type ManifestProjectConfig = {
-    name: string;
-    environmentName: string;
-    projectRoot: string;
-  };
-
-  export type ManifestTestContext = {
-    getTestKeys: () => string[];
-    loadTest: (key: string) => Promise<unknown>;
-    projectRoot: string;
-  };
-
-  export const projects: ManifestProjectConfig[];
-
-  export const projectSetupLoaders: Record<
-    string,
-    Array<() => Promise<unknown>>
-  >;
-
-  export const projectTestContexts: Record<string, ManifestTestContext>;
-
-  // Backward compatibility exports
-  export const projectConfig: ManifestProjectConfig | undefined;
-  export const setupLoaders: Array<() => Promise<unknown>>;
-  export const getTestKeys: () => string[];
-  export const loadTest: (key: string) => Promise<unknown>;
-}
-
-declare global {
-  const RSTEST_VERSION: string;
-
-  interface Window {
-    __RSTEST_BROWSER_OPTIONS__?: BrowserHostConfig;
-    // Keyed by the sentinel constants so the declared global name and the
-    // constant are the same source — renaming a constant moves this key with it,
-    // and every `window[CONST]` access site stays in lockstep automatically.
-    [DISPATCH_MESSAGE_TYPE]?: (message: BrowserClientMessage) => void;
-    [DISPATCH_RPC_BRIDGE_NAME]?: (
-      request: BrowserDispatchRequest,
-    ) => Promise<unknown>;
-    __rstest_container_dispatch__?: (data: unknown) => void;
-    __rstest_container_on__?: (data: unknown) => void;
-    __RSTEST_DONE__?: boolean;
-    __RSTEST_TEST_FILES__?: string[];
-  }
-}

package/src/headedSerialTaskQueue.ts

@@ -1,23 +0,0 @@
-type HeadedSerialTask = () => Promise<void>;
-
-type HeadedSerialTaskQueue = {
-  enqueue: (task: HeadedSerialTask) => Promise<void>;
-};
-
-/**
- * Serializes headed browser file execution so only one task runs at a time.
- * The queue keeps draining even if an earlier task rejects.
- */
-export const createHeadedSerialTaskQueue = (): HeadedSerialTaskQueue => {
-  let queue: Promise<void> = Promise.resolve();
-
-  const enqueue = (task: HeadedSerialTask): Promise<void> => {
-    const next = queue.then(task);
-    queue = next.catch(() => {});
-    return next;
-  };
-
-  return {
-    enqueue,
-  };
-};