@rspack/dev-server 2.0.0 → 2.0.1

package/client/utils/ansiHTML.js

@@ -133,7 +133,7 @@ function ansiHTML(text) {
         }
     });
     const l = ansiCodes.length;
-    l > 0 && (ret += Array(l + 1).join('</span>'));
+    if (l > 0) ret += Array(l + 1).join('</span>');
     return ret;
 }
 ansiHTML.setColors = (colors)=>{

package/dist/0~http-proxy-middleware.js

@@ -2842,7 +2842,7 @@ function setupOutgoing(outgoing, options, req, forward) {
     if (options.ca) outgoing.ca = options.ca;
     if (isSSL.test(options[forward || "target"].protocol ?? "http")) outgoing.rejectUnauthorized = void 0 === options.secure ? true : options.secure;
     if (void 0 !== options.agent) outgoing.agent = options.agent || false;
-    else if (req.httpVersionMajor > 1) outgoing.agent = false;
+    else if (req.httpVersionMajor > 1 || upgradeHeader.test(req.headers.connection || "")) outgoing.agent = false;
     else {
         const targetProto = options[forward || "target"].protocol ?? "http";
         outgoing.agent = isSSL.test(targetProto) ? defaultAgents.https : defaultAgents.http;
@@ -3040,7 +3040,7 @@ const webIncomingMiddleware = [
             "proto"
         ]){
             const key = "x-forwarded-" + header;
-            if (!req.headers[key]) req.headers[key] = values[header];
+            if (!req.headers[key] && void 0 !== values[header]) req.headers[key] = values[header];
         }
         req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers.host || "";
     }),
@@ -3197,7 +3197,7 @@ const websocketIncomingMiddleware = [
             "proto"
         ]){
             const key = "x-forwarded-" + header;
-            if (!req.headers[key]) req.headers[key] = values[header];
+            if (!req.headers[key] && void 0 !== values[header]) req.headers[key] = values[header];
         }
     }),
     defineProxyMiddleware((req, socket, options, server, head, callback)=>{
@@ -3274,7 +3274,7 @@ var ProxyServer = class extends EventEmitter {
         this.web = _createProxyFn("web", this);
         this.ws = _createProxyFn("ws", this);
     }
-    listen(port, hostname) {
+    listen(port, hostname, listeningListener) {
         const closure = (req, res)=>this.web(req, res);
         if (this.options.http2) {
             if (!this.options.ssl) throw new Error("HTTP/2 requires ssl option");
@@ -3287,7 +3287,7 @@ var ProxyServer = class extends EventEmitter {
         if (this.options.ws) this._server.on("upgrade", (req, socket, head)=>{
             this.ws(req, socket, this.options, head).catch(()=>{});
         });
-        this._server.listen(port, hostname);
+        this._server.listen(port, hostname, listeningListener);
         return this;
     }
     close(callback) {
@@ -3640,8 +3640,8 @@ async function getTarget(req, config) {
 }
 function getTargetFromProxyTable(req, table) {
     let result;
-    const host = req.headers.host;
-    const path = req.url;
+    const host = req.headers.host ?? '';
+    const path = req.url ?? '';
     const hostAndPath = host + path;
     for (const [key, value] of Object.entries(table))if (containsPath(key)) {
         if (hostAndPath.indexOf(key) > -1) {
@@ -3659,6 +3659,35 @@ function getTargetFromProxyTable(req, table) {
 function containsPath(v) {
     return v.indexOf('/') > -1;
 }
+const ipv6_debug = Debug.extend('ipv6');
+function normalizeIPv6LiteralTargets(options) {
+    options.target = normalizeIPv6ProxyTarget(options.target, 'target');
+    options.forward = normalizeIPv6ProxyTarget(options.forward, 'forward');
+}
+function normalizeIPv6ProxyTarget(target, optionName) {
+    const targetUrl = toTargetUrl(target);
+    if (targetUrl && isBracketedIPv6Hostname(targetUrl.hostname)) {
+        ipv6_debug('normalized IPv6 "%s" %s', optionName, target);
+        return {
+            hostname: stripBrackets(targetUrl.hostname),
+            pathname: targetUrl.pathname,
+            port: targetUrl.port,
+            protocol: targetUrl.protocol,
+            search: targetUrl.search
+        };
+    }
+    return target;
+}
+function toTargetUrl(target) {
+    if ('string' == typeof target) return new URL(target);
+    if (target instanceof URL) return target;
+}
+function isBracketedIPv6Hostname(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']');
+}
+function stripBrackets(hostname) {
+    return hostname.replace(/^\[|\]$/g, '');
+}
 class HttpProxyMiddleware {
     wsInternalSubscribed = false;
     serverOnCloseSubscribed = false;
@@ -3746,6 +3775,7 @@ class HttpProxyMiddleware {
     prepareProxyRequest = async (req)=>{
         const newProxyOptions = Object.assign({}, this.proxyOptions);
         await this.applyRouter(req, newProxyOptions);
+        normalizeIPv6LiteralTargets(newProxyOptions);
         await this.applyPathRewrite(req, this.pathRewriter);
         return newProxyOptions;
     };

package/dist/0~launch-editor.js

@@ -442,7 +442,7 @@ __webpack_require__.add({
         module.exports.createColors = createColors;
     },
     "./node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/index.js" (__unused_rspack_module, exports, __webpack_require__) {
-        exports.quote = __webpack_require__("./node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js");
+        __webpack_require__("./node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/quote.js");
         exports.parse = __webpack_require__("./node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js");
     },
     "./node_modules/.pnpm/shell-quote@1.8.3/node_modules/shell-quote/parse.js" (module) {

package/dist/index.d.ts

@@ -1,8 +1,14 @@
+/// <reference types="node" />
+
+import { Agent } from 'http';
 import { API } from '@rspack/dev-middleware';
 import { Callback } from '@rspack/dev-middleware';
+import { ClientRequest } from 'http';
+import { ClientRequestArgs } from 'http';
 import { Compiler } from '@rspack/core';
 import { DevServer as Configuration } from '@rspack/core';
 import { Context } from '@rspack/dev-middleware';
+import { createConnection } from 'net';
 import type { DevServerClient } from '@rspack/core';
 import type { DevServerHeaders } from '@rspack/core';
 import type { DevServerHost } from '@rspack/core';
@@ -11,26 +17,33 @@ import type { DevServerOpenOptions } from '@rspack/core';
 import type { DevServerProxyConfigArray } from '@rspack/core';
 import type { DevServerStatic } from '@rspack/core';
 import type { Dirent } from 'node:fs';
+import { Duplex } from 'stream';
 import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter_2 } from 'events';
 import * as http from 'node:http';
 import type { IncomingMessage as IncomingMessage_2 } from 'node:http';
+import { IncomingMessage as IncomingMessage_3 } from 'http';
 import type { ListenOptions } from 'node:net';
 import { MultiCompiler } from '@rspack/core';
 import { MultiStats } from '@rspack/core';
 import { Options } from '@rspack/dev-middleware';
+import { OutgoingHttpHeaders } from 'http';
 import { Readable } from 'node:stream';
+import { SecureContextOptions } from 'tls';
 import { Server as Server_2 } from 'node:net';
 import { Server as Server_3 } from 'node:tls';
 import type { Server as Server_4 } from 'node:http';
+import { Server as Server_6 } from 'http';
+import { Server as Server_7 } from 'https';
 import type { ServerOptions } from 'node:https';
 import type { ServerResponse } from 'node:http';
 import { Socket } from 'node:net';
 import { Stats } from 'node:fs';
 import { Stats as Stats_2 } from '@rspack/core';
 import { StatsOptions } from '@rspack/core';
+import { URL as URL_2 } from 'url';
 import type { WatchEventType } from 'node:fs';
-import { WebSocket as WebSocket_2 } from 'ws';
-import { WebSocketServer as WebSocketServer_2 } from 'ws';
+import { ZlibOptions } from 'zlib';
 
 declare type AWF = {
     stabilityThreshold: number;
@@ -57,6 +70,25 @@ declare type BasicOpts = {
 
 declare type BasicServer = Server_2 | Server_3;
 
+declare type BufferLike =
+| string
+| Buffer
+| DataView
+| number
+| ArrayBufferView
+| Uint8Array
+| ArrayBuffer
+| SharedArrayBuffer
+| Blob
+| readonly any[]
+| readonly number[]
+| { valueOf(): ArrayBuffer }
+| { valueOf(): SharedArrayBuffer }
+| { valueOf(): Uint8Array }
+| { valueOf(): readonly number[] }
+| { valueOf(): string }
+| { [Symbol.toPrimitive](hint: string): string };
+
 declare type ChokidarOptions = Partial<BasicOpts & {
     ignored: Matcher | Matcher[];
     awaitWriteFinish: boolean | Partial<AWF>;
@@ -510,6 +542,75 @@ declare interface Server extends EventEmitter {
     listen(handle: unknown, listeningListener?: Function): http.Server;
 }
 
+declare class Server_5<
+T extends typeof WebSocket_2 = typeof WebSocket_2,
+U extends typeof IncomingMessage_3 = typeof IncomingMessage_3,
+> extends EventEmitter_2 {
+    options: WebSocket_2.ServerOptions<T, U>;
+    path: string;
+    clients: Set<InstanceType<T>>;
+
+    constructor(options?: WebSocket_2.ServerOptions<T, U>, callback?: () => void);
+
+    address(): WebSocket_2.AddressInfo | string | null;
+    close(cb?: (err?: Error) => void): void;
+    handleUpgrade(
+    request: InstanceType<U>,
+    socket: Duplex,
+    upgradeHead: Buffer,
+    callback: (client: InstanceType<T>, request: InstanceType<U>) => void,
+    ): void;
+    shouldHandle(request: InstanceType<U>): boolean | Promise<boolean>;
+
+    // Events
+    on(event: "connection", cb: (this: Server_5<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    on(event: "error", cb: (this: Server_5<T>, error: Error) => void): this;
+    on(event: "headers", cb: (this: Server_5<T>, headers: string[], request: InstanceType<U>) => void): this;
+    on(event: "close" | "listening", cb: (this: Server_5<T>) => void): this;
+    on(
+    event: "wsClientError",
+    cb: (this: Server_5<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
+    ): this;
+    on(event: string | symbol, listener: (this: Server_5<T>, ...args: any[]) => void): this;
+
+    once(
+    event: "connection",
+    cb: (this: Server_5<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void,
+    ): this;
+    once(event: "error", cb: (this: Server_5<T>, error: Error) => void): this;
+    once(event: "headers", cb: (this: Server_5<T>, headers: string[], request: InstanceType<U>) => void): this;
+    once(event: "close" | "listening", cb: (this: Server_5<T>) => void): this;
+    once(
+    event: "wsClientError",
+    cb: (this: Server_5<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
+    ): this;
+    once(event: string | symbol, listener: (this: Server_5<T>, ...args: any[]) => void): this;
+
+    off(event: "connection", cb: (this: Server_5<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    off(event: "error", cb: (this: Server_5<T>, error: Error) => void): this;
+    off(event: "headers", cb: (this: Server_5<T>, headers: string[], request: InstanceType<U>) => void): this;
+    off(event: "close" | "listening", cb: (this: Server_5<T>) => void): this;
+    off(
+    event: "wsClientError",
+    cb: (this: Server_5<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
+    ): this;
+    off(event: string | symbol, listener: (this: Server_5<T>, ...args: any[]) => void): this;
+
+    addListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    addListener(event: "error", cb: (error: Error) => void): this;
+    addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    addListener(event: "close" | "listening", cb: () => void): this;
+    addListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
+    removeListener(event: "error", cb: (error: Error) => void): this;
+    removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
+    removeListener(event: "close" | "listening", cb: () => void): this;
+    removeListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
 declare interface ServerConfiguration<A extends BasicApplication = Server, S extends BasicServer = Server_4> {
     type?: ServerType<A, S>;
     options?: ServerOptions;
@@ -572,8 +673,328 @@ declare class WatchHelper {
     filterDir(entry: EntryInfo): boolean;
 }
 
+declare class WebSocket_2 extends EventEmitter_2 {
+    /** The connection is not yet open. */
+    static readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    static readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    static readonly CLOSING: 2;
+    /** The connection is closed. */
+    static readonly CLOSED: 3;
+
+    binaryType: "nodebuffer" | "arraybuffer" | "fragments";
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    /** Indicates whether the websocket is paused */
+    readonly isPaused: boolean;
+    readonly protocol: string;
+    /** The current state of the connection */
+    readonly readyState:
+    | typeof WebSocket_2.CONNECTING
+    | typeof WebSocket_2.OPEN
+    | typeof WebSocket_2.CLOSING
+    | typeof WebSocket_2.CLOSED;
+    readonly url: string;
+
+    /** The connection is not yet open. */
+    readonly CONNECTING: 0;
+    /** The connection is open and ready to communicate. */
+    readonly OPEN: 1;
+    /** The connection is in the process of closing. */
+    readonly CLOSING: 2;
+    /** The connection is closed. */
+    readonly CLOSED: 3;
+
+    onopen: ((event: WebSocket_2.Event) => void) | null;
+    onerror: ((event: WebSocket_2.ErrorEvent) => void) | null;
+    onclose: ((event: WebSocket_2.CloseEvent) => void) | null;
+    onmessage: ((event: WebSocket_2.MessageEvent) => void) | null;
+
+    constructor(address: null);
+    constructor(address: string | URL_2, options?: WebSocket_2.ClientOptions | ClientRequestArgs);
+    constructor(
+    address: string | URL_2,
+    protocols?: string | string[],
+    options?: WebSocket_2.ClientOptions | ClientRequestArgs,
+    );
+
+    close(code?: number, data?: string | Buffer): void;
+    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+    // https://github.com/websockets/ws/issues/2076#issuecomment-1250354722
+    send(data: BufferLike, cb?: (err?: Error) => void): void;
+    send(
+    data: BufferLike,
+    options: {
+        mask?: boolean | undefined;
+        binary?: boolean | undefined;
+        compress?: boolean | undefined;
+        fin?: boolean | undefined;
+    },
+    cb?: (err?: Error) => void,
+    ): void;
+    terminate(): void;
+
+    /**
+     * Pause the websocket causing it to stop emitting events. Some events can still be
+     * emitted after this is called, until all buffered data is consumed. This method
+     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+     */
+    pause(): void;
+    /**
+     * Make a paused socket resume emitting events. This method is a noop if the ready
+     * state is `CONNECTING` or `CLOSED`.
+     */
+    resume(): void;
+
+    // HTML5 WebSocket events
+    addEventListener<K extends keyof WebSocket_2.WebSocketEventMap>(
+    type: K,
+    listener:
+    | ((event: WebSocket_2.WebSocketEventMap[K]) => void)
+    | { handleEvent(event: WebSocket_2.WebSocketEventMap[K]): void },
+    options?: WebSocket_2.EventListenerOptions,
+    ): void;
+    removeEventListener<K extends keyof WebSocket_2.WebSocketEventMap>(
+    type: K,
+    listener:
+    | ((event: WebSocket_2.WebSocketEventMap[K]) => void)
+    | { handleEvent(event: WebSocket_2.WebSocketEventMap[K]): void },
+    ): void;
+
+    // Events
+    on(event: "close", listener: (this: WebSocket_2, code: number, reason: Buffer) => void): this;
+    on(event: "error", listener: (this: WebSocket_2, error: Error) => void): this;
+    on(event: "upgrade", listener: (this: WebSocket_2, request: IncomingMessage_3) => void): this;
+    on(event: "message", listener: (this: WebSocket_2, data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    on(event: "open", listener: (this: WebSocket_2) => void): this;
+    on(event: "ping" | "pong", listener: (this: WebSocket_2, data: Buffer) => void): this;
+    on(event: "redirect", listener: (this: WebSocket_2, url: string, request: ClientRequest) => void): this;
+    on(
+    event: "unexpected-response",
+    listener: (this: WebSocket_2, request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    on(event: string | symbol, listener: (this: WebSocket_2, ...args: any[]) => void): this;
+
+    once(event: "close", listener: (this: WebSocket_2, code: number, reason: Buffer) => void): this;
+    once(event: "error", listener: (this: WebSocket_2, error: Error) => void): this;
+    once(event: "upgrade", listener: (this: WebSocket_2, request: IncomingMessage_3) => void): this;
+    once(event: "message", listener: (this: WebSocket_2, data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    once(event: "open", listener: (this: WebSocket_2) => void): this;
+    once(event: "ping" | "pong", listener: (this: WebSocket_2, data: Buffer) => void): this;
+    once(event: "redirect", listener: (this: WebSocket_2, url: string, request: ClientRequest) => void): this;
+    once(
+    event: "unexpected-response",
+    listener: (this: WebSocket_2, request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    once(event: string | symbol, listener: (this: WebSocket_2, ...args: any[]) => void): this;
+
+    off(event: "close", listener: (this: WebSocket_2, code: number, reason: Buffer) => void): this;
+    off(event: "error", listener: (this: WebSocket_2, error: Error) => void): this;
+    off(event: "upgrade", listener: (this: WebSocket_2, request: IncomingMessage_3) => void): this;
+    off(event: "message", listener: (this: WebSocket_2, data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    off(event: "open", listener: (this: WebSocket_2) => void): this;
+    off(event: "ping" | "pong", listener: (this: WebSocket_2, data: Buffer) => void): this;
+    off(event: "redirect", listener: (this: WebSocket_2, url: string, request: ClientRequest) => void): this;
+    off(
+    event: "unexpected-response",
+    listener: (this: WebSocket_2, request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    off(event: string | symbol, listener: (this: WebSocket_2, ...args: any[]) => void): this;
+
+    addListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    addListener(event: "error", listener: (error: Error) => void): this;
+    addListener(event: "upgrade", listener: (request: IncomingMessage_3) => void): this;
+    addListener(event: "message", listener: (data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    addListener(event: "open", listener: () => void): this;
+    addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    addListener(event: "redirect", listener: (url: string, request: ClientRequest) => void): this;
+    addListener(
+    event: "unexpected-response",
+    listener: (request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+
+    removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
+    removeListener(event: "error", listener: (error: Error) => void): this;
+    removeListener(event: "upgrade", listener: (request: IncomingMessage_3) => void): this;
+    removeListener(event: "message", listener: (data: WebSocket_2.RawData, isBinary: boolean) => void): this;
+    removeListener(event: "open", listener: () => void): this;
+    removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
+    removeListener(event: "redirect", listener: (url: string, request: ClientRequest) => void): this;
+    removeListener(
+    event: "unexpected-response",
+    listener: (request: ClientRequest, response: IncomingMessage_3) => void,
+    ): this;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+
+declare namespace WebSocket_2 {
+    /**
+     * Data represents the raw message payload received over the WebSocket.
+     */
+    type RawData = Buffer | ArrayBuffer | Buffer[];
+
+    /**
+     * Data represents the message payload received over the WebSocket.
+     */
+    type Data = string | Buffer | ArrayBuffer | Buffer[];
+
+    /**
+     * CertMeta represents the accepted types for certificate & key data.
+     */
+    type CertMeta = string | string[] | Buffer | Buffer[];
+
+    /**
+     * VerifyClientCallbackSync is a synchronous callback used to inspect the
+     * incoming message. The return value (boolean) of the function determines
+     * whether or not to accept the handshake.
+     */
+    type VerifyClientCallbackSync<Request extends IncomingMessage_3 = IncomingMessage_3> = (info: {
+        origin: string;
+        secure: boolean;
+        req: Request;
+    }) => boolean;
+
+    /**
+     * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+     * incoming message. The return value (boolean) of the function determines
+     * whether or not to accept the handshake.
+     */
+    type VerifyClientCallbackAsync<Request extends IncomingMessage_3 = IncomingMessage_3> = (
+    info: { origin: string; secure: boolean; req: Request },
+    callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void,
+    ) => void;
+
+    /**
+     * FinishRequestCallback is a callback for last minute customization of the
+     * headers. If finishRequest is set, then it has the responsibility to call
+     * request.end() once it is done setting request headers.
+     */
+    type FinishRequestCallback = (request: ClientRequest, websocket: WebSocket_2) => void;
+
+    interface ClientOptions extends SecureContextOptions {
+        protocol?: string | undefined;
+        followRedirects?: boolean | undefined;
+        generateMask?(mask: Buffer): void;
+        handshakeTimeout?: number | undefined;
+        maxRedirects?: number | undefined;
+        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+        localAddress?: string | undefined;
+        protocolVersion?: number | undefined;
+        headers?: { [key: string]: string } | undefined;
+        origin?: string | undefined;
+        agent?: Agent | undefined;
+        host?: string | undefined;
+        family?: number | undefined;
+        checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+        rejectUnauthorized?: boolean | undefined;
+        allowSynchronousEvents?: boolean | undefined;
+        autoPong?: boolean | undefined;
+        maxPayload?: number | undefined;
+        skipUTF8Validation?: boolean | undefined;
+        createConnection?: typeof createConnection | undefined;
+        finishRequest?: FinishRequestCallback | undefined;
+    }
+
+    interface PerMessageDeflateOptions {
+        serverNoContextTakeover?: boolean | undefined;
+        clientNoContextTakeover?: boolean | undefined;
+        serverMaxWindowBits?: number | undefined;
+        clientMaxWindowBits?: number | undefined;
+        zlibDeflateOptions?:
+        | {
+            flush?: number | undefined;
+            finishFlush?: number | undefined;
+            chunkSize?: number | undefined;
+            windowBits?: number | undefined;
+            level?: number | undefined;
+            memLevel?: number | undefined;
+            strategy?: number | undefined;
+            dictionary?: Buffer | Buffer[] | DataView | undefined;
+            info?: boolean | undefined;
+        }
+        | undefined;
+        zlibInflateOptions?: ZlibOptions | undefined;
+        threshold?: number | undefined;
+        concurrencyLimit?: number | undefined;
+    }
+
+    interface Event {
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface ErrorEvent {
+        error: any;
+        message: string;
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface CloseEvent {
+        wasClean: boolean;
+        code: number;
+        reason: string;
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface MessageEvent {
+        data: Data;
+        type: string;
+        target: WebSocket_2;
+    }
+
+    interface WebSocketEventMap {
+        open: Event;
+        error: ErrorEvent;
+        close: CloseEvent;
+        message: MessageEvent;
+    }
+
+    interface EventListenerOptions {
+        once?: boolean | undefined;
+    }
+
+    interface ServerOptions<
+    U extends typeof WebSocket_2 = typeof WebSocket_2,
+    V extends typeof IncomingMessage_3 = typeof IncomingMessage_3,
+    > {
+        host?: string | undefined;
+        port?: number | undefined;
+        backlog?: number | undefined;
+        server?: Server_6<V> | Server_7<V> | undefined;
+        verifyClient?:
+        | VerifyClientCallbackAsync<InstanceType<V>>
+        | VerifyClientCallbackSync<InstanceType<V>>
+        | undefined;
+        handleProtocols?: (protocols: Set<string>, request: InstanceType<V>) => string | false;
+        path?: string | undefined;
+        noServer?: boolean | undefined;
+        allowSynchronousEvents?: boolean | undefined;
+        autoPong?: boolean | undefined;
+        clientTracking?: boolean | undefined;
+        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+        maxPayload?: number | undefined;
+        skipUTF8Validation?: boolean | undefined;
+        WebSocket?: U | undefined;
+    }
+
+    interface AddressInfo {
+        address: string;
+        family: string;
+        port: number;
+    }
+}
+
 declare type WebSocketServer = WebSocketServer_2;
 
+declare const WebSocketServer_2: typeof Server_5;
+
+declare interface WebSocketServer_2 extends Server_5 {}
+
 declare interface WebSocketServerConfiguration {
     type?: LiteralUnion<'ws', string> | (() => WebSocketServerConfiguration);
     options?: Record<string, EXPECTED_ANY>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/dev-server",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Development server for Rspack",
   "homepage": "https://github.com/rstackjs/rspack-dev-server",
   "bugs": "https://github.com/rstackjs/rspack-dev-server/issues",
@@ -49,13 +49,13 @@
     "@rspack/dev-middleware": "^2.0.1"
   },
   "devDependencies": {
-    "@hono/node-server": "^1.19.14",
-    "@microsoft/api-extractor": "^7.58.2",
-    "@rslib/core": "^0.21.1",
-    "@rslint/core": "^0.4.2",
+    "@hono/node-server": "^2.0.0",
+    "@microsoft/api-extractor": "^7.58.7",
+    "@rslib/core": "^0.21.3",
+    "@rslint/core": "^0.5.0",
     "@rspack/core": "2.0.0-rc.0",
-    "@rspack/plugin-react-refresh": "1.6.2",
-    "@rstest/core": "^0.9.7",
+    "@rspack/plugin-react-refresh": "2.0.0",
+    "@rstest/core": "^0.9.9",
     "@types/connect-history-api-fallback": "^1.5.4",
     "@types/mime-types": "3.0.1",
     "@types/node": "^24.12.2",
@@ -67,23 +67,23 @@
     "connect-next": "^4.0.1",
     "cross-env": "^10.1.0",
     "express": "^5.2.1",
-    "hono": "^4.12.14",
+    "hono": "^4.12.15",
     "http-compression": "^1.1.3",
     "http-proxy": "^1.18.1",
-    "http-proxy-middleware": "4.0.0-beta.3",
+    "http-proxy-middleware": "4.0.0-beta.4",
     "ipaddr.js": "^2.3.0",
     "launch-editor": "^2.13.2",
     "nano-staged": "^0.9.0",
     "open": "^11.0.0",
     "p-retry": "^7.1.1",
     "prettier": "3.8.3",
-    "puppeteer": "^24.40.0",
+    "puppeteer": "^24.42.0",
     "react-refresh": "0.18.0",
     "require-from-string": "^2.0.2",
     "selfsigned": "^5.5.0",
     "serve-static": "^2.2.1",
     "simple-git-hooks": "^2.13.1",
-    "typescript": "^6.0.2",
+    "typescript": "^6.0.3",
     "ws": "^8.20.0"
   },
   "peerDependencies": {
@@ -95,7 +95,7 @@
       "optional": true
     }
   },
-  "packageManager": "pnpm@10.33.0",
+  "packageManager": "pnpm@10.33.2",
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },