@mswjs/interceptors 0.41.9 → 0.42.1

package/lib/node/has-configurable-global-CJCh_g1I.js

@@ -0,0 +1,22 @@
+import { a as getDeepPropertyDescriptor } from "./net-DtMnyEeg.js";
+//#region src/utils/has-configurable-global.ts
+/**
+* Returns a boolean indicating whether the given global property
+* is defined and is configurable.
+*/
+function hasConfigurableGlobal(propertyName) {
+	const match = getDeepPropertyDescriptor(globalThis, propertyName);
+	if (typeof match === "undefined") return false;
+	const { descriptor } = match;
+	if (typeof descriptor.get === "function" && typeof descriptor.get() === "undefined") return false;
+	if (typeof descriptor.get === "undefined" && descriptor.value == null) return false;
+	if (typeof descriptor.set === "undefined" && !descriptor.configurable) {
+		console.error(`[MSW] Failed to apply interceptor: the global \`${propertyName}\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`);
+		return false;
+	}
+	return true;
+}
+//#endregion
+export { hasConfigurableGlobal as t };
+
+//# sourceMappingURL=has-configurable-global-CJCh_g1I.js.map

package/lib/node/has-configurable-global-CJCh_g1I.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-configurable-global-CJCh_g1I.js","names":[],"sources":["../../src/utils/has-configurable-global.ts"],"sourcesContent":["import { getDeepPropertyDescriptor } from './patches-registry'\n\n/**\n * Returns a boolean indicating whether the given global property\n * is defined and is configurable.\n */\nexport function hasConfigurableGlobal(propertyName: string): boolean {\n  const match = getDeepPropertyDescriptor(globalThis, propertyName)\n\n  // The property is not set at all.\n  if (typeof match === 'undefined') {\n    return false\n  }\n\n  const { descriptor } = match\n\n  // The property is set to a getter that returns undefined.\n  if (\n    typeof descriptor.get === 'function' &&\n    typeof descriptor.get() === 'undefined'\n  ) {\n    return false\n  }\n\n  // The property is set to a value equal to undefined.\n  if (typeof descriptor.get === 'undefined' && descriptor.value == null) {\n    return false\n  }\n\n  if (typeof descriptor.set === 'undefined' && !descriptor.configurable) {\n    console.error(\n      `[MSW] Failed to apply interceptor: the global \\`${propertyName}\\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`\n    )\n    return false\n  }\n\n  return true\n}\n"],"mappings":";;;;;;AAMA,SAAgB,sBAAsB,cAA+B;CACnE,MAAM,QAAQ,0BAA0B,YAAY,YAAY;CAGhE,IAAI,OAAO,UAAU,aACnB,OAAO;CAGT,MAAM,EAAE,eAAe;CAGvB,IACE,OAAO,WAAW,QAAQ,cAC1B,OAAO,WAAW,IAAI,MAAM,aAE5B,OAAO;CAIT,IAAI,OAAO,WAAW,QAAQ,eAAe,WAAW,SAAS,MAC/D,OAAO;CAGT,IAAI,OAAO,WAAW,QAAQ,eAAe,CAAC,WAAW,cAAc;EACrE,QAAQ,MACN,mDAAmD,aAAa,mKAClE;EACA,OAAO;CACT;CAEA,OAAO;AACT"}

package/lib/node/http-CB9rQ7i_.d.ts

@@ -0,0 +1,105 @@
+import { n as Logger } from "./interceptor-dtJZ_9QT.js";
+import { TypedEvent } from "rettime";
+//#region src/request-controller.d.ts
+interface RequestControllerSource {
+  passthrough(): void | Promise<void>;
+  respondWith(response: Response): void | Promise<void>;
+  errorWith(reason?: unknown): void | Promise<void>;
+}
+interface RequestControllerOptions {
+  logger: Logger;
+  requestId: string;
+}
+declare class RequestController {
+  #private;
+  protected readonly request: Request;
+  protected readonly source: RequestControllerSource;
+  protected readonly options?: RequestControllerOptions | undefined;
+  static PENDING: 0;
+  static PASSTHROUGH: 1;
+  static RESPONSE: 2;
+  static ERROR: 3;
+  readyState: number;
+  /**
+   * A Promise that resolves when this controller handles a request.
+   * See `controller.readyState` for more information on the handling result.
+   */
+  handled: Promise<void>;
+  constructor(request: Request, source: RequestControllerSource, options?: RequestControllerOptions | undefined);
+  /**
+   * Perform this request as-is.
+   */
+  passthrough(): Promise<void>;
+  /**
+   * Respond to this request with the given `Response` instance.
+   *
+   * @example
+   * controller.respondWith(new Response())
+   * controller.respondWith(Response.json({ id }))
+   * controller.respondWith(Response.error())
+   */
+  respondWith(response: Response): void;
+  /**
+   * Error this request with the given reason.
+   *
+   * @example
+   * controller.errorWith()
+   * controller.errorWith(new Error('Oops!'))
+   * controller.errorWith({ message: 'Oops!'})
+   */
+  errorWith(reason?: unknown): void;
+}
+//#endregion
+//#region src/events/http.d.ts
+interface HttpRequestEventData {
+  request: Request;
+  requestId: string;
+  initiator: unknown;
+  controller: RequestController;
+}
+declare class HttpRequestEvent<DataType extends HttpRequestEventData = HttpRequestEventData> extends TypedEvent<DataType, void, 'request'> {
+  request: Request;
+  requestId: string;
+  initiator: unknown;
+  controller: RequestController;
+  constructor(data: DataType);
+}
+type HttpResponseType = 'mock' | 'original';
+interface HttpResponseEventData {
+  response: Response;
+  responseType: HttpResponseType;
+  request: Request;
+  requestId: string;
+  initiator: unknown;
+}
+declare class HttpResponseEvent<DataType extends HttpResponseEventData = HttpResponseEventData> extends TypedEvent<DataType, void, 'response'> {
+  response: Response;
+  responseType: HttpResponseType;
+  request: Request;
+  requestId: string;
+  initiator: unknown;
+  constructor(data: DataType);
+}
+interface UnhandledHttpExceptionEventData {
+  error: unknown;
+  request: Request;
+  requestId: string;
+  initiator: unknown;
+  controller: RequestController;
+}
+declare class UnhandledHttpException<DataType extends UnhandledHttpExceptionEventData = UnhandledHttpExceptionEventData> extends TypedEvent<DataType, void, 'unhandledException'> {
+  error: unknown;
+  request: Request;
+  requestId: string;
+  initiator: unknown;
+  controller: RequestController;
+  constructor(data: DataType);
+}
+type HttpRequestEventMap = {
+  request: HttpRequestEvent;
+  response: HttpResponseEvent;
+  unhandledException: UnhandledHttpException;
+};
+//#endregion
+export { RequestControllerSource as a, RequestController as i, HttpRequestEventMap as n, HttpResponseEvent as r, HttpRequestEvent as t };
+//# sourceMappingURL=http-CB9rQ7i_.d.ts.map

package/lib/{browser/interceptors/WebSocket/index.d.mts → node/index.d.ts}

@@ -1,25 +1,13 @@
-import { r as Interceptor } from "../../Interceptor-gqKgs-aF.mjs";
-
-//#region src/interceptors/WebSocket/utils/events.d.ts
-declare const kCancelable: unique symbol;
-declare const kDefaultPrevented: unique symbol;
-/**
- * A `MessageEvent` superset that supports event cancellation
- * in Node.js. It's rather non-intrusive so it can be safely
- * used in the browser as well.
- *
- * @see https://github.com/nodejs/node/issues/51767
- */
-declare class CancelableMessageEvent<T = any> extends MessageEvent<T> {
-  [kCancelable]: boolean;
-  [kDefaultPrevented]: boolean;
-  constructor(type: string, init: MessageEventInit<T>);
-  get cancelable(): boolean;
-  set cancelable(nextCancelable: boolean);
-  get defaultPrevented(): boolean;
-  set defaultPrevented(nextDefaultPrevented: boolean);
-  preventDefault(): void;
+import { t as Interceptor } from "./interceptor-dtJZ_9QT.js";
+import { t as BatchInterceptor } from "./batch-interceptor-CPjFK2td.js";
+import { a as RequestControllerSource, i as RequestController, n as HttpRequestEventMap, r as HttpResponseEvent, t as HttpRequestEvent } from "./http-CB9rQ7i_.js";
+import { TypedEvent } from "rettime";
+//#region src/interceptor-error.d.ts
+declare class InterceptorError extends Error {
+  constructor(message?: string);
 }
+//#endregion
+//#region src/interceptors/WebSocket/utils/events.d.ts
 interface CloseEventInit extends EventInit {
   code?: number;
   reason?: string;
@@ -31,19 +19,9 @@ declare class CloseEvent extends Event {
   wasClean: boolean;
   constructor(type: string, init?: CloseEventInit);
 }
-declare class CancelableCloseEvent extends CloseEvent {
-  [kCancelable]: boolean;
-  [kDefaultPrevented]: boolean;
-  constructor(type: string, init?: CloseEventInit);
-  get cancelable(): boolean;
-  set cancelable(nextCancelable: boolean);
-  get defaultPrevented(): boolean;
-  set defaultPrevented(nextDefaultPrevented: boolean);
-  preventDefault(): void;
-}
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketTransport.d.ts
-type WebSocketData = string | ArrayBufferLike | Blob | ArrayBufferView;
+//#region src/interceptors/WebSocket/web-socket-transport.d.ts
+type WebSocketData = string | ArrayBuffer | Blob | ArrayBufferView<ArrayBuffer>;
 type WebSocketTransportEventMap = {
   incoming: MessageEvent<WebSocketData>;
   outgoing: MessageEvent<WebSocketData>;
@@ -65,7 +43,7 @@ interface WebSocketTransport {
   close(code?: number, reason?: string): void;
 }
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketOverride.d.ts
+//#region src/interceptors/WebSocket/web-socket-override.d.ts
 type WebSocketEventListener<EventType extends WebSocketEventMap[keyof WebSocketEventMap] = Event> = (this: WebSocket, event: EventType) => void;
 declare const kPassthroughPromise: unique symbol;
 declare const kOnSend: unique symbol;
@@ -111,7 +89,7 @@ declare class WebSocketOverride extends EventTarget implements WebSocket {
   removeEventListener<K extends keyof WebSocketEventMap>(type: K, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
 }
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketClientConnection.d.ts
+//#region src/interceptors/WebSocket/web-socket-client-connection.d.ts
 declare const kEmitter$1: unique symbol;
 interface WebSocketClientEventMap {
   message: MessageEvent<WebSocketData>;
@@ -157,7 +135,7 @@ declare class WebSocketClientConnection implements WebSocketClientConnectionProt
   close(code?: number, reason?: string): void;
 }
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketClassTransport.d.ts
+//#region src/interceptors/WebSocket/web-socket-class-transport.d.ts
 /**
  * Abstraction over the given mock `WebSocket` instance that allows
  * for controlling that instance (e.g. sending and receiving messages).
@@ -171,7 +149,7 @@ declare class WebSocketClassTransport extends EventTarget implements WebSocketTr
   close(code: number, reason?: string): void;
 }
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketServerConnection.d.ts
+//#region src/interceptors/WebSocket/web-socket-server-connection.d.ts
 declare const kEmitter: unique symbol;
 declare const kSend: unique symbol;
 interface WebSocketServerEventMap {
@@ -239,11 +217,17 @@ declare class WebSocketServerConnection implements WebSocketServerConnectionProt
   private handleRealClose;
 }
 //#endregion
-//#region src/interceptors/WebSocket/index.d.ts
-type WebSocketEventMap$1 = {
-  connection: [args: WebSocketConnectionData];
-};
-type WebSocketConnectionData = {
+//#region src/events/websocket.d.ts
+/**
+ * The connection information.
+ */
+interface WebSocketConnectionInfo {
+  /**
+   * The protocols supported by the WebSocket client.
+   */
+  protocols: string | Array<string> | undefined;
+}
+interface WebSocketConnectionEventData {
   /**
    * The incoming WebSocket client connection.
    */
@@ -252,26 +236,102 @@ type WebSocketConnectionData = {
    * The original WebSocket server connection.
    */
   server: WebSocketServerConnection;
-  /**
-   * The connection information.
-   */
-  info: {
-    /**
-     * The protocols supported by the WebSocket client.
-     */
-    protocols: string | Array<string> | undefined;
-  };
+  info: WebSocketConnectionInfo;
+}
+declare class WebSocketConnectionEvent<DataType extends WebSocketConnectionEventData = WebSocketConnectionEventData> extends TypedEvent<DataType, void, 'connection'> {
+  client: WebSocketClientConnection;
+  server: WebSocketServerConnection;
+  info: WebSocketConnectionInfo;
+  constructor(data: DataType);
+}
+type WebSocketEventMap$1 = {
+  connection: WebSocketConnectionEvent;
 };
+//#endregion
+//#region src/create-request-id.d.ts
 /**
- * Intercept the outgoing WebSocket connections created using
- * the global `WebSocket` class.
+ * Generate a random ID string to represent a request.
+ * @example
+ * createRequestId()
+ * // "f774b6c9c600f"
  */
-declare class WebSocketInterceptor extends Interceptor<WebSocketEventMap$1> {
-  static symbol: symbol;
-  constructor();
-  protected checkEnvironment(): boolean;
-  protected setup(): void;
+declare function createRequestId(): string;
+//#endregion
+//#region src/utils/get-clean-url.d.ts
+/**
+ * Removes query parameters and hashes from a given URL.
+ */
+declare function getCleanUrl(url: URL, isAbsolute?: boolean): string;
+//#endregion
+//#region src/utils/buffer-utils.d.ts
+declare function encodeBuffer(text: string): Uint8Array<ArrayBuffer>;
+declare function decodeBuffer(buffer: AllowSharedBufferSource, encoding?: string): string;
+//#endregion
+//#region src/utils/fetch-utils.d.ts
+interface FetchRequestInit extends Omit<RequestInit, 'mode'> {
+  mode?: RequestMode | 'websocket' | 'webtransport';
+  duplex?: 'half' | 'full';
+}
+declare class FetchRequest extends Request {
+  #private;
+  /**
+   * Check if the given request method is configurable.
+   * @see https://fetch.spec.whatwg.org/#methods
+   */
+  static isConfigurableMethod(method: string): boolean;
+  static isMethodWithBody(method: string): boolean;
+  /**
+   * Check if the given request `mode` is configurable.
+   * @see https://fetch.spec.whatwg.org/#concept-request-mode
+   */
+  static isConfigurableMode(mode: string): boolean;
+  constructor(input: URL | RequestInfo, init?: FetchRequestInit);
 }
+interface FetchResponseInit extends ResponseInit {
+  url?: string;
+}
+declare class FetchResponse extends Response {
+  #private;
+  static from(response: Response, init?: FetchResponseInit): FetchResponse;
+  /**
+   * Response status codes for responses that cannot have body.
+   * @see https://fetch.spec.whatwg.org/#statuses
+   */
+  static readonly STATUS_CODES_WITHOUT_BODY: number[];
+  static readonly STATUS_CODES_WITH_REDIRECT: number[];
+  static isConfigurableStatusCode(status: number): boolean;
+  static isRedirectResponse(status: number): boolean;
+  /**
+   * Returns a boolean indicating whether the given response status
+   * code represents a response that can have a body.
+   */
+  static isResponseWithBody(status: number): boolean;
+  static setStatus(status: number, response: Response): void;
+  static setUrl(url: string | undefined, response: Response): void;
+  /**
+   * Parses the given raw HTTP headers into a Fetch API `Headers` instance.
+   */
+  static parseRawHeaders(rawHeaders: Array<string>): Headers;
+  /**
+   * Safely clones the given `Response`.
+   * Coerces response clone exceptions into 500 mocked responses.
+   * Handy in the environments that introduce arbitrary response
+   * cloning restrictions, like "101 Switching Protocols" cloning
+   * in "miniflare".
+   */
+  static clone(response: Response): Response;
+  constructor(body?: BodyInit | null, init?: FetchResponseInit);
+  clone(): Response;
+}
+//#endregion
+//#region src/utils/resolve-web-socket-url.d.ts
+/**
+ * Resolve potentially relative WebSocket URLs the same way
+ * the browser does (replace the protocol, use the origin, etc).
+ *
+ * @see https://websockets.spec.whatwg.org//#dom-websocket-websocket
+ */
+declare function resolveWebSocketUrl(url: string | URL): string;
 //#endregion
-export { CancelableCloseEvent, CancelableMessageEvent, CloseEvent, WebSocketClientConnection, WebSocketClientConnectionProtocol, WebSocketClientEventMap, WebSocketConnectionData, type WebSocketData, WebSocketEventMap$1 as WebSocketEventMap, WebSocketInterceptor, WebSocketServerConnection, WebSocketServerConnectionProtocol, WebSocketServerEventMap, type WebSocketTransport };
-//# sourceMappingURL=index.d.mts.map
+export { BatchInterceptor, FetchRequest, FetchResponse, type HttpRequestEvent, type HttpRequestEventMap, type HttpResponseEvent, Interceptor, InterceptorError, RequestController, type RequestControllerSource, type WebSocketConnectionEvent, type WebSocketEventMap$1 as WebSocketEventMap, createRequestId, decodeBuffer, encodeBuffer, getCleanUrl, resolveWebSocketUrl };
+//# sourceMappingURL=index.d.ts.map

package/lib/node/{index.mjs → index.js}

@@ -1,18 +1,15 @@
-import { a as RequestController, c as Interceptor, d as getGlobalSymbol, i as createRequestId, l as InterceptorReadyState, n as FetchResponse, s as INTERNAL_REQUEST_ID_HEADER_NAME, t as FetchRequest, u as deleteGlobalSymbol } from "./fetchUtils-BKJ1XmiO.mjs";
-import { t as BatchInterceptor } from "./BatchInterceptor-C4-RX5rg.mjs";
-import { n as encodeBuffer, t as decodeBuffer } from "./bufferUtils-DxPxwff_.mjs";
-import { t as getRawRequest } from "./getRawRequest-C2-1urzA.mjs";
-
-//#region src/utils/getCleanUrl.ts
+import { i as Interceptor, n as encodeBuffer, t as decodeBuffer } from "./buffer-utils-BvPY1Tc-.js";
+import { t as BatchInterceptor } from "./batch-interceptor-ByEZVih3.js";
+import { d as createRequestId, f as RequestController, n as FetchResponse, p as InterceptorError, t as FetchRequest } from "./fetch-utils-Dw1PsmtX.js";
+//#region src/utils/get-clean-url.ts
 /**
 * Removes query parameters and hashes from a given URL.
 */
 function getCleanUrl(url, isAbsolute = true) {
 	return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
 }
-
 //#endregion
-//#region src/utils/resolveWebSocketUrl.ts
+//#region src/utils/resolve-web-socket-url.ts
 /**
 * Resolve potentially relative WebSocket URLs the same way
 * the browser does (replace the protocol, use the origin, etc).
@@ -33,7 +30,7 @@ function resolveWebSocketUrl(url) {
 	if (url.hash !== "") throw new SyntaxError(`Failed to construct 'WebSocket': The URL contains a fragment identifier ('${url.hash}'). Fragment identifiers are not allowed in WebSocket URLs.`);
 	return url.href;
 }
-
 //#endregion
-export { BatchInterceptor, FetchRequest, FetchResponse, INTERNAL_REQUEST_ID_HEADER_NAME, Interceptor, InterceptorReadyState, RequestController, createRequestId, decodeBuffer, deleteGlobalSymbol, encodeBuffer, getCleanUrl, getGlobalSymbol, getRawRequest, resolveWebSocketUrl };
-//# sourceMappingURL=index.mjs.map
+export { BatchInterceptor, FetchRequest, FetchResponse, Interceptor, InterceptorError, RequestController, createRequestId, decodeBuffer, encodeBuffer, getCleanUrl, resolveWebSocketUrl };
+
+//# sourceMappingURL=index.js.map

package/lib/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/utils/get-clean-url.ts","../../src/utils/resolve-web-socket-url.ts"],"sourcesContent":["/**\n * Removes query parameters and hashes from a given URL.\n */\nexport function getCleanUrl(url: URL, isAbsolute: boolean = true): string {\n  return [isAbsolute && url.origin, url.pathname].filter(Boolean).join('')\n}\n","/**\n * Resolve potentially relative WebSocket URLs the same way\n * the browser does (replace the protocol, use the origin, etc).\n *\n * @see https://websockets.spec.whatwg.org//#dom-websocket-websocket\n */\nexport function resolveWebSocketUrl(url: string | URL): string {\n  if (typeof url === 'string') {\n    /**\n     * @note Cast the string to a URL first so the parsing errors\n     * are thrown as a part of the WebSocket constructor, not consumers.\n     */\n    const urlRecord = new URL(\n      url,\n      typeof location !== 'undefined' ? location.href : undefined\n    )\n\n    return resolveWebSocketUrl(urlRecord)\n  }\n\n  if (url.protocol === 'http:') {\n    url.protocol = 'ws:'\n  } else if (url.protocol === 'https:') {\n    url.protocol = 'wss:'\n  }\n\n  if (url.protocol !== 'ws:' && url.protocol !== 'wss:') {\n    /**\n     * @note These errors are modeled after the browser errors.\n     * The exact error messages aren't provided in the specification.\n     * Node.js uses more obscure error messages that I don't wish to replicate.\n     */\n    throw new SyntaxError(\n      `Failed to construct 'WebSocket': The URL's scheme must be either 'http', 'https', 'ws', or 'wss'. '${url.protocol}' is not allowed.`\n    )\n  }\n\n  if (url.hash !== '') {\n    throw new SyntaxError(\n      `Failed to construct 'WebSocket': The URL contains a fragment identifier ('${url.hash}'). Fragment identifiers are not allowed in WebSocket URLs.`\n    )\n  }\n\n  return url.href\n}\n"],"mappings":";;;;;;;AAGA,SAAgB,YAAY,KAAU,aAAsB,MAAc;CACxE,OAAO,CAAC,cAAc,IAAI,QAAQ,IAAI,QAAQ,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,EAAE;AACzE;;;;;;;;;ACCA,SAAgB,oBAAoB,KAA2B;CAC7D,IAAI,OAAO,QAAQ,UAUjB,OAAO,oBAAoB,IALL,IACpB,KACA,OAAO,aAAa,cAAc,SAAS,OAAO,KAAA,CAGjB,CAAC;CAGtC,IAAI,IAAI,aAAa,SACnB,IAAI,WAAW;MACV,IAAI,IAAI,aAAa,UAC1B,IAAI,WAAW;CAGjB,IAAI,IAAI,aAAa,SAAS,IAAI,aAAa;;;;;;CAM7C,MAAM,IAAI,YACR,sGAAsG,IAAI,SAAS,kBACrH;CAGF,IAAI,IAAI,SAAS,IACf,MAAM,IAAI,YACR,6EAA6E,IAAI,KAAK,4DACxF;CAGF,OAAO,IAAI;AACb"}

package/lib/node/interceptor-dtJZ_9QT.d.ts

@@ -0,0 +1,50 @@
+import { DefaultEventMap, Emitter } from "rettime";
+//#region src/disposable.d.ts
+type DisposableSubscription = () => void;
+declare class Disposable {
+  protected subscriptions: Array<DisposableSubscription>;
+  dispose(): void;
+}
+//#endregion
+//#region src/utils/logger.d.ts
+type LogLevel = 'default' | 'verbose';
+interface Logger {
+  info(message: string, ...positionals: Array<unknown>): void;
+  verbose(message: string, ...positionals: Array<unknown>): void;
+  isEnabled(level: LogLevel): boolean;
+}
+//#endregion
+//#region src/interceptor.d.ts
+declare enum InterceptorReadyState {
+  INACTIVE = "INACTIVE",
+  ACTIVE = "ACTIVE",
+  DISPOSED = "DISPOSED"
+}
+declare global {
+  var __MSW_INTERCEPTORS_REGISTRY: Map<symbol, Interceptor<any>> | undefined;
+}
+declare abstract class Interceptor<Events extends DefaultEventMap> extends Disposable {
+  #private;
+  ['constructor']: typeof Interceptor;
+  protected emitter: Emitter<Events>;
+  protected readonly logger: Logger;
+  readyState: InterceptorReadyState;
+  static readonly symbol: symbol;
+  static singleton<T extends Interceptor<any>>(InterceptorClass: (new () => T) & {
+    symbol: symbol;
+  }): T;
+  constructor();
+  protected abstract predicate(): boolean;
+  protected abstract setup(): void;
+  apply(owner?: object): void;
+  dispose(owner?: object): void;
+  on: Emitter<Events>['on'];
+  once: Emitter<Events>['once'];
+  listeners: Emitter<Events>['listeners'];
+  listenerCount: Emitter<Events>['listenerCount'];
+  removeListener: Emitter<Events>['removeListener'];
+  removeAllListeners: Emitter<Events>['removeAllListeners'];
+}
+//#endregion
+export { Logger as n, Interceptor as t };
+//# sourceMappingURL=interceptor-dtJZ_9QT.d.ts.map

package/lib/node/interceptors/ClientRequest/index.d.ts

@@ -0,0 +1,14 @@
+import { t as Interceptor } from "../../interceptor-dtJZ_9QT.js";
+import { n as HttpRequestEventMap } from "../../http-CB9rQ7i_.js";
+//#region src/interceptors/ClientRequest/index.d.ts
+/**
+ * Interceptor for HTTP requests in Node.js made via `http.ClientRequest`.
+ */
+declare class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol: symbol;
+  protected predicate(): boolean;
+  protected setup(): void;
+}
+//#endregion
+export { ClientRequestInterceptor };
+//# sourceMappingURL=index.d.ts.map

package/lib/node/interceptors/ClientRequest/index.js

@@ -0,0 +1,67 @@
+import { i as forwardHttpEvents, o as runInRequestContext, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
+import { o as patchesRegistry } from "../../net-DtMnyEeg.js";
+import http from "node:http";
+import https from "node:https";
+//#region src/interceptors/ClientRequest/index.ts
+/**
+* Interceptor for HTTP requests in Node.js made via `http.ClientRequest`.
+*/
+var ClientRequestInterceptor = class extends Interceptor {
+	static {
+		this.symbol = Symbol.for("client-request-interceptor");
+	}
+	predicate() {
+		return true;
+	}
+	setup() {
+		const requestSource = Interceptor.singleton(NodeHttpRequestSource);
+		const requestLogger = this.logger;
+		requestSource.apply(this);
+		this.subscriptions.push(() => {
+			requestSource.dispose(this);
+		});
+		this.subscriptions.push(forwardHttpEvents({
+			source: requestSource,
+			emitter: this.emitter,
+			predicate: (initiator) => {
+				return initiator instanceof http.ClientRequest;
+			}
+		}));
+		this.subscriptions.push(patchesRegistry.applyPatch(http, "ClientRequest", (ClientRequest) => {
+			return new Proxy(ClientRequest, { construct(target, args, newTarget) {
+				return runInRequestContext(() => {
+					return Reflect.construct(target, args, newTarget);
+				}, requestLogger);
+			} });
+		}), patchesRegistry.applyPatch(http, "get", (httpGet) => {
+			return function mockHttpGet(...args) {
+				return runInRequestContext(() => {
+					return httpGet(...args);
+				}, requestLogger);
+			};
+		}), patchesRegistry.applyPatch(http, "request", (httpRequest) => {
+			return function mockHttpRequest(...args) {
+				return runInRequestContext(() => {
+					return httpRequest(...args);
+				}, requestLogger);
+			};
+		}), patchesRegistry.applyPatch(https, "get", (httpsGet) => {
+			return function mockHttpsGet(...args) {
+				return runInRequestContext(() => {
+					return httpsGet(...args);
+				}, requestLogger);
+			};
+		}), patchesRegistry.applyPatch(https, "request", (httpsRequest) => {
+			return function mockHttpsRequest(...args) {
+				return runInRequestContext(() => {
+					return httpsRequest(...args);
+				}, requestLogger);
+			};
+		}));
+	}
+};
+//#endregion
+export { ClientRequestInterceptor };
+
+//# sourceMappingURL=index.js.map

package/lib/node/interceptors/ClientRequest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/interceptors/ClientRequest/index.ts"],"sourcesContent":["import http from 'node:http'\nimport https from 'node:https'\nimport { runInRequestContext } from '#/src/request-context'\nimport { patchesRegistry } from '#/src/utils/patches-registry'\nimport { forwardHttpEvents } from '#/src/interceptors/http/forward-events'\nimport { NodeHttpRequestSource } from '#/src/interceptors/http/source'\nimport { Interceptor } from '../../interceptor'\nimport { HttpRequestEventMap } from '#/src/events/http'\n\n/**\n * Interceptor for HTTP requests in Node.js made via `http.ClientRequest`.\n */\nexport class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol.for('client-request-interceptor')\n\n  protected predicate(): boolean {\n    return true\n  }\n\n  protected setup(): void {\n    const requestSource = Interceptor.singleton(NodeHttpRequestSource)\n    const requestLogger = this.logger\n    requestSource.apply(this)\n    this.subscriptions.push(() => {\n      requestSource.dispose(this)\n    })\n\n    this.subscriptions.push(\n      forwardHttpEvents({\n        source: requestSource,\n        emitter: this.emitter,\n        predicate: (initiator) => {\n          return initiator instanceof http.ClientRequest\n        },\n      })\n    )\n\n    this.subscriptions.push(\n      patchesRegistry.applyPatch(http, 'ClientRequest', (ClientRequest) => {\n        return new Proxy(ClientRequest, {\n          construct(target, args, newTarget) {\n            return runInRequestContext(() => {\n              return Reflect.construct(target, args, newTarget)\n            }, requestLogger)\n          },\n        })\n      }),\n      patchesRegistry.applyPatch(http, 'get', (httpGet) => {\n        return function mockHttpGet(...args) {\n          return runInRequestContext(() => {\n            return httpGet(...(args as [any, any]))\n          }, requestLogger)\n        }\n      }),\n      patchesRegistry.applyPatch(http, 'request', (httpRequest) => {\n        return function mockHttpRequest(...args) {\n          return runInRequestContext(() => {\n            return httpRequest(...(args as [any, any]))\n          }, requestLogger)\n        }\n      }),\n      patchesRegistry.applyPatch(https, 'get', (httpsGet) => {\n        return function mockHttpsGet(...args) {\n          return runInRequestContext(() => {\n            return httpsGet(...(args as [any, any]))\n          }, requestLogger)\n        }\n      }),\n      patchesRegistry.applyPatch(https, 'request', (httpsRequest) => {\n        return function mockHttpsRequest(...args) {\n          return runInRequestContext(() => {\n            return httpsRequest(...(args as [any, any]))\n          }, requestLogger)\n        }\n      })\n    )\n  }\n}\n"],"mappings":";;;;;;;;;AAYA,IAAa,2BAAb,cAA8C,YAAiC;;EAC7D,KAAA,SAAA,OAAO,IAAI,4BAA4B;;CAEvD,YAA+B;EAC7B,OAAO;CACT;CAEA,QAAwB;EACtB,MAAM,gBAAgB,YAAY,UAAU,qBAAqB;EACjE,MAAM,gBAAgB,KAAK;EAC3B,cAAc,MAAM,IAAI;EACxB,KAAK,cAAc,WAAW;GAC5B,cAAc,QAAQ,IAAI;EAC5B,CAAC;EAED,KAAK,cAAc,KACjB,kBAAkB;GAChB,QAAQ;GACR,SAAS,KAAK;GACd,YAAY,cAAc;IACxB,OAAO,qBAAqB,KAAK;GACnC;EACF,CAAC,CACH;EAEA,KAAK,cAAc,KACjB,gBAAgB,WAAW,MAAM,kBAAkB,kBAAkB;GACnE,OAAO,IAAI,MAAM,eAAe,EAC9B,UAAU,QAAQ,MAAM,WAAW;IACjC,OAAO,0BAA0B;KAC/B,OAAO,QAAQ,UAAU,QAAQ,MAAM,SAAS;IAClD,GAAG,aAAa;GAClB,EACF,CAAC;EACH,CAAC,GACD,gBAAgB,WAAW,MAAM,QAAQ,YAAY;GACnD,OAAO,SAAS,YAAY,GAAG,MAAM;IACnC,OAAO,0BAA0B;KAC/B,OAAO,QAAQ,GAAI,IAAmB;IACxC,GAAG,aAAa;GAClB;EACF,CAAC,GACD,gBAAgB,WAAW,MAAM,YAAY,gBAAgB;GAC3D,OAAO,SAAS,gBAAgB,GAAG,MAAM;IACvC,OAAO,0BAA0B;KAC/B,OAAO,YAAY,GAAI,IAAmB;IAC5C,GAAG,aAAa;GAClB;EACF,CAAC,GACD,gBAAgB,WAAW,OAAO,QAAQ,aAAa;GACrD,OAAO,SAAS,aAAa,GAAG,MAAM;IACpC,OAAO,0BAA0B;KAC/B,OAAO,SAAS,GAAI,IAAmB;IACzC,GAAG,aAAa;GAClB;EACF,CAAC,GACD,gBAAgB,WAAW,OAAO,YAAY,iBAAiB;GAC7D,OAAO,SAAS,iBAAiB,GAAG,MAAM;IACxC,OAAO,0BAA0B;KAC/B,OAAO,aAAa,GAAI,IAAmB;IAC7C,GAAG,aAAa;GAClB;EACF,CAAC,CACH;CACF;AACF"}

package/lib/node/interceptors/XMLHttpRequest/node.d.ts

@@ -0,0 +1,12 @@
+import { t as Interceptor } from "../../interceptor-dtJZ_9QT.js";
+import { n as HttpRequestEventMap } from "../../http-CB9rQ7i_.js";
+//#region src/interceptors/XMLHttpRequest/node.d.ts
+declare class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  #private;
+  static symbol: symbol;
+  protected predicate(): boolean;
+  protected setup(): void;
+}
+//#endregion
+export { XMLHttpRequestInterceptor };
+//# sourceMappingURL=node.d.ts.map

package/lib/node/interceptors/XMLHttpRequest/node.js

@@ -0,0 +1,74 @@
+import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { a as createLogger, i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
+import { t as FetchRequest } from "../../fetch-utils-Dw1PsmtX.js";
+import { o as patchesRegistry } from "../../net-DtMnyEeg.js";
+import { t as hasConfigurableGlobal } from "../../has-configurable-global-CJCh_g1I.js";
+//#region src/interceptors/XMLHttpRequest/node.ts
+const logger = createLogger("xhr");
+var XMLHttpRequestInterceptor = class extends Interceptor {
+	static {
+		this.symbol = Symbol.for("xhr-interceptor");
+	}
+	predicate() {
+		return hasConfigurableGlobal("XMLHttpRequest");
+	}
+	setup() {
+		const requestSource = Interceptor.singleton(NodeHttpRequestSource);
+		requestSource.apply(this);
+		this.subscriptions.push(() => {
+			requestSource.dispose(this);
+		});
+		this.subscriptions.push(forwardHttpEvents({
+			source: requestSource,
+			emitter: this.emitter,
+			predicate: (initiator) => {
+				return initiator instanceof XMLHttpRequest;
+			}
+		}));
+		logger.verbose("patching global \"XMLHttpRequest\"...");
+		const prepareRequest = this.#transformRequest.bind(this);
+		const requestLogger = this.logger;
+		this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "XMLHttpRequest", (realXMLHttpRequest) => {
+			return new Proxy(realXMLHttpRequest, { construct(target, args, newTarget) {
+				const xmlHttpRequest = Reflect.construct(target, args, newTarget);
+				/**
+				* @note Scope the request context to the `send()` call.
+				* XHR in JSDOM is implemented via `http`/`https`, and the
+				* underlying `http.ClientRequest` is created within `send()`,
+				* so the initiator cascading keeps working. Binding the
+				* context to the caller's scope instead (e.g. `enterWith`)
+				* would attribute unrelated requests performed after this
+				* XMLHttpRequest to it.
+				*/
+				const realSend = xmlHttpRequest.send;
+				xmlHttpRequest.send = (...sendArgs) => {
+					return requestContext.run({
+						initiator: xmlHttpRequest,
+						logger: requestLogger,
+						transformRequest: (request) => {
+							return prepareRequest(request, xmlHttpRequest);
+						}
+					}, () => realSend.apply(xmlHttpRequest, sendArgs));
+				};
+				return xmlHttpRequest;
+			} });
+		}));
+		logger.verbose("global \"XMLHttpRequest\" patched!");
+	}
+	#transformRequest(request, initiator) {
+		const expectedCredentials = initiator.withCredentials ? "include" : "same-origin";
+		if (request.credentials === expectedCredentials) return request;
+		return new FetchRequest(request.url, {
+			...request,
+			method: request.method,
+			headers: request.headers,
+			credentials: expectedCredentials,
+			body: request.body,
+			signal: request.signal
+		});
+	}
+};
+//#endregion
+export { XMLHttpRequestInterceptor };
+
+//# sourceMappingURL=node.js.map

package/lib/node/interceptors/XMLHttpRequest/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":["#transformRequest"],"sources":["../../../../src/interceptors/XMLHttpRequest/node.ts"],"sourcesContent":["import { requestContext } from '#/src/request-context'\nimport { hasConfigurableGlobal } from '#/src/utils/has-configurable-global'\nimport { Interceptor } from '#/src/interceptor'\nimport { forwardHttpEvents } from '#/src/interceptors/http/forward-events'\nimport { NodeHttpRequestSource } from '#/src/interceptors/http/source'\nimport { patchesRegistry } from '#/src/utils/patches-registry'\nimport { FetchRequest } from '#/src/utils/fetch-utils'\nimport { HttpRequestEventMap } from '#/src/events/http'\nimport { createLogger } from '#/src/utils/logger'\n\nconst logger = createLogger('xhr')\n\nexport class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol.for('xhr-interceptor')\n\n  protected predicate() {\n    return hasConfigurableGlobal('XMLHttpRequest')\n  }\n\n  protected setup(): void {\n    const requestSource = Interceptor.singleton(NodeHttpRequestSource)\n    requestSource.apply(this)\n    this.subscriptions.push(() => {\n      requestSource.dispose(this)\n    })\n\n    this.subscriptions.push(\n      forwardHttpEvents({\n        source: requestSource,\n        emitter: this.emitter,\n        predicate: (initiator) => {\n          return initiator instanceof XMLHttpRequest\n        },\n      })\n    )\n\n    logger.verbose('patching global \"XMLHttpRequest\"...')\n\n    const prepareRequest = this.#transformRequest.bind(this)\n    const requestLogger = this.logger\n\n    this.subscriptions.push(\n      patchesRegistry.applyPatch(\n        globalThis,\n        'XMLHttpRequest',\n        (realXMLHttpRequest) => {\n          return new Proxy(realXMLHttpRequest, {\n            construct(target, args, newTarget) {\n              const xmlHttpRequest = Reflect.construct(target, args, newTarget)\n\n              /**\n               * @note Scope the request context to the `send()` call.\n               * XHR in JSDOM is implemented via `http`/`https`, and the\n               * underlying `http.ClientRequest` is created within `send()`,\n               * so the initiator cascading keeps working. Binding the\n               * context to the caller's scope instead (e.g. `enterWith`)\n               * would attribute unrelated requests performed after this\n               * XMLHttpRequest to it.\n               */\n              const realSend = xmlHttpRequest.send\n              xmlHttpRequest.send = (\n                ...sendArgs: Parameters<XMLHttpRequest['send']>\n              ) => {\n                return requestContext.run(\n                  {\n                    initiator: xmlHttpRequest,\n                    logger: requestLogger,\n                    transformRequest: (request) => {\n                      return prepareRequest(request, xmlHttpRequest)\n                    },\n                  },\n                  () => realSend.apply(xmlHttpRequest, sendArgs)\n                )\n              }\n\n              return xmlHttpRequest\n            },\n          })\n        }\n      )\n    )\n\n    logger.verbose('global \"XMLHttpRequest\" patched!')\n  }\n\n  #transformRequest(request: Request, initiator: XMLHttpRequest): Request {\n    const expectedCredentials = initiator.withCredentials\n      ? 'include'\n      : 'same-origin'\n\n    if (request.credentials === expectedCredentials) {\n      return request\n    }\n\n    return new FetchRequest(request.url, {\n      ...request,\n      method: request.method,\n      headers: request.headers,\n      credentials: expectedCredentials,\n      body: request.body,\n      signal: request.signal,\n    })\n  }\n}\n"],"mappings":";;;;;;AAUA,MAAM,SAAS,aAAa,KAAK;AAEjC,IAAa,4BAAb,cAA+C,YAAiC;;EAC9D,KAAA,SAAA,OAAO,IAAI,iBAAiB;;CAE5C,YAAsB;EACpB,OAAO,sBAAsB,gBAAgB;CAC/C;CAEA,QAAwB;EACtB,MAAM,gBAAgB,YAAY,UAAU,qBAAqB;EACjE,cAAc,MAAM,IAAI;EACxB,KAAK,cAAc,WAAW;GAC5B,cAAc,QAAQ,IAAI;EAC5B,CAAC;EAED,KAAK,cAAc,KACjB,kBAAkB;GAChB,QAAQ;GACR,SAAS,KAAK;GACd,YAAY,cAAc;IACxB,OAAO,qBAAqB;GAC9B;EACF,CAAC,CACH;EAEA,OAAO,QAAQ,uCAAqC;EAEpD,MAAM,iBAAiB,KAAKA,kBAAkB,KAAK,IAAI;EACvD,MAAM,gBAAgB,KAAK;EAE3B,KAAK,cAAc,KACjB,gBAAgB,WACd,YACA,mBACC,uBAAuB;GACtB,OAAO,IAAI,MAAM,oBAAoB,EACnC,UAAU,QAAQ,MAAM,WAAW;IACjC,MAAM,iBAAiB,QAAQ,UAAU,QAAQ,MAAM,SAAS;;;;;;;;;;IAWhE,MAAM,WAAW,eAAe;IAChC,eAAe,QACb,GAAG,aACA;KACH,OAAO,eAAe,IACpB;MACE,WAAW;MACX,QAAQ;MACR,mBAAmB,YAAY;OAC7B,OAAO,eAAe,SAAS,cAAc;MAC/C;KACF,SACM,SAAS,MAAM,gBAAgB,QAAQ,CAC/C;IACF;IAEA,OAAO;GACT,EACF,CAAC;EACH,CACF,CACF;EAEA,OAAO,QAAQ,oCAAkC;CACnD;CAEA,kBAAkB,SAAkB,WAAoC;EACtE,MAAM,sBAAsB,UAAU,kBAClC,YACA;EAEJ,IAAI,QAAQ,gBAAgB,qBAC1B,OAAO;EAGT,OAAO,IAAI,aAAa,QAAQ,KAAK;GACnC,GAAG;GACH,QAAQ,QAAQ;GAChB,SAAS,QAAQ;GACjB,aAAa;GACb,MAAM,QAAQ;GACd,QAAQ,QAAQ;EAClB,CAAC;CACH;AACF"}