@mswjs/interceptors 0.40.0 → 0.41.0

package/lib/node/handleRequest-Bb7Y-XLw.cjs

@@ -0,0 +1,220 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+const require_fetchUtils = require('./fetchUtils-BaY5iWXw.cjs');
+let _open_draft_deferred_promise = require("@open-draft/deferred-promise");
+let _open_draft_until = require("@open-draft/until");
+
+//#region src/utils/isPropertyAccessible.ts
+/**
+* A function that validates if property access is possible on an object
+* without throwing. It returns `true` if the property access is possible
+* and `false` otherwise.
+*
+* Environments like miniflare will throw on property access on certain objects
+* like Request and Response, for unimplemented properties.
+*/
+function isPropertyAccessible(obj, key) {
+	try {
+		obj[key];
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/emitAsync.ts
+/**
+* Emits an event on the given emitter but executes
+* the listeners sequentially. This accounts for asynchronous
+* listeners (e.g. those having "sleep" and handling the request).
+*/
+async function emitAsync(emitter, eventName, ...data) {
+	const listeners = emitter.listeners(eventName);
+	if (listeners.length === 0) return;
+	for (const listener of listeners) await listener.apply(emitter, data);
+}
+
+//#endregion
+//#region src/utils/isObject.ts
+/**
+* Determines if a given value is an instance of object.
+*/
+function isObject(value, loose = false) {
+	return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+//#region src/utils/responseUtils.ts
+/**
+* Creates a generic 500 Unhandled Exception response.
+*/
+function createServerErrorResponse(body) {
+	return new Response(JSON.stringify(body instanceof Error ? {
+		name: body.name,
+		message: body.message,
+		stack: body.stack
+	} : body), {
+		status: 500,
+		statusText: "Unhandled Exception",
+		headers: { "Content-Type": "application/json" }
+	});
+}
+/**
+* Check if the given response is a `Response.error()`.
+*
+* @note Some environments, like Miniflare (Cloudflare) do not
+* implement the "Response.type" property and throw on its access.
+* Safely check if we can access "type" on "Response" before continuing.
+* @see https://github.com/mswjs/msw/issues/1834
+*/
+function isResponseError(response) {
+	return response != null && response instanceof Response && isPropertyAccessible(response, "type") && response.type === "error";
+}
+/**
+* Check if the given value is a `Response` or a Response-like object.
+* This is different from `value instanceof Response` because it supports
+* custom `Response` constructors, like the one when using Undici directly.
+*/
+function isResponseLike(value) {
+	return isObject(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
+}
+
+//#endregion
+//#region src/utils/isNodeLikeError.ts
+function isNodeLikeError(error) {
+	if (error == null) return false;
+	if (!(error instanceof Error)) return false;
+	return "code" in error && "errno" in error;
+}
+
+//#endregion
+//#region src/utils/handleRequest.ts
+async function handleRequest(options) {
+	const handleResponse = async (response) => {
+		if (response instanceof Error) {
+			await options.controller.errorWith(response);
+			return true;
+		}
+		if (isResponseError(response)) {
+			await options.controller.respondWith(response);
+			return true;
+		}
+		/**
+		* Handle normal responses or response-like objects.
+		* @note This must come before the arbitrary object check
+		* since Response instances are, in fact, objects.
+		*/
+		if (isResponseLike(response)) {
+			await options.controller.respondWith(response);
+			return true;
+		}
+		if (isObject(response)) {
+			await options.controller.errorWith(response);
+			return true;
+		}
+		return false;
+	};
+	const handleResponseError = async (error) => {
+		if (error instanceof require_fetchUtils.InterceptorError) throw result.error;
+		if (isNodeLikeError(error)) {
+			await options.controller.errorWith(error);
+			return true;
+		}
+		if (error instanceof Response) return await handleResponse(error);
+		return false;
+	};
+	const requestAbortPromise = new _open_draft_deferred_promise.DeferredPromise();
+	/**
+	* @note `signal` is not always defined in React Native.
+	*/
+	if (options.request.signal) {
+		if (options.request.signal.aborted) {
+			await options.controller.errorWith(options.request.signal.reason);
+			return;
+		}
+		options.request.signal.addEventListener("abort", () => {
+			requestAbortPromise.reject(options.request.signal.reason);
+		}, { once: true });
+	}
+	const result = await (0, _open_draft_until.until)(async () => {
+		const requestListenersPromise = emitAsync(options.emitter, "request", {
+			requestId: options.requestId,
+			request: options.request,
+			controller: options.controller
+		});
+		await Promise.race([
+			requestAbortPromise,
+			requestListenersPromise,
+			options.controller.handled
+		]);
+	});
+	if (requestAbortPromise.state === "rejected") {
+		await options.controller.errorWith(requestAbortPromise.rejectionReason);
+		return;
+	}
+	if (result.error) {
+		if (await handleResponseError(result.error)) return;
+		if (options.emitter.listenerCount("unhandledException") > 0) {
+			const unhandledExceptionController = new require_fetchUtils.RequestController(options.request, {
+				passthrough() {},
+				async respondWith(response) {
+					await handleResponse(response);
+				},
+				async errorWith(reason) {
+					/**
+					* @note Handle the result of the unhandled controller
+					* in the same way as the original request controller.
+					* The exception here is that thrown errors within the
+					* "unhandledException" event do NOT result in another
+					* emit of the same event. They are forwarded as-is.
+					*/
+					await options.controller.errorWith(reason);
+				}
+			});
+			await emitAsync(options.emitter, "unhandledException", {
+				error: result.error,
+				request: options.request,
+				requestId: options.requestId,
+				controller: unhandledExceptionController
+			});
+			if (unhandledExceptionController.readyState !== require_fetchUtils.RequestController.PENDING) return;
+		}
+		await options.controller.respondWith(createServerErrorResponse(result.error));
+		return;
+	}
+	if (options.controller.readyState === require_fetchUtils.RequestController.PENDING) return await options.controller.passthrough();
+	return options.controller.handled;
+}
+
+//#endregion
+Object.defineProperty(exports, 'emitAsync', {
+  enumerable: true,
+  get: function () {
+    return emitAsync;
+  }
+});
+Object.defineProperty(exports, 'handleRequest', {
+  enumerable: true,
+  get: function () {
+    return handleRequest;
+  }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () {
+    return isObject;
+  }
+});
+Object.defineProperty(exports, 'isPropertyAccessible', {
+  enumerable: true,
+  get: function () {
+    return isPropertyAccessible;
+  }
+});
+Object.defineProperty(exports, 'isResponseError', {
+  enumerable: true,
+  get: function () {
+    return isResponseError;
+  }
+});
+//# sourceMappingURL=handleRequest-Bb7Y-XLw.cjs.map

package/lib/node/handleRequest-Bb7Y-XLw.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleRequest-Bb7Y-XLw.cjs","names":["InterceptorError","DeferredPromise","RequestController"],"sources":["../../src/utils/isPropertyAccessible.ts","../../src/utils/emitAsync.ts","../../src/utils/isObject.ts","../../src/utils/responseUtils.ts","../../src/utils/isNodeLikeError.ts","../../src/utils/handleRequest.ts"],"sourcesContent":["/**\n * A function that validates if property access is possible on an object\n * without throwing. It returns `true` if the property access is possible\n * and `false` otherwise.\n *\n * Environments like miniflare will throw on property access on certain objects\n * like Request and Response, for unimplemented properties.\n */\nexport function isPropertyAccessible<Obj extends Record<string, any>>(\n  obj: Obj,\n  key: keyof Obj\n) {\n  try {\n    obj[key]\n    return true\n  } catch {\n    return false\n  }\n}\n","import { Emitter, EventMap } from 'strict-event-emitter'\n\n/**\n * Emits an event on the given emitter but executes\n * the listeners sequentially. This accounts for asynchronous\n * listeners (e.g. those having \"sleep\" and handling the request).\n */\nexport async function emitAsync<\n  Events extends EventMap,\n  EventName extends keyof Events\n>(\n  emitter: Emitter<Events>,\n  eventName: EventName,\n  ...data: Events[EventName]\n): Promise<void> {\n  const listeners = emitter.listeners(eventName)\n\n  if (listeners.length === 0) {\n    return\n  }\n\n  for (const listener of listeners) {\n    await listener.apply(emitter, data)\n  }\n}\n","/**\n * Determines if a given value is an instance of object.\n */\nexport function isObject<T>(value: any, loose = false): value is T {\n  return loose\n    ? Object.prototype.toString.call(value).startsWith('[object ')\n    : Object.prototype.toString.call(value) === '[object Object]'\n}\n","import { isObject } from './isObject'\nimport { isPropertyAccessible } from './isPropertyAccessible'\n\n/**\n * Creates a generic 500 Unhandled Exception response.\n */\nexport function createServerErrorResponse(body: unknown): Response {\n  return new Response(\n    JSON.stringify(\n      body instanceof Error\n        ? {\n            name: body.name,\n            message: body.message,\n            stack: body.stack,\n          }\n        : body\n    ),\n    {\n      status: 500,\n      statusText: 'Unhandled Exception',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n    }\n  )\n}\n\nexport type ResponseError = Response & { type: 'error' }\n\n/**\n * Check if the given response is a `Response.error()`.\n *\n * @note Some environments, like Miniflare (Cloudflare) do not\n * implement the \"Response.type\" property and throw on its access.\n * Safely check if we can access \"type\" on \"Response\" before continuing.\n * @see https://github.com/mswjs/msw/issues/1834\n */\nexport function isResponseError(response: unknown): response is ResponseError {\n  return (\n    response != null &&\n    response instanceof Response &&\n    isPropertyAccessible(response, 'type') &&\n    response.type === 'error'\n  )\n}\n\n/**\n * Check if the given value is a `Response` or a Response-like object.\n * This is different from `value instanceof Response` because it supports\n * custom `Response` constructors, like the one when using Undici directly.\n */\nexport function isResponseLike(value: unknown): value is Response {\n  return (\n    isObject<Record<string, any>>(value, true) &&\n    isPropertyAccessible(value, 'status') &&\n    isPropertyAccessible(value, 'statusText') &&\n    isPropertyAccessible(value, 'bodyUsed')\n  )\n}\n","export function isNodeLikeError(\n  error: unknown\n): error is NodeJS.ErrnoException {\n  if (error == null) {\n    return false\n  }\n\n  if (!(error instanceof Error)) {\n    return false\n  }\n\n  return 'code' in error && 'errno' in error\n}\n","import type { Emitter } from 'strict-event-emitter'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { until } from '@open-draft/until'\nimport type { HttpRequestEventMap } from '../glossary'\nimport { emitAsync } from './emitAsync'\nimport { RequestController } from '../RequestController'\nimport {\n  createServerErrorResponse,\n  isResponseError,\n  isResponseLike,\n} from './responseUtils'\nimport { InterceptorError } from '../InterceptorError'\nimport { isNodeLikeError } from './isNodeLikeError'\nimport { isObject } from './isObject'\n\ninterface HandleRequestOptions {\n  requestId: string\n  request: Request\n  emitter: Emitter<HttpRequestEventMap>\n  controller: RequestController\n}\n\nexport async function handleRequest(\n  options: HandleRequestOptions\n): Promise<void> {\n  const handleResponse = async (\n    response: Response | Error | Record<string, any>\n  ) => {\n    if (response instanceof Error) {\n      await options.controller.errorWith(response)\n      return true\n    }\n\n    // Handle \"Response.error()\" instances.\n    if (isResponseError(response)) {\n      await options.controller.respondWith(response)\n      return true\n    }\n\n    /**\n     * Handle normal responses or response-like objects.\n     * @note This must come before the arbitrary object check\n     * since Response instances are, in fact, objects.\n     */\n    if (isResponseLike(response)) {\n      await options.controller.respondWith(response)\n      return true\n    }\n\n    // Handle arbitrary objects provided to `.errorWith(reason)`.\n    if (isObject(response)) {\n      await options.controller.errorWith(response)\n      return true\n    }\n\n    return false\n  }\n\n  const handleResponseError = async (error: unknown): Promise<boolean> => {\n    // Forward the special interceptor error instances\n    // to the developer. These must not be handled in any way.\n    if (error instanceof InterceptorError) {\n      throw result.error\n    }\n\n    // Support mocking Node.js-like errors.\n    if (isNodeLikeError(error)) {\n      await options.controller.errorWith(error)\n      return true\n    }\n\n    // Handle thrown responses.\n    if (error instanceof Response) {\n      return await handleResponse(error)\n    }\n\n    return false\n  }\n\n  // Add the last \"request\" listener to check if the request\n  // has been handled in any way. If it hasn't, resolve the\n  // response promise with undefined.\n  // options.emitter.once('request', async ({ requestId: pendingRequestId }) => {\n  //   if (\n  //     pendingRequestId === options.requestId &&\n  //     options.controller.readyState === RequestController.PENDING\n  //   ) {\n  //     await options.controller.passthrough()\n  //   }\n  // })\n\n  const requestAbortPromise = new DeferredPromise<void, unknown>()\n\n  /**\n   * @note `signal` is not always defined in React Native.\n   */\n  if (options.request.signal) {\n    if (options.request.signal.aborted) {\n      await options.controller.errorWith(options.request.signal.reason)\n      return\n    }\n\n    options.request.signal.addEventListener(\n      'abort',\n      () => {\n        requestAbortPromise.reject(options.request.signal.reason)\n      },\n      { once: true }\n    )\n  }\n\n  const result = await until(async () => {\n    // Emit the \"request\" event and wait until all the listeners\n    // for that event are finished (e.g. async listeners awaited).\n    // By the end of this promise, the developer cannot affect the\n    // request anymore.\n    const requestListenersPromise = emitAsync(options.emitter, 'request', {\n      requestId: options.requestId,\n      request: options.request,\n      controller: options.controller,\n    })\n\n    await Promise.race([\n      // Short-circuit the request handling promise if the request gets aborted.\n      requestAbortPromise,\n      requestListenersPromise,\n      options.controller.handled,\n    ])\n  })\n\n  // Handle the request being aborted while waiting for the request listeners.\n  if (requestAbortPromise.state === 'rejected') {\n    await options.controller.errorWith(requestAbortPromise.rejectionReason)\n    return\n  }\n\n  if (result.error) {\n    // Handle the error during the request listener execution.\n    // These can be thrown responses or request errors.\n    if (await handleResponseError(result.error)) {\n      return\n    }\n\n    // If the developer has added \"unhandledException\" listeners,\n    // allow them to handle the error. They can translate it to a\n    // mocked response, network error, or forward it as-is.\n    if (options.emitter.listenerCount('unhandledException') > 0) {\n      // Create a new request controller just for the unhandled exception case.\n      // This is needed because the original controller might have been already\n      // interacted with (e.g. \"respondWith\" or \"errorWith\" called on it).\n      const unhandledExceptionController = new RequestController(\n        options.request,\n        {\n          /**\n           * @note Intentionally empty passthrough handle.\n           * This controller is created within another controller and we only need\n           * to know if `unhandledException` listeners handled the request.\n           */\n          passthrough() {},\n          async respondWith(response) {\n            await handleResponse(response)\n          },\n          async errorWith(reason) {\n            /**\n             * @note Handle the result of the unhandled controller\n             * in the same way as the original request controller.\n             * The exception here is that thrown errors within the\n             * \"unhandledException\" event do NOT result in another\n             * emit of the same event. They are forwarded as-is.\n             */\n            await options.controller.errorWith(reason)\n          },\n        }\n      )\n\n      await emitAsync(options.emitter, 'unhandledException', {\n        error: result.error,\n        request: options.request,\n        requestId: options.requestId,\n        controller: unhandledExceptionController,\n      })\n\n      // If all the \"unhandledException\" listeners have finished\n      // but have not handled the request in any way, passthrough.\n      if (\n        unhandledExceptionController.readyState !== RequestController.PENDING\n      ) {\n        return\n      }\n    }\n\n    // Otherwise, coerce unhandled exceptions to a 500 Internal Server Error response.\n    await options.controller.respondWith(\n      createServerErrorResponse(result.error)\n    )\n    return\n  }\n\n  // If the request hasn't been handled by this point, passthrough.\n  if (options.controller.readyState === RequestController.PENDING) {\n    return await options.controller.passthrough()\n  }\n\n  return options.controller.handled\n}\n"],"mappings":";;;;;;;;;;;;;;AAQA,SAAgB,qBACd,KACA,KACA;AACA,KAAI;AACF,MAAI;AACJ,SAAO;SACD;AACN,SAAO;;;;;;;;;;;ACTX,eAAsB,UAIpB,SACA,WACA,GAAG,MACY;CACf,MAAM,YAAY,QAAQ,UAAU,UAAU;AAE9C,KAAI,UAAU,WAAW,EACvB;AAGF,MAAK,MAAM,YAAY,UACrB,OAAM,SAAS,MAAM,SAAS,KAAK;;;;;;;;ACnBvC,SAAgB,SAAY,OAAY,QAAQ,OAAmB;AACjE,QAAO,QACH,OAAO,UAAU,SAAS,KAAK,MAAM,CAAC,WAAW,WAAW,GAC5D,OAAO,UAAU,SAAS,KAAK,MAAM,KAAK;;;;;;;;ACAhD,SAAgB,0BAA0B,MAAyB;AACjE,QAAO,IAAI,SACT,KAAK,UACH,gBAAgB,QACZ;EACE,MAAM,KAAK;EACX,SAAS,KAAK;EACd,OAAO,KAAK;EACb,GACD,KACL,EACD;EACE,QAAQ;EACR,YAAY;EACZ,SAAS,EACP,gBAAgB,oBACjB;EACF,CACF;;;;;;;;;;AAaH,SAAgB,gBAAgB,UAA8C;AAC5E,QACE,YAAY,QACZ,oBAAoB,YACpB,qBAAqB,UAAU,OAAO,IACtC,SAAS,SAAS;;;;;;;AAStB,SAAgB,eAAe,OAAmC;AAChE,QACE,SAA8B,OAAO,KAAK,IAC1C,qBAAqB,OAAO,SAAS,IACrC,qBAAqB,OAAO,aAAa,IACzC,qBAAqB,OAAO,WAAW;;;;;ACxD3C,SAAgB,gBACd,OACgC;AAChC,KAAI,SAAS,KACX,QAAO;AAGT,KAAI,EAAE,iBAAiB,OACrB,QAAO;AAGT,QAAO,UAAU,SAAS,WAAW;;;;;ACWvC,eAAsB,cACpB,SACe;CACf,MAAM,iBAAiB,OACrB,aACG;AACH,MAAI,oBAAoB,OAAO;AAC7B,SAAM,QAAQ,WAAW,UAAU,SAAS;AAC5C,UAAO;;AAIT,MAAI,gBAAgB,SAAS,EAAE;AAC7B,SAAM,QAAQ,WAAW,YAAY,SAAS;AAC9C,UAAO;;;;;;;AAQT,MAAI,eAAe,SAAS,EAAE;AAC5B,SAAM,QAAQ,WAAW,YAAY,SAAS;AAC9C,UAAO;;AAIT,MAAI,SAAS,SAAS,EAAE;AACtB,SAAM,QAAQ,WAAW,UAAU,SAAS;AAC5C,UAAO;;AAGT,SAAO;;CAGT,MAAM,sBAAsB,OAAO,UAAqC;AAGtE,MAAI,iBAAiBA,oCACnB,OAAM,OAAO;AAIf,MAAI,gBAAgB,MAAM,EAAE;AAC1B,SAAM,QAAQ,WAAW,UAAU,MAAM;AACzC,UAAO;;AAIT,MAAI,iBAAiB,SACnB,QAAO,MAAM,eAAe,MAAM;AAGpC,SAAO;;CAeT,MAAM,sBAAsB,IAAIC,8CAAgC;;;;AAKhE,KAAI,QAAQ,QAAQ,QAAQ;AAC1B,MAAI,QAAQ,QAAQ,OAAO,SAAS;AAClC,SAAM,QAAQ,WAAW,UAAU,QAAQ,QAAQ,OAAO,OAAO;AACjE;;AAGF,UAAQ,QAAQ,OAAO,iBACrB,eACM;AACJ,uBAAoB,OAAO,QAAQ,QAAQ,OAAO,OAAO;KAE3D,EAAE,MAAM,MAAM,CACf;;CAGH,MAAM,SAAS,mCAAY,YAAY;EAKrC,MAAM,0BAA0B,UAAU,QAAQ,SAAS,WAAW;GACpE,WAAW,QAAQ;GACnB,SAAS,QAAQ;GACjB,YAAY,QAAQ;GACrB,CAAC;AAEF,QAAM,QAAQ,KAAK;GAEjB;GACA;GACA,QAAQ,WAAW;GACpB,CAAC;GACF;AAGF,KAAI,oBAAoB,UAAU,YAAY;AAC5C,QAAM,QAAQ,WAAW,UAAU,oBAAoB,gBAAgB;AACvE;;AAGF,KAAI,OAAO,OAAO;AAGhB,MAAI,MAAM,oBAAoB,OAAO,MAAM,CACzC;AAMF,MAAI,QAAQ,QAAQ,cAAc,qBAAqB,GAAG,GAAG;GAI3D,MAAM,+BAA+B,IAAIC,qCACvC,QAAQ,SACR;IAME,cAAc;IACd,MAAM,YAAY,UAAU;AAC1B,WAAM,eAAe,SAAS;;IAEhC,MAAM,UAAU,QAAQ;;;;;;;;AAQtB,WAAM,QAAQ,WAAW,UAAU,OAAO;;IAE7C,CACF;AAED,SAAM,UAAU,QAAQ,SAAS,sBAAsB;IACrD,OAAO,OAAO;IACd,SAAS,QAAQ;IACjB,WAAW,QAAQ;IACnB,YAAY;IACb,CAAC;AAIF,OACE,6BAA6B,eAAeA,qCAAkB,QAE9D;;AAKJ,QAAM,QAAQ,WAAW,YACvB,0BAA0B,OAAO,MAAM,CACxC;AACD;;AAIF,KAAI,QAAQ,WAAW,eAAeA,qCAAkB,QACtD,QAAO,MAAM,QAAQ,WAAW,aAAa;AAG/C,QAAO,QAAQ,WAAW"}

package/lib/node/handleRequest-Y97UwBbF.mjs

@@ -0,0 +1,190 @@
+import { a as InterceptorError, i as RequestController } from "./fetchUtils-CoU35g3M.mjs";
+import { DeferredPromise } from "@open-draft/deferred-promise";
+import { until } from "@open-draft/until";
+
+//#region src/utils/isPropertyAccessible.ts
+/**
+* A function that validates if property access is possible on an object
+* without throwing. It returns `true` if the property access is possible
+* and `false` otherwise.
+*
+* Environments like miniflare will throw on property access on certain objects
+* like Request and Response, for unimplemented properties.
+*/
+function isPropertyAccessible(obj, key) {
+	try {
+		obj[key];
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/utils/emitAsync.ts
+/**
+* Emits an event on the given emitter but executes
+* the listeners sequentially. This accounts for asynchronous
+* listeners (e.g. those having "sleep" and handling the request).
+*/
+async function emitAsync(emitter, eventName, ...data) {
+	const listeners = emitter.listeners(eventName);
+	if (listeners.length === 0) return;
+	for (const listener of listeners) await listener.apply(emitter, data);
+}
+
+//#endregion
+//#region src/utils/isObject.ts
+/**
+* Determines if a given value is an instance of object.
+*/
+function isObject(value, loose = false) {
+	return loose ? Object.prototype.toString.call(value).startsWith("[object ") : Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+//#region src/utils/responseUtils.ts
+/**
+* Creates a generic 500 Unhandled Exception response.
+*/
+function createServerErrorResponse(body) {
+	return new Response(JSON.stringify(body instanceof Error ? {
+		name: body.name,
+		message: body.message,
+		stack: body.stack
+	} : body), {
+		status: 500,
+		statusText: "Unhandled Exception",
+		headers: { "Content-Type": "application/json" }
+	});
+}
+/**
+* Check if the given response is a `Response.error()`.
+*
+* @note Some environments, like Miniflare (Cloudflare) do not
+* implement the "Response.type" property and throw on its access.
+* Safely check if we can access "type" on "Response" before continuing.
+* @see https://github.com/mswjs/msw/issues/1834
+*/
+function isResponseError(response) {
+	return response != null && response instanceof Response && isPropertyAccessible(response, "type") && response.type === "error";
+}
+/**
+* Check if the given value is a `Response` or a Response-like object.
+* This is different from `value instanceof Response` because it supports
+* custom `Response` constructors, like the one when using Undici directly.
+*/
+function isResponseLike(value) {
+	return isObject(value, true) && isPropertyAccessible(value, "status") && isPropertyAccessible(value, "statusText") && isPropertyAccessible(value, "bodyUsed");
+}
+
+//#endregion
+//#region src/utils/isNodeLikeError.ts
+function isNodeLikeError(error) {
+	if (error == null) return false;
+	if (!(error instanceof Error)) return false;
+	return "code" in error && "errno" in error;
+}
+
+//#endregion
+//#region src/utils/handleRequest.ts
+async function handleRequest(options) {
+	const handleResponse = async (response) => {
+		if (response instanceof Error) {
+			await options.controller.errorWith(response);
+			return true;
+		}
+		if (isResponseError(response)) {
+			await options.controller.respondWith(response);
+			return true;
+		}
+		/**
+		* Handle normal responses or response-like objects.
+		* @note This must come before the arbitrary object check
+		* since Response instances are, in fact, objects.
+		*/
+		if (isResponseLike(response)) {
+			await options.controller.respondWith(response);
+			return true;
+		}
+		if (isObject(response)) {
+			await options.controller.errorWith(response);
+			return true;
+		}
+		return false;
+	};
+	const handleResponseError = async (error) => {
+		if (error instanceof InterceptorError) throw result.error;
+		if (isNodeLikeError(error)) {
+			await options.controller.errorWith(error);
+			return true;
+		}
+		if (error instanceof Response) return await handleResponse(error);
+		return false;
+	};
+	const requestAbortPromise = new DeferredPromise();
+	/**
+	* @note `signal` is not always defined in React Native.
+	*/
+	if (options.request.signal) {
+		if (options.request.signal.aborted) {
+			await options.controller.errorWith(options.request.signal.reason);
+			return;
+		}
+		options.request.signal.addEventListener("abort", () => {
+			requestAbortPromise.reject(options.request.signal.reason);
+		}, { once: true });
+	}
+	const result = await until(async () => {
+		const requestListenersPromise = emitAsync(options.emitter, "request", {
+			requestId: options.requestId,
+			request: options.request,
+			controller: options.controller
+		});
+		await Promise.race([
+			requestAbortPromise,
+			requestListenersPromise,
+			options.controller.handled
+		]);
+	});
+	if (requestAbortPromise.state === "rejected") {
+		await options.controller.errorWith(requestAbortPromise.rejectionReason);
+		return;
+	}
+	if (result.error) {
+		if (await handleResponseError(result.error)) return;
+		if (options.emitter.listenerCount("unhandledException") > 0) {
+			const unhandledExceptionController = new RequestController(options.request, {
+				passthrough() {},
+				async respondWith(response) {
+					await handleResponse(response);
+				},
+				async errorWith(reason) {
+					/**
+					* @note Handle the result of the unhandled controller
+					* in the same way as the original request controller.
+					* The exception here is that thrown errors within the
+					* "unhandledException" event do NOT result in another
+					* emit of the same event. They are forwarded as-is.
+					*/
+					await options.controller.errorWith(reason);
+				}
+			});
+			await emitAsync(options.emitter, "unhandledException", {
+				error: result.error,
+				request: options.request,
+				requestId: options.requestId,
+				controller: unhandledExceptionController
+			});
+			if (unhandledExceptionController.readyState !== RequestController.PENDING) return;
+		}
+		await options.controller.respondWith(createServerErrorResponse(result.error));
+		return;
+	}
+	if (options.controller.readyState === RequestController.PENDING) return await options.controller.passthrough();
+	return options.controller.handled;
+}
+
+//#endregion
+export { isPropertyAccessible as a, emitAsync as i, isResponseError as n, isObject as r, handleRequest as t };
+//# sourceMappingURL=handleRequest-Y97UwBbF.mjs.map

package/lib/node/handleRequest-Y97UwBbF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleRequest-Y97UwBbF.mjs","names":[],"sources":["../../src/utils/isPropertyAccessible.ts","../../src/utils/emitAsync.ts","../../src/utils/isObject.ts","../../src/utils/responseUtils.ts","../../src/utils/isNodeLikeError.ts","../../src/utils/handleRequest.ts"],"sourcesContent":["/**\n * A function that validates if property access is possible on an object\n * without throwing. It returns `true` if the property access is possible\n * and `false` otherwise.\n *\n * Environments like miniflare will throw on property access on certain objects\n * like Request and Response, for unimplemented properties.\n */\nexport function isPropertyAccessible<Obj extends Record<string, any>>(\n  obj: Obj,\n  key: keyof Obj\n) {\n  try {\n    obj[key]\n    return true\n  } catch {\n    return false\n  }\n}\n","import { Emitter, EventMap } from 'strict-event-emitter'\n\n/**\n * Emits an event on the given emitter but executes\n * the listeners sequentially. This accounts for asynchronous\n * listeners (e.g. those having \"sleep\" and handling the request).\n */\nexport async function emitAsync<\n  Events extends EventMap,\n  EventName extends keyof Events\n>(\n  emitter: Emitter<Events>,\n  eventName: EventName,\n  ...data: Events[EventName]\n): Promise<void> {\n  const listeners = emitter.listeners(eventName)\n\n  if (listeners.length === 0) {\n    return\n  }\n\n  for (const listener of listeners) {\n    await listener.apply(emitter, data)\n  }\n}\n","/**\n * Determines if a given value is an instance of object.\n */\nexport function isObject<T>(value: any, loose = false): value is T {\n  return loose\n    ? Object.prototype.toString.call(value).startsWith('[object ')\n    : Object.prototype.toString.call(value) === '[object Object]'\n}\n","import { isObject } from './isObject'\nimport { isPropertyAccessible } from './isPropertyAccessible'\n\n/**\n * Creates a generic 500 Unhandled Exception response.\n */\nexport function createServerErrorResponse(body: unknown): Response {\n  return new Response(\n    JSON.stringify(\n      body instanceof Error\n        ? {\n            name: body.name,\n            message: body.message,\n            stack: body.stack,\n          }\n        : body\n    ),\n    {\n      status: 500,\n      statusText: 'Unhandled Exception',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n    }\n  )\n}\n\nexport type ResponseError = Response & { type: 'error' }\n\n/**\n * Check if the given response is a `Response.error()`.\n *\n * @note Some environments, like Miniflare (Cloudflare) do not\n * implement the \"Response.type\" property and throw on its access.\n * Safely check if we can access \"type\" on \"Response\" before continuing.\n * @see https://github.com/mswjs/msw/issues/1834\n */\nexport function isResponseError(response: unknown): response is ResponseError {\n  return (\n    response != null &&\n    response instanceof Response &&\n    isPropertyAccessible(response, 'type') &&\n    response.type === 'error'\n  )\n}\n\n/**\n * Check if the given value is a `Response` or a Response-like object.\n * This is different from `value instanceof Response` because it supports\n * custom `Response` constructors, like the one when using Undici directly.\n */\nexport function isResponseLike(value: unknown): value is Response {\n  return (\n    isObject<Record<string, any>>(value, true) &&\n    isPropertyAccessible(value, 'status') &&\n    isPropertyAccessible(value, 'statusText') &&\n    isPropertyAccessible(value, 'bodyUsed')\n  )\n}\n","export function isNodeLikeError(\n  error: unknown\n): error is NodeJS.ErrnoException {\n  if (error == null) {\n    return false\n  }\n\n  if (!(error instanceof Error)) {\n    return false\n  }\n\n  return 'code' in error && 'errno' in error\n}\n","import type { Emitter } from 'strict-event-emitter'\nimport { DeferredPromise } from '@open-draft/deferred-promise'\nimport { until } from '@open-draft/until'\nimport type { HttpRequestEventMap } from '../glossary'\nimport { emitAsync } from './emitAsync'\nimport { RequestController } from '../RequestController'\nimport {\n  createServerErrorResponse,\n  isResponseError,\n  isResponseLike,\n} from './responseUtils'\nimport { InterceptorError } from '../InterceptorError'\nimport { isNodeLikeError } from './isNodeLikeError'\nimport { isObject } from './isObject'\n\ninterface HandleRequestOptions {\n  requestId: string\n  request: Request\n  emitter: Emitter<HttpRequestEventMap>\n  controller: RequestController\n}\n\nexport async function handleRequest(\n  options: HandleRequestOptions\n): Promise<void> {\n  const handleResponse = async (\n    response: Response | Error | Record<string, any>\n  ) => {\n    if (response instanceof Error) {\n      await options.controller.errorWith(response)\n      return true\n    }\n\n    // Handle \"Response.error()\" instances.\n    if (isResponseError(response)) {\n      await options.controller.respondWith(response)\n      return true\n    }\n\n    /**\n     * Handle normal responses or response-like objects.\n     * @note This must come before the arbitrary object check\n     * since Response instances are, in fact, objects.\n     */\n    if (isResponseLike(response)) {\n      await options.controller.respondWith(response)\n      return true\n    }\n\n    // Handle arbitrary objects provided to `.errorWith(reason)`.\n    if (isObject(response)) {\n      await options.controller.errorWith(response)\n      return true\n    }\n\n    return false\n  }\n\n  const handleResponseError = async (error: unknown): Promise<boolean> => {\n    // Forward the special interceptor error instances\n    // to the developer. These must not be handled in any way.\n    if (error instanceof InterceptorError) {\n      throw result.error\n    }\n\n    // Support mocking Node.js-like errors.\n    if (isNodeLikeError(error)) {\n      await options.controller.errorWith(error)\n      return true\n    }\n\n    // Handle thrown responses.\n    if (error instanceof Response) {\n      return await handleResponse(error)\n    }\n\n    return false\n  }\n\n  // Add the last \"request\" listener to check if the request\n  // has been handled in any way. If it hasn't, resolve the\n  // response promise with undefined.\n  // options.emitter.once('request', async ({ requestId: pendingRequestId }) => {\n  //   if (\n  //     pendingRequestId === options.requestId &&\n  //     options.controller.readyState === RequestController.PENDING\n  //   ) {\n  //     await options.controller.passthrough()\n  //   }\n  // })\n\n  const requestAbortPromise = new DeferredPromise<void, unknown>()\n\n  /**\n   * @note `signal` is not always defined in React Native.\n   */\n  if (options.request.signal) {\n    if (options.request.signal.aborted) {\n      await options.controller.errorWith(options.request.signal.reason)\n      return\n    }\n\n    options.request.signal.addEventListener(\n      'abort',\n      () => {\n        requestAbortPromise.reject(options.request.signal.reason)\n      },\n      { once: true }\n    )\n  }\n\n  const result = await until(async () => {\n    // Emit the \"request\" event and wait until all the listeners\n    // for that event are finished (e.g. async listeners awaited).\n    // By the end of this promise, the developer cannot affect the\n    // request anymore.\n    const requestListenersPromise = emitAsync(options.emitter, 'request', {\n      requestId: options.requestId,\n      request: options.request,\n      controller: options.controller,\n    })\n\n    await Promise.race([\n      // Short-circuit the request handling promise if the request gets aborted.\n      requestAbortPromise,\n      requestListenersPromise,\n      options.controller.handled,\n    ])\n  })\n\n  // Handle the request being aborted while waiting for the request listeners.\n  if (requestAbortPromise.state === 'rejected') {\n    await options.controller.errorWith(requestAbortPromise.rejectionReason)\n    return\n  }\n\n  if (result.error) {\n    // Handle the error during the request listener execution.\n    // These can be thrown responses or request errors.\n    if (await handleResponseError(result.error)) {\n      return\n    }\n\n    // If the developer has added \"unhandledException\" listeners,\n    // allow them to handle the error. They can translate it to a\n    // mocked response, network error, or forward it as-is.\n    if (options.emitter.listenerCount('unhandledException') > 0) {\n      // Create a new request controller just for the unhandled exception case.\n      // This is needed because the original controller might have been already\n      // interacted with (e.g. \"respondWith\" or \"errorWith\" called on it).\n      const unhandledExceptionController = new RequestController(\n        options.request,\n        {\n          /**\n           * @note Intentionally empty passthrough handle.\n           * This controller is created within another controller and we only need\n           * to know if `unhandledException` listeners handled the request.\n           */\n          passthrough() {},\n          async respondWith(response) {\n            await handleResponse(response)\n          },\n          async errorWith(reason) {\n            /**\n             * @note Handle the result of the unhandled controller\n             * in the same way as the original request controller.\n             * The exception here is that thrown errors within the\n             * \"unhandledException\" event do NOT result in another\n             * emit of the same event. They are forwarded as-is.\n             */\n            await options.controller.errorWith(reason)\n          },\n        }\n      )\n\n      await emitAsync(options.emitter, 'unhandledException', {\n        error: result.error,\n        request: options.request,\n        requestId: options.requestId,\n        controller: unhandledExceptionController,\n      })\n\n      // If all the \"unhandledException\" listeners have finished\n      // but have not handled the request in any way, passthrough.\n      if (\n        unhandledExceptionController.readyState !== RequestController.PENDING\n      ) {\n        return\n      }\n    }\n\n    // Otherwise, coerce unhandled exceptions to a 500 Internal Server Error response.\n    await options.controller.respondWith(\n      createServerErrorResponse(result.error)\n    )\n    return\n  }\n\n  // If the request hasn't been handled by this point, passthrough.\n  if (options.controller.readyState === RequestController.PENDING) {\n    return await options.controller.passthrough()\n  }\n\n  return options.controller.handled\n}\n"],"mappings":"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"}

package/lib/node/hasConfigurableGlobal-C97fWuaA.cjs

@@ -0,0 +1,26 @@
+
+//#region src/utils/hasConfigurableGlobal.ts
+/**
+* Returns a boolean indicating whether the given global property
+* is defined and is configurable.
+*/
+function hasConfigurableGlobal(propertyName) {
+	const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
+	if (typeof descriptor === "undefined") return false;
+	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
+Object.defineProperty(exports, 'hasConfigurableGlobal', {
+  enumerable: true,
+  get: function () {
+    return hasConfigurableGlobal;
+  }
+});
+//# sourceMappingURL=hasConfigurableGlobal-C97fWuaA.cjs.map

package/lib/node/hasConfigurableGlobal-C97fWuaA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasConfigurableGlobal-C97fWuaA.cjs","names":[],"sources":["../../src/utils/hasConfigurableGlobal.ts"],"sourcesContent":["/**\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 descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName)\n\n  // The property is not set at all.\n  if (typeof descriptor === 'undefined') {\n    return false\n  }\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":";;;;;;AAIA,SAAgB,sBAAsB,cAA+B;CACnE,MAAM,aAAa,OAAO,yBAAyB,YAAY,aAAa;AAG5E,KAAI,OAAO,eAAe,YACxB,QAAO;AAIT,KACE,OAAO,WAAW,QAAQ,cAC1B,OAAO,WAAW,KAAK,KAAK,YAE5B,QAAO;AAIT,KAAI,OAAO,WAAW,QAAQ,eAAe,WAAW,SAAS,KAC/D,QAAO;AAGT,KAAI,OAAO,WAAW,QAAQ,eAAe,CAAC,WAAW,cAAc;AACrE,UAAQ,MACN,mDAAmD,aAAa,oKACjE;AACD,SAAO;;AAGT,QAAO"}

package/lib/node/hasConfigurableGlobal-DBJA0vjm.mjs

@@ -0,0 +1,20 @@
+//#region src/utils/hasConfigurableGlobal.ts
+/**
+* Returns a boolean indicating whether the given global property
+* is defined and is configurable.
+*/
+function hasConfigurableGlobal(propertyName) {
+	const descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName);
+	if (typeof descriptor === "undefined") return false;
+	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=hasConfigurableGlobal-DBJA0vjm.mjs.map

package/lib/node/hasConfigurableGlobal-DBJA0vjm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasConfigurableGlobal-DBJA0vjm.mjs","names":[],"sources":["../../src/utils/hasConfigurableGlobal.ts"],"sourcesContent":["/**\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 descriptor = Object.getOwnPropertyDescriptor(globalThis, propertyName)\n\n  // The property is not set at all.\n  if (typeof descriptor === 'undefined') {\n    return false\n  }\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":";;;;;AAIA,SAAgB,sBAAsB,cAA+B;CACnE,MAAM,aAAa,OAAO,yBAAyB,YAAY,aAAa;AAG5E,KAAI,OAAO,eAAe,YACxB,QAAO;AAIT,KACE,OAAO,WAAW,QAAQ,cAC1B,OAAO,WAAW,KAAK,KAAK,YAE5B,QAAO;AAIT,KAAI,OAAO,WAAW,QAAQ,eAAe,WAAW,SAAS,KAC/D,QAAO;AAGT,KAAI,OAAO,WAAW,QAAQ,eAAe,CAAC,WAAW,cAAc;AACrE,UAAQ,MACN,mDAAmD,aAAa,oKACjE;AACD,SAAO;;AAGT,QAAO"}

package/lib/node/index-BMbJ8FXL.d.cts

@@ -0,0 +1,113 @@
+import { l as HttpRequestEventMap, r as Interceptor } from "./Interceptor-DJ2akVWI.cjs";
+import net from "node:net";
+
+//#region src/interceptors/Socket/utils/normalizeSocketWriteArgs.d.ts
+type WriteCallback = (error?: Error | null) => void;
+//#endregion
+//#region src/interceptors/Socket/MockSocket.d.ts
+interface MockSocketOptions {
+  write: (chunk: Buffer | string, encoding: BufferEncoding | undefined, callback?: WriteCallback) => void;
+  read: (chunk: Buffer, encoding: BufferEncoding | undefined) => void;
+}
+declare class MockSocket extends net.Socket {
+  protected readonly options: MockSocketOptions;
+  connecting: boolean;
+  constructor(options: MockSocketOptions);
+  connect(): this;
+  write(...args: Array<unknown>): boolean;
+  end(...args: Array<unknown>): this;
+  push(chunk: any, encoding?: BufferEncoding): boolean;
+}
+//#endregion
+//#region src/interceptors/ClientRequest/MockHttpSocket.d.ts
+type HttpConnectionOptions = any;
+type MockHttpSocketRequestCallback = (args: {
+  requestId: string;
+  request: Request;
+  socket: MockHttpSocket;
+}) => void;
+type MockHttpSocketResponseCallback = (args: {
+  requestId: string;
+  request: Request;
+  response: Response;
+  isMockedResponse: boolean;
+  socket: MockHttpSocket;
+}) => Promise<void>;
+interface MockHttpSocketOptions {
+  connectionOptions: HttpConnectionOptions;
+  createConnection: () => net.Socket;
+  onRequest: MockHttpSocketRequestCallback;
+  onResponse: MockHttpSocketResponseCallback;
+}
+declare class MockHttpSocket extends MockSocket {
+  private connectionOptions;
+  private createConnection;
+  private baseUrl;
+  private onRequest;
+  private onResponse;
+  private responseListenersPromise?;
+  private requestRawHeadersBuffer;
+  private responseRawHeadersBuffer;
+  private writeBuffer;
+  private request?;
+  private requestParser;
+  private requestStream?;
+  private shouldKeepAlive?;
+  private socketState;
+  private responseParser;
+  private responseStream?;
+  private originalSocket?;
+  constructor(options: MockHttpSocketOptions);
+  emit(event: string | symbol, ...args: any[]): boolean;
+  destroy(error?: Error | undefined): this;
+  /**
+   * Establish this Socket connection as-is and pipe
+   * its data/events through this Socket.
+   */
+  passthrough(): void;
+  /**
+   * Convert the given Fetch API `Response` instance to an
+   * HTTP message and push it to the socket.
+   */
+  respondWith(response: Response): Promise<void>;
+  /**
+   * Close this socket connection with the given error.
+   */
+  errorWith(error?: Error): void;
+  private mockConnect;
+  private flushWriteBuffer;
+  /**
+   * This callback might be called when the request is "slow":
+   * - Request headers were fragmented across multiple TCP packages;
+   * - Request headers were too large to be processed in a single run
+   * (e.g. more than 30 request headers).
+   * @note This is called before request start.
+   */
+  private onRequestHeaders;
+  private onRequestStart;
+  private onRequestBody;
+  private onRequestEnd;
+  /**
+   * This callback might be called when the response is "slow":
+   * - Response headers were fragmented across multiple TCP packages;
+   * - Response headers were too large to be processed in a single run
+   * (e.g. more than 30 response headers).
+   * @note This is called before response start.
+   */
+  private onResponseHeaders;
+  private onResponseStart;
+  private onResponseBody;
+  private onResponseEnd;
+}
+//#endregion
+//#region src/interceptors/ClientRequest/index.d.ts
+declare class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol: symbol;
+  constructor();
+  protected setup(): void;
+  private onRequest;
+  onResponse: MockHttpSocketResponseCallback;
+}
+//#endregion
+export { ClientRequestInterceptor as t };
+//# sourceMappingURL=index-BMbJ8FXL.d.cts.map