@rstest/browser 0.11.6 → 0.11.7

package/src/watchRerunPlanner.ts

@@ -1,88 +0,0 @@
-import { normalize } from 'pathe';
-import type { TestFileInfo } from './protocol';
-
-/**
- * Paths the previous cycle ran that the current file set no longer contains.
- * Core prunes its own state from this, so a file deleted mid-session stops
- * being reported instead of lingering as a passing result.
- */
-export const collectDeletedTestPaths = (
-  previous: TestFileInfo[],
-  current: TestFileInfo[],
-): string[] => {
-  const currentPathSet = new Set(current.map((file) => file.testPath));
-  return previous
-    .map((file) => file.testPath)
-    .filter((testPath) => !currentPathSet.has(testPath));
-};
-
-type WatchPlannerProjectEntry = {
-  project: {
-    name: string;
-  };
-  testFiles: string[];
-};
-
-type WatchRerunPlannerInput = {
-  projectEntries: WatchPlannerProjectEntry[];
-  previousTestFiles: TestFileInfo[];
-  affectedTestFiles: string[];
-};
-
-type WatchRerunPlan = {
-  currentTestFiles: TestFileInfo[];
-  filesChanged: boolean;
-  normalizedAffectedTestFiles: string[];
-  affectedTestFiles: TestFileInfo[];
-};
-
-const serializeTestFiles = (files: TestFileInfo[]): string => {
-  return JSON.stringify(
-    files.map((f) => `${f.projectName}:${f.testPath}`).sort(),
-  );
-};
-
-const normalizeTestFiles = (files: TestFileInfo[]): TestFileInfo[] => {
-  return files.map((file) => ({
-    ...file,
-    testPath: normalize(file.testPath),
-  }));
-};
-
-export const collectWatchTestFiles = (
-  projectEntries: WatchPlannerProjectEntry[],
-): TestFileInfo[] => {
-  return projectEntries.flatMap((entry) =>
-    entry.testFiles.map((testPath) => ({
-      testPath: normalize(testPath),
-      projectName: entry.project.name,
-    })),
-  );
-};
-
-export const planWatchRerun = ({
-  projectEntries,
-  previousTestFiles,
-  affectedTestFiles,
-}: WatchRerunPlannerInput): WatchRerunPlan => {
-  const currentTestFiles = collectWatchTestFiles(projectEntries);
-  const normalizedPrevious = normalizeTestFiles(previousTestFiles);
-  const filesChanged =
-    serializeTestFiles(currentTestFiles) !==
-    serializeTestFiles(normalizedPrevious);
-
-  const normalizedAffectedTestFiles = affectedTestFiles.map((testFile) =>
-    normalize(testFile),
-  );
-  const affectedPathSet = new Set(normalizedAffectedTestFiles);
-  const matchedAffectedFiles = currentTestFiles.filter((file) =>
-    affectedPathSet.has(file.testPath),
-  );
-
-  return {
-    currentTestFiles,
-    filesChanged,
-    normalizedAffectedTestFiles,
-    affectedTestFiles: matchedAffectedFiles,
-  };
-};

package/src/watchRuntime.ts

@@ -1,83 +0,0 @@
-import { FATAL_SIGNALS } from '@rstest/core/internal/browser';
-import { destroyBrowserRuntime, type BrowserRuntime } from './browserRsbuild';
-
-// Only process-wide concerns stay module-level: the runtime handle reused
-// across controller re-entry (config-change restarts), and the signal/exit
-// cleanup that must run once per process. Diff/rerun state lives on
-// `BrowserRuntime.watchState`.
-export type WatchContext = {
-  runtime: BrowserRuntime | null;
-  cleanupRegistered: boolean;
-  cleanupPromise: Promise<void> | null;
-};
-
-export const watchContext: WatchContext = {
-  runtime: null,
-  cleanupRegistered: false,
-  cleanupPromise: null,
-};
-
-/**
- * Tear down the persistent watch runtime (dev servers, provider, browser,
- * WebSocket server). Idempotent, and the single teardown the browser executor's
- * `close` and the process-exit nets both go through.
- */
-export const runWatchRuntimeTeardown = <T>(
-  state: { runtime: T | null; cleanupPromise: Promise<void> | null },
-  destroy: (runtime: T) => Promise<void>,
-): Promise<void> => {
-  if (state.cleanupPromise) {
-    return state.cleanupPromise;
-  }
-
-  state.cleanupPromise = (async () => {
-    if (!state.runtime) {
-      return;
-    }
-
-    await destroy(state.runtime);
-    state.runtime = null;
-  })();
-
-  // The memo is released once this teardown settles, because the state outlives
-  // the session: a config-file change restarts the run against a fresh runtime,
-  // and a memo left resolved from the previous session would make every later
-  // teardown a no-op — leaving the session after that to reuse a runtime built
-  // from the pre-restart config. Idempotency only has to hold within a runtime.
-  return state.cleanupPromise.finally(() => {
-    state.cleanupPromise = null;
-  });
-};
-
-export const cleanupWatchRuntime = (): Promise<void> =>
-  // `cleanupRegistered` is deliberately not re-armed alongside the memo: the
-  // signal nets it installs read `watchContext.runtime` live, so they stay
-  // correct across a restart, and re-registering would stack a fresh set of
-  // listeners on every one.
-  runWatchRuntimeTeardown(watchContext, destroyBrowserRuntime);
-
-export const registerWatchCleanup = (embedded: boolean): void => {
-  if (watchContext.cleanupRegistered) {
-    return;
-  }
-  watchContext.cleanupRegistered = true;
-
-  // Embedded (programmatic) hosts own the process lifecycle; they tear the
-  // session down through the browser executor's `close` instead of signals.
-  if (embedded) {
-    return;
-  }
-
-  // Cleanup-only nets: core's watch loop owns the signal → exit-code path and
-  // awaits the same idempotent `cleanupWatchRuntime` promise through the
-  // browser executor's `close`.
-  for (const signal of FATAL_SIGNALS) {
-    process.once(signal, () => {
-      void cleanupWatchRuntime();
-    });
-  }
-
-  process.once('exit', () => {
-    void cleanupWatchRuntime();
-  });
-};

package/src/watchSignals.ts

@@ -1,93 +0,0 @@
-import {
-  color,
-  type ExecutorInvalidationCallback,
-  logger,
-} from '@rstest/core/internal/browser';
-
-/**
- * The handover between this host's rerun triggers and core's watch-cycle
- * driver. Triggers reach it from three unrelated places — the bundler's
- * dev-compile hook, a CLI shortcut's fanout, the in-page rerun button — and
- * only the ordering inside `signalInvalidation` keeps them from racing each
- * other. Each run branch installs the pieces it owns; nothing here knows which
- * branch is running.
- */
-export type WatchSignals = ReturnType<typeof createWatchSignals>;
-
-export const createWatchSignals = (
-  onInvalidate: ExecutorInvalidationCallback | undefined,
-) => {
-  // The transport-owned rerun trigger, installed by whichever run branch
-  // (headless/headed) is driving this run: resolve this rebuild's scope, then
-  // hand it to core's invalidation subscriber. Populated after the initial
-  // cycle.
-  let dispatchRerun: (() => Promise<void>) | undefined;
-
-  /**
-   * Latest-wins interrupt, installed by the run branch whose in-flight run can
-   * be cut short (headless). Core serializes cycles, so a trigger arriving
-   * mid-cycle would otherwise wait out a run the user has already superseded.
-   */
-  let interruptInFlightRun: (() => Promise<void>) | undefined;
-
-  /**
-   * The cycle core is running for the scope last signalled. Only an explicit
-   * request awaits it, right after it dispatched: a CLI shortcut's
-   * `updateSnapshot` stays flipped only until `requestRerun` resolves, and the
-   * in-page rerun button answers its RPC when the rerun is done. A rejection is
-   * reported here rather than left to an awaiting caller, because compile-driven
-   * triggers have no caller — and a failed cycle must not end the session.
-   */
-  let signalledCycle: Promise<void> | undefined;
-
-  return {
-    setDispatchRerun(fn: () => Promise<void>): void {
-      dispatchRerun = fn;
-    },
-    async runDispatchRerun(): Promise<void> {
-      await dispatchRerun?.();
-    },
-    setInterrupt(fn: () => Promise<void>): void {
-      interruptInFlightRun = fn;
-    },
-    /**
-     * Hand the scope this trigger resolved to core, which resets the cycle state,
-     * calls back into the session's `runCycle`, and finalizes.
-     *
-     * The cycle is deliberately *not* awaited here. Rebuild triggers reach this
-     * from inside the bundler's dev-compile hook, and the bundler keeps no
-     * watcher attached while that hook is pending: anything created or deleted in
-     * that window is never seen, so it never rebuilds and never reruns. Holding
-     * the hook for a whole cycle widens that blind window to the cycle's full
-     * duration, which loses test files added or removed mid-run for good. Core
-     * serializes the cycles itself, so nothing here has to.
-     *
-     * The in-flight run is cut short here rather than at the trigger, because only
-     * this point knows a replacement cycle is actually coming: a trigger that
-     * resolves to no affected files must leave the running cycle alone, or it
-     * finalizes on results it never produced.
-     */
-    async signalInvalidation(
-      fileFilters: string[],
-      /**
-       * Run state this trigger binds to its own paths, taken in the same turn as
-       * the handover — after any interrupt, so no queued cycle can be dequeued in
-       * between and read it. The headed rerun's per-file test-name pattern is the
-       * one such state; core's cycle options cannot carry it, so the only thing
-       * that makes it the property of one cycle is claiming it here.
-       */
-      claimScope?: () => void,
-    ): Promise<void> {
-      await interruptInFlightRun?.();
-      claimScope?.();
-      signalledCycle = Promise.resolve(
-        onInvalidate?.({ isFirstBuild: false, fileFilters }),
-      ).catch((error) => {
-        logger.error(color.red('Browser Mode watch cycle failed:'), error);
-      });
-    },
-    async awaitSignalledCycle(): Promise<void> {
-      await signalledCycle;
-    },
-  };
-};