@mswjs/interceptors 0.41.9 → 0.42.1

package/lib/{node/hasConfigurableGlobal-BiTmog1u.mjs → browser/has-configurable-global-Cew-dYqk.js}

@@ -1,6 +1,5 @@
 import { invariant } from "outvariant";
-
-//#region src/utils/patchesRegistry.ts
+//#region src/utils/patches-registry.ts
 var PatchesRegistry = class {
 	#replacements = /* @__PURE__ */ new Map();
 	applyPatch(owner, key, getNextValue) {
@@ -38,7 +37,7 @@ var PatchesRegistry = class {
 			if (currentReplacements.size === 0) this.#replacements.delete(owner);
 		};
 		if (ownerReplacements) ownerReplacements.set(key, restorePatch);
-		else this.#replacements.set(owner, new Map([[key, restorePatch]]));
+		else this.#replacements.set(owner, /* @__PURE__ */ new Map([[key, restorePatch]]));
 		return restorePatch;
 	}
 	restoreAllPatches() {
@@ -71,9 +70,8 @@ function getDeepPropertyDescriptor(owner, key) {
 		currentOwner = Object.getPrototypeOf(currentOwner);
 	}
 }
-
 //#endregion
-//#region src/utils/hasConfigurableGlobal.ts
+//#region src/utils/has-configurable-global.ts
 /**
 * Returns a boolean indicating whether the given global property
 * is defined and is configurable.
@@ -90,7 +88,7 @@ function hasConfigurableGlobal(propertyName) {
 	}
 	return true;
 }
-
 //#endregion
 export { patchesRegistry as n, hasConfigurableGlobal as t };
-//# sourceMappingURL=hasConfigurableGlobal-BiTmog1u.mjs.map
+
+//# sourceMappingURL=has-configurable-global-Cew-dYqk.js.map

package/lib/browser/has-configurable-global-Cew-dYqk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-configurable-global-Cew-dYqk.js","names":["#replacements"],"sources":["../../src/utils/patches-registry.ts","../../src/utils/has-configurable-global.ts"],"sourcesContent":["import { invariant } from 'outvariant'\n\nclass PatchesRegistry {\n  #replacements = new Map<object, Map<PropertyKey, () => void>>()\n\n  public applyPatch<Owner extends object, K extends keyof Owner>(\n    owner: Owner,\n    key: K,\n    getNextValue: (realValue: Owner[K]) => Owner[K]\n  ): () => void {\n    const ownerReplacements = this.#replacements.get(owner)\n\n    invariant(\n      !ownerReplacements?.has(key),\n      `Failed to replace a global value at \"${String(key)}\": already replaced.`\n    )\n\n    const match = getDeepPropertyDescriptor(owner, key)\n\n    if (typeof match === 'undefined') {\n      console.warn(\n        `Failed to replace a global value at \"${String(key)}\": not a global value.`\n      )\n      return () => {}\n    }\n\n    if (match.descriptor.configurable) {\n      Object.defineProperty(owner, key, {\n        value: getNextValue(owner[key]),\n        enumerable: true,\n        configurable: true,\n      })\n    } else if (match.descriptor.writable) {\n      owner[key] = getNextValue(owner[key])\n    } else {\n      throw new Error(\n        `Failed to patch a non-configurable non-writable property \"${key.toString()}\"`\n      )\n    }\n\n    const restorePatch = () => {\n      const currentReplacements = this.#replacements.get(owner)\n\n      if (!currentReplacements?.has(key)) {\n        return\n      }\n\n      if (match.owner === owner) {\n        /**\n         * @note Restoring non-configurable properties works as long as \"writable: true\"\n         * and none of the other descriptor properties except for \"value\" have changed.\n         */\n        Object.defineProperty(match.owner, key, match.descriptor)\n      } else {\n        /**\n         * @todo Delete the proxy property set by the registry.\n         * If the match's owner isn't the original owner, the property is likely nested in the prototype.\n         * The registry does not meddle with those, they are left intact.\n         */\n        Reflect.deleteProperty(owner, key)\n      }\n\n      currentReplacements.delete(key)\n\n      if (currentReplacements.size === 0) {\n        this.#replacements.delete(owner)\n      }\n    }\n\n    if (ownerReplacements) {\n      ownerReplacements.set(key, restorePatch)\n    } else {\n      this.#replacements.set(owner, new Map([[key, restorePatch]]))\n    }\n\n    return restorePatch\n  }\n\n  public restoreAllPatches(): void {\n    const errors: Array<Error> = []\n\n    for (const [, ownerReplacements] of this.#replacements) {\n      for (const [, restorePatch] of ownerReplacements) {\n        try {\n          restorePatch()\n        } catch (error) {\n          if (error instanceof Error) {\n            errors.push(error)\n          } else {\n            throw error\n          }\n        }\n      }\n    }\n\n    if (errors.length > 0) {\n      throw new AggregateError(errors, 'FOO!')\n    }\n  }\n}\n\nexport const patchesRegistry = new PatchesRegistry()\n\ninterface DeepDescriptorMatch {\n  owner: object\n  descriptor: PropertyDescriptor\n}\n\n/**\n * Returns a property descriptor for the given property on the owner.\n * Walks down the prototype chain if the property does not exist on the owner.\n * Handy for getting a global property descriptor where `globalThis` is\n * replaced with a controlled class (e.g. ServiceWorkerGlobalScope).\n */\nexport function getDeepPropertyDescriptor<Owner extends object>(\n  owner: Owner,\n  key: PropertyKey\n): DeepDescriptorMatch | undefined {\n  let currentOwner: Owner | null = owner\n  let descriptor: PropertyDescriptor | undefined\n\n  while (currentOwner) {\n    descriptor = Object.getOwnPropertyDescriptor(currentOwner, key)\n\n    if (descriptor) {\n      return {\n        owner: currentOwner,\n        descriptor,\n      }\n    }\n\n    currentOwner = Object.getPrototypeOf(currentOwner)\n  }\n}\n","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":";;AAEA,IAAM,kBAAN,MAAsB;CACpB,gCAAgB,IAAI,IAA0C;CAE9D,WACE,OACA,KACA,cACY;EACZ,MAAM,oBAAoB,KAAKA,cAAc,IAAI,KAAK;EAEtD,UACE,CAAC,mBAAmB,IAAI,GAAG,GAC3B,wCAAwC,OAAO,GAAG,EAAE,qBACtD;EAEA,MAAM,QAAQ,0BAA0B,OAAO,GAAG;EAElD,IAAI,OAAO,UAAU,aAAa;GAChC,QAAQ,KACN,wCAAwC,OAAO,GAAG,EAAE,uBACtD;GACA,aAAa,CAAC;EAChB;EAEA,IAAI,MAAM,WAAW,cACnB,OAAO,eAAe,OAAO,KAAK;GAChC,OAAO,aAAa,MAAM,IAAI;GAC9B,YAAY;GACZ,cAAc;EAChB,CAAC;OACI,IAAI,MAAM,WAAW,UAC1B,MAAM,OAAO,aAAa,MAAM,IAAI;OAEpC,MAAM,IAAI,MACR,6DAA6D,IAAI,SAAS,EAAE,EAC9E;EAGF,MAAM,qBAAqB;GACzB,MAAM,sBAAsB,KAAKA,cAAc,IAAI,KAAK;GAExD,IAAI,CAAC,qBAAqB,IAAI,GAAG,GAC/B;GAGF,IAAI,MAAM,UAAU;;;;;GAKlB,OAAO,eAAe,MAAM,OAAO,KAAK,MAAM,UAAU;;;;;;;GAOxD,QAAQ,eAAe,OAAO,GAAG;GAGnC,oBAAoB,OAAO,GAAG;GAE9B,IAAI,oBAAoB,SAAS,GAC/B,KAAKA,cAAc,OAAO,KAAK;EAEnC;EAEA,IAAI,mBACF,kBAAkB,IAAI,KAAK,YAAY;OAEvC,KAAKA,cAAc,IAAI,uBAAO,IAAI,IAAI,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC;EAG9D,OAAO;CACT;CAEA,oBAAiC;EAC/B,MAAM,SAAuB,CAAC;EAE9B,KAAK,MAAM,GAAG,sBAAsB,KAAKA,eACvC,KAAK,MAAM,GAAG,iBAAiB,mBAC7B,IAAI;GACF,aAAa;EACf,SAAS,OAAO;GACd,IAAI,iBAAiB,OACnB,OAAO,KAAK,KAAK;QAEjB,MAAM;EAEV;EAIJ,IAAI,OAAO,SAAS,GAClB,MAAM,IAAI,eAAe,QAAQ,MAAM;CAE3C;AACF;AAEA,MAAa,kBAAkB,IAAI,gBAAgB;;;;;;;AAanD,SAAgB,0BACd,OACA,KACiC;CACjC,IAAI,eAA6B;CACjC,IAAI;CAEJ,OAAO,cAAc;EACnB,aAAa,OAAO,yBAAyB,cAAc,GAAG;EAE9D,IAAI,YACF,OAAO;GACL,OAAO;GACP;EACF;EAGF,eAAe,OAAO,eAAe,YAAY;CACnD;AACF;;;;;;;AC/HA,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/browser/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/{index.d.cts → index.d.ts}

@@ -1,29 +1,37 @@
-import { i as RequestControllerSource, n as RequestCredentials, r as RequestController, t as HttpRequestEventMap } from "./glossary-1lhZx6Aw.cjs";
-import { a as InterceptorReadyState, c as getGlobalSymbol, i as InterceptorEventMap, n as INTERNAL_REQUEST_ID_HEADER_NAME, o as InterceptorSubscription, r as Interceptor, s as deleteGlobalSymbol, t as ExtractEventNames } from "./Interceptor-Deczogc8.cjs";
-import { EventMap, Listener } from "strict-event-emitter";
-
-//#region src/BatchInterceptor.d.ts
-interface BatchInterceptorOptions<InterceptorList extends ReadonlyArray<Interceptor<any>>> {
+import { t as Interceptor } from "./interceptor-dtJZ_9QT.js";
+import { a as RequestControllerSource, i as RequestController, n as HttpRequestEventMap, r as HttpResponseEvent, t as HttpRequestEvent } from "./http-CB9rQ7i_.js";
+import { n as WebSocketEventMap, t as WebSocketConnectionEvent } from "./websocket-CC0nB0md.js";
+import { DefaultEventMap } from "rettime";
+//#region src/batch-interceptor.d.ts
+interface BatchInterceptorOptions<InterceptorList extends ReadonlyArray<Interceptor<DefaultEventMap>>> {
   name: string;
   interceptors: InterceptorList;
 }
-type ExtractEventMapType<InterceptorList extends ReadonlyArray<Interceptor<any>>> = InterceptorList extends ReadonlyArray<infer InterceptorType> ? InterceptorType extends Interceptor<infer EventMap> ? EventMap : never : never;
+type UnionToIntersection<Union> = (Union extends unknown ? (argument: Union) => void : never) extends ((argument: infer Intersection) => void) ? Intersection : never;
+/**
+ * @note Merge the event maps of all the given interceptors into
+ * an intersection. A naive conditional type distributes over the
+ * interceptor union, producing a union of event maps whose `keyof`
+ * is `never` (no common keys), which would make `.on()` unusable.
+ */
+type ExtractEventMapType<InterceptorList extends ReadonlyArray<Interceptor<DefaultEventMap>>> = InterceptorList extends ReadonlyArray<infer InterceptorType> ? UnionToIntersection<InterceptorType extends Interceptor<infer EventMap> ? EventMap : never> : never;
 /**
  * A batch interceptor that exposes a single interface
  * to apply and operate with multiple interceptors at once.
  */
-declare class BatchInterceptor<InterceptorList extends ReadonlyArray<Interceptor<any>>, Events extends EventMap = ExtractEventMapType<InterceptorList>> extends Interceptor<Events> {
-  static symbol: symbol;
-  private interceptors;
+declare class BatchInterceptor<InterceptorList extends ReadonlyArray<Interceptor<DefaultEventMap>>, Events extends DefaultEventMap = ExtractEventMapType<InterceptorList>> extends Interceptor<Events> {
+  #private;
   constructor(options: BatchInterceptorOptions<InterceptorList>);
+  protected predicate(): boolean;
   protected setup(): void;
-  on<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
-  once<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
-  off<EventName extends ExtractEventNames<Events>>(event: EventName, listener: Listener<Events[EventName]>): this;
-  removeAllListeners<EventName extends ExtractEventNames<Events>>(event?: EventName | undefined): this;
 }
 //#endregion
-//#region src/createRequestId.d.ts
+//#region src/interceptor-error.d.ts
+declare class InterceptorError extends Error {
+  constructor(message?: string);
+}
+//#endregion
+//#region src/create-request-id.d.ts
 /**
  * Generate a random ID string to represent a request.
  * @example
@@ -32,17 +40,17 @@ declare class BatchInterceptor<InterceptorList extends ReadonlyArray<Interceptor
  */
 declare function createRequestId(): string;
 //#endregion
-//#region src/utils/getCleanUrl.d.ts
+//#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/bufferUtils.d.ts
-declare function encodeBuffer(text: string): Uint8Array;
-declare function decodeBuffer(buffer: ArrayBuffer, encoding?: string): string;
+//#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/fetchUtils.d.ts
+//#region src/utils/fetch-utils.d.ts
 interface FetchRequestInit extends Omit<RequestInit, 'mode'> {
   mode?: RequestMode | 'websocket' | 'webtransport';
   duplex?: 'half' | 'full';
@@ -66,6 +74,8 @@ 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
@@ -97,22 +107,7 @@ declare class FetchResponse extends Response {
   clone(): Response;
 }
 //#endregion
-//#region src/getRawRequest.d.ts
-/**
- * Returns a raw request instance associated with this request.
- *
- * @example
- * interceptor.on('request', ({ request }) => {
- *   const rawRequest = getRawRequest(request)
- *
- *   if (rawRequest instanceof http.ClientRequest) {
- *     console.log(rawRequest.rawHeaders)
- *   }
- * })
- */
-declare function getRawRequest(request: Request): unknown | undefined;
-//#endregion
-//#region src/utils/resolveWebSocketUrl.d.ts
+//#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).
@@ -121,5 +116,5 @@ declare function getRawRequest(request: Request): unknown | undefined;
  */
 declare function resolveWebSocketUrl(url: string | URL): string;
 //#endregion
-export { BatchInterceptor, BatchInterceptorOptions, ExtractEventMapType, ExtractEventNames, FetchRequest, FetchResponse, HttpRequestEventMap, INTERNAL_REQUEST_ID_HEADER_NAME, Interceptor, InterceptorEventMap, InterceptorReadyState, InterceptorSubscription, RequestController, type RequestControllerSource, RequestCredentials, createRequestId, decodeBuffer, deleteGlobalSymbol, encodeBuffer, getCleanUrl, getGlobalSymbol, getRawRequest, resolveWebSocketUrl };
-//# sourceMappingURL=index.d.cts.map
+export { BatchInterceptor, FetchRequest, FetchResponse, type HttpRequestEvent, type HttpRequestEventMap, type HttpResponseEvent, Interceptor, InterceptorError, RequestController, type RequestControllerSource, type WebSocketConnectionEvent, type WebSocketEventMap, createRequestId, decodeBuffer, encodeBuffer, getCleanUrl, resolveWebSocketUrl };
+//# sourceMappingURL=index.d.ts.map

package/lib/browser/index.js

@@ -0,0 +1,130 @@
+import { n as Interceptor, t as createRequestId } from "./create-request-id-Bk5YX1AM.js";
+import { c as RequestController, l as InterceptorError, n as FetchResponse, t as FetchRequest } from "./fetch-utils-CUOrwEQf.js";
+import { n as encodeBuffer, t as decodeBuffer } from "./buffer-utils-DJj7YzLG.js";
+import { t as resolveWebSocketUrl } from "./resolve-web-socket-url-CSvNPLGi.js";
+//#region src/batch-interceptor.ts
+function addEventBridge(interceptor, type, listener) {
+	interceptor.on(type, listener);
+}
+function removeEventBridge(interceptor, type, listener) {
+	interceptor.removeListener(type, listener);
+}
+/**
+* A batch interceptor that exposes a single interface
+* to apply and operate with multiple interceptors at once.
+*/
+var BatchInterceptor = class extends Interceptor {
+	#interceptors;
+	#eventBridges;
+	#forwardedEvents;
+	constructor(options) {
+		super();
+		this.#interceptors = options.interceptors;
+		this.#eventBridges = /* @__PURE__ */ new Map();
+		this.#forwardedEvents = /* @__PURE__ */ new Map();
+		this.emitter.hooks.on("newListener", (type) => {
+			this.#ensureEventBridge(type);
+		}, { persist: true });
+		this.emitter.hooks.on("removeListener", (type) => {
+			if (this.emitter.listenerCount(type) === 0) this.#removeEventBridge(type);
+		}, { persist: true });
+	}
+	predicate() {
+		for (const interceptor of this.#interceptors) if (interceptor["predicate"]())
+ /**
+		* @note If at least one of the provided interceptors suits the environment,
+		* treat this batch interceptor as matching. Since all the interceptors abide
+		* by the same event map, it will handle the events from any that match.
+		*/
+		return true;
+		return false;
+	}
+	setup() {
+		const interceptors = new Set(this.#interceptors);
+		this.#forwardedEvents = /* @__PURE__ */ new Map();
+		this.logger.verbose("applying batch %s with %d interceptors", this.constructor.name, interceptors.size);
+		this.subscriptions.push(() => {
+			this.#removeAllEventBridges();
+		});
+		for (const interceptor of interceptors) {
+			this.logger.verbose("applying \"%s\" interceptor...", interceptor.constructor.name);
+			interceptor.apply(this);
+			this.logger.verbose("adding interceptor dispose subscription");
+			this.subscriptions.push(() => {
+				interceptor.dispose(this);
+			});
+		}
+	}
+	#ensureEventBridge(type) {
+		if (this.#eventBridges.has(type)) return;
+		if (type === "*") {
+			this.#ensureWildcardEventBridge();
+			return;
+		}
+		this.#ensureTypedEventBridge(type);
+	}
+	#ensureTypedEventBridge(type) {
+		const interceptors = new Set(this.#interceptors);
+		const batchEmitter = this.emitter;
+		const forwardEvent = async (event) => {
+			if (this.#recordForwardedEvent(event)) {
+				this.logger.verbose("skipping duplicate \"%s\" event", event.type);
+				return;
+			}
+			this.logger.verbose("forwarding \"%s\" event", event.type);
+			await batchEmitter.emitAsPromise(event);
+		};
+		for (const interceptor of interceptors) addEventBridge(interceptor, type, forwardEvent);
+		this.#eventBridges.set(type, () => {
+			for (const interceptor of interceptors) removeEventBridge(interceptor, type, forwardEvent);
+		});
+	}
+	#ensureWildcardEventBridge() {
+		const interceptors = new Set(this.#interceptors);
+		const batchEmitter = this.emitter;
+		const forwardEvent = (event) => {
+			if (this.#recordForwardedEvent(event)) {
+				this.logger.verbose("skipping duplicate \"%s\" event", event.type);
+				return;
+			}
+			this.logger.verbose("forwarding wildcard \"%s\" event", event.type);
+			batchEmitter.emitAsPromise(event);
+		};
+		for (const interceptor of interceptors) addEventBridge(interceptor, "*", forwardEvent);
+		this.#eventBridges.set("*", () => {
+			for (const interceptor of interceptors) removeEventBridge(interceptor, "*", forwardEvent);
+		});
+	}
+	#recordForwardedEvent(event) {
+		const forwardedEvents = this.#forwardedEvents.get(event.type);
+		if (forwardedEvents?.has(event)) return true;
+		if (forwardedEvents) {
+			forwardedEvents.add(event);
+			return false;
+		}
+		this.#forwardedEvents.set(event.type, new WeakSet([event]));
+		return false;
+	}
+	#removeEventBridge(type) {
+		const disposeEventBridge = this.#eventBridges.get(type);
+		if (!disposeEventBridge) return;
+		disposeEventBridge();
+		this.#eventBridges.delete(type);
+	}
+	#removeAllEventBridges() {
+		for (const disposeEventBridge of this.#eventBridges.values()) disposeEventBridge();
+		this.#eventBridges.clear();
+	}
+};
+//#endregion
+//#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
+export { BatchInterceptor, FetchRequest, FetchResponse, Interceptor, InterceptorError, RequestController, createRequestId, decodeBuffer, encodeBuffer, getCleanUrl, resolveWebSocketUrl };
+
+//# sourceMappingURL=index.js.map

package/lib/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#interceptors","#eventBridges","#forwardedEvents","#ensureEventBridge","#removeEventBridge","#removeAllEventBridges","#ensureWildcardEventBridge","#ensureTypedEventBridge","#recordForwardedEvent"],"sources":["../../src/batch-interceptor.ts","../../src/utils/get-clean-url.ts"],"sourcesContent":["import {\n  type DefaultEventMap,\n  Emitter,\n  type TypedEvent,\n  type WithReservedEvents,\n} from 'rettime'\nimport { Interceptor } from './interceptor'\nimport { type DisposableSubscription } from './disposable'\n\ntype GenericEventListener = Emitter.Listener<\n  Emitter<DefaultEventMap>,\n  string\n>\n\nfunction addEventBridge(\n  interceptor: Interceptor<DefaultEventMap>,\n  type: string,\n  listener: GenericEventListener\n): void {\n  interceptor.on(type, listener)\n}\n\nfunction removeEventBridge(\n  interceptor: Interceptor<DefaultEventMap>,\n  type: string,\n  listener: GenericEventListener\n): void {\n  interceptor.removeListener(type, listener)\n}\n\nexport interface BatchInterceptorOptions<\n  InterceptorList extends ReadonlyArray<Interceptor<DefaultEventMap>>,\n> {\n  name: string\n  interceptors: InterceptorList\n}\n\ntype UnionToIntersection<Union> = (\n  Union extends unknown ? (argument: Union) => void : never\n) extends (argument: infer Intersection) => void\n  ? Intersection\n  : never\n\n/**\n * @note Merge the event maps of all the given interceptors into\n * an intersection. A naive conditional type distributes over the\n * interceptor union, producing a union of event maps whose `keyof`\n * is `never` (no common keys), which would make `.on()` unusable.\n */\nexport type ExtractEventMapType<\n  InterceptorList extends ReadonlyArray<Interceptor<DefaultEventMap>>,\n> =\n  InterceptorList extends ReadonlyArray<infer InterceptorType>\n    ? UnionToIntersection<\n        InterceptorType extends Interceptor<infer EventMap> ? EventMap : never\n      >\n    : never\n\n/**\n * A batch interceptor that exposes a single interface\n * to apply and operate with multiple interceptors at once.\n */\nexport class BatchInterceptor<\n  InterceptorList extends ReadonlyArray<Interceptor<DefaultEventMap>>,\n  Events extends DefaultEventMap = ExtractEventMapType<InterceptorList>,\n> extends Interceptor<Events> {\n  #interceptors: InterceptorList\n  #eventBridges: Map<string, DisposableSubscription>\n  #forwardedEvents: Map<string, WeakSet<object>>\n\n  constructor(options: BatchInterceptorOptions<InterceptorList>) {\n    super()\n\n    this.#interceptors = options.interceptors\n    this.#eventBridges = new Map()\n    this.#forwardedEvents = new Map()\n\n    this.emitter.hooks.on(\n      'newListener',\n      (type) => {\n        this.#ensureEventBridge(type)\n      },\n      {\n        persist: true,\n      }\n    )\n\n    this.emitter.hooks.on(\n      'removeListener',\n      (type) => {\n        if (this.emitter.listenerCount(type) === 0) {\n          this.#removeEventBridge(type)\n        }\n      },\n      {\n        persist: true,\n      }\n    )\n  }\n\n  protected predicate(): boolean {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor['predicate']()) {\n        /**\n         * @note If at least one of the provided interceptors suits the environment,\n         * treat this batch interceptor as matching. Since all the interceptors abide\n         * by the same event map, it will handle the events from any that match.\n         */\n        return true\n      }\n    }\n\n    return false\n  }\n\n  protected setup(): void {\n    const interceptors = new Set(this.#interceptors)\n\n    this.#forwardedEvents = new Map()\n\n    this.logger.verbose(\n      'applying batch %s with %d interceptors',\n      this.constructor.name,\n      interceptors.size\n    )\n\n    this.subscriptions.push(() => {\n      this.#removeAllEventBridges()\n    })\n\n    for (const interceptor of interceptors) {\n      this.logger.verbose(\n        'applying \"%s\" interceptor...',\n        interceptor.constructor.name\n      )\n      interceptor.apply(this)\n\n      this.logger.verbose('adding interceptor dispose subscription')\n      this.subscriptions.push(() => {\n        interceptor.dispose(this)\n      })\n    }\n  }\n\n  #ensureEventBridge(\n    type: keyof WithReservedEvents<Events> & string\n  ): void {\n    if (this.#eventBridges.has(type)) {\n      return\n    }\n\n    if (type === '*') {\n      this.#ensureWildcardEventBridge()\n      return\n    }\n\n    this.#ensureTypedEventBridge(type)\n  }\n\n  #ensureTypedEventBridge(type: keyof Events & string): void {\n    const interceptors = new Set(this.#interceptors)\n    const batchEmitter = this.emitter as Emitter<DefaultEventMap>\n    const forwardEvent: GenericEventListener = async (event) => {\n      if (this.#recordForwardedEvent(event)) {\n        this.logger.verbose('skipping duplicate \"%s\" event', event.type)\n        return\n      }\n\n      this.logger.verbose('forwarding \"%s\" event', event.type)\n      await batchEmitter.emitAsPromise(event)\n    }\n\n    for (const interceptor of interceptors) {\n      addEventBridge(interceptor, type, forwardEvent)\n    }\n\n    this.#eventBridges.set(type, () => {\n      for (const interceptor of interceptors) {\n        removeEventBridge(interceptor, type, forwardEvent)\n      }\n    })\n  }\n\n  #ensureWildcardEventBridge(): void {\n    const interceptors = new Set(this.#interceptors)\n    const batchEmitter = this.emitter as Emitter<DefaultEventMap>\n    const forwardEvent: GenericEventListener = (event: TypedEvent): void => {\n      if (this.#recordForwardedEvent(event)) {\n        this.logger.verbose('skipping duplicate \"%s\" event', event.type)\n        return\n      }\n\n      this.logger.verbose('forwarding wildcard \"%s\" event', event.type)\n      void batchEmitter.emitAsPromise(event)\n    }\n\n    for (const interceptor of interceptors) {\n      addEventBridge(interceptor, '*', forwardEvent)\n    }\n\n    this.#eventBridges.set('*', () => {\n      for (const interceptor of interceptors) {\n        removeEventBridge(interceptor, '*', forwardEvent)\n      }\n    })\n  }\n\n  #recordForwardedEvent(event: TypedEvent): boolean {\n    const forwardedEvents = this.#forwardedEvents.get(event.type)\n\n    if (forwardedEvents?.has(event)) {\n      return true\n    }\n\n    if (forwardedEvents) {\n      forwardedEvents.add(event)\n      return false\n    }\n\n    this.#forwardedEvents.set(event.type, new WeakSet([event]))\n    return false\n  }\n\n  #removeEventBridge(\n    type: keyof WithReservedEvents<Events> & string\n  ): void {\n    const disposeEventBridge = this.#eventBridges.get(type)\n\n    if (!disposeEventBridge) {\n      return\n    }\n\n    disposeEventBridge()\n    this.#eventBridges.delete(type)\n  }\n\n  #removeAllEventBridges(): void {\n    for (const disposeEventBridge of this.#eventBridges.values()) {\n      disposeEventBridge()\n    }\n\n    this.#eventBridges.clear()\n  }\n}\n","/**\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"],"mappings":"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"}

package/lib/browser/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/browser/interceptors/WebSocket/index.d.ts

@@ -0,0 +1,2 @@
+import { a as WebSocketServerConnectionProtocol, c as WebSocketClientConnectionProtocol, d as WebSocketTransport, f as CancelableCloseEvent, i as WebSocketServerConnection, l as WebSocketClientEventMap, m as CloseEvent, o as WebSocketServerEventMap, p as CancelableMessageEvent, r as WebSocketInterceptor, s as WebSocketClientConnection, u as WebSocketData } from "../../websocket-CC0nB0md.js";
+export { CancelableCloseEvent, CancelableMessageEvent, CloseEvent, WebSocketClientConnection, WebSocketClientConnectionProtocol, type WebSocketClientEventMap, type WebSocketData, WebSocketInterceptor, WebSocketServerConnection, WebSocketServerConnectionProtocol, type WebSocketServerEventMap, type WebSocketTransport };

package/lib/browser/interceptors/WebSocket/{index.mjs → index.js}

@@ -1,10 +1,19 @@
-import { r as Interceptor, t as createRequestId } from "../../createRequestId-DYCsFHOi.mjs";
-import { t as resolveWebSocketUrl } from "../../resolveWebSocketUrl-C83-x9iE.mjs";
-import { n as patchesRegistry, r as emitAsync, t as hasConfigurableGlobal } from "../../hasConfigurableGlobal-C8zq1MCg.mjs";
-import { DeferredPromise } from "@open-draft/deferred-promise";
+import { n as Interceptor, r as createLogger, t as createRequestId } from "../../create-request-id-Bk5YX1AM.js";
+import { t as resolveWebSocketUrl } from "../../resolve-web-socket-url-CSvNPLGi.js";
+import { n as patchesRegistry, t as hasConfigurableGlobal } from "../../has-configurable-global-Cew-dYqk.js";
+import { TypedEvent } from "rettime";
 import { invariant } from "outvariant";
-
-//#region src/interceptors/WebSocket/utils/bindEvent.ts
+//#region src/events/websocket.ts
+var WebSocketConnectionEvent = class extends TypedEvent {
+	constructor(data) {
+		super(...["connection", {}]);
+		this.client = data.client;
+		this.server = data.server;
+		this.info = data.info;
+	}
+};
+//#endregion
+//#region src/interceptors/WebSocket/utils/bind-event.ts
 function bindEvent(target, event) {
 	Object.defineProperties(event, {
 		target: {
@@ -20,7 +29,6 @@ function bindEvent(target, event) {
 	});
 	return event;
 }
-
 //#endregion
 //#region src/interceptors/WebSocket/utils/events.ts
 const kCancelable = Symbol("kCancelable");
@@ -84,9 +92,8 @@ var CancelableCloseEvent = class extends CloseEvent {
 		if (this.cancelable && !this[kDefaultPrevented]) this[kDefaultPrevented] = true;
 	}
 };
-
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketClientConnection.ts
+//#region src/interceptors/WebSocket/web-socket-client-connection.ts
 const kEmitter$1 = Symbol("kEmitter");
 const kBoundListener$1 = Symbol("kBoundListener");
 var WebSocketClientConnectionProtocol = class {};
@@ -158,9 +165,8 @@ var WebSocketClientConnection = class {
 		this.transport.close(code, reason);
 	}
 };
-
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketOverride.ts
+//#region src/interceptors/WebSocket/web-socket-override.ts
 const WEBSOCKET_CLOSE_CODE_RANGE_ERROR = "InvalidAccessError: close code out of user configurable range";
 const kPassthroughPromise = Symbol("kPassthroughPromise");
 const kOnSend = Symbol("kOnSend");
@@ -194,9 +200,9 @@ var WebSocketOverride = class extends EventTarget {
 		this.binaryType = "blob";
 		this.readyState = this.CONNECTING;
 		this.bufferedAmount = 0;
-		this[kPassthroughPromise] = new DeferredPromise();
+		this[kPassthroughPromise] = Promise.withResolvers();
 		queueMicrotask(async () => {
-			if (await this[kPassthroughPromise]) return;
+			if (await this[kPassthroughPromise].promise) return;
 			this.protocol = typeof protocols === "string" ? protocols : Array.isArray(protocols) && protocols.length > 0 ? protocols[0] : "";
 			/**
 			* @note Check that nothing has prevented this connection
@@ -299,9 +305,8 @@ function getDataSize(data) {
 	if (data instanceof Blob) return data.size;
 	return data.byteLength;
 }
-
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketServerConnection.ts
+//#region src/interceptors/WebSocket/web-socket-server-connection.ts
 const kEmitter = Symbol("kEmitter");
 const kBoundListener = Symbol("kBoundListener");
 const kSend = Symbol("kSend");
@@ -422,6 +427,10 @@ var WebSocketServerConnection = class {
 		realWebSocket.close();
 		queueMicrotask(() => {
 			this[kEmitter].dispatchEvent(bindEvent(this.realWebSocket, new CancelableCloseEvent("close", {
+				/**
+				* @note `server.close()` in the interceptor
+				* always results in clean closures.
+				*/
 				code: 1e3,
 				cancelable: true
 			})));
@@ -473,9 +482,8 @@ var WebSocketServerConnection = class {
 		if (!closeEvent.defaultPrevented) this.client[kClose](event.code, event.reason);
 	}
 };
-
 //#endregion
-//#region src/interceptors/WebSocket/WebSocketClassTransport.ts
+//#region src/interceptors/WebSocket/web-socket-class-transport.ts
 /**
 * Abstraction over the given mock `WebSocket` instance that allows
 * for controlling that instance (e.g. sending and receiving messages).
@@ -540,27 +548,28 @@ var WebSocketClassTransport = class extends EventTarget {
 		this.socket[kClose](code, reason);
 	}
 };
-
 //#endregion
 //#region src/interceptors/WebSocket/index.ts
+const logger = createLogger("websocket");
 /**
 * Intercept the outgoing WebSocket connections created using
 * the global `WebSocket` class.
 */
-var WebSocketInterceptor = class WebSocketInterceptor extends Interceptor {
+var WebSocketInterceptor = class extends Interceptor {
 	static {
 		this.symbol = Symbol.for("websocket-interceptor");
 	}
-	constructor() {
-		super(WebSocketInterceptor.symbol);
-	}
-	checkEnvironment() {
+	predicate() {
 		return hasConfigurableGlobal("WebSocket");
 	}
 	setup() {
-		const logger = this.logger.extend("setup");
+		logger.verbose("setup");
 		const WebSocketProxy = new Proxy(globalThis.WebSocket, { construct: (target, args, newTarget) => {
 			const [url, protocols] = args;
+			logger.info("connection intercepted %o", {
+				url: url.toString(),
+				protocols
+			});
 			const createConnection = () => {
 				return Reflect.construct(target, args, newTarget);
 			};
@@ -570,11 +579,11 @@ var WebSocketInterceptor = class WebSocketInterceptor extends Interceptor {
 				try {
 					const server = new WebSocketServerConnection(socket, transport, createConnection);
 					const hasConnectionListeners = this.emitter.listenerCount("connection") > 0;
-					await emitAsync(this.emitter, "connection", {
+					await this.emitter.emitAsPromise(new WebSocketConnectionEvent({
 						client: new WebSocketClientConnection(socket, transport),
 						server,
 						info: { protocols }
-					});
+					}));
 					if (hasConnectionListeners) socket[kPassthroughPromise].resolve(false);
 					else {
 						socket[kPassthroughPromise].resolve(true);
@@ -600,12 +609,12 @@ var WebSocketInterceptor = class WebSocketInterceptor extends Interceptor {
 			});
 			return socket;
 		} });
-		logger.info("patching global WebSocket...");
+		logger.verbose("patching global WebSocket...");
 		this.subscriptions.push(patchesRegistry.applyPatch(globalThis, "WebSocket", () => WebSocketProxy));
-		logger.info("global WebSocket patched!", globalThis.WebSocket.name);
+		logger.verbose("global WebSocket patched: %s", globalThis.WebSocket.name);
 	}
 };
-
 //#endregion
 export { CancelableCloseEvent, CancelableMessageEvent, CloseEvent, WebSocketClientConnection, WebSocketClientConnectionProtocol, WebSocketInterceptor, WebSocketServerConnection, WebSocketServerConnectionProtocol };
-//# sourceMappingURL=index.mjs.map
+
+//# sourceMappingURL=index.js.map