msw 2.14.7 → 3.0.0

package/lib/_chunks/request-handler.js

@@ -0,0 +1,369 @@
+import { c as copyResponseOwnProperties, g as Handler, h as getCallFrame, m as devUtils, u as getRawSetCookie } from "./cookie-store.js";
+import { isNodeProcess } from "is-node-process";
+import { FetchResponse } from "@mswjs/interceptors";
+//#region src/core/utils/internal/is-iterable.ts
+/**
+* Determines if the given function is an iterator.
+*/
+function isIterable(fn) {
+	if (!fn) return false;
+	return Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator);
+}
+//#endregion
+//#region src/core/utils/internal/observe-response-body-stream.ts
+/**
+* Observe the `ReadableStream` body of the given response.
+* Returns a copy of that response whose body reports when it has
+* settled (was read to completion, errored, or canceled by the consumer).
+* Returns `null` for responses whose body cannot be observed
+* (no body, already used, or locked).
+*/
+function observeResponseBodyStream(response) {
+	if (response.body == null || response.bodyUsed || response.body.locked) return null;
+	const settled = Promise.withResolvers();
+	const reader = response.body.getReader();
+	/**
+	* @note Relay the body through a manual underlying source instead of
+	* `.pipeThrough(new TransformStream({ flush, cancel }))`. The `cancel`
+	* transformer callback is not implemented in Chromium, which loses
+	* the stream error/cancelation signals there entirely.
+	*/
+	const observedStream = new ReadableStream({
+		async pull(controller) {
+			try {
+				const readResult = await reader.read();
+				if (readResult.done) {
+					settled.resolve();
+					controller.close();
+					return;
+				}
+				controller.enqueue(readResult.value);
+			} catch (error) {
+				settled.resolve();
+				throw error;
+			}
+		},
+		async cancel(reason) {
+			settled.resolve();
+			await reader.cancel(reason);
+		}
+	});
+	/**
+	* @note Reconstruct the response because the body of an existing
+	* response cannot be replaced. Use `FetchResponse` to support
+	* non-standard response status codes (e.g. 101).
+	*/
+	const observedResponse = new FetchResponse(observedStream, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+	copyResponseOwnProperties(response, observedResponse);
+	return {
+		response: observedResponse,
+		settled: settled.promise
+	};
+}
+//#endregion
+//#region src/core/handlers/request-handler.ts
+var RequestHandler = class RequestHandler extends Handler {
+	static cache = /* @__PURE__ */ new WeakMap();
+	kind = "request";
+	resolver;
+	resolverIterator;
+	resolverIteratorResult;
+	resolverIteratorCleanups;
+	options;
+	scheduledCleanups;
+	info;
+	/**
+	* Indicates whether this request handler has been used
+	* (its resolver has successfully executed).
+	*/
+	isUsed;
+	constructor(args) {
+		super();
+		this.resolver = args.resolver;
+		this.options = args.options;
+		this.scheduledCleanups = /* @__PURE__ */ new Map();
+		const callFrame = getCallFrame(/* @__PURE__ */ new Error());
+		this.info = {
+			...args.info,
+			callFrame
+		};
+		this.isUsed = false;
+	}
+	/**
+	* Reset the runtime state accumulated during response resolution,
+	* such as generator iterator progress. Called when this handler is
+	* removed from the active handlers list so re-adding it later starts
+	* from a clean state.
+	*/
+	reset() {
+		this.scheduledCleanups.clear();
+		const iterator = this.resolverIterator;
+		this.resolverIterator = void 0;
+		this.resolverIteratorResult = void 0;
+		this.resolverIteratorCleanups = void 0;
+		if (typeof iterator?.return === "function") Promise.resolve(iterator.return());
+	}
+	/**
+	* Restore this handler so it can match requests again after being
+	* exhausted (e.g. via `{ once: true }`). Also clears any accumulated
+	* resolution state.
+	*/
+	restore() {
+		if (this.options?.once) {
+			this.reset();
+			this.isUsed = false;
+		}
+	}
+	/**
+	* Parse the intercepted request to extract additional information from it.
+	* Parsed result is then exposed to other methods of this request handler.
+	*/
+	async parse(_args) {
+		return {};
+	}
+	/**
+	* Test if this handler matches the given request.
+	*
+	* This method is not used internally but is exposed
+	* as a convenience method for consumers writing custom
+	* handlers.
+	*/
+	async test(args) {
+		const parsedResult = await this.parse({
+			request: args.request,
+			resolutionContext: args.resolutionContext
+		});
+		return this.predicate({
+			request: args.request,
+			parsedResult,
+			resolutionContext: args.resolutionContext
+		});
+	}
+	extendResolverArgs(_args) {
+		return {};
+	}
+	cloneRequestOrGetFromCache(request) {
+		const existingClone = RequestHandler.cache.get(request);
+		if (typeof existingClone !== "undefined") return existingClone;
+		const clonedRequest = request.clone();
+		RequestHandler.cache.set(request, clonedRequest);
+		return clonedRequest;
+	}
+	/**
+	* Execute this request handler and produce a mocked response
+	* using the given resolver function.
+	*/
+	async run(args) {
+		if (this.isUsed && this.options?.once) return null;
+		const requestClone = this.cloneRequestOrGetFromCache(args.request);
+		const parsedResult = await this.parse({
+			request: args.request,
+			resolutionContext: args.resolutionContext
+		});
+		if (!await this.predicate({
+			request: args.request,
+			parsedResult,
+			resolutionContext: args.resolutionContext
+		})) return null;
+		if (this.isUsed && this.options?.once) return null;
+		this.isUsed = true;
+		const executeResolver = this.wrapResolver(this.resolver);
+		const resolverExtras = this.extendResolverArgs({
+			request: args.request,
+			parsedResult
+		});
+		const listenerController = new AbortController();
+		/**
+		* @note Initialize the `finalize` machinery lazily, on the first
+		* access of the `finalize` property by the resolver. If the resolver
+		* never accesses it, the handler behaves as if `finalize` never
+		* existed: no abort listeners, no scheduled cleanups, and no response
+		* body stream observation (see `this.complete()`).
+		*/
+		let finalizeFunction;
+		const getFinalize = () => {
+			if (finalizeFunction == null) {
+				if (!args.request.signal.aborted) args.request.signal.addEventListener("abort", () => this.runScheduledCleanups(args.requestId), {
+					once: true,
+					signal: listenerController.signal
+				});
+				finalizeFunction = (callback) => {
+					this.scheduleCleanup(args.requestId, callback);
+					/**
+					* @note Run the cleanup immediately if the request has already
+					* been aborted. The "abort" listener above never fires for an
+					* already-aborted signal (and fires at most once), while
+					* long-lived resolvers (streams, generators) may never settle
+					* to run the cleanups on completion.
+					*/
+					if (args.request.signal.aborted) this.runScheduledCleanups(args.requestId);
+				};
+			}
+			return finalizeFunction;
+		};
+		const mockedResponse = await executeResolver({
+			...resolverExtras,
+			get finalize() {
+				return getFinalize();
+			},
+			requestId: args.requestId,
+			request: args.request
+		}).catch((errorOrResponse) => {
+			if (errorOrResponse instanceof Response) return errorOrResponse;
+			throw errorOrResponse;
+		}).finally(() => {
+			listenerController.abort();
+		});
+		if (mockedResponse) forwardResponseCookies(mockedResponse);
+		return this.createExecutionResult({
+			request: requestClone,
+			requestId: args.requestId,
+			response: mockedResponse,
+			parsedResult
+		});
+	}
+	wrapResolver(resolver) {
+		return async (info) => {
+			if (!this.resolverIterator) {
+				let result;
+				try {
+					result = await resolver(info);
+				} catch (error) {
+					await this.runScheduledCleanups(info.requestId);
+					throw error;
+				}
+				if (!isIterable(result)) return this.complete({
+					request: info.request,
+					requestId: info.requestId,
+					response: result
+				});
+				/**
+				* @note Carry over any previously registered cleanups onto the iterator cleanups.
+				* This is only relevant if "finalize()" is called in a regular resolver that
+				* returns an iterator.
+				* @example
+				* http.get('/', async ({ finalize }) => {
+				*   finalize(cleanup)
+				*   return (async function*() {})()
+				* })
+				*/
+				const existingCleanups = this.scheduledCleanups.get(info.requestId);
+				if (existingCleanups != null && existingCleanups.length > 0) {
+					this.resolverIteratorCleanups = existingCleanups;
+					this.scheduledCleanups.delete(info.requestId);
+				}
+				this.resolverIterator = Symbol.iterator in result ? result[Symbol.iterator]() : result[Symbol.asyncIterator]();
+			}
+			this.isUsed = false;
+			const { done, value } = await this.resolverIterator.next();
+			const nextResponse = await value;
+			if (nextResponse) this.resolverIteratorResult = nextResponse.clone();
+			if (done) {
+				this.isUsed = true;
+				return this.complete({
+					request: info.request,
+					requestId: info.requestId,
+					response: this.resolverIteratorResult?.clone()
+				});
+			}
+			return nextResponse;
+		};
+	}
+	createExecutionResult(args) {
+		return {
+			handler: this,
+			request: args.request,
+			requestId: args.requestId,
+			response: args.response,
+			parsedResult: args.parsedResult
+		};
+	}
+	scheduleCleanup(requestId, callback) {
+		if (this.resolverIterator) {
+			(this.resolverIteratorCleanups ||= []).unshift(callback);
+			return;
+		}
+		const cleanups = this.scheduledCleanups.get(requestId) || [];
+		cleanups.unshift(callback);
+		this.scheduledCleanups.set(requestId, cleanups);
+	}
+	async exhaustCleanups(cleanups) {
+		const errors = [];
+		for (const cleanup of cleanups) try {
+			await cleanup();
+		} catch (error) {
+			if (error instanceof Error) errors.push(error);
+		}
+		if (errors.length > 0) devUtils.error("Failed to execute cleanup for request handler \"%s\"", this.info.header, new AggregateError(errors, `Failed to execute cleanup for request handler "${this.info.header}"`));
+	}
+	/**
+	* Remove and return the cleanups scheduled for the given request
+	* (or the pending iterator cleanups for generator resolvers).
+	*/
+	takeScheduledCleanups(requestId) {
+		if (this.resolverIterator && this.resolverIteratorCleanups != null && this.resolverIteratorCleanups.length > 0) {
+			const cleanups = this.resolverIteratorCleanups;
+			this.resolverIteratorCleanups = void 0;
+			return cleanups;
+		}
+		const cleanups = this.scheduledCleanups.get(requestId);
+		if (!cleanups || cleanups.length === 0) return;
+		this.scheduledCleanups.delete(requestId);
+		return cleanups;
+	}
+	async runScheduledCleanups(requestId) {
+		const cleanups = this.takeScheduledCleanups(requestId);
+		if (cleanups) await this.exhaustCleanups(cleanups);
+	}
+	/**
+	* Conclude the response resolution for the given request.
+	* Runs the scheduled cleanups immediately for responses without a
+	* `ReadableStream` body. For streamed responses, returns an observed
+	* copy of the response and defers the cleanups until its body settles
+	* (is read to completion, errored, or canceled) or the request is
+	* aborted, whichever comes first.
+	*/
+	async complete(args) {
+		const cleanups = this.takeScheduledCleanups(args.requestId);
+		if (!cleanups) return args.response;
+		const observedResponse = args.response ? observeResponseBodyStream(args.response) : null;
+		if (!observedResponse) {
+			await this.exhaustCleanups(cleanups);
+			return args.response;
+		}
+		const listenerController = new AbortController();
+		const runCleanupsOnce = () => {
+			if (listenerController.signal.aborted) return;
+			listenerController.abort();
+			this.exhaustCleanups(cleanups);
+		};
+		observedResponse.settled.then(runCleanupsOnce);
+		/**
+		* @note Also run the cleanups when the request is aborted.
+		* Stream cancellation does not always propagate to the observed
+		* response (e.g. if an unconsumed clone of the response exists),
+		* while the request abort reliably means the response is unused.
+		*/
+		if (args.request.signal.aborted) runCleanupsOnce();
+		else args.request.signal.addEventListener("abort", runCleanupsOnce, {
+			once: true,
+			signal: listenerController.signal
+		});
+		return observedResponse.response;
+	}
+};
+/**
+* Forwards the cookies from the given response to `document.cookie`.
+*/
+function forwardResponseCookies(response) {
+	if (isNodeProcess() || typeof document === "undefined") return;
+	for (const cookieString of getRawSetCookie(response)) document.cookie = cookieString;
+}
+//#endregion
+export { RequestHandler as t };
+
+//# sourceMappingURL=request-handler.js.map

package/lib/_chunks/request-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-handler.js","names":[],"sources":["../../src/core/utils/internal/is-iterable.ts","../../src/core/utils/internal/observe-response-body-stream.ts","../../src/core/handlers/request-handler.ts"],"sourcesContent":["/**\n * Determines if the given function is an iterator.\n */\nexport function isIterable<IteratorType>(\n  fn: any,\n): fn is\n  | Iterable<IteratorType, IteratorType, IteratorType>\n  | AsyncIterable<IteratorType, IteratorType, IteratorType> {\n  if (!fn) {\n    return false\n  }\n\n  return (\n    Reflect.has(fn, Symbol.iterator) || Reflect.has(fn, Symbol.asyncIterator)\n  )\n}\n","import { FetchResponse } from '@mswjs/interceptors'\nimport { copyResponseOwnProperties } from '../response-decorators'\n\nexport interface ObservedResponse {\n  response: Response\n  /**\n   * A promise that resolves once the response body stream has settled:\n   * it was closed, errored, or canceled, and will not be used anymore.\n   */\n  settled: Promise<void>\n}\n\n/**\n * Observe the `ReadableStream` body of the given response.\n * Returns a copy of that response whose body reports when it has\n * settled (was read to completion, errored, or canceled by the consumer).\n * Returns `null` for responses whose body cannot be observed\n * (no body, already used, or locked).\n */\nexport function observeResponseBodyStream(\n  response: Response,\n): ObservedResponse | null {\n  if (response.body == null || response.bodyUsed || response.body.locked) {\n    return null\n  }\n\n  const settled = Promise.withResolvers<void>()\n  const reader = response.body.getReader()\n\n  /**\n   * @note Relay the body through a manual underlying source instead of\n   * `.pipeThrough(new TransformStream({ flush, cancel }))`. The `cancel`\n   * transformer callback is not implemented in Chromium, which loses\n   * the stream error/cancelation signals there entirely.\n   */\n  const observedStream = new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const readResult = await reader.read()\n\n        if (readResult.done) {\n          settled.resolve()\n          controller.close()\n          return\n        }\n\n        controller.enqueue(readResult.value)\n      } catch (error) {\n        settled.resolve()\n        throw error\n      }\n    },\n    async cancel(reason) {\n      settled.resolve()\n      await reader.cancel(reason)\n    },\n  })\n\n  /**\n   * @note Reconstruct the response because the body of an existing\n   * response cannot be replaced. Use `FetchResponse` to support\n   * non-standard response status codes (e.g. 101).\n   */\n  const observedResponse = new FetchResponse(observedStream, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  })\n\n  copyResponseOwnProperties(response, observedResponse)\n\n  return {\n    response: observedResponse,\n    settled: settled.promise,\n  }\n}\n","import { isNodeProcess } from 'is-node-process'\nimport { Handler } from './handler'\nimport { getCallFrame } from '../utils/internal/get-call-frame'\nimport { isIterable } from '../utils/internal/is-iterable'\nimport type { ResponseResolutionContext } from '../utils/execute-handlers'\nimport type { MaybePromise } from '../type-utils'\nimport type {\n  HttpResponse,\n  StrictRequest,\n  DefaultUnsafeFetchResponse,\n} from '#http/http-response'\nimport { devUtils } from '../utils/internal/dev-utils'\nimport { getRawSetCookie } from '../utils/response-decorators'\nimport { observeResponseBodyStream } from '../utils/internal/observe-response-body-stream'\n\nexport type DefaultRequestMultipartBody = Record<\n  string,\n  string | File | Array<string | File>\n>\n\nexport type DefaultBodyType =\n  | Record<string, any>\n  | DefaultRequestMultipartBody\n  | string\n  | number\n  | boolean\n  | null\n  | undefined\n\nexport type JsonBodyType =\n  Record<string, any> | string | number | boolean | null | undefined\n\nexport interface RequestHandlerDefaultInfo {\n  header: string\n}\n\nexport interface RequestHandlerInternalInfo {\n  callFrame?: string\n}\n\nexport type ResponseResolverReturnType<\n  ResponseBodyType extends DefaultBodyType = undefined,\n> =\n  // If ResponseBodyType is a union and one of the types is `undefined`,\n  // allow plain Response as the type.\n  | ([ResponseBodyType] extends [undefined]\n      ? Response\n      : /**\n         * Treat GraphQL response body type as a special case.\n         * For esome reason, making the default HttpResponse<T> | DefaultUnsafeFetchResponse\n         * union breaks the body type inference for HTTP requests.\n         * @see https://github.com/mswjs/msw/issues/2130\n         * @note Don't import the actual GraphQL types not to introduce a dependency\n         * from /core to /graphql.\n         */\n        ResponseBodyType extends Record<string, any> | undefined\n        ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse\n        : HttpResponse<ResponseBodyType>)\n  | undefined\n  | void\n\nexport type MaybeAsyncResponseResolverReturnType<\n  ResponseBodyType extends DefaultBodyType,\n> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>\n\nexport type AsyncResponseResolverReturnType<\n  ResponseBodyType extends DefaultBodyType,\n> = MaybePromise<\n  | ResponseResolverReturnType<ResponseBodyType>\n  | Iterable<\n      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,\n      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,\n      MaybeAsyncResponseResolverReturnType<ResponseBodyType>\n    >\n  | AsyncIterable<\n      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,\n      MaybeAsyncResponseResolverReturnType<ResponseBodyType>,\n      MaybeAsyncResponseResolverReturnType<ResponseBodyType>\n    >\n>\n\nexport type ResponseResolverInfo<\n  ResolverExtraInfo extends Record<string, unknown>,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n> = {\n  request: StrictRequest<RequestBodyType>\n  requestId: string\n  /**\n   * Schedule a callback to run after this response resolver completes.\n   * Handy for cleaning up the side effects introduced in the resolver.\n   *\n   * For responses with a `ReadableStream` body (including `sse()` handlers),\n   * the callback runs once the response stream settles: it is read to\n   * completion, errored, or canceled, or the request is aborted.\n   * @example\n   * sse('/', ({ client, finalize }) => {\n   *   const interval = setInterval(() => client.send({ data: 'ping' }))\n   *   finalize(() => clearInterval(interval))\n   * })\n   */\n  finalize: ResponseResolverFinalizeFunction\n} & ResolverExtraInfo\n\nexport type ResponseResolverFinalizeFunction = (\n  callback: () => MaybePromise<void>,\n) => void\n\nexport type ResponseResolver<\n  ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  ResponseBodyType extends DefaultBodyType = undefined,\n> = (\n  info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>,\n) => AsyncResponseResolverReturnType<ResponseBodyType>\n\nexport interface RequestHandlerArgs<\n  HandlerInfo,\n  HandlerOptions extends RequestHandlerOptions,\n> {\n  info: HandlerInfo\n  resolver: ResponseResolver<any>\n  options?: HandlerOptions\n}\n\nexport interface RequestHandlerOptions {\n  once?: boolean\n}\n\nexport interface RequestHandlerExecutionResult<\n  ParsedResult extends object | undefined,\n> {\n  handler: RequestHandler\n  parsedResult?: ParsedResult\n  request: Request\n  requestId: string\n  response?: Response\n}\n\nexport abstract class RequestHandler<\n  HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo,\n  ParsedResult extends Record<string, any> | undefined = any,\n  ResolverExtras extends Record<string, unknown> = any,\n  HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions,\n> extends Handler {\n  static cache = new WeakMap<\n    StrictRequest<DefaultBodyType>,\n    StrictRequest<DefaultBodyType>\n  >()\n\n  public readonly kind = 'request'\n\n  protected resolver: ResponseResolver<ResolverExtras, any, any>\n  private resolverIterator?:\n    | Iterator<\n        MaybeAsyncResponseResolverReturnType<any>,\n        MaybeAsyncResponseResolverReturnType<any>,\n        MaybeAsyncResponseResolverReturnType<any>\n      >\n    | AsyncIterator<\n        MaybeAsyncResponseResolverReturnType<any>,\n        MaybeAsyncResponseResolverReturnType<any>,\n        MaybeAsyncResponseResolverReturnType<any>\n      >\n  private resolverIteratorResult?: Response | HttpResponse<any>\n  private resolverIteratorCleanups?: Array<() => MaybePromise<void>>\n  private options?: HandlerOptions\n  private scheduledCleanups: Map<string, Array<() => MaybePromise<void>>>\n\n  public info: HandlerInfo & RequestHandlerInternalInfo\n\n  /**\n   * Indicates whether this request handler has been used\n   * (its resolver has successfully executed).\n   */\n  public isUsed: boolean\n\n  constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>) {\n    super()\n\n    this.resolver = args.resolver\n    this.options = args.options\n    this.scheduledCleanups = new Map()\n\n    const callFrame = getCallFrame(new Error())\n\n    this.info = {\n      ...args.info,\n      callFrame,\n    }\n\n    this.isUsed = false\n  }\n\n  /**\n   * Reset the runtime state accumulated during response resolution,\n   * such as generator iterator progress. Called when this handler is\n   * removed from the active handlers list so re-adding it later starts\n   * from a clean state.\n   */\n  public reset(): void {\n    this.scheduledCleanups.clear()\n\n    const iterator = this.resolverIterator\n    this.resolverIterator = undefined\n    this.resolverIteratorResult = undefined\n    this.resolverIteratorCleanups = undefined\n\n    if (typeof iterator?.return === 'function') {\n      void Promise.resolve(iterator.return())\n    }\n  }\n\n  /**\n   * Restore this handler so it can match requests again after being\n   * exhausted (e.g. via `{ once: true }`). Also clears any accumulated\n   * resolution state.\n   */\n  public restore(): void {\n    if (this.options?.once) {\n      this.reset()\n      this.isUsed = false\n    }\n  }\n\n  /**\n   * Determine if the intercepted request should be mocked.\n   */\n  abstract predicate(args: {\n    request: Request\n    parsedResult: ParsedResult\n    resolutionContext?: ResponseResolutionContext\n  }): boolean | Promise<boolean>\n\n  /**\n   * Print out the successfully handled request.\n   */\n  abstract log(args: {\n    request: Request\n    response: Response\n    parsedResult: ParsedResult\n  }): void\n\n  /**\n   * Parse the intercepted request to extract additional information from it.\n   * Parsed result is then exposed to other methods of this request handler.\n   */\n  async parse(_args: {\n    request: Request\n    resolutionContext?: ResponseResolutionContext\n  }): Promise<ParsedResult> {\n    return {} as ParsedResult\n  }\n\n  /**\n   * Test if this handler matches the given request.\n   *\n   * This method is not used internally but is exposed\n   * as a convenience method for consumers writing custom\n   * handlers.\n   */\n  public async test(args: {\n    request: Request\n    resolutionContext?: ResponseResolutionContext\n  }): Promise<boolean> {\n    const parsedResult = await this.parse({\n      request: args.request,\n      resolutionContext: args.resolutionContext,\n    })\n\n    return this.predicate({\n      request: args.request,\n      parsedResult,\n      resolutionContext: args.resolutionContext,\n    })\n  }\n\n  protected extendResolverArgs(_args: {\n    request: Request\n    parsedResult: ParsedResult\n  }): ResolverExtras {\n    return {} as ResolverExtras\n  }\n\n  // Clone the request instance before it's passed to the handler phases\n  // and the response resolver so we can always read it for logging.\n  // We only clone it once per request to avoid unnecessary overhead.\n  private cloneRequestOrGetFromCache(\n    request: StrictRequest<DefaultBodyType>,\n  ): StrictRequest<DefaultBodyType> {\n    const existingClone = RequestHandler.cache.get(request)\n\n    if (typeof existingClone !== 'undefined') {\n      return existingClone\n    }\n\n    const clonedRequest = request.clone()\n    RequestHandler.cache.set(request, clonedRequest)\n\n    return clonedRequest\n  }\n\n  /**\n   * Execute this request handler and produce a mocked response\n   * using the given resolver function.\n   */\n  public async run(args: {\n    request: StrictRequest<any>\n    requestId: string\n    resolutionContext?: ResponseResolutionContext\n  }): Promise<RequestHandlerExecutionResult<ParsedResult> | null> {\n    if (this.isUsed && this.options?.once) {\n      return null\n    }\n\n    // Clone the request.\n    // If this is the first time MSW handles this request, a fresh clone\n    // will be created and cached. Upon further handling of the same request,\n    // the request clone from the cache will be reused to prevent abundant\n    // \"abort\" listeners and save up resources on cloning.\n    const requestClone = this.cloneRequestOrGetFromCache(args.request)\n\n    const parsedResult = await this.parse({\n      request: args.request,\n      resolutionContext: args.resolutionContext,\n    })\n    const shouldInterceptRequest = await this.predicate({\n      request: args.request,\n      parsedResult,\n      resolutionContext: args.resolutionContext,\n    })\n\n    if (!shouldInterceptRequest) {\n      return null\n    }\n\n    // Re-check isUsed, in case another request hit this handler while we were\n    // asynchronously parsing the request.\n    if (this.isUsed && this.options?.once) {\n      return null\n    }\n\n    // Preemptively mark the handler as used.\n    // Generators will undo this because only when the resolver reaches the\n    // \"done\" state of the generator that it considers the handler used.\n    this.isUsed = true\n\n    // Create a response extraction wrapper around the resolver\n    // since it can be both an async function and a generator.\n    const executeResolver = this.wrapResolver(this.resolver)\n\n    const resolverExtras = this.extendResolverArgs({\n      request: args.request,\n      parsedResult,\n    })\n\n    const listenerController = new AbortController()\n\n    /**\n     * @note Initialize the `finalize` machinery lazily, on the first\n     * access of the `finalize` property by the resolver. If the resolver\n     * never accesses it, the handler behaves as if `finalize` never\n     * existed: no abort listeners, no scheduled cleanups, and no response\n     * body stream observation (see `this.complete()`).\n     */\n    let finalizeFunction: ResponseResolverFinalizeFunction | undefined\n\n    const getFinalize = (): ResponseResolverFinalizeFunction => {\n      if (finalizeFunction == null) {\n        // Run any scheduled cleanups if the request gets aborted\n        // while the resolver is still executing.\n        if (!args.request.signal.aborted) {\n          args.request.signal.addEventListener(\n            'abort',\n            () => this.runScheduledCleanups(args.requestId),\n            {\n              once: true,\n              signal: listenerController.signal,\n            },\n          )\n        }\n\n        finalizeFunction = (callback) => {\n          this.scheduleCleanup(args.requestId, callback)\n\n          /**\n           * @note Run the cleanup immediately if the request has already\n           * been aborted. The \"abort\" listener above never fires for an\n           * already-aborted signal (and fires at most once), while\n           * long-lived resolvers (streams, generators) may never settle\n           * to run the cleanups on completion.\n           */\n          if (args.request.signal.aborted) {\n            void this.runScheduledCleanups(args.requestId)\n          }\n        }\n      }\n\n      return finalizeFunction\n    }\n\n    const mockedResponsePromise = (\n      executeResolver({\n        ...resolverExtras,\n        get finalize(): ResponseResolverFinalizeFunction {\n          return getFinalize()\n        },\n        requestId: args.requestId,\n        request: args.request,\n      }) as Promise<Response>\n    )\n      .catch((errorOrResponse) => {\n        // Allow throwing a Response instance in a response resolver.\n        if (errorOrResponse instanceof Response) {\n          return errorOrResponse\n        }\n\n        // Otherwise, throw the error as-is.\n        throw errorOrResponse\n      })\n      .finally(() => {\n        listenerController.abort()\n      })\n\n    const mockedResponse = await mockedResponsePromise\n\n    if (mockedResponse) {\n      forwardResponseCookies(mockedResponse)\n    }\n\n    const executionResult = this.createExecutionResult({\n      // Pass the cloned request to the result so that logging\n      // and other consumers could read its body once more.\n      request: requestClone,\n      requestId: args.requestId,\n      response: mockedResponse,\n      parsedResult,\n    })\n\n    return executionResult\n  }\n\n  private wrapResolver(\n    resolver: ResponseResolver<ResolverExtras>,\n  ): ResponseResolver<ResolverExtras> {\n    return async (info): Promise<ResponseResolverReturnType<any>> => {\n      if (!this.resolverIterator) {\n        let result\n\n        try {\n          result = await resolver(info)\n        } catch (error) {\n          // Ensure cleanup if the resolver throws, regardless of the returned type.\n          await this.runScheduledCleanups(info.requestId)\n\n          // Re-throw the error for the \"run()\" method to handle (e.g. thrown responses).\n          throw error\n        }\n\n        if (!isIterable(result)) {\n          // Otherwise, run the cleanups if it's a plain response resolver\n          // (deferred until the response stream settles for streamed responses).\n          return this.complete({\n            request: info.request,\n            requestId: info.requestId,\n            response: result,\n          })\n        }\n\n        /**\n         * @note Carry over any previously registered cleanups onto the iterator cleanups.\n         * This is only relevant if \"finalize()\" is called in a regular resolver that\n         * returns an iterator.\n         * @example\n         * http.get('/', async ({ finalize }) => {\n         *   finalize(cleanup)\n         *   return (async function*() {})()\n         * })\n         */\n        const existingCleanups = this.scheduledCleanups.get(info.requestId)\n        if (existingCleanups != null && existingCleanups.length > 0) {\n          this.resolverIteratorCleanups = existingCleanups\n          this.scheduledCleanups.delete(info.requestId)\n        }\n\n        this.resolverIterator =\n          Symbol.iterator in result\n            ? result[Symbol.iterator]()\n            : result[Symbol.asyncIterator]()\n      }\n\n      // Opt-out from marking this handler as used.\n      this.isUsed = false\n\n      const { done, value } = await this.resolverIterator.next()\n      const nextResponse = await value\n\n      if (nextResponse) {\n        this.resolverIteratorResult = nextResponse.clone()\n      }\n\n      if (done) {\n        // A one-time generator resolver stops affecting the network\n        // only after it's been completely exhausted.\n        this.isUsed = true\n\n        // Clone the previously stored response so it can be read\n        // when receiving it repeatedly from the \"done\" generator.\n        return this.complete({\n          request: info.request,\n          requestId: info.requestId,\n          response: this.resolverIteratorResult?.clone(),\n        })\n      }\n\n      return nextResponse\n    }\n  }\n\n  private createExecutionResult(args: {\n    request: Request\n    requestId: string\n    parsedResult: ParsedResult\n    response?: Response\n  }): RequestHandlerExecutionResult<ParsedResult> {\n    return {\n      handler: this,\n      request: args.request,\n      requestId: args.requestId,\n      response: args.response,\n      parsedResult: args.parsedResult,\n    }\n  }\n\n  private scheduleCleanup(\n    requestId: string,\n    callback: () => MaybePromise<void>,\n  ): void {\n    if (this.resolverIterator) {\n      ;(this.resolverIteratorCleanups ||= []).unshift(callback)\n      return\n    }\n\n    const cleanups = this.scheduledCleanups.get(requestId) || []\n    cleanups.unshift(callback)\n    this.scheduledCleanups.set(requestId, cleanups)\n  }\n\n  private async exhaustCleanups(\n    cleanups: Array<() => MaybePromise<void>>,\n  ): Promise<void> {\n    const errors: Array<Error> = []\n\n    for (const cleanup of cleanups) {\n      try {\n        await cleanup()\n      } catch (error) {\n        if (error instanceof Error) {\n          errors.push(error)\n        }\n      }\n    }\n\n    if (errors.length > 0) {\n      devUtils.error(\n        'Failed to execute cleanup for request handler \"%s\"',\n        this.info.header,\n        new AggregateError(\n          errors,\n          `Failed to execute cleanup for request handler \"${this.info.header}\"`,\n        ),\n      )\n    }\n  }\n\n  /**\n   * Remove and return the cleanups scheduled for the given request\n   * (or the pending iterator cleanups for generator resolvers).\n   */\n  private takeScheduledCleanups(\n    requestId: string,\n  ): Array<() => MaybePromise<void>> | undefined {\n    if (\n      this.resolverIterator &&\n      this.resolverIteratorCleanups != null &&\n      this.resolverIteratorCleanups.length > 0\n    ) {\n      const cleanups = this.resolverIteratorCleanups\n      this.resolverIteratorCleanups = undefined\n      return cleanups\n    }\n\n    const cleanups = this.scheduledCleanups.get(requestId)\n\n    if (!cleanups || cleanups.length === 0) {\n      return undefined\n    }\n\n    this.scheduledCleanups.delete(requestId)\n    return cleanups\n  }\n\n  private async runScheduledCleanups(requestId: string): Promise<void> {\n    const cleanups = this.takeScheduledCleanups(requestId)\n\n    if (cleanups) {\n      await this.exhaustCleanups(cleanups)\n    }\n  }\n\n  /**\n   * Conclude the response resolution for the given request.\n   * Runs the scheduled cleanups immediately for responses without a\n   * `ReadableStream` body. For streamed responses, returns an observed\n   * copy of the response and defers the cleanups until its body settles\n   * (is read to completion, errored, or canceled) or the request is\n   * aborted, whichever comes first.\n   */\n  private async complete(args: {\n    request: StrictRequest<any>\n    requestId: string\n    response: Response | undefined | void\n  }): Promise<Response | undefined | void> {\n    const cleanups = this.takeScheduledCleanups(args.requestId)\n\n    if (!cleanups) {\n      return args.response\n    }\n\n    const observedResponse = args.response\n      ? observeResponseBodyStream(args.response)\n      : null\n\n    if (!observedResponse) {\n      await this.exhaustCleanups(cleanups)\n      return args.response\n    }\n\n    const listenerController = new AbortController()\n\n    const runCleanupsOnce = (): void => {\n      if (listenerController.signal.aborted) {\n        return\n      }\n\n      listenerController.abort()\n      void this.exhaustCleanups(cleanups)\n    }\n\n    void observedResponse.settled.then(runCleanupsOnce)\n\n    /**\n     * @note Also run the cleanups when the request is aborted.\n     * Stream cancellation does not always propagate to the observed\n     * response (e.g. if an unconsumed clone of the response exists),\n     * while the request abort reliably means the response is unused.\n     */\n    if (args.request.signal.aborted) {\n      runCleanupsOnce()\n    } else {\n      args.request.signal.addEventListener('abort', runCleanupsOnce, {\n        once: true,\n        signal: listenerController.signal,\n      })\n    }\n\n    return observedResponse.response\n  }\n}\n\n/**\n * Forwards the cookies from the given response to `document.cookie`.\n */\nfunction forwardResponseCookies(response: Response): void {\n  // Cookie forwarding is only relevant in the browser.\n  if (isNodeProcess() || typeof document === 'undefined') {\n    return\n  }\n\n  for (const cookieString of getRawSetCookie(response)) {\n    document.cookie = cookieString\n  }\n}\n"],"mappings":"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"}

package/lib/_chunks/shared-options.d.ts

@@ -0,0 +1,20 @@
+import { b as UnhandledFrameHandle } from "./handlers-controller.js";
+import { DefaultEventMap, Emitter } from "rettime";
+//#region src/core/shared-options.d.ts
+interface SharedOptions {
+  /**
+   * Specifies how to react to a network frame (e.g. a request or
+   * a WebSocket connection) that has no corresponding handler.
+   * Warns on unhandled frames by default.
+   *
+   * @example worker.start({ onUnhandledFrame: 'bypass' })
+   * @example worker.start({ onUnhandledFrame: 'warn' })
+   * @example server.listen({ onUnhandledFrame: 'error' })
+   * @example server.listen({ onUnhandledFrame({ frame, defaults }) { defaults.warn() } })
+   */
+  onUnhandledFrame?: UnhandledFrameHandle;
+}
+type LifeCycleEventEmitter<EventMap extends DefaultEventMap> = Pick<Emitter<EventMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
+//#endregion
+export { SharedOptions as n, LifeCycleEventEmitter as t };
+//# sourceMappingURL=shared-options.d.ts.map

package/lib/_chunks/sse.d.ts

@@ -0,0 +1,95 @@
+import { l as ResponseResolver } from "./request-handler.js";
+import { n as Path, r as PathParams } from "./match-request-url.js";
+import { c as HttpRequestResolverExtras, n as HttpHandler } from "./http-handler.js";
+//#region src/sse/sse.d.ts
+type EventMapConstraint = {
+  message?: unknown;
+  [key: string]: unknown;
+  [key: symbol | number]: never;
+};
+type ServerSentEventResolverExtras<EventMap extends EventMapConstraint, Params extends PathParams> = HttpRequestResolverExtras<Params> & {
+  client: ServerSentEventClient<EventMap>;
+  server: ServerSentEventServer;
+};
+type ServerSentEventResolver<EventMap extends EventMapConstraint, Params extends PathParams> = ResponseResolver<ServerSentEventResolverExtras<EventMap, Params>, any, any>;
+type ServerSentEventRequestHandler = <EventMap extends EventMapConstraint = {
+  message: unknown;
+}, Params extends PathParams<keyof Params> = PathParams, RequestPath extends Path = Path>(path: RequestPath, resolver: ServerSentEventResolver<EventMap, Params>) => HttpHandler;
+type ServerSentEventMessage<EventMap extends EventMapConstraint = {
+  message: unknown;
+}> = ToEventDiscriminatedUnion<EventMap & {
+  message: unknown;
+}> | {
+  id?: never;
+  event?: never;
+  data?: never;
+  retry: number;
+};
+/**
+ * Intercept Server-Sent Events (SSE).
+ *
+ * @example
+ * sse('http://localhost:4321', ({ client }) => {
+ *   client.send({ data: 'hello world' })
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/sse/ Mocking Server-Sent Events}
+ * @see {@link https://mswjs.io/docs/api/sse `sse()` API reference}
+ */
+declare const sse: ServerSentEventRequestHandler;
+type Values<T> = T[keyof T];
+type Identity<T> = { [K in keyof T]: T[K]; } & unknown;
+type ToEventDiscriminatedUnion<T> = Values<{ [K in keyof T]: Identity<(K extends 'message' ? {
+  id?: string;
+  event?: K;
+  data?: T[K];
+  retry?: never;
+} : {
+  id?: string;
+  event: K;
+  data?: T[K];
+  retry?: never;
+}) & (undefined extends T[K] ? unknown : {
+  data: unknown;
+})>; }>;
+declare const kClientEmitter: unique symbol;
+declare class ServerSentEventClient<EventMap extends EventMapConstraint = {
+  message: unknown;
+}> {
+  #private;
+  private [kClientEmitter]?;
+  constructor(controller: ReadableStreamDefaultController<Uint8Array>);
+  /**
+   * Sends the given payload to the intercepted `EventSource`.
+   */
+  send(payload: ServerSentEventMessage<EventMap>): void;
+  /**
+   * Dispatches the given event on the intercepted `EventSource`.
+   */
+  dispatchEvent(event: Event): void;
+  /**
+   * Errors the underlying `EventSource`, closing the connection with an error.
+   * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+   * error.
+   */
+  error(): void;
+  /**
+   * Closes the underlying `EventSource`, closing the connection.
+   */
+  close(): void;
+}
+declare class ServerSentEventServer {
+  #private;
+  constructor(args: {
+    request: Request;
+    client: ServerSentEventClient<any>;
+  });
+  /**
+   * Establishes the actual connection for this SSE request
+   * and returns the `EventSource` instance.
+   */
+  connect(): EventSource;
+}
+//#endregion
+export { sse as a, ServerSentEventResolverExtras as i, ServerSentEventRequestHandler as n, ServerSentEventResolver as r, ServerSentEventMessage as t };
+//# sourceMappingURL=sse.d.ts.map