@rstest/browser 0.11.5 → 0.11.7

package/src/headlessLatestRerunScheduler.ts

@@ -1,76 +0,0 @@
-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 const createHeadlessLatestRerunScheduler = <TFile, TRun>(
-  options: HeadlessLatestRerunSchedulerOptions<TFile, TRun>,
-): HeadlessLatestRerunScheduler<TFile> => {
-  let pendingFiles: TFile[] | null = null;
-  let draining: Promise<void> | null = null;
-  let latestEnqueueVersion = 0;
-
-  const runDrainLoop = async (): Promise<void> => {
-    while (pendingFiles) {
-      const nextFiles = pendingFiles;
-      pendingFiles = null;
-
-      try {
-        await options.runFiles(nextFiles);
-      } catch (error) {
-        try {
-          await options.onError?.(error);
-        } catch {
-          // Keep draining even if error reporting fails.
-        }
-      }
-    }
-  };
-
-  const ensureDrainLoop = (): void => {
-    if (draining) {
-      return;
-    }
-
-    draining = runDrainLoop().finally(() => {
-      draining = null;
-    });
-  };
-
-  return {
-    async enqueueLatest(files: TFile[]): Promise<void> {
-      const enqueueVersion = ++latestEnqueueVersion;
-      const activeRun = options.getActiveRun();
-      if (activeRun && !options.isRunCancelled(activeRun)) {
-        options.onInterrupt?.(activeRun);
-        options.invalidateActiveRun();
-        await options.interruptActiveRun(activeRun);
-      }
-
-      // If a newer enqueue arrived while interrupting, drop this stale payload.
-      if (enqueueVersion !== latestEnqueueVersion) {
-        return;
-      }
-
-      pendingFiles = files;
-      ensureDrainLoop();
-    },
-    async whenIdle(): Promise<void> {
-      await draining;
-    },
-  };
-};

package/src/headlessTransport.ts

@@ -1,28 +0,0 @@
-import type {
-  BrowserClientMessage,
-  BrowserDispatchRequest,
-  BrowserDispatchResponse,
-} from './protocol';
-import { DISPATCH_MESSAGE_TYPE, DISPATCH_RPC_BRIDGE_NAME } 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 const attachHeadlessRunnerTransport = async (
-  page: BrowserProviderPage,
-  handlers: HeadlessRunnerTransportHandlers,
-): Promise<void> => {
-  // Fire-and-forget runner lifecycle messages (ready/log/result/fatal).
-  await page.exposeFunction(DISPATCH_MESSAGE_TYPE, handlers.onDispatchMessage);
-  // Request/response RPC bridge shared by snapshot and future namespaces.
-  await page.exposeFunction(DISPATCH_RPC_BRIDGE_NAME, handlers.onDispatchRpc);
-};