msw/lib/_chunks/interceptor-source.js

Seamless REST/GraphQL API mocking library for browser and Node.js.

import { m as devUtils, p as InternalError, r as toPublicUrl, t as cookieStore, u as getRawSetCookie } from "./cookie-store.js";
import { n as getSiblingHandlers, o as kAutoConnect, r as isSiblingHandler, s as kConnect } from "./attach-sibling-handlers.js";
import { t as executeHandlers } from "./execute-handlers.js";
import { isPassthroughResponse } from "../utils/passthrough.js";
import { isCommonAssetRequest } from "../utils/is-common-asset-request.js";
import { invariant } from "outvariant";
import { BatchInterceptor, createRequestId } from "@mswjs/interceptors";
import { Emitter, TypedEvent } from "rettime";
import { until } from "until-async";
//#region src/core/experimental/sources/network-source.ts
var NetworkFrameEvent = class extends TypedEvent {
	frame;
	constructor(type, frame) {
		super(...[type, {}]);
		this.frame = frame;
	}
};
var NetworkSource = class {
	emitter;
	constructor() {
		this.emitter = new Emitter();
	}
	async queue(frame) {
		await this.emitter.emitAsPromise(new NetworkFrameEvent("frame", frame));
	}
	on(type, listener, options) {
		this.emitter.on(type, listener, options);
	}
	disable() {
		this.emitter.removeAllListeners();
	}
};
//#endregion
//#region src/core/experimental/handlers-controller.ts
function addHandlerToGroup(groups, kind, handler) {
	(groups[kind] ||= []).push(handler);
}
function prependHandlersToGroup(groups, kind, overridesForKind) {
	const existingForKind = groups[kind];
	groups[kind] = existingForKind ? [...overridesForKind, ...existingForKind.filter((existingHandler) => {
		return !overridesForKind.includes(existingHandler);
	})] : overridesForKind;
}
function groupHandlersByKind(handlers) {
	const groups = {};
	const visitedHandlers = /* @__PURE__ */ new Set();
	const visit = (handler) => {
		if (visitedHandlers.has(handler)) return;
		visitedHandlers.add(handler);
		addHandlerToGroup(groups, handler.kind, handler);
		for (const sibling of getSiblingHandlers(handler)) visit(sibling);
	};
	for (const handler of handlers) visit(handler);
	return groups;
}
var HandlersController = class {
	getInitialState(initialHandlers) {
		invariant(this.#validateHandlers(initialHandlers), devUtils.formatMessage("Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?"));
		const normalizedInitialHandlers = groupHandlersByKind(initialHandlers);
		return {
			initialHandlers: normalizedInitialHandlers,
			handlers: { ...normalizedInitialHandlers }
		};
	}
	currentHandlers() {
		return Object.values(this.getState().handlers).flat().filter((handler) => handler != null);
	}
	/**
	* Return the list of explicitly registered handlers.
	* Unlike `currentHandlers()`, this excludes sibling handlers,
	* which are an implementation detail (e.g. the WebSocket upgrade
	* handler or the GraphQL subscription transport).
	*/
	listHandlers() {
		return this.currentHandlers().filter((handler) => {
			return !isSiblingHandler(handler);
		});
	}
	/**
	* Return the list of handlers of the given kind.
	*/
	getHandlersByKind(kind) {
		return this.getState().handlers[kind] || [];
	}
	use(nextHandlers) {
		invariant(this.#validateHandlers(nextHandlers), devUtils.formatMessage("[MSW] Failed to call \"use()\" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?"));
		if (nextHandlers.length === 0) return;
		const { handlers } = this.getState();
		const overrides = groupHandlersByKind(nextHandlers);
		if (overrides.request) prependHandlersToGroup(handlers, "request", overrides.request);
		if (overrides.websocket) prependHandlersToGroup(handlers, "websocket", overrides.websocket);
		this.setState({ handlers });
	}
	reset(nextHandlers) {
		invariant(nextHandlers.length > 0 ? this.#validateHandlers(nextHandlers) : true, devUtils.formatMessage("Failed to replace initial handlers during reset: invalid handlers. Did you forget to spread the handlers array?"));
		for (const handler of this.currentHandlers()) handler.reset();
		const { initialHandlers } = this.getState();
		if (nextHandlers.length === 0) {
			this.setState({ handlers: { ...initialHandlers } });
			return;
		}
		const normalizedNextHandlers = groupHandlersByKind(nextHandlers);
		this.setState({
			initialHandlers: normalizedNextHandlers,
			handlers: { ...normalizedNextHandlers }
		});
	}
	restore() {
		for (const handler of this.currentHandlers()) handler.restore();
	}
	dispose() {
		const pendingDisposals = [];
		for (const handler of this.currentHandlers()) {
			const disposal = handler.dispose();
			if (disposal instanceof Promise) pendingDisposals.push(disposal);
		}
		if (pendingDisposals.length > 0) return Promise.all(pendingDisposals).then(() => {});
	}
	#validateHandlers(handlers) {
		return handlers.every((handler) => !Array.isArray(handler));
	}
};
var InMemoryHandlersController = class extends HandlersController {
	#handlers;
	#initialHandlers;
	constructor(initialHandlers) {
		super();
		const initialState = this.getInitialState(initialHandlers);
		this.#initialHandlers = initialState.initialHandlers;
		this.#handlers = initialState.handlers;
	}
	getState() {
		return {
			initialHandlers: this.#initialHandlers,
			handlers: this.#handlers
		};
	}
	setState(nextState) {
		if (nextState.initialHandlers) this.#initialHandlers = nextState.initialHandlers;
		if (nextState.handlers) this.#handlers = nextState.handlers;
	}
};
//#endregion
//#region src/core/utils/internal/to-readonly-array.ts
/**
* Creates an immutable copy of the given array.
*/
function toReadonlyArray(source) {
	const clone = [...source];
	Object.freeze(clone);
	return clone;
}
//#endregion
//#region src/core/utils/internal/disposable.ts
var Disposable = class {
	subscriptions = [];
	dispose() {
		let subscription;
		const errors = [];
		while (subscription = this.subscriptions.shift()) try {
			subscription();
		} catch (error) {
			if (error instanceof Error) errors.push(error);
		}
		if (errors.length > 0) console.error(new AggregateError(errors, devUtils.formatMessage("Failed to dispose of some side effects. This is likely an issue with MSW, please report it on GitHub: https://github.com/mswjs/msw/issues")));
	}
};
//#endregion
//#region src/core/experimental/define-network.ts
function colorlessPromiseAll(values) {
	const promises = [];
	for (const value of values) if (value instanceof Promise) promises.push(value);
	if (promises.length > 0) return Promise.all(promises).then(() => {});
}
let NetworkReadyState = /* @__PURE__ */ function(NetworkReadyState) {
	NetworkReadyState[NetworkReadyState["DISABLED"] = 0] = "DISABLED";
	NetworkReadyState[NetworkReadyState["ENABLED"] = 1] = "ENABLED";
	return NetworkReadyState;
}({});
/**
* Define a network instance with the given configuration.
* @example
* import { InterceptorSource } from 'msw/experimental'
* import { handlers } from './handlers'
*
* const network = defineNetwork({
*   sources: [new InterceptorSource({ interceptors })],
*   handlers,
* })
* await network.enable()
*/
function defineNetwork(options) {
	let readyState = 0;
	const events = new Emitter();
	const disposable = new Disposable();
	const deriveHandlersController = (handlers) => {
		return handlers instanceof HandlersController ? handlers : new InMemoryHandlersController(handlers || []);
	};
	let resolvedOptions = { ...options };
	/**
	* @note Create the handlers controller immediately because
	* certain setup APIs, like `setupServer`, don't await `.enable` (`.listen`).
	*/
	let handlersController = deriveHandlersController(resolvedOptions.handlers);
	return {
		get readyState() {
			return readyState;
		},
		events,
		configure(options) {
			invariant(readyState === 0, "Failed to call \"configure()\" on the network: cannot configure an already enabled network.");
			if (options.handlers && !Object.is(options.handlers, resolvedOptions.handlers)) handlersController = deriveHandlersController(options.handlers);
			resolvedOptions = {
				...resolvedOptions,
				...options
			};
		},
		enable() {
			invariant(readyState === 0, "Failed to call \"enable\" on the network: already enabled");
			readyState = 1;
			/**
			* @note Use a session object scoped to the current "enable()"
			* to prevent "frame.events" listeners from surviving across enable/disable cycles.
			* @see The note about `AbortController` below.
			*/
			const session = { active: true };
			disposable["subscriptions"].push(() => {
				session.active = false;
			});
			return colorlessPromiseAll(resolvedOptions.sources.map((source) => {
				/**
				* @note Preemptively disable the network source before enabling.
				* This intentionally calls only the prototype method that clears the
				* event listeners and nothing else. This prevents the "frame" listeners
				* from accumulating across enable/disable in case the source is a singleton.
				*/
				NetworkSource.prototype.disable.call(source);
				source.on("frame", async ({ frame }) => {
					frame.events.on("*", (event) => {
						/**
						* @note Prevent event forwarding manually and not via an AbortController
						* because certain runtimes, like Cloudflare, throw when referencing an
						* AbortController created in a different context. Bear in mind that the frame
						* events run in the patched request client context while the AbortController
						* is created outside, in the "defineNetwork" closure, which is a test context.
						*/
						if (!session.active) return;
						events.emit(event);
					});
					const handlers = frame.getHandlers(handlersController);
					await frame.resolve(handlers, resolvedOptions.onUnhandledFrame || "warn", resolvedOptions.context);
				});
				return source.enable();
			}));
		},
		disable() {
			invariant(readyState === 1, "Failed to call \"disable\" on the network: already disabled");
			readyState = 0;
			const handlersDisposal = handlersController.dispose();
			disposable.dispose();
			/**
			* @note Tear down the sources synchronously, never behind the
			* handlers disposal. `disable()` is not always awaited (e.g.
			* `server.close()` is synchronous), and a deferred teardown would
			* race any `enable()` that follows, disabling the sources that the
			* new session has just enabled.
			*/
			const sourcesDisposal = colorlessPromiseAll(resolvedOptions.sources.map((source) => source.disable()));
			/**
			* @note Await both disposals so neither rejection goes unobserved.
			* Chaining them would leave the source disposal floating whenever
			* the handlers disposal rejects.
			*/
			return handlersDisposal instanceof Promise ? Promise.all([handlersDisposal, sourcesDisposal]).then(() => {}) : sourcesDisposal;
		},
		use(...handlers) {
			handlersController.use(handlers);
		},
		resetHandlers(...handlers) {
			handlersController.reset(handlers);
		},
		restoreHandlers() {
			handlersController.restore();
		},
		listHandlers() {
			return toReadonlyArray(handlersController.listHandlers());
		}
	};
}
//#endregion
//#region src/core/experimental/frames/network-frame.ts
/**
* The base for the network frames. Extend this abstract class
* to implement custom network frames.
*/
var NetworkFrame = class {
	protocol;
	data;
	events;
	constructor(protocol, data) {
		this.protocol = protocol;
		this.data = data;
		this.events = new Emitter();
	}
};
//#endregion
//#region src/core/utils/request/store-response-cookies.ts
async function storeResponseCookies(request, response) {
	if (cookieStore === null) return;
	for (const responseCookie of getRawSetCookie(response)) await cookieStore.setCookie(responseCookie, request.url);
}
//#endregion
//#region src/core/experimental/request-utils.ts
function shouldBypassRequest(request) {
	return !!request.headers.get("accept")?.includes("msw/passthrough");
}
/**
* Remove the internal passthrough instruction from the request's `Accept` header.
*/
function deleteRequestPassthroughHeader(request) {
	const acceptHeader = request.headers.get("accept");
	/**
	* @note Remove the internal bypass request header.
	* In the browser, this is done by the worker script.
	* In Node.js, it has to be done here.
	*/
	if (acceptHeader) {
		const nextAcceptHeader = acceptHeader.replace(/(,\s+)?msw\/passthrough/, "");
		if (nextAcceptHeader) request.headers.set("accept", nextAcceptHeader);
		else request.headers.delete("accept");
	}
}
//#endregion
//#region src/core/experimental/on-unhandled-frame.ts
async function executeUnhandledFrameHandle(frame, handle) {
	const printStrategyMessage = async (strategy) => {
		if (strategy === "bypass") return;
		const message = await frame.getUnhandledMessage();
		switch (strategy) {
			case "warn": return devUtils.warn("Warning: %s", message);
			case "error": return devUtils.error("Error: %s", message);
		}
	};
	const applyStrategy = async (strategy) => {
		invariant.as(InternalError, strategy === "bypass" || strategy === "warn" || strategy === "error", devUtils.formatMessage("Failed to react to an unhandled network frame: unknown strategy \"%s\". Please provide one of the supported strategies (\"bypass\", \"warn\", \"error\") or a custom callback function as the value of the \"onUnhandledFrame\" option.", strategy));
		if (strategy === "bypass") return;
		await printStrategyMessage(strategy);
		if (strategy === "error") return Promise.reject(new InternalError(devUtils.formatMessage("Cannot bypass a request when using the \"error\" strategy for the \"onUnhandledFrame\" option.")));
	};
	if (typeof handle === "function") return handle({
		frame,
		defaults: {
			warn: printStrategyMessage.bind(null, "warn"),
			/**
			* @note The defaults only print the corresponding messages now.
			* They do not affect the frame resolution (e.g. do not error the frame).
			* That is only for backward compatibility reasons. In the future, these should
			* be an alias to `applyStrategy.bind(null, 'error')` instead.
			*/
			error: printStrategyMessage.bind(null, "error")
		}
	});
	/**
	* Ignore unhandled common HTTP assets.
	* @note Calling this here applies the common assets check
	* only to the scenarios when `onUnhandledFrame` was set to a predefined strategy.
	* When using a custom function, you need to check for common assets manually.
	*/
	if (frame instanceof HttpNetworkFrame && isCommonAssetRequest(frame.data.request)) return;
	return applyStrategy(handle);
}
//#endregion
//#region src/core/experimental/frames/http-frame.ts
var RequestEvent = class extends TypedEvent {
	requestId;
	request;
	constructor(type, data) {
		super(...[type, {}]);
		this.requestId = data.requestId;
		this.request = data.request;
	}
};
var ResponseEvent = class extends TypedEvent {
	requestId;
	request;
	response;
	constructor(type, data) {
		super(...[type, {}]);
		this.requestId = data.requestId;
		this.request = data.request;
		this.response = data.response;
	}
};
var UnhandledExceptionEvent = class extends TypedEvent {
	error;
	requestId;
	request;
	constructor(type, data) {
		super(...[type, {}]);
		this.error = data.error;
		this.requestId = data.requestId;
		this.request = data.request;
	}
};
var HttpNetworkFrame = class extends NetworkFrame {
	constructor(options) {
		const id = options.id || createRequestId();
		super("http", {
			id,
			request: options.request
		});
	}
	getHandlers(controller) {
		return controller.getHandlersByKind("request");
	}
	async getUnhandledMessage() {
		const { request } = this.data;
		const url = new URL(request.url);
		const publicUrl = toPublicUrl(url) + url.search;
		const requestBody = request.body == null ? null : await request.clone().text();
		return `intercepted a request without a matching request handler:${`\n\n  \u2022 ${request.method} ${publicUrl}\n\n${requestBody ? `  \u2022 Request body: ${requestBody}\n\n` : ""}`}If you still wish to intercept this unhandled request, please create a request handler for it.\nRead more: https://mswjs.io/docs/http/intercepting-requests`;
	}
	async resolve(handlers, onUnhandledFrame, resolutionContext) {
		const { id: requestId, request } = this.data;
		const requestCloneForLogs = resolutionContext?.quiet ? null : request.clone();
		this.events.emit(new RequestEvent("request:start", {
			requestId,
			request
		}));
		if (shouldBypassRequest(request)) {
			this.events.emit(new RequestEvent("request:end", {
				requestId,
				request
			}));
			this.passthrough();
			return null;
		}
		const [lookupError, lookupResult] = await until(() => {
			return executeHandlers({
				requestId,
				request,
				handlers,
				resolutionContext: {
					baseUrl: resolutionContext?.baseUrl?.toString(),
					quiet: resolutionContext?.quiet
				}
			});
		});
		if (lookupError != null) {
			if (!this.events.emit(new UnhandledExceptionEvent("unhandledException", {
				error: lookupError,
				requestId,
				request
			}))) {
				console.error(lookupError);
				devUtils.error("Encountered an unhandled exception during the handler lookup for \"%s %s\". Please see the original error above.", request.method, request.url);
			}
			this.errorWith(lookupError);
			return null;
		}
		if (lookupResult == null) {
			this.events.emit(new RequestEvent("request:unhandled", {
				requestId,
				request
			}));
			/**
			* @note The unhandled frame handle must be executed during the request resolution
			* since it can influence it (e.g. error the request if the "error" startegy was used).
			*/
			await executeUnhandledFrameHandle(this, onUnhandledFrame).then(() => this.passthrough(), (error) => this.errorWith(error));
			this.events.emit(new RequestEvent("request:end", {
				requestId,
				request
			}));
			return false;
		}
		const { response, handler, parsedResult } = lookupResult;
		this.events.emit(new RequestEvent("request:match", {
			requestId,
			request
		}));
		if (response == null) {
			this.events.emit(new RequestEvent("request:end", {
				requestId,
				request
			}));
			this.passthrough();
			return null;
		}
		if (isPassthroughResponse(response)) {
			this.events.emit(new RequestEvent("request:end", {
				requestId,
				request
			}));
			this.passthrough();
			return null;
		}
		const responseCloneForLogs = resolutionContext?.quiet ? null : response.clone();
		await storeResponseCookies(request, response);
		this.respondWith(response);
		this.events.emit(new RequestEvent("request:end", {
			requestId,
			request
		}));
		if (!resolutionContext?.quiet) handler.log({
			request: requestCloneForLogs,
			response: responseCloneForLogs,
			parsedResult
		});
		return true;
	}
};
//#endregion
//#region src/core/experimental/frames/websocket-frame.ts
var WebSocketConnectionEvent = class extends TypedEvent {
	url;
	protocols;
	constructor(type, data) {
		super(...[type, {}]);
		this.url = data.url;
		this.protocols = data.protocols;
	}
};
var WebSocketErrorEvent = class extends WebSocketConnectionEvent {
	error;
	constructor(type, data) {
		super(type, data);
		this.error = data.error;
	}
};
var WebSocketNetworkFrame = class extends NetworkFrame {
	constructor(options) {
		super("ws", { connection: options.connection });
	}
	getHandlers(controller) {
		return controller.getHandlersByKind("websocket");
	}
	async resolve(handlers, onUnhandledFrame, resolutionContext) {
		const { connection } = this.data;
		this.events.emit(new WebSocketConnectionEvent("websocket:connection", {
			url: connection.client.url,
			protocols: connection.info.protocols
		}));
		const handleSocketError = (event) => {
			this.events.emit(new WebSocketErrorEvent("websocket:error", {
				url: connection.client.url,
				protocols: connection.info.protocols,
				error: getErrorFromEvent(event)
			}));
		};
		connection.client.socket.addEventListener("error", handleSocketError);
		connection.client.socket.addEventListener("close", () => {
			connection.client.socket.removeEventListener("error", handleSocketError);
		}, { once: true });
		if (handlers.length === 0) {
			await executeUnhandledFrameHandle(this, onUnhandledFrame).then(() => this.passthrough(), (error) => this.errorWith(error));
			return false;
		}
		let hasMatchingHandlers = false;
		for (const handler of handlers) {
			const handlerConnection = await handler.run(connection, {
				baseUrl: resolutionContext?.baseUrl?.toString(),
				/**
				* @note Expose an emit-only reference to this frame's events
				* so the handlers can emit additional events not covered by
				* the frame (e.g. "graphql:subscription").
				*/
				events: this.events,
				/**
				* @note Do not emit the handler's "connection" event when running the handler.
				* Use the run only to get the resolved connection object.
				*/
				[kAutoConnect]: false
			});
			if (!handlerConnection) continue;
			hasMatchingHandlers = true;
			/**
			* @note Attach the WebSocket logger *before* emitting the handler's "connection" event.
			* Connection event listeners may perform actions that should be reflected in the logs
			* (e.g. closing the connection immediately). If the logger is attached after the connection,
			* those actions cannot be properly logged.
			*/
			const removeLogger = !resolutionContext?.quiet ? handler.log(connection) : void 0;
			try {
				if (!handler[kConnect](handlerConnection)) removeLogger?.();
			} catch (error) {
				if (!this.events.emit(new WebSocketErrorEvent("unhandledException", {
					error,
					url: connection.client.url,
					protocols: connection.info.protocols
				}))) {
					console.error(error);
					devUtils.error("Encountered an unhandled exception during the handler lookup for \"%s\". Please see the original error above.", connection.client.url);
				}
				/**
				* @note Throw the caught error so it gets picked up by WebSocketInterceptor.
				* It's the interceptor who translates handler errors to WebSocket closures.
				*/
				throw error;
			}
		}
		if (!hasMatchingHandlers) {
			await executeUnhandledFrameHandle(this, onUnhandledFrame).then(() => this.passthrough(), (error) => this.errorWith(error));
			return false;
		}
		return true;
	}
	async getUnhandledMessage() {
		const { connection } = this.data;
		return `intercepted a WebSocket connection without a matching event handler:${`\n\n  \u2022 ${connection.client.url}\n\n`}If you still wish to intercept this unhandled connection, please create an event handler for it.\nRead more: https://mswjs.io/docs/websocket`;
	}
};
/**
* Extract the error from the given "error" event, if any.
* Supports both the `ErrorEvent.error` property and the `cause`
* property that MSW sets when erroring the connection itself.
*/
function getErrorFromEvent(event) {
	if ("error" in event && event.error != null) return event.error;
	if ("cause" in event && event.cause != null) return event.cause;
}
//#endregion
//#region src/core/experimental/sources/interceptor-source.ts
/**
* Create a network source from the given list of interceptors.
*/
var InterceptorSource = class extends NetworkSource {
	#interceptor;
	/**
	* @note Frames are keyed by the request instance, not the request ID.
	* The interceptor emits the same request instance on the "request"
	* and "response" events, so the frame can be looked up by identity.
	* A weak reference lets the frame be garbage collected alongside
	* its request once the request settles without producing a response
	* (e.g. a passthrough request failing with a network error).
	* @see https://github.com/mswjs/msw/issues/2792
	*/
	#frames;
	constructor(options) {
		super();
		this.#interceptor = new BatchInterceptor({
			name: "interceptor-source",
			interceptors: options.interceptors
		});
		this.#frames = /* @__PURE__ */ new WeakMap();
	}
	enable() {
		this.#interceptor.apply();
		this.#interceptor.on("request", this.#handleRequest.bind(this)).on("response", this.#handleResponse.bind(this)).on("connection", this.#handleWebSocketConnection.bind(this));
	}
	disable() {
		super.disable();
		this.#interceptor.dispose();
		/**
		* @todo We can also abort any pending frames here, given we implement
		* the `NetworkFrame.abort()` method.
		*/
		this.#frames = /* @__PURE__ */ new WeakMap();
	}
	async #handleRequest(event) {
		const { requestId, request, controller } = event;
		const httpFrame = new InterceptorHttpNetworkFrame({
			id: requestId,
			request,
			controller
		});
		this.#frames.set(request, httpFrame);
		await this.queue(httpFrame);
	}
	async #handleResponse({ requestId, request, response, responseType }) {
		const httpFrame = this.#frames.get(request);
		this.#frames.delete(request);
		if (httpFrame == null) return;
		queueMicrotask(() => {
			try {
				httpFrame.events.emit(new ResponseEvent(responseType === "mock" ? "response:mocked" : "response:bypass", {
					requestId,
					request,
					response
				}));
			} finally {
				/**
				* @note Remove any listeners from this frame.
				* Past this point, it won't emit anything. The removal is crucial
				* to prevent "rettime" from keeping the abort cleanup listeners internally.
				* @see https://github.com/mswjs/msw/issues/2735
				*/
				httpFrame.events.removeAllListeners();
			}
		});
	}
	async #handleWebSocketConnection(connection) {
		await this.queue(new InterceptorWebSocketNetworkFrame({ connection }));
	}
};
var InterceptorHttpNetworkFrame = class extends HttpNetworkFrame {
	#controller;
	constructor(options) {
		super({
			id: options.id,
			request: options.request
		});
		this.#controller = options.controller;
	}
	passthrough() {
		deleteRequestPassthroughHeader(this.data.request);
	}
	respondWith(response) {
		if (response) this.#controller.respondWith(response);
	}
	errorWith(reason) {
		if (reason instanceof Response) return this.respondWith(reason);
		if (reason instanceof InternalError) this.#controller.errorWith(reason);
		throw reason;
	}
};
var InterceptorWebSocketNetworkFrame = class extends WebSocketNetworkFrame {
	/**
	* The in-process client connection, whose socket
	* the frame dispatches errors on.
	*/
	#client;
	constructor(args) {
		super({ connection: args.connection });
		this.#client = args.connection.client;
		/**
		* @note Provide a similar frame listener cleanup as for HTTP.
		* When the client connection closes, the handler can no longer be used.
		*/
		args.connection.client.addEventListener("close", () => {
			this.events.removeAllListeners();
		}, { once: true });
	}
	errorWith(reason) {
		if (reason instanceof Error) {
			/**
			* Use `client.errorWith(reason)` in the future.
			* @see https://github.com/mswjs/interceptors/issues/747
			*/
			const errorEvent = new Event("error");
			Object.defineProperty(errorEvent, "cause", {
				enumerable: true,
				configurable: false,
				value: reason
			});
			this.#client.socket.dispatchEvent(errorEvent);
		}
	}
	passthrough() {
		this.data.connection.server.connect();
	}
};
//#endregion
export { NetworkFrame as a, HandlersController as c, ResponseEvent as i, InMemoryHandlersController as l, WebSocketNetworkFrame as n, NetworkReadyState as o, HttpNetworkFrame as r, defineNetwork as s, InterceptorSource as t, NetworkSource as u };

//# sourceMappingURL=interceptor-source.js.map