msw 2.14.7 → 3.0.0

package/lib/_chunks/handlers-controller.d.ts

@@ -0,0 +1,262 @@
+import { _ as Handler, a as RequestHandler, v as HandlerKind, y as MaybePromise } from "./request-handler.js";
+import { n as Path, r as PathParams, t as Match } from "./match-request-url.js";
+import { DefaultEventMap, Emitter, TypedEvent } from "rettime";
+import { WebSocketClientHandle, WebSocketConnectionEventData, WebSocketConnectionInfo, WebSocketData, WebSocketExtension, WebSocketExtensionApi, WebSocketExtensionMessage, WebSocketServerHandle } from "@mswjs/interceptors/WebSocket";
+//#region src/graphql/graphql-subscription-event.d.ts
+interface GraphQLSubscriptionEventInit {
+  operationName: string;
+  query: string;
+  variables: Record<string, unknown>;
+  request: Request;
+}
+/**
+ * Emitted when a GraphQL subscription is established over an
+ * intercepted WebSocket connection (i.e. matched by a subscription
+ * handler and resolved).
+ *
+ * @note The event is referenced by the WebSocket frame event map so
+ * the life-cycle event emitters derived from it (e.g. `server.events`)
+ * are typed correctly. It lives in its own module so the emitting
+ * `msw/graphql` module doesn't pull the entire frame graph, and the
+ * core stays free of the `graphql` dependency (the event carries
+ * plain data only).
+ */
+declare class GraphQLSubscriptionEvent extends TypedEvent<void, void, 'graphql:subscription'> {
+  readonly operationName: string;
+  readonly query: string;
+  readonly variables: Record<string, unknown>;
+  readonly request: Request;
+  constructor(init: GraphQLSubscriptionEventInit);
+}
+//#endregion
+//#region src/core/experimental/on-unhandled-frame.d.ts
+type UnhandledFrameHandle = UnhandledFrameStrategy | UnhandledFrameCallback;
+type UnhandledFrameStrategy = 'bypass' | 'warn' | 'error';
+type UnhandledFrameCallback = (args: {
+  frame: AnyNetworkFrame;
+  defaults: UnhandledFrameDefaults;
+}) => Promise<void> | void;
+type UnhandledFrameDefaults = {
+  warn: () => void;
+  error: () => void;
+};
+//#endregion
+//#region src/core/experimental/frames/network-frame.d.ts
+type AnyNetworkFrame = NetworkFrame<string, unknown, any>;
+type ExtractFrameEvents<Frame> = Frame extends NetworkFrame<any, any, infer Events> ? Events : never;
+interface NetworkFrameResolutionContext {
+  baseUrl?: string | URL;
+  quiet?: boolean;
+}
+/**
+ * The base for the network frames. Extend this abstract class
+ * to implement custom network frames.
+ */
+declare abstract class NetworkFrame<Protocol extends string, Data, Events extends DefaultEventMap> {
+  readonly protocol: Protocol;
+  readonly data: Data;
+  events: Emitter<Events>;
+  constructor(protocol: Protocol, data: Data);
+  abstract getHandlers(controller: HandlersController): Array<AnyHandler>;
+  /**
+   * Resolve the current frame against the given list of handlers.
+   * Optionally, use a custom resolution context to control behaviors
+   * like `baseUrl`.
+   *
+   * Returns `true` if the frame was handled, `false` if it wasn't, and `null`
+   * if its handling was skipped (e.g. the frame was bypassed).
+   */
+  abstract resolve(handlers: Array<AnyHandler>, onUnhandledFrame: UnhandledFrameHandle, resolutionContext?: NetworkFrameResolutionContext): Promise<boolean | null>;
+  /**
+   * Perform this network frame as-is.
+   */
+  abstract passthrough(): void;
+  /**
+   * Error the underling network frame.
+   * @param reason The reason for the error.
+   */
+  abstract errorWith(reason?: unknown): void;
+  /**
+   * Get a message to be used when this frame is unhandled.
+   */
+  abstract getUnhandledMessage(): Promise<string>;
+}
+//#endregion
+//#region src/core/experimental/frames/websocket-frame.d.ts
+interface WebSocketNetworkFrameOptions {
+  connection: WebSocketConnectionEventData;
+}
+type WebSocketNetworkFrameEventMap = {
+  /**
+   * Emitted when a WebSocket connection is intercepted,
+   * before any handlers are resolved against it.
+   */
+  'websocket:connection': WebSocketConnectionEvent$1;
+  /**
+   * Emitted when the WebSocket connection errors.
+   * This includes initial connection errors as well as runtime errors
+   * after the connection has been established.
+   */
+  'websocket:error': WebSocketErrorEvent;
+  'graphql:subscription': GraphQLSubscriptionEvent;
+  unhandledException: WebSocketErrorEvent;
+};
+declare class WebSocketConnectionEvent$1<DataType extends {
+  url: URL;
+  protocols: string | Array<string> | undefined;
+} = {
+  url: URL;
+  protocols: string | Array<string> | undefined;
+}, ReturnType = void, EventType extends string = string> extends TypedEvent<DataType, ReturnType, EventType> {
+  readonly url: URL;
+  readonly protocols: string | Array<string> | undefined;
+  constructor(type: EventType, data: DataType);
+}
+declare class WebSocketErrorEvent<DataType extends {
+  url: URL;
+  protocols: string | Array<string> | undefined;
+  error: unknown;
+} = {
+  url: URL;
+  protocols: string | Array<string> | undefined;
+  error: unknown;
+}, ReturnType = void, EventType extends string = string> extends WebSocketConnectionEvent$1<DataType, ReturnType, EventType> {
+  readonly error: unknown;
+  constructor(type: EventType, data: DataType);
+}
+declare abstract class WebSocketNetworkFrame extends NetworkFrame<'ws', {
+  connection: WebSocketConnectionEventData;
+}, WebSocketNetworkFrameEventMap> {
+  constructor(options: WebSocketNetworkFrameOptions);
+  getHandlers(controller: HandlersController): Array<AnyHandler>;
+  resolve(handlers: Array<WebSocketHandler<AnyWebSocketExtension>>, onUnhandledFrame: UnhandledFrameHandle, resolutionContext?: NetworkFrameResolutionContext): Promise<boolean | null>;
+  getUnhandledMessage(): Promise<string>;
+}
+//#endregion
+//#region src/ws/websocket-handler.d.ts
+type WebSocketHandlerParsedResult = {
+  match: Match;
+};
+interface WebSocketHandlerOptions {
+  /**
+   * WebSocket extensions applied to every connection matched by this handler,
+   * left to right. The last one applied encodes and decodes the traffic,
+   * and every one of them extends the connection event with its own API.
+   */
+  extensions?: ReadonlyArray<AnyWebSocketExtension>;
+}
+type AnyWebSocketExtension = WebSocketExtension<unknown, unknown>;
+/**
+ * The connection event of a handler with the given extension:
+ * the connection speaks the extension's messages and the event
+ * carries the extension's own API (e.g. rooms).
+ */
+type WebSocketHandlerConnectionEvent<Extension extends AnyWebSocketExtension = WebSocketExtension> = WebSocketConnectionEvent<WebSocketExtensionMessage<Extension>> & WebSocketExtensionApi<Extension>;
+type WebSocketHandlerEventMap<Extension extends AnyWebSocketExtension = WebSocketExtension> = {
+  connection: WebSocketHandlerConnectionEvent<Extension>;
+};
+/**
+ * The connection matched by a handler.
+ *
+ * @note Typed against the connection handles, not the connection classes,
+ * so a handler accepts connections living anywhere (e.g. in another
+ * runtime, or a custom implementation of the handles).
+ */
+interface WebSocketHandlerConnection<Message = WebSocketData> {
+  client: WebSocketClientHandle<Message>;
+  server: WebSocketServerHandle<Message>;
+  info: WebSocketConnectionInfo;
+  params: PathParams;
+}
+declare class WebSocketConnectionEvent<Message = WebSocketData> extends TypedEvent<void, void, 'connection'> implements WebSocketHandlerConnection<Message> {
+  readonly client: WebSocketClientHandle<Message>;
+  readonly server: WebSocketServerHandle<Message>;
+  readonly info: WebSocketConnectionInfo;
+  readonly params: PathParams;
+  constructor(connection: WebSocketHandlerConnection<Message>);
+}
+/**
+ * The connection resolved by a handler: the matched connection
+ * extended with the handler extension's own API.
+ */
+type WebSocketHandlerResolvedConnection<Extension extends AnyWebSocketExtension = WebSocketExtension> = WebSocketHandlerConnection<WebSocketExtensionMessage<Extension>> & WebSocketExtensionApi<Extension>;
+interface WebSocketResolutionContext {
+  baseUrl?: string;
+  /**
+   * An emit-only reference to the network frame's events.
+   * Allows handlers to emit additional events not covered by the frame
+   * into the network's life-cycle event stream (e.g. `server.events`).
+   */
+  events?: Pick<Emitter<WebSocketNetworkFrameEventMap>, 'emit'>;
+  [kAutoConnect]?: boolean;
+}
+declare const kEmitter: unique symbol;
+declare const kConnect: unique symbol;
+declare const kAutoConnect: unique symbol;
+declare class WebSocketHandler<Extension extends AnyWebSocketExtension = WebSocketExtension> extends Handler {
+  #private;
+  protected readonly url: Path;
+  id: string;
+  callFrame?: string;
+  readonly kind = "websocket";
+  protected [kEmitter]: Emitter<WebSocketHandlerEventMap<Extension>>;
+  protected readonly extensions: ReadonlyArray<AnyWebSocketExtension>;
+  constructor(url: Path, options?: WebSocketHandlerOptions);
+  parse(args: {
+    url: string | URL;
+    resolutionContext?: WebSocketResolutionContext;
+  }): WebSocketHandlerParsedResult;
+  predicate(args: {
+    url: string | URL;
+    parsedResult: WebSocketHandlerParsedResult;
+  }): boolean;
+  test(url: string | URL, resolutionContext?: WebSocketResolutionContext & {
+    strict?: boolean;
+  }): boolean;
+  run(connection: WebSocketConnectionEventData, resolutionContext?: WebSocketResolutionContext): Promise<WebSocketHandlerResolvedConnection<Extension> | null>;
+  protected [kConnect](connection: WebSocketHandlerResolvedConnection<Extension>): boolean;
+  log(connection: WebSocketConnectionEventData): () => void;
+}
+//#endregion
+//#region src/core/experimental/handlers-controller.d.ts
+type AnyHandler = RequestHandler | WebSocketHandler<AnyWebSocketExtension>;
+type HandlerOfKind<Kind extends HandlerKind> = Extract<AnyHandler, {
+  kind: Kind;
+}>;
+type HandlersMapOfKind<Kind extends HandlerKind> = { [K in Kind]?: Array<HandlerOfKind<K>>; };
+type HandlersMap = HandlersMapOfKind<HandlerKind>;
+interface HandlersControllerState {
+  initialHandlers: HandlersMap;
+  handlers: HandlersMap;
+}
+declare abstract class HandlersController {
+  #private;
+  protected getInitialState(initialHandlers: Array<AnyHandler>): HandlersControllerState;
+  protected abstract getState(): HandlersControllerState;
+  protected abstract setState(nextState: Partial<HandlersControllerState>): void;
+  currentHandlers(): Array<AnyHandler>;
+  /**
+   * Return the list of explicitly registered handlers.
+   * Unlike `currentHandlers()`, this excludes sibling handlers,
+   * which are an implementation detail (e.g. the WebSocket upgrade
+   * handler or the GraphQL subscription transport).
+   */
+  listHandlers(): Array<AnyHandler>;
+  /**
+   * Return the list of handlers of the given kind.
+   */
+  getHandlersByKind<Kind extends HandlerKind>(kind: Kind): Array<HandlerOfKind<Kind>>;
+  use(nextHandlers: Array<AnyHandler>): void;
+  reset(nextHandlers: Array<AnyHandler>): void;
+  restore(): void;
+  dispose(): MaybePromise<void>;
+}
+declare class InMemoryHandlersController extends HandlersController {
+  #private;
+  constructor(initialHandlers: Array<AnyHandler>);
+  protected getState(): HandlersControllerState;
+  protected setState(nextState: Partial<HandlersControllerState>): void;
+}
+//#endregion
+export { ExtractFrameEvents as _, InMemoryHandlersController as a, UnhandledFrameHandle as b, WebSocketHandler as c, WebSocketHandlerOptions as d, WebSocketResolutionContext as f, AnyNetworkFrame as g, WebSocketNetworkFrameEventMap as h, HandlersMap as i, WebSocketHandlerConnection as l, WebSocketNetworkFrame as m, HandlersController as n, AnyWebSocketExtension as o, kConnect as p, HandlersControllerState as r, WebSocketConnectionEvent as s, AnyHandler as t, WebSocketHandlerEventMap as u, NetworkFrame as v, UnhandledFrameStrategy as x, NetworkFrameResolutionContext as y };
+//# sourceMappingURL=handlers-controller.d.ts.map

package/lib/_chunks/has-ref-counted.js

@@ -0,0 +1,9 @@
+import { t as isObject } from "./is-object.js";
+//#region src/core/utils/internal/has-ref-counted.ts
+function hasRefCounted(value) {
+	return isObject(value) && typeof Reflect.get(value, "ref") === "function" && typeof Reflect.get(value, "unref") === "function";
+}
+//#endregion
+export { hasRefCounted as t };
+
+//# sourceMappingURL=has-ref-counted.js.map

package/lib/_chunks/has-ref-counted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-ref-counted.js","names":[],"sources":["../../src/core/utils/internal/has-ref-counted.ts"],"sourcesContent":["import { isObject } from './is-object'\n\nexport function hasRefCounted<T extends object>(\n  value: T,\n): value is T & NodeJS.RefCounted {\n  return (\n    /**\n     * @note Guard against non-object values.\n     * E.g. `setTimeout` returns an object in Node.js but a number in the browser.\n     */\n    isObject(value) &&\n    typeof Reflect.get(value, 'ref') === 'function' &&\n    typeof Reflect.get(value, 'unref') === 'function'\n  )\n}\n"],"mappings":";;AAEA,SAAgB,cACd,OACgC;CAChC,OAKE,SAAS,KAAK,KACd,OAAO,QAAQ,IAAI,OAAO,KAAK,MAAM,cACrC,OAAO,QAAQ,IAAI,OAAO,OAAO,MAAM;AAE3C"}

package/lib/_chunks/http-handler.d.ts

@@ -0,0 +1,72 @@
+import { a as RequestHandler, c as RequestHandlerOptions, g as ResponseResolutionContext, l as ResponseResolver, o as RequestHandlerDefaultInfo } from "./request-handler.js";
+import { n as Path, r as PathParams, t as Match } from "./match-request-url.js";
+//#region src/http/http-handler.d.ts
+type HttpHandlerMethod = string | RegExp;
+interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
+  method: HttpHandlerMethod;
+  path: HttpRequestPredicate<PathParams>;
+}
+declare enum HttpMethods {
+  HEAD = "HEAD",
+  GET = "GET",
+  POST = "POST",
+  PUT = "PUT",
+  PATCH = "PATCH",
+  OPTIONS = "OPTIONS",
+  DELETE = "DELETE"
+}
+type RequestQuery = {
+  [queryName: string]: string;
+};
+type HttpRequestParsedResult = {
+  match: Match;
+  cookies: Record<string, string>;
+};
+type HttpRequestResolverExtras<Params extends PathParams> = {
+  params: Params;
+  cookies: Record<string, string>;
+};
+type HttpCustomPredicate<Params extends PathParams> = (args: {
+  request: Request;
+  cookies: Record<string, string>;
+}) => HttpCustomPredicateResult<Params> | Promise<HttpCustomPredicateResult<Params>>;
+type HttpCustomPredicateResult<Params extends PathParams> = boolean | {
+  matches: boolean;
+  params: Params;
+};
+type HttpRequestPredicate<Params extends PathParams> = Path | HttpCustomPredicate<Params>;
+/**
+ * Request handler for HTTP requests.
+ * Provides request matching based on method and URL.
+ */
+declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
+  constructor(method: HttpHandlerMethod, predicate: HttpRequestPredicate<PathParams>, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+  private checkRedundantQueryParameters;
+  parse(args: {
+    request: Request;
+    resolutionContext?: ResponseResolutionContext;
+  }): Promise<{
+    match: Match;
+    cookies: Record<string, string>;
+  }>;
+  predicate(args: {
+    request: Request;
+    parsedResult: HttpRequestParsedResult;
+    resolutionContext?: ResponseResolutionContext;
+  }): Promise<boolean>;
+  private matchMethod;
+  protected extendResolverArgs(args: {
+    request: Request;
+    parsedResult: HttpRequestParsedResult;
+  }): {
+    params: PathParams<string>;
+    cookies: Record<string, string>;
+  };
+  log(args: {
+    request: Request;
+    response: Response;
+  }): Promise<void>;
+}
+//#endregion
+export { HttpMethods as a, HttpRequestResolverExtras as c, HttpHandlerMethod as i, RequestQuery as l, HttpHandler as n, HttpRequestParsedResult as o, HttpHandlerInfo as r, HttpRequestPredicate as s, HttpCustomPredicate as t };
+//# sourceMappingURL=http-handler.d.ts.map

package/lib/_chunks/http-handler.js

@@ -0,0 +1,182 @@
+import { a as matchRequestUrl, f as httpStatusMessages, m as devUtils, r as toPublicUrl, s as getTimestamp, t as cookieStore } from "./cookie-store.js";
+import { t as RequestHandler } from "./request-handler.js";
+import { getCleanUrlString } from "../utils/get-clean-url-string.js";
+import { parseCookie } from "cookie";
+//#region src/core/utils/internal/is-string-equal.ts
+/**
+* Performs a case-insensitive comparison of two given strings.
+*/
+function isStringEqual(actual, expected) {
+	return actual.toLowerCase() === expected.toLowerCase();
+}
+//#endregion
+//#region src/core/utils/logging/get-status-code-color.ts
+/**
+* Returns a HEX color for a given response status code number.
+*/
+function getStatusCodeColor(status) {
+	if (status < 300) return "#69AB32";
+	if (status < 400) return "#F0BB4B";
+	return "#E95F5D";
+}
+//#endregion
+//#region src/core/utils/logging/serialize-request.ts
+/**
+* Formats a mocked request for introspection in browser's console.
+*/
+async function serializeRequest(request) {
+	const requestText = await request.clone().text();
+	return {
+		url: new URL(request.url),
+		method: request.method,
+		headers: Object.fromEntries(request.headers.entries()),
+		body: requestText
+	};
+}
+//#endregion
+//#region src/core/utils/logging/serialize-response.ts
+async function serializeResponse(response) {
+	const responseClone = response.clone();
+	const responseText = await responseClone.text();
+	const responseStatus = responseClone.status || 200;
+	return {
+		status: responseStatus,
+		statusText: responseClone.statusText || httpStatusMessages[responseStatus] || "OK",
+		headers: Object.fromEntries(responseClone.headers.entries()),
+		body: responseText
+	};
+}
+//#endregion
+//#region src/core/utils/request/get-request-cookies.ts
+function parseCookies(input) {
+	const parsedCookies = parseCookie(input);
+	const cookies = {};
+	for (const cookieName in parsedCookies) if (typeof parsedCookies[cookieName] !== "undefined") cookies[cookieName] = parsedCookies[cookieName];
+	return cookies;
+}
+function getAllDocumentCookies() {
+	return parseCookies(document.cookie);
+}
+/**
+* Returns whether the given request would carry cookies,
+* based on its `credentials` mode.
+*/
+function includesCredentials(request) {
+	switch (request.credentials) {
+		case "same-origin": return typeof location !== "undefined" && location.origin === new URL(request.url).origin;
+		case "include": return true;
+		default: return false;
+	}
+}
+function getDocumentCookies() {
+	if (typeof document === "undefined") return {};
+	return getAllDocumentCookies();
+}
+function getAllRequestCookies(request) {
+	const requestCookieHeader = request.headers.get("cookie");
+	const cookiesFromHeaders = requestCookieHeader ? parseCookies(requestCookieHeader) : {};
+	if (cookieStore === null || !includesCredentials(request)) return cookiesFromHeaders;
+	const cookiesFromDocument = getDocumentCookies();
+	const cookiesFromStore = cookieStore.getCookies(request.url);
+	const storedCookiesObject = Object.fromEntries(cookiesFromStore.map((cookie) => [cookie.key, cookie.value]));
+	return {
+		...cookiesFromDocument,
+		...storedCookiesObject,
+		...cookiesFromHeaders
+	};
+}
+//#endregion
+//#region src/http/http-handler.ts
+let HttpMethods = /* @__PURE__ */ function(HttpMethods) {
+	HttpMethods["HEAD"] = "HEAD";
+	HttpMethods["GET"] = "GET";
+	HttpMethods["POST"] = "POST";
+	HttpMethods["PUT"] = "PUT";
+	HttpMethods["PATCH"] = "PATCH";
+	HttpMethods["OPTIONS"] = "OPTIONS";
+	HttpMethods["DELETE"] = "DELETE";
+	return HttpMethods;
+}({});
+/**
+* Request handler for HTTP requests.
+* Provides request matching based on method and URL.
+*/
+var HttpHandler = class extends RequestHandler {
+	constructor(method, predicate, resolver, options) {
+		const displayPath = typeof predicate === "function" ? "[custom predicate]" : predicate;
+		super({
+			info: {
+				header: `${method}${displayPath ? ` ${displayPath}` : ""}`,
+				path: predicate,
+				method
+			},
+			resolver,
+			options
+		});
+		this.checkRedundantQueryParameters();
+	}
+	checkRedundantQueryParameters() {
+		const { method, path } = this.info;
+		if (!path || path instanceof RegExp || typeof path === "function") return;
+		if (getCleanUrlString(path) === path) return;
+		devUtils.warn(`Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`);
+	}
+	async parse(args) {
+		const url = new URL(args.request.url);
+		const cookies = getAllRequestCookies(args.request);
+		/**
+		* Handle custom predicate functions.
+		* @note Invoke this during parsing so the user can parse the path parameters
+		* manually. Otherwise, `params` is always an empty object, which isn't nice.
+		*/
+		if (typeof this.info.path === "function") {
+			const customPredicateResult = await this.info.path({
+				request: args.request,
+				cookies
+			});
+			return {
+				match: typeof customPredicateResult === "boolean" ? {
+					matches: customPredicateResult,
+					params: {}
+				} : customPredicateResult,
+				cookies
+			};
+		}
+		return {
+			match: this.info.path ? matchRequestUrl(url, this.info.path, args.resolutionContext?.baseUrl) : {
+				matches: false,
+				params: {}
+			},
+			cookies
+		};
+	}
+	async predicate(args) {
+		const hasMatchingMethod = this.matchMethod(args.request.method);
+		const hasMatchingUrl = args.parsedResult.match.matches;
+		return hasMatchingMethod && hasMatchingUrl;
+	}
+	matchMethod(actualMethod) {
+		return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : isStringEqual(this.info.method, actualMethod);
+	}
+	extendResolverArgs(args) {
+		return {
+			params: args.parsedResult.match?.params || {},
+			cookies: args.parsedResult.cookies
+		};
+	}
+	async log(args) {
+		const publicUrl = toPublicUrl(args.request.url);
+		const loggedRequest = await serializeRequest(args.request);
+		const loggedResponse = await serializeResponse(args.response);
+		const statusColor = getStatusCodeColor(loggedResponse.status);
+		console.groupCollapsed(devUtils.formatMessage(`${getTimestamp()} ${args.request.method} ${publicUrl} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`), `color:${statusColor}`, "color:inherit");
+		console.log("Request", loggedRequest);
+		console.log("Handler:", this);
+		console.log("Response", loggedResponse);
+		console.groupEnd();
+	}
+};
+//#endregion
+export { serializeRequest as a, serializeResponse as i, HttpMethods as n, getStatusCodeColor as o, getAllRequestCookies as r, HttpHandler as t };
+
+//# sourceMappingURL=http-handler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http-handler.js","names":[],"sources":["../../src/core/utils/internal/is-string-equal.ts","../../src/core/utils/logging/get-status-code-color.ts","../../src/core/utils/logging/serialize-request.ts","../../src/core/utils/logging/serialize-response.ts","../../src/core/utils/request/get-request-cookies.ts","../../src/http/http-handler.ts"],"sourcesContent":["/**\n * Performs a case-insensitive comparison of two given strings.\n */\nexport function isStringEqual(actual: string, expected: string): boolean {\n  return actual.toLowerCase() === expected.toLowerCase()\n}\n","export enum StatusCodeColor {\n  Success = '#69AB32',\n  Warning = '#F0BB4B',\n  Danger = '#E95F5D',\n}\n\n/**\n * Returns a HEX color for a given response status code number.\n */\nexport function getStatusCodeColor(status: number): StatusCodeColor {\n  if (status < 300) {\n    return StatusCodeColor.Success\n  }\n\n  if (status < 400) {\n    return StatusCodeColor.Warning\n  }\n\n  return StatusCodeColor.Danger\n}\n","export interface LoggedRequest {\n  url: URL\n  method: string\n  headers: Record<string, string>\n  body: string\n}\n\n/**\n * Formats a mocked request for introspection in browser's console.\n */\nexport async function serializeRequest(\n  request: Request,\n): Promise<LoggedRequest> {\n  const requestClone = request.clone()\n  const requestText = await requestClone.text()\n\n  return {\n    url: new URL(request.url),\n    method: request.method,\n    headers: Object.fromEntries(request.headers.entries()),\n    body: requestText,\n  }\n}\n","import { httpStatusMessages } from '../http-status-messages'\n\nexport interface SerializedResponse {\n  status: number\n  statusText: string\n  headers: Record<string, any>\n  body: string\n}\n\nexport async function serializeResponse(\n  response: Response,\n): Promise<SerializedResponse> {\n  const responseClone = response.clone()\n  const responseText = await responseClone.text()\n\n  // Normalize the response status and status text when logging\n  // since the default Response instance doesn't infer status texts\n  // from status codes. This has no effect on the actual response instance.\n  const responseStatus = responseClone.status || 200\n  const responseStatusText =\n    responseClone.statusText || httpStatusMessages[responseStatus] || 'OK'\n\n  return {\n    status: responseStatus,\n    statusText: responseStatusText,\n    headers: Object.fromEntries(responseClone.headers.entries()),\n    body: responseText,\n  }\n}\n","import { parseCookie } from 'cookie'\nimport { cookieStore } from '../cookie-store'\n\nfunction parseCookies(input: string): Record<string, string> {\n  const parsedCookies = parseCookie(input)\n  const cookies: Record<string, string> = {}\n\n  for (const cookieName in parsedCookies) {\n    if (typeof parsedCookies[cookieName] !== 'undefined') {\n      cookies[cookieName] = parsedCookies[cookieName]\n    }\n  }\n\n  return cookies\n}\n\nfunction getAllDocumentCookies() {\n  return parseCookies(document.cookie)\n}\n\n/**\n * Returns whether the given request would carry cookies,\n * based on its `credentials` mode.\n */\nfunction includesCredentials(request: Request): boolean {\n  switch (request.credentials) {\n    case 'same-origin': {\n      // Include cookies only when requesting a resource\n      // from the same origin as the current document.\n      return (\n        typeof location !== 'undefined' &&\n        location.origin === new URL(request.url).origin\n      )\n    }\n\n    case 'include': {\n      return true\n    }\n\n    default: {\n      return false\n    }\n  }\n}\n\nfunction getDocumentCookies(): Record<string, string> {\n  if (typeof document === 'undefined') {\n    return {}\n  }\n\n  return getAllDocumentCookies()\n}\n\nexport function getAllRequestCookies(request: Request): Record<string, string> {\n  const requestCookieHeader = request.headers.get('cookie')\n  const cookiesFromHeaders = requestCookieHeader\n    ? parseCookies(requestCookieHeader)\n    : {}\n\n  if (cookieStore === null || !includesCredentials(request)) {\n    return cookiesFromHeaders\n  }\n\n  const cookiesFromDocument = getDocumentCookies()\n\n  const cookiesFromStore = cookieStore.getCookies(request.url)\n  const storedCookiesObject = Object.fromEntries(\n    cookiesFromStore.map((cookie) => [cookie.key, cookie.value]),\n  )\n\n  return {\n    ...cookiesFromDocument,\n    ...storedCookiesObject,\n    ...cookiesFromHeaders,\n  }\n}\n","import type { ResponseResolutionContext } from '#core/utils/execute-handlers'\nimport { devUtils } from '#core/utils/internal/dev-utils'\nimport { isStringEqual } from '#core/utils/internal/is-string-equal'\nimport { getStatusCodeColor } from '#core/utils/logging/get-status-code-color'\nimport { getTimestamp } from '#core/utils/logging/get-timestamp'\nimport { serializeRequest } from '#core/utils/logging/serialize-request'\nimport { serializeResponse } from '#core/utils/logging/serialize-response'\nimport {\n  matchRequestUrl,\n  type Match,\n  type Path,\n  type PathParams,\n} from '#core/utils/matching/match-request-url'\nimport { toPublicUrl } from '#core/utils/request/to-public-url'\nimport { getAllRequestCookies } from '#core/utils/request/get-request-cookies'\nimport { getCleanUrlString } from '#utils/get-clean-url-string'\nimport {\n  RequestHandler,\n  type RequestHandlerDefaultInfo,\n  type RequestHandlerOptions,\n  type ResponseResolver,\n} from '#core/handlers/request-handler'\n\nexport type HttpHandlerMethod = string | RegExp\n\nexport interface HttpHandlerInfo extends RequestHandlerDefaultInfo {\n  method: HttpHandlerMethod\n  path: HttpRequestPredicate<PathParams>\n}\n\nexport enum HttpMethods {\n  HEAD = 'HEAD',\n  GET = 'GET',\n  POST = 'POST',\n  PUT = 'PUT',\n  PATCH = 'PATCH',\n  OPTIONS = 'OPTIONS',\n  DELETE = 'DELETE',\n}\n\nexport type RequestQuery = {\n  [queryName: string]: string\n}\n\nexport type HttpRequestParsedResult = {\n  match: Match\n  cookies: Record<string, string>\n}\n\nexport type HttpRequestResolverExtras<Params extends PathParams> = {\n  params: Params\n  cookies: Record<string, string>\n}\n\nexport type HttpCustomPredicate<Params extends PathParams> = (args: {\n  request: Request\n  cookies: Record<string, string>\n}) =>\n  HttpCustomPredicateResult<Params> | Promise<HttpCustomPredicateResult<Params>>\n\ntype HttpCustomPredicateResult<Params extends PathParams> =\n  | boolean\n  | {\n      matches: boolean\n      params: Params\n    }\n\nexport type HttpRequestPredicate<Params extends PathParams> =\n  Path | HttpCustomPredicate<Params>\n\n/**\n * Request handler for HTTP requests.\n * Provides request matching based on method and URL.\n */\nexport class HttpHandler extends RequestHandler<\n  HttpHandlerInfo,\n  HttpRequestParsedResult,\n  HttpRequestResolverExtras<any>\n> {\n  constructor(\n    method: HttpHandlerMethod,\n    predicate: HttpRequestPredicate<PathParams>,\n    resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>,\n    options?: RequestHandlerOptions,\n  ) {\n    const displayPath =\n      typeof predicate === 'function' ? '[custom predicate]' : predicate\n\n    super({\n      info: {\n        header: `${method}${displayPath ? ` ${displayPath}` : ''}`,\n        path: predicate,\n        method,\n      },\n      resolver,\n      options,\n    })\n\n    this.checkRedundantQueryParameters()\n  }\n\n  private checkRedundantQueryParameters() {\n    const { method, path } = this.info\n\n    if (!path || path instanceof RegExp || typeof path === 'function') {\n      return\n    }\n\n    const url = getCleanUrlString(path)\n\n    // Bypass request handler URLs that have no redundant characters.\n    if (url === path) {\n      return\n    }\n\n    devUtils.warn(\n      `Found a redundant usage of query parameters in the request handler URL for \"${method} ${path}\". Please match against a path instead and access query parameters using \"new URL(request.url).searchParams\" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`,\n    )\n  }\n\n  async parse(args: {\n    request: Request\n    resolutionContext?: ResponseResolutionContext\n  }) {\n    const url = new URL(args.request.url)\n    const cookies = getAllRequestCookies(args.request)\n\n    /**\n     * Handle custom predicate functions.\n     * @note Invoke this during parsing so the user can parse the path parameters\n     * manually. Otherwise, `params` is always an empty object, which isn't nice.\n     */\n    if (typeof this.info.path === 'function') {\n      const customPredicateResult = await this.info.path({\n        request: args.request,\n        cookies,\n      })\n\n      const match =\n        typeof customPredicateResult === 'boolean'\n          ? {\n              matches: customPredicateResult,\n              params: {},\n            }\n          : customPredicateResult\n\n      return {\n        match,\n        cookies,\n      }\n    }\n\n    const match = this.info.path\n      ? matchRequestUrl(url, this.info.path, args.resolutionContext?.baseUrl)\n      : { matches: false, params: {} }\n\n    return {\n      match,\n      cookies,\n    }\n  }\n\n  async predicate(args: {\n    request: Request\n    parsedResult: HttpRequestParsedResult\n    resolutionContext?: ResponseResolutionContext\n  }) {\n    const hasMatchingMethod = this.matchMethod(args.request.method)\n    const hasMatchingUrl = args.parsedResult.match.matches\n    return hasMatchingMethod && hasMatchingUrl\n  }\n\n  private matchMethod(actualMethod: string): boolean {\n    return this.info.method instanceof RegExp\n      ? this.info.method.test(actualMethod)\n      : isStringEqual(this.info.method, actualMethod)\n  }\n\n  protected extendResolverArgs(args: {\n    request: Request\n    parsedResult: HttpRequestParsedResult\n  }) {\n    return {\n      params: args.parsedResult.match?.params || {},\n      cookies: args.parsedResult.cookies,\n    }\n  }\n\n  async log(args: { request: Request; response: Response }) {\n    const publicUrl = toPublicUrl(args.request.url)\n    const loggedRequest = await serializeRequest(args.request)\n    const loggedResponse = await serializeResponse(args.response)\n    const statusColor = getStatusCodeColor(loggedResponse.status)\n\n    console.groupCollapsed(\n      devUtils.formatMessage(\n        `${getTimestamp()} ${args.request.method} ${publicUrl} (%c${\n          loggedResponse.status\n        } ${loggedResponse.statusText}%c)`,\n      ),\n      `color:${statusColor}`,\n      'color:inherit',\n    )\n    // eslint-disable-next-line no-console\n    console.log('Request', loggedRequest)\n    // eslint-disable-next-line no-console\n    console.log('Handler:', this)\n    // eslint-disable-next-line no-console\n    console.log('Response', loggedResponse)\n    console.groupEnd()\n  }\n}\n"],"mappings":";;;;;;;;AAGA,SAAgB,cAAc,QAAgB,UAA2B;CACvE,OAAO,OAAO,YAAY,MAAM,SAAS,YAAY;AACvD;;;;;;ACIA,SAAgB,mBAAmB,QAAiC;CAClE,IAAI,SAAS,KACX,OAAA;CAGF,IAAI,SAAS,KACX,OAAA;CAGF,OAAA;AACF;;;;;;ACTA,eAAsB,iBACpB,SACwB;CAExB,MAAM,cAAc,MADC,QAAQ,MACQ,CAAC,CAAC,KAAK;CAE5C,OAAO;EACL,KAAK,IAAI,IAAI,QAAQ,GAAG;EACxB,QAAQ,QAAQ;EAChB,SAAS,OAAO,YAAY,QAAQ,QAAQ,QAAQ,CAAC;EACrD,MAAM;CACR;AACF;;;ACbA,eAAsB,kBACpB,UAC6B;CAC7B,MAAM,gBAAgB,SAAS,MAAM;CACrC,MAAM,eAAe,MAAM,cAAc,KAAK;CAK9C,MAAM,iBAAiB,cAAc,UAAU;CAI/C,OAAO;EACL,QAAQ;EACR,YAJA,cAAc,cAAc,mBAAmB,mBAAmB;EAKlE,SAAS,OAAO,YAAY,cAAc,QAAQ,QAAQ,CAAC;EAC3D,MAAM;CACR;AACF;;;ACzBA,SAAS,aAAa,OAAuC;CAC3D,MAAM,gBAAgB,YAAY,KAAK;CACvC,MAAM,UAAkC,CAAC;CAEzC,KAAK,MAAM,cAAc,eACvB,IAAI,OAAO,cAAc,gBAAgB,aACvC,QAAQ,cAAc,cAAc;CAIxC,OAAO;AACT;AAEA,SAAS,wBAAwB;CAC/B,OAAO,aAAa,SAAS,MAAM;AACrC;;;;;AAMA,SAAS,oBAAoB,SAA2B;CACtD,QAAQ,QAAQ,aAAhB;EACE,KAAK,eAGH,OACE,OAAO,aAAa,eACpB,SAAS,WAAW,IAAI,IAAI,QAAQ,GAAG,CAAC,CAAC;EAI7C,KAAK,WACH,OAAO;EAGT,SACE,OAAO;CAEX;AACF;AAEA,SAAS,qBAA6C;CACpD,IAAI,OAAO,aAAa,aACtB,OAAO,CAAC;CAGV,OAAO,sBAAsB;AAC/B;AAEA,SAAgB,qBAAqB,SAA0C;CAC7E,MAAM,sBAAsB,QAAQ,QAAQ,IAAI,QAAQ;CACxD,MAAM,qBAAqB,sBACvB,aAAa,mBAAmB,IAChC,CAAC;CAEL,IAAI,gBAAgB,QAAQ,CAAC,oBAAoB,OAAO,GACtD,OAAO;CAGT,MAAM,sBAAsB,mBAAmB;CAE/C,MAAM,mBAAmB,YAAY,WAAW,QAAQ,GAAG;CAC3D,MAAM,sBAAsB,OAAO,YACjC,iBAAiB,KAAK,WAAW,CAAC,OAAO,KAAK,OAAO,KAAK,CAAC,CAC7D;CAEA,OAAO;EACL,GAAG;EACH,GAAG;EACH,GAAG;CACL;AACF;;;AC7CA,IAAY,cAAL,yBAAA,aAAA;CACL,YAAA,UAAA;CACA,YAAA,SAAA;CACA,YAAA,UAAA;CACA,YAAA,SAAA;CACA,YAAA,WAAA;CACA,YAAA,aAAA;CACA,YAAA,YAAA;;AACF,EAAA,CAAA,CAAA;;;;;AAoCA,IAAa,cAAb,cAAiC,eAI/B;CACA,YACE,QACA,WACA,UACA,SACA;EACA,MAAM,cACJ,OAAO,cAAc,aAAa,uBAAuB;EAE3D,MAAM;GACJ,MAAM;IACJ,QAAQ,GAAG,SAAS,cAAc,IAAI,gBAAgB;IACtD,MAAM;IACN;GACF;GACA;GACA;EACF,CAAC;EAED,KAAK,8BAA8B;CACrC;CAEA,gCAAwC;EACtC,MAAM,EAAE,QAAQ,SAAS,KAAK;EAE9B,IAAI,CAAC,QAAQ,gBAAgB,UAAU,OAAO,SAAS,YACrD;EAMF,IAHY,kBAAkB,IAGxB,MAAM,MACV;EAGF,SAAS,KACP,+EAA+E,OAAO,GAAG,KAAK,0MAChG;CACF;CAEA,MAAM,MAAM,MAGT;EACD,MAAM,MAAM,IAAI,IAAI,KAAK,QAAQ,GAAG;EACpC,MAAM,UAAU,qBAAqB,KAAK,OAAO;;;;;;EAOjD,IAAI,OAAO,KAAK,KAAK,SAAS,YAAY;GACxC,MAAM,wBAAwB,MAAM,KAAK,KAAK,KAAK;IACjD,SAAS,KAAK;IACd;GACF,CAAC;GAUD,OAAO;IACL,OARA,OAAO,0BAA0B,YAC7B;KACE,SAAS;KACT,QAAQ,CAAC;IACX,IACA;IAIJ;GACF;EACF;EAMA,OAAO;GACL,OALY,KAAK,KAAK,OACpB,gBAAgB,KAAK,KAAK,KAAK,MAAM,KAAK,mBAAmB,OAAO,IACpE;IAAE,SAAS;IAAO,QAAQ,CAAC;GAAE;GAI/B;EACF;CACF;CAEA,MAAM,UAAU,MAIb;EACD,MAAM,oBAAoB,KAAK,YAAY,KAAK,QAAQ,MAAM;EAC9D,MAAM,iBAAiB,KAAK,aAAa,MAAM;EAC/C,OAAO,qBAAqB;CAC9B;CAEA,YAAoB,cAA+B;EACjD,OAAO,KAAK,KAAK,kBAAkB,SAC/B,KAAK,KAAK,OAAO,KAAK,YAAY,IAClC,cAAc,KAAK,KAAK,QAAQ,YAAY;CAClD;CAEA,mBAA6B,MAG1B;EACD,OAAO;GACL,QAAQ,KAAK,aAAa,OAAO,UAAU,CAAC;GAC5C,SAAS,KAAK,aAAa;EAC7B;CACF;CAEA,MAAM,IAAI,MAAgD;EACxD,MAAM,YAAY,YAAY,KAAK,QAAQ,GAAG;EAC9C,MAAM,gBAAgB,MAAM,iBAAiB,KAAK,OAAO;EACzD,MAAM,iBAAiB,MAAM,kBAAkB,KAAK,QAAQ;EAC5D,MAAM,cAAc,mBAAmB,eAAe,MAAM;EAE5D,QAAQ,eACN,SAAS,cACP,GAAG,aAAa,EAAE,GAAG,KAAK,QAAQ,OAAO,GAAG,UAAU,MACpD,eAAe,OAChB,GAAG,eAAe,WAAW,IAChC,GACA,SAAS,eACT,eACF;EAEA,QAAQ,IAAI,WAAW,aAAa;EAEpC,QAAQ,IAAI,YAAY,IAAI;EAE5B,QAAQ,IAAI,YAAY,cAAc;EACtC,QAAQ,SAAS;CACnB;AACF"}