@mswjs/interceptors 0.41.9 → 0.42.0

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"}

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

@@ -0,0 +1,18 @@
+import { t as Interceptor } from "../../interceptor-dtJZ_9QT.js";
+import { n as HttpRequestEventMap } from "../../http-CB9rQ7i_.js";
+//#region src/interceptors/fetch/node.d.ts
+/**
+ * Interceptor for `fetch` requests in Node.js.
+ * @note This interceptor only affects requests performed via
+ * the global `fetch` function. To intercept fetch requests performed
+ * by other means (e.g. direct `request()` from Undici) use the
+ * `HttpRequestInterceptor` instead.
+ */
+declare class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol: symbol;
+  protected predicate(): boolean;
+  protected setup(): void;
+}
+//#endregion
+export { FetchInterceptor };
+//# sourceMappingURL=node.d.ts.map

package/lib/node/interceptors/fetch/node.js

@@ -0,0 +1,83 @@
+import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
+import { i as getErrorResponse } 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/fetch/node.ts
+/**
+* Interceptor for `fetch` requests in Node.js.
+* @note This interceptor only affects requests performed via
+* the global `fetch` function. To intercept fetch requests performed
+* by other means (e.g. direct `request()` from Undici) use the
+* `HttpRequestInterceptor` instead.
+*/
+var FetchInterceptor = class extends Interceptor {
+	static {
+		this.symbol = Symbol.for("fetch-interceptor");
+	}
+	predicate() {
+		return hasConfigurableGlobal("fetch");
+	}
+	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 Request;
+			},
+			responsePredicate: (event) => {
+				/**
+				* @note Fetch clients never observe informational responses (1xx).
+				* Undici treats them as a network error, failing the request,
+				* so do not forward their "response" events to fetch consumers.
+				*/
+				return event.response.status >= 200;
+			}
+		}));
+		this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "fetch", (realFetch) => {
+			return (input, init) => {
+				/**
+				* Resolve potentially relative request URL against the present `location`.
+				* This is mainly for native `fetch` in browser-like environments.
+				* @see https://github.com/mswjs/msw/issues/1625
+				*/
+				const resolvedInput = typeof input === "string" && typeof location !== "undefined" && !URL.canParse(input) ? new URL(input, location.href) : input;
+				const request = new Request(resolvedInput, init);
+				/**
+				* @note Scope the request context to the `fetch` call itself.
+				* Using `enterWith` here would rebind the store for the caller's
+				* entire asynchronous scope, attributing unrelated requests
+				* performed after this `fetch` to it.
+				*/
+				return requestContext.run({
+					initiator: request,
+					logger: this.logger
+				}, () => {
+					return realFetch(request).catch((error) => {
+						/**
+						* @note A mocked `Response.error()` destroys the socket with
+						* an internal error, which Undici reports as the cause of its
+						* "fetch failed" rejection. Surface the error response as the
+						* rejection cause instead, so the consumer can tell a mocked
+						* network error apart from an actual connectivity issue.
+						*/
+						if (error instanceof TypeError) {
+							const errorResponse = getErrorResponse(error.cause);
+							if (errorResponse) error.cause = errorResponse;
+						}
+						throw error;
+					});
+				});
+			};
+		}));
+	}
+};
+//#endregion
+export { FetchInterceptor };
+
+//# sourceMappingURL=node.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":[],"sources":["../../../../src/interceptors/fetch/node.ts"],"sourcesContent":["import { hasConfigurableGlobal } from '#/src/utils/has-configurable-global'\nimport { getErrorResponse } from '#/src/utils/response-utils'\nimport { requestContext } 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 { HttpRequestEventMap } from '#/src/events/http'\nimport { Interceptor } from '../../interceptor'\n\n/**\n * Interceptor for `fetch` requests in Node.js.\n * @note This interceptor only affects requests performed via\n * the global `fetch` function. To intercept fetch requests performed\n * by other means (e.g. direct `request()` from Undici) use the\n * `HttpRequestInterceptor` instead.\n */\nexport class FetchInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol.for('fetch-interceptor')\n\n  protected predicate() {\n    return hasConfigurableGlobal('fetch')\n  }\n\n  protected setup(): void {\n    const requestSource = Interceptor.singleton(NodeHttpRequestSource)\n    requestSource.apply(this)\n\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 Request\n        },\n        responsePredicate: (event) => {\n          /**\n           * @note Fetch clients never observe informational responses (1xx).\n           * Undici treats them as a network error, failing the request,\n           * so do not forward their \"response\" events to fetch consumers.\n           */\n          return event.response.status >= 200\n        },\n      })\n    )\n\n    this.subscriptions.push(\n      patchesRegistry.applyPatch(globalThis, 'fetch', (realFetch) => {\n        return (input, init) => {\n          /**\n           * Resolve potentially relative request URL against the present `location`.\n           * This is mainly for native `fetch` in browser-like environments.\n           * @see https://github.com/mswjs/msw/issues/1625\n           */\n          const resolvedInput =\n            typeof input === 'string' &&\n            typeof location !== 'undefined' &&\n            !URL.canParse(input)\n              ? new URL(input, location.href)\n              : input\n\n          const request = new Request(resolvedInput, init)\n\n          /**\n           * @note Scope the request context to the `fetch` call itself.\n           * Using `enterWith` here would rebind the store for the caller's\n           * entire asynchronous scope, attributing unrelated requests\n           * performed after this `fetch` to it.\n           */\n          return requestContext.run(\n            {\n              initiator: request,\n              logger: this.logger,\n            },\n            () => {\n              return realFetch(request).catch((error: unknown) => {\n                /**\n                 * @note A mocked `Response.error()` destroys the socket with\n                 * an internal error, which Undici reports as the cause of its\n                 * \"fetch failed\" rejection. Surface the error response as the\n                 * rejection cause instead, so the consumer can tell a mocked\n                 * network error apart from an actual connectivity issue.\n                 */\n                if (error instanceof TypeError) {\n                  const errorResponse = getErrorResponse(error.cause)\n\n                  if (errorResponse) {\n                    error.cause = errorResponse\n                  }\n                }\n\n                throw error\n              })\n            }\n          )\n        }\n      })\n    )\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAgBA,IAAa,mBAAb,cAAsC,YAAiC;;EACrD,KAAA,SAAA,OAAO,IAAI,mBAAmB;;CAE9C,YAAsB;EACpB,OAAO,sBAAsB,OAAO;CACtC;CAEA,QAAwB;EACtB,MAAM,gBAAgB,YAAY,UAAU,qBAAqB;EACjE,cAAc,MAAM,IAAI;EAExB,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;GACA,oBAAoB,UAAU;;;;;;IAM5B,OAAO,MAAM,SAAS,UAAU;GAClC;EACF,CAAC,CACH;EAEA,KAAK,cAAc,KACjB,gBAAgB,WAAW,YAAY,UAAU,cAAc;GAC7D,QAAQ,OAAO,SAAS;;;;;;IAMtB,MAAM,gBACJ,OAAO,UAAU,YACjB,OAAO,aAAa,eACpB,CAAC,IAAI,SAAS,KAAK,IACf,IAAI,IAAI,OAAO,SAAS,IAAI,IAC5B;IAEN,MAAM,UAAU,IAAI,QAAQ,eAAe,IAAI;;;;;;;IAQ/C,OAAO,eAAe,IACpB;KACE,WAAW;KACX,QAAQ,KAAK;IACf,SACM;KACJ,OAAO,UAAU,OAAO,CAAC,CAAC,OAAO,UAAmB;;;;;;;;MAQlD,IAAI,iBAAiB,WAAW;OAC9B,MAAM,gBAAgB,iBAAiB,MAAM,KAAK;OAElD,IAAI,eACF,MAAM,QAAQ;MAElB;MAEA,MAAM;KACR,CAAC;IACH,CACF;GACF;EACF,CAAC,CACH;CACF;AACF"}

package/lib/node/interceptors/http/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/http/index.d.ts
+/**
+ * Interceptor for all HTTP requests in Node.js.
+ */
+declare class HttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol: symbol;
+  protected predicate(): boolean;
+  protected setup(): void;
+}
+//#endregion
+export { HttpRequestInterceptor };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,32 @@
+import { i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
+//#region src/interceptors/http/index.ts
+/**
+* Interceptor for all HTTP requests in Node.js.
+*/
+var HttpRequestInterceptor = class extends Interceptor {
+	static {
+		this.symbol = Symbol.for("http-request-interceptor");
+	}
+	predicate() {
+		return true;
+	}
+	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: () => {
+				return true;
+			}
+		}));
+	}
+};
+//#endregion
+export { HttpRequestInterceptor };
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../src/interceptors/http/index.ts"],"sourcesContent":["import { Interceptor } from '#/src/interceptor'\nimport { type HttpRequestEventMap } from '#/src/events/http'\nimport { forwardHttpEvents } from './forward-events'\nimport { NodeHttpRequestSource } from './source'\n\n/**\n * Interceptor for all HTTP requests in Node.js.\n */\nexport class HttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {\n  static symbol = Symbol.for('http-request-interceptor')\n\n  protected predicate(): boolean {\n    return true\n  }\n\n  protected setup(): void {\n    const requestSource = Interceptor.singleton(NodeHttpRequestSource)\n    requestSource.apply(this)\n\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: () => {\n          return true\n        },\n      })\n    )\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,yBAAb,cAA4C,YAAiC;;EAC3D,KAAA,SAAA,OAAO,IAAI,0BAA0B;;CAErD,YAA+B;EAC7B,OAAO;CACT;CAEA,QAAwB;EACtB,MAAM,gBAAgB,YAAY,UAAU,qBAAqB;EACjE,cAAc,MAAM,IAAI;EAExB,KAAK,cAAc,WAAW;GAC5B,cAAc,QAAQ,IAAI;EAC5B,CAAC;EAED,KAAK,cAAc,KACjB,kBAAkB;GAChB,QAAQ;GACR,SAAS,KAAK;GACd,iBAAiB;IACf,OAAO;GACT;EACF,CAAC,CACH;CACF;AACF"}

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

@@ -0,0 +1,203 @@
+import { t as Interceptor } from "../../interceptor-dtJZ_9QT.js";
+import { TypedEvent } from "rettime";
+import http from "node:http";
+import net from "node:net";
+import tls from "node:tls";
+//#region src/interceptors/net/utils/normalize-net-connect-args.d.ts
+interface NetworkConnectionOptions {
+  /**
+   * @note The port may be a string when a URL is (incorrectly) passed
+   * to `net.connect()`. Node.js reads URLs as plain options objects.
+   */
+  port?: number | string | null;
+  path: string | null;
+  host?: string | null;
+  protocol?: string | null;
+  auth?: string | null;
+  family?: number | null;
+  hints?: number | null;
+  session?: Buffer;
+  localAddress?: string | null;
+  localPort?: number | null;
+  timeout?: number;
+  lookup?: net.LookupFunction;
+  allowHalfOpen?: boolean | null;
+  noDelay?: boolean | null;
+  keepAlive?: boolean | null;
+  keepAliveInitialDelay?: number | null;
+  autoSelectFamily?: boolean | null;
+  autoSelectFamilyAttemptTimeout?: number | null;
+}
+//#endregion
+//#region src/interceptors/net/utils/normalize-tls-connect-args.d.ts
+type TlsConnectionOptions = tls.ConnectionOptions & NetworkConnectionOptions;
+//#endregion
+//#region src/interceptors/net/socket-controller.d.ts
+declare const kRawSocket: unique symbol;
+declare const kPatched: unique symbol;
+type OperationStatus = 0 | 1;
+declare module 'node:net' {
+  interface Socket {
+    [kPatched]?: boolean;
+    _httpMessage?: object | null;
+    _pendingData: string | Buffer | Array<{
+      chunk: string | Buffer;
+      encoding?: BufferEncoding;
+      callback?: (error?: Error | null) => void;
+    }> | null;
+    _pendingEncoding: BufferEncoding | '';
+    _bytesDispatched: number;
+    _writeGeneric(writev: boolean, data: NonNullable<net.Socket['_pendingData']>, encoding: BufferEncoding, callback?: (error?: Error | null) => void): void;
+    _handle: TcpHandle;
+    _start: () => void;
+    _unrefTimer: () => void;
+  }
+}
+declare module 'node:tls' {
+  interface TLSSocket {
+    _handle: TcpHandle & {
+      start: () => void;
+      onhandshakedone: () => void;
+      onnewsession: (sessionId: unknown, session: Buffer) => void;
+      getSession: () => Buffer;
+      isSessionReused: () => boolean;
+      getServername: () => string;
+      getALPNNegotiatedProtocol: () => string | false;
+      getCipher: () => {
+        name: string;
+        standardName: string;
+        version: string;
+      };
+      getEphemeralKeyInfo: () => tls.EphemeralKeyInfo;
+      verifyError: () => void;
+    };
+  }
+}
+interface TcpHandle {
+  open: (fd: unknown) => OperationStatus;
+  connect: (request: TcpWrap, address: string, port: number) => void;
+  connect6: (request: TcpWrap, address: string, port: number) => void;
+  listen: (backlog: number) => OperationStatus;
+  onconnection?: () => void;
+  getpeername?: (addressInfo: ReturnType<net.Socket['address']>) => OperationStatus;
+  getsockname?: (addressInfo: ReturnType<net.Socket['address']>) => OperationStatus;
+  reading: boolean;
+  onread: () => void;
+  readStart: () => void;
+  readStop: () => void;
+  bytesRead: number;
+  bytesWritten: number;
+  ref?: () => void;
+  unref?: () => void;
+  hasRef?: () => boolean;
+  fchmod: (mode: number) => void;
+  setBlocking: (blocking: boolean) => OperationStatus;
+  setNoDelay?: (noDelay: boolean) => void;
+  setKeepAlive?: (keepAlive: boolean, initialDelay: number) => void;
+  setTypeOfService?: (tos: number) => OperationStatus;
+  shutdown: (reqest: unknown) => OperationStatus;
+  close: () => void;
+  _parent?: TcpHandle;
+}
+interface TcpWrap {
+  oncomplete: (status: OperationStatus, owner: TcpHandle, request: TcpWrap, readable?: boolean, writable?: boolean) => void;
+}
+declare abstract class SocketController {
+  static PENDING: 0;
+  static CLAIMED: 1;
+  static PASSTHROUGH: 2;
+  readyState: typeof SocketController.PENDING | typeof SocketController.CLAIMED | typeof SocketController.PASSTHROUGH;
+  private [kRawSocket];
+  constructor(socket: net.Socket);
+  /**
+   * Claim this socket. Once claimed, the connection attempt succeeds
+   * regardless of the requested host and the interceptor becomes the
+   * mocked server for this connection.
+   */
+  claim(): void;
+  /**
+   * Establish this socket connection as-is.
+   */
+  passthrough(): void;
+}
+type FlushPendingDataFunction = (data: NonNullable<net.Socket['_pendingData']>, encoding: BufferEncoding | undefined, callback: (data: NonNullable<net.Socket['_pendingData']>) => void) => void;
+declare class TcpSocketController extends SocketController {
+  #private;
+  protected readonly socket: net.Socket;
+  protected readonly createConnection: () => net.Socket;
+  serverSocket: net.Socket;
+  protected pendingConnection: PromiseWithResolvers<[TcpWrap, TcpHandle]>;
+  constructor(socket: net.Socket, createConnection: () => net.Socket, connectionOptions?: NetworkConnectionOptions);
+  /**
+   * Reset this controller to the pending state so the next exchange
+   * on this socket can be handled anew. This is meant for kept-alive
+   * sockets that are reused for multiple exchanges by clients that
+   * don't emit the "free" event on the socket (e.g. Undici).
+   */
+  reset(): void;
+  protected emulateConnect(): void;
+  /**
+   * Suspend forwarding of the passthrough socket events ("data", "end", "close")
+   * to the client socket. The events are buffered in order until `uncorkReads()`
+   * is called. This allows the consumer to delay the delivery of the original
+   * response to the client (e.g. until its own asynchronous logic settles).
+   *
+   * @note Pausing the client socket is not enough to delay the delivery.
+   * Consumers like Undici read the pushed data from a paused socket
+   * directly via `socket.read()`, which is unaffected by `socket.pause()`.
+   */
+  corkReads(): void;
+  /**
+   * Resume forwarding of the passthrough socket events to the client socket,
+   * replaying any events buffered while the reads were corked.
+   */
+  uncorkReads(): void;
+  claim(): void;
+  passthrough(flushPendingData?: FlushPendingDataFunction): net.Socket;
+}
+declare class TlsSocketController extends TcpSocketController {
+  #private;
+  protected readonly socket: tls.TLSSocket;
+  protected readonly createConnection: () => tls.TLSSocket;
+  constructor(socket: tls.TLSSocket, createConnection: () => tls.TLSSocket, tlsConnectionOptions?: TlsConnectionOptions);
+  protected emulateConnect(): void;
+  claim(): void;
+  passthrough(flushPendingData?: FlushPendingDataFunction): tls.TLSSocket;
+}
+//#endregion
+//#region src/interceptors/net/index.d.ts
+declare module 'node:http' {
+  interface Agent {
+    /**
+     * @note An undocumented method backing every agent-driven request
+     * (see "#stopReusingUnpatchedSockets").
+     */
+    addRequest?: (request: http.ClientRequest, ...args: Array<unknown>) => void;
+  }
+}
+interface SocketConnectionEventData {
+  socket: net.Socket | tls.TLSSocket;
+  connectionOptions: NetworkConnectionOptions;
+  controller: TcpSocketController | TlsSocketController;
+}
+declare class SocketConnectionEvent<DataType extends SocketConnectionEventData = SocketConnectionEventData> extends TypedEvent<DataType, void, 'connection'> {
+  socket: net.Socket | tls.TLSSocket;
+  connectionOptions: NetworkConnectionOptions;
+  controller: TcpSocketController | TlsSocketController;
+  constructor(data: DataType);
+}
+type SocketEventMap = {
+  connection: SocketConnectionEvent;
+};
+/**
+ * Interceptor for `net.Socket` connections.
+ */
+declare class SocketInterceptor extends Interceptor<SocketEventMap> {
+  #private;
+  static symbol: symbol;
+  protected predicate(): boolean;
+  protected setup(): void;
+}
+//#endregion
+export { SocketInterceptor };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+import { t as SocketInterceptor } from "../../net-DtMnyEeg.js";
+export { SocketInterceptor };