@r0hitsharma/http-client-msw 0.12.0-rohit-fork-ci.1

package/src/worker-options.ts

@@ -0,0 +1,108 @@
+import type { StartOptions } from 'msw/browser';
+
+import { resolveWorkerScriptUrl } from './base-url.js';
+
+/**
+ * The browser entry's decisions, factored out of `browser.ts` so they are
+ * testable without a service worker: a vitest run cannot register one, but it
+ * can assert the options that would be passed and the start-once behaviour.
+ */
+
+export type MockWorkerOptions = {
+  /**
+   * The app's **public base path** — `import.meta.env.BASE_URL` under Vite — used
+   * to locate the worker script for a subpath deployment. This is not the API
+   * base from `createMockApi`: the script is served by the app, the API is
+   * whatever the app talks to.
+   *
+   * @default '/'
+   */
+  baseUrl?: string;
+  /**
+   * What msw does with a request no handler matched.
+   *
+   * Defaults to `'bypass'`, unlike msw's own `'warn'`: an app running against
+   * mocks still loads its own documents, modules, images, and fonts, and warning
+   * on every one of them buries the requests a developer is actually looking at.
+   * Use `'warn'` while filling gaps in a mock set.
+   */
+  onUnhandledRequest?: StartOptions['onUnhandledRequest'];
+  /**
+   * Suppress msw's per-request console logging. Defaults to `true` — the request
+   * log is long enough to hide application logs, and the network panel already
+   * shows the same traffic.
+   */
+  quiet?: boolean;
+  /** Escape hatch merged last into msw's own `worker.start()` options. */
+  start?: StartOptions;
+};
+
+export function buildWorkerStartOptions(
+  options: MockWorkerOptions = {},
+): StartOptions {
+  const { baseUrl, onUnhandledRequest, quiet, start } = options;
+
+  return {
+    ...start,
+    // Resolved after the spread rather than defaulted before it: an options
+    // object forwarded with explicit `undefined` values would otherwise put
+    // those keys back and hand msw its own defaults instead of ours. `start`
+    // still wins over the named options where it sets a value.
+    onUnhandledRequest:
+      start?.onUnhandledRequest ?? onUnhandledRequest ?? 'bypass',
+    quiet: start?.quiet ?? quiet ?? true,
+    serviceWorker: {
+      ...start?.serviceWorker,
+      // The same hole one level down: a `serviceWorker` object populated from
+      // another options bag carries an explicit `url: undefined`, which spread
+      // over the resolved path would erase it and send msw to its own default
+      // location — the wrong one for a subpath deployment.
+      url: start?.serviceWorker?.url ?? resolveWorkerScriptUrl(baseUrl),
+    },
+  };
+}
+
+export type IdempotentStart = {
+  /** Runs the wrapped function at most once, until `invalidate()`. */
+  start: () => Promise<void>;
+  /**
+   * Forgets a completed start so the next `start()` runs again. Whatever the
+   * start registered has to be torn down first — a memo pointing at a stopped
+   * worker resolves immediately and intercepts nothing.
+   */
+  invalidate: () => void;
+};
+
+/**
+ * Wraps a start function so concurrent and repeated calls share one
+ * registration. An app entry, a hot reload, and a Playwright fixture can all
+ * call `start()`; registering the worker again mid-session would reset its
+ * handler list and drop any runtime overrides a test had installed.
+ *
+ * A rejected start invalidates itself, so a caller can retry after fixing
+ * whatever failed (a missing `mockServiceWorker.js`, most often).
+ */
+export function createIdempotentStart(
+  start: () => Promise<void>,
+): IdempotentStart {
+  let pending: Promise<void> | undefined;
+
+  const invalidate = (): void => {
+    pending = undefined;
+  };
+
+  return {
+    start: () => {
+      // Called through an async wrapper so a synchronous throw from `start`
+      // rejects the returned promise instead of escaping as an exception the
+      // caller has no way to `.catch`.
+      pending ??= (async () => await start())().catch((error: unknown) => {
+        invalidate();
+        throw error;
+      });
+
+      return pending;
+    },
+    invalidate,
+  };
+}