@depup/mswjs__interceptors 0.43.2-depup.0 → 0.45.1-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/mswjs__interceptors
 
 | Field | Value |
 |-------|-------|
-| Original | [@mswjs/interceptors](https://www.npmjs.com/package/@mswjs/interceptors) @ 0.43.2 |
-| Processed | 2026-09-18 |
+| Original | [@mswjs/interceptors](https://www.npmjs.com/package/@mswjs/interceptors) @ 0.45.1 |
+| Processed | 2026-09-24 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-09-18T16:08:27.396Z",
+  "timestamp": "2026-09-24T16:10:45.805Z",
   "totalUpdated": 0
 }

package/lib/browser/interceptors/WebSocket/index.d.ts

@@ -10,25 +10,25 @@ interface WebSocketConnectionInfo {
    */
   protocols: string | Array<string> | undefined;
 }
-interface WebSocketConnectionEventData {
+interface WebSocketConnectionEventData<Message = WebSocketData> {
   /**
    * The incoming WebSocket client connection.
    */
-  client: WebSocketClientConnection;
+  client: WebSocketClientConnection<Message>;
   /**
    * The original WebSocket server connection.
    */
-  server: WebSocketServerConnection;
+  server: WebSocketServerConnection<Message>;
   info: WebSocketConnectionInfo;
 }
-declare class WebSocketConnectionEvent<DataType extends WebSocketConnectionEventData = WebSocketConnectionEventData> extends TypedEvent<DataType, void, 'connection'> {
-  client: WebSocketClientConnection;
-  server: WebSocketServerConnection;
+declare class WebSocketConnectionEvent<Message = WebSocketData> extends TypedEvent<WebSocketConnectionEventData<Message>, void, 'connection'> {
+  client: WebSocketClientConnection<Message>;
+  server: WebSocketServerConnection<Message>;
   info: WebSocketConnectionInfo;
-  constructor(data: DataType);
+  constructor(data: WebSocketConnectionEventData<Message>);
 }
-type WebSocketEventMap$1 = {
-  connection: WebSocketConnectionEvent;
+type WebSocketEventMap$1<Message = WebSocketData, Extension = {}> = {
+  connection: WebSocketConnectionEvent<Message> & Extension;
 };
 //#endregion
 //#region src/interceptors/WebSocket/utils/events.d.ts
@@ -97,7 +97,7 @@ interface WebSocketTransport {
 }
 //#endregion
 //#region src/interceptors/WebSocket/web-socket-override.d.ts
-type WebSocketEventListener<EventType extends WebSocketEventMap[keyof WebSocketEventMap] = Event> = (this: WebSocket, event: EventType) => void;
+type WebSocketEventListener<EventType extends Event = Event> = (this: WebSocket, event: EventType) => void;
 declare const kPassthroughPromise: unique symbol;
 declare const kOnSend: unique symbol;
 declare const kClose: unique symbol;
@@ -142,52 +142,6 @@ declare class WebSocketOverride extends EventTarget implements WebSocket {
   removeEventListener<K extends keyof WebSocketEventMap>(type: K, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
 }
 //#endregion
-//#region src/interceptors/WebSocket/web-socket-client-connection.d.ts
-declare const kEmitter$1: unique symbol;
-interface WebSocketClientEventMap {
-  message: MessageEvent<WebSocketData>;
-  close: CloseEvent;
-}
-declare abstract class WebSocketClientConnectionProtocol {
-  abstract id: string;
-  abstract url: URL;
-  abstract send(data: WebSocketData): void;
-  abstract close(code?: number, reason?: string): void;
-  abstract addEventListener<EventType extends keyof WebSocketClientEventMap>(type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
-  abstract removeEventListener<EventType extends keyof WebSocketClientEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
-}
-/**
- * The WebSocket client instance represents an incoming
- * client connection. The user can control the connection,
- * send and receive events.
- */
-declare class WebSocketClientConnection implements WebSocketClientConnectionProtocol {
-  readonly socket: WebSocket;
-  private readonly transport;
-  readonly id: string;
-  readonly url: URL;
-  private [kEmitter$1];
-  constructor(socket: WebSocket, transport: WebSocketTransport);
-  /**
-   * Listen for the outgoing events from the connected WebSocket client.
-   */
-  addEventListener<EventType extends keyof WebSocketClientEventMap>(type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
-  /**
-   * Removes the listener for the given event.
-   */
-  removeEventListener<EventType extends keyof WebSocketClientEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
-  /**
-   * Send data to the connected client.
-   */
-  send(data: WebSocketData): void;
-  /**
-   * Close the WebSocket connection.
-   * @param {number} code A status code (see https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1).
-   * @param {string} reason A custom connection close reason.
-   */
-  close(code?: number, reason?: string): void;
-}
-//#endregion
 //#region src/interceptors/WebSocket/web-socket-class-transport.d.ts
 /**
  * Abstraction over the given mock `WebSocket` instance that allows
@@ -203,27 +157,34 @@ declare class WebSocketClassTransport extends EventTarget implements WebSocketTr
 }
 //#endregion
 //#region src/interceptors/WebSocket/web-socket-server-connection.d.ts
-declare const kEmitter: unique symbol;
+declare const kEmitter$1: unique symbol;
 declare const kSend: unique symbol;
-interface WebSocketServerEventMap {
+interface WebSocketServerEventMap<Message = WebSocketData> {
   open: Event;
-  message: MessageEvent<WebSocketData>;
+  message: MessageEvent<Message>;
   error: Event;
   close: CloseEvent;
 }
-declare abstract class WebSocketServerConnectionProtocol {
+/**
+ * The handle to the original WebSocket server connection: its controls.
+ * A `WebSocketServerConnection` is a handle bound to a connection
+ * in this process.
+ */
+declare abstract class WebSocketServerHandle<Message = WebSocketData> {
+  extension?: WebSocketExtension<unknown, unknown>;
   abstract connect(): void;
-  abstract send(data: WebSocketData): void;
+  abstract send(data: Message): void;
   abstract close(): void;
-  abstract addEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
-  abstract removeEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
+  abstract addEventListener<EventType extends keyof WebSocketServerEventMap<Message>>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap<Message>[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  abstract removeEventListener<EventType extends keyof WebSocketServerEventMap<Message>>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap<Message>[EventType]>, options?: EventListenerOptions | boolean): void;
 }
 /**
  * The WebSocket server instance represents the actual production
  * WebSocket server connection. It's idle by default but you can
  * establish it by calling `server.connect()`.
  */
-declare class WebSocketServerConnection implements WebSocketServerConnectionProtocol {
+declare class WebSocketServerConnection<Message = WebSocketData> implements WebSocketServerHandle<Message> {
+  #private;
   private readonly client;
   private readonly transport;
   private readonly createConnection;
@@ -233,13 +194,29 @@ declare class WebSocketServerConnection implements WebSocketServerConnectionProt
   private realWebSocket?;
   private mockCloseController;
   private realCloseController;
-  private [kEmitter];
+  private [kEmitter$1];
+  /**
+   * An optional extension applied to the data crossing this connection:
+   * `send()` encodes, incoming server frames are decoded
+   * before being dispatched as `message` events.
+   */
+  extension?: WebSocketExtension<unknown, unknown>;
+  /**
+   * The intercepted connection this server belongs to.
+   * Provided by the interceptor once both connections exist.
+   */
+  [kExtensionContext]?: WebSocketExtensionContext<unknown>;
   constructor(client: WebSocketOverride, transport: WebSocketClassTransport, createConnection: () => WebSocket);
   /**
    * The `WebSocket` instance connected to the original server.
    * Accessing this before calling `server.connect()` will throw.
    */
   get socket(): WebSocket;
+  /**
+   * The ready state of the connection to the original WebSocket server.
+   * Equals `WebSocket.CLOSED` until `server.connect()` is called.
+   */
+  get readyState(): number;
   /**
    * Open connection to the original WebSocket server.
    */
@@ -247,11 +224,11 @@ declare class WebSocketServerConnection implements WebSocketServerConnectionProt
   /**
    * Listen for the incoming events from the original WebSocket server.
    */
-  addEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  addEventListener<EventType extends keyof WebSocketServerEventMap<Message>>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap<Message>[EventType]>, options?: AddEventListenerOptions | boolean): void;
   /**
    * Remove the listener for the given event.
    */
-  removeEventListener<EventType extends keyof WebSocketServerEventMap>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap[EventType]>, options?: EventListenerOptions | boolean): void;
+  removeEventListener<EventType extends keyof WebSocketServerEventMap<Message>>(event: EventType, listener: WebSocketEventListener<WebSocketServerEventMap<Message>[EventType]>, options?: EventListenerOptions | boolean): void;
   /**
    * Send data to the original WebSocket server.
    * @example
@@ -259,7 +236,12 @@ declare class WebSocketServerConnection implements WebSocketServerConnectionProt
    * server.send(new Blob(['hello']))
    * server.send(new TextEncoder().encode('hello'))
    */
-  send(data: WebSocketData): void;
+  send(data: Message): void;
+  /**
+   * Return the original WebSocket, throwing if
+   * the connection to the original server was not established.
+   */
+  private assertConnected;
   private [kSend];
   /**
    * Close the actual server connection.
@@ -270,16 +252,241 @@ declare class WebSocketServerConnection implements WebSocketServerConnectionProt
   private handleRealClose;
 }
 //#endregion
+//#region src/interceptors/WebSocket/web-socket-extension.d.ts
+declare const kExtensionContext: unique symbol;
+/**
+ * The messages the given extension encodes and decodes.
+ *
+ * @note Inferred from the `encode()` parameter alone. Inferring from the
+ * whole class would also consider the return type of `decode()`, where a
+ * `Generator<Message>` (whose return type defaults to `any`) would widen
+ * the messages to `any`.
+ */
+type WebSocketExtensionMessage<Extension> = Extension extends {
+  encode(message: infer Message, context: never): unknown;
+} ? Message : never;
+/**
+ * The API the given extension adds to the connection event.
+ */
+type WebSocketExtensionApi<Extension> = Extension extends WebSocketExtension<unknown, infer Api> ? Api : never;
+/**
+ * The result of an extension method: a single value, an iterator
+ * over multiple values, or `undefined` for no values at all.
+ *
+ * @note Only iterators (objects with a `next()` method, like generators)
+ * are unfolded. Iterables that are not iterators, like strings, arrays,
+ * or typed arrays, are treated as a single value so array-shaped
+ * messages remain unambiguous.
+ */
+type WebSocketExtensionResult<Value> = Value | Iterator<Value, Value | void> | undefined;
+/**
+ * The intercepted connection an extension operates on.
+ */
+interface WebSocketExtensionContext<Message = WebSocketData> {
+  client: WebSocketClientConnection<Message>;
+  server: WebSocketServerConnection<Message>;
+  info: WebSocketConnectionInfo;
+}
+interface WebSocketExtensionMessageContext<Message = WebSocketData> extends WebSocketExtensionContext<Message> {
+  /**
+   * The connection whose data is being encoded or decoded:
+   * the `client` for data crossing the client connection,
+   * the `server` for data crossing the original server connection.
+   */
+  connection: WebSocketClientConnection<Message> | WebSocketServerConnection<Message>;
+}
+/**
+ * A WebSocket extension: the server-side implementation of a protocol layered on top of
+ * WebSocket (e.g. Socket.IO): its message framing (`encode`/`decode`),
+ * its session as spoken by a server endpoint (`connect`/`receive`),
+ * and the server API it adds to every connection (`extend`).
+ *
+ * The interceptor decides *when* each part applies: `send()` encodes,
+ * frames are decoded before being dispatched as `message` events,
+ * `connect` and `receive` frames are sent while the mocked connection
+ * plays the server, and the extension is exposed on the connection event.
+ *
+ * An extension is invisible to the connection consumer: `client.send()`,
+ * `server.send()`, and the `message` events all operate on messages,
+ * and the session frames never surface. Raw frames forwarded between
+ * the client and the original server (passthrough) are never touched.
+ *
+ * A method returns a single value for a one-to-one mapping,
+ * an iterator (e.g. a generator) to unfold one input into many,
+ * or nothing to drop the input.
+ *
+ * @example
+ * class SocketIo extends WebSocketExtension<SocketIoMessage, { rooms: Rooms }> {
+ *   match({ client }) {
+ *     return client.url.searchParams.has('EIO')
+ *   }
+ *   encode(message) { ... }
+ *   decode(data) { ... }
+ *   connect() { ... }
+ *   receive(data) { ... }
+ *   extend({ client }) {
+ *     return { rooms: new Rooms(client) }
+ *   }
+ * }
+ *
+ * new WebSocketInterceptor({ extensions: [new SocketIo()] })
+ */
+declare abstract class WebSocketExtension<Message = WebSocketData, Extension = {}> {
+  /**
+   * Whether this extension applies to the given connection.
+   * Allows applying the extension to a subset of intercepted connections.
+   */
+  match?(context: WebSocketExtensionContext<Message>): boolean;
+  /**
+   * Encode the given message into the raw frame(s) to send to the peer.
+   */
+  abstract encode(message: Message, context: WebSocketExtensionMessageContext<Message>): WebSocketExtensionResult<WebSocketData>;
+  /**
+   * Decode the given raw frame into the message(s) to dispatch
+   * as `message` events. Return nothing to swallow the frame
+   * (e.g. protocol control frames).
+   */
+  abstract decode(data: WebSocketData, context: WebSocketExtensionMessageContext<Message>): WebSocketExtensionResult<Message>;
+  /**
+   * The raw frame(s) a server of this extension's protocol sends once the
+   * connection is established (e.g. a session handshake).
+   * Sent to the client by the interceptor when the mocked connection
+   * opens, unless a connection to the original server was established,
+   * in which case the original server speaks for itself.
+   */
+  connect?(context: WebSocketExtensionContext<Message>): WebSocketExtensionResult<WebSocketData>;
+  /**
+   * The raw frame(s) a server of this extension's protocol sends back in response
+   * to the given client frame (e.g. a control frame acknowledgement),
+   * the way a WebSocket endpoint answers a ping with a pong.
+   * Applied by the interceptor under the same condition as `connect`.
+   */
+  receive?(data: WebSocketData, context: WebSocketExtensionContext<Message>): WebSocketExtensionResult<WebSocketData>;
+  /**
+   * The server API this extension adds to the given connection
+   * (e.g. rooms). Exposed on the connection event alongside
+   * the `client` and the `server`.
+   */
+  extend?(context: WebSocketExtensionContext<Message>): Extension;
+  /**
+   * Apply this extension to the given connection.
+   * From then on, both the client and the server of that connection
+   * encode the data they send and decode the data they receive.
+   *
+   * @note Typed against the connection classes, not the handles:
+   * a connection is assignable across `Message` types only when
+   * compared as the same class, which is what lets an extension narrow
+   * the raw `WebSocketData` connections it is applied to.
+   */
+  apply(connection: {
+    client: WebSocketClientConnection<Message>;
+    server: WebSocketServerConnection<Message>;
+  }): void;
+}
+//#endregion
+//#region src/interceptors/WebSocket/web-socket-client-connection.d.ts
+declare const kEmitter: unique symbol;
+interface WebSocketClientEventMap<Message = WebSocketData> {
+  open: Event;
+  message: MessageEvent<Message>;
+  close: CloseEvent;
+}
+/**
+ * The handle to a WebSocket client connection: its identity and controls.
+ * A handle is what a connection is regardless of where it lives.
+ * A `WebSocketClientConnection` is a handle bound to a connection in this
+ * process; a handle can also be revived from a serialized connection
+ * in another process (e.g. a connection stored by a worker).
+ *
+ * `Message` is what crosses this connection: raw WebSocket data, or the
+ * messages of the extension applied to it.
+ */
+declare abstract class WebSocketClientHandle<Message = WebSocketData> {
+  abstract id: string;
+  abstract url: URL;
+  extension?: WebSocketExtension<unknown, unknown>;
+  abstract send(data: Message): void;
+  abstract close(code?: number, reason?: string): void;
+  abstract addEventListener<EventType extends keyof WebSocketClientEventMap<Message>>(type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap<Message>[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  abstract removeEventListener<EventType extends keyof WebSocketClientEventMap<Message>>(event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap<Message>[EventType]>, options?: EventListenerOptions | boolean): void;
+}
+/**
+ * The WebSocket client instance represents an incoming
+ * client connection. The user can control the connection,
+ * send and receive events.
+ */
+declare class WebSocketClientConnection<Message = WebSocketData> implements WebSocketClientHandle<Message> {
+  #private;
+  readonly socket: WebSocket;
+  private readonly transport;
+  readonly id: string;
+  readonly url: URL;
+  /**
+   * An optional extension applied to the data crossing this connection:
+   * `send()` encodes, outgoing client frames are decoded
+   * before being dispatched as `message` events.
+   */
+  extension?: WebSocketExtension<unknown, unknown>;
+  /**
+   * The intercepted connection this client belongs to.
+   * Provided by the interceptor once both connections exist.
+   */
+  [kExtensionContext]?: WebSocketExtensionContext<unknown>;
+  private [kEmitter];
+  constructor(socket: WebSocket, transport: WebSocketTransport);
+  /**
+   * Listen for the outgoing events from the connected WebSocket client.
+   */
+  addEventListener<EventType extends keyof WebSocketClientEventMap<Message>>(type: EventType, listener: WebSocketEventListener<WebSocketClientEventMap<Message>[EventType]>, options?: AddEventListenerOptions | boolean): void;
+  /**
+   * Removes the listener for the given event.
+   */
+  removeEventListener<EventType extends keyof WebSocketClientEventMap<Message>>(event: EventType, listener: WebSocketEventListener<WebSocketClientEventMap<Message>[EventType]>, options?: EventListenerOptions | boolean): void;
+  /**
+   * Send data to the connected client.
+   */
+  send(data: Message): void;
+  /**
+   * Close the WebSocket connection.
+   * @param {number} code A status code (see https://www.rfc-editor.org/rfc/rfc6455#section-7.4.1).
+   * @param {string} reason A custom connection close reason.
+   */
+  close(code?: number, reason?: string): void;
+}
+//#endregion
 //#region src/interceptors/WebSocket/index.d.ts
+type WebSocketExtensions = ReadonlyArray<WebSocketExtension<unknown, unknown>>;
+/**
+ * The messages crossing the connections intercepted with the given
+ * extensions: the messages of the extension applied to a connection,
+ * or raw WebSocket data when there are no extensions.
+ *
+ * @note The types assume one of the extensions matches the connection.
+ */
+type WebSocketInterceptorMessage<Extensions extends WebSocketExtensions> = [Extensions] extends [readonly []] ? WebSocketData : WebSocketExtensionMessage<Extensions[number]>;
+/**
+ * The API the extension applied to a connection adds to the connection event.
+ */
+type WebSocketInterceptorApi<Extensions extends WebSocketExtensions> = [Extensions] extends [readonly []] ? {} : WebSocketExtensionApi<Extensions[number]>;
+interface WebSocketInterceptorOptions<Extensions extends WebSocketExtensions = []> {
+  /**
+   * Extensions to apply to the intercepted connections.
+   * The first extension whose `match()` accepts a connection is applied
+   * to it. An extension without `match()` accepts every connection.
+   */
+  extensions?: Extensions;
+}
 /**
  * Intercept the outgoing WebSocket connections created using
  * the global `WebSocket` class.
  */
-declare class WebSocketInterceptor extends Interceptor<WebSocketEventMap$1> {
+declare class WebSocketInterceptor<const Extensions extends WebSocketExtensions = []> extends Interceptor<WebSocketEventMap$1<WebSocketInterceptorMessage<Extensions>, WebSocketInterceptorApi<Extensions>>> {
   static symbol: symbol;
+  private readonly extensions;
+  constructor(options?: WebSocketInterceptorOptions<Extensions>);
   protected predicate(): boolean;
   protected setup(): void;
 }
 //#endregion
-export { CancelableCloseEvent, CancelableMessageEvent, CloseEvent, WebSocketClientConnection, WebSocketClientConnectionProtocol, type WebSocketClientEventMap, WebSocketConnectionEvent, type WebSocketConnectionEventData, type WebSocketConnectionInfo, type WebSocketData, type WebSocketEventMap$1 as WebSocketEventMap, WebSocketInterceptor, WebSocketServerConnection, WebSocketServerConnectionProtocol, type WebSocketServerEventMap, type WebSocketTransport };
+export { CancelableCloseEvent, CancelableMessageEvent, CloseEvent, WebSocketClientConnection, type WebSocketClientEventMap, WebSocketClientHandle, WebSocketConnectionEvent, type WebSocketConnectionEventData, type WebSocketConnectionInfo, type WebSocketData, type WebSocketEventMap$1 as WebSocketEventMap, WebSocketExtension, type WebSocketExtensionApi, type WebSocketExtensionContext, type WebSocketExtensionMessage, type WebSocketExtensionMessageContext, type WebSocketExtensionResult, WebSocketInterceptor, WebSocketInterceptorApi, WebSocketInterceptorMessage, WebSocketInterceptorOptions, WebSocketServerConnection, type WebSocketServerEventMap, WebSocketServerHandle, type WebSocketTransport };
 //# sourceMappingURL=index.d.ts.map