@rspack/dev-server 2.0.0-rc.3 → 2.0.1

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

@@ -1,31 +1,3 @@
-/*!
- * Array of passes.
- *
- * A `pass` is just a function that is executed on `req, res, options`
- * so that you can easily add new checks while still keeping the base
- * flexible.
- */
-
-/*!
- * Array of passes.
- *
- * A `pass` is just a function that is executed on `req, socket, options`
- * so that you can easily add new checks while still keeping the base
- * flexible.
- */
-
-/*!
- * Caron dimonio, con occhi di bragia
- * loro accennando, tutte le raccoglie;
- * batte col remo qualunque s’adagia 
- *
- * Charon the demon, with the eyes of glede,
- * Beckoning to them, collects them all together,
- * Beats with his oar whoever lags behind
- *          
- *          Dante - The Divine Comedy (Canto III)
- */
-
 /*!
  * fill-range <https://github.com/jonschlinkert/fill-range>
  *
@@ -54,13 +26,6 @@
  * Released under the MIT License.
  */
 
-/*!
- * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
- *
- * Copyright (c) 2014-2017, Jon Schlinkert.
- * Released under the MIT License.
- */
-
 /*!
  * to-regex-range <https://github.com/micromatch/to-regex-range>
  *

package/dist/0~launch-editor.js

@@ -1,5 +1,5 @@
-import { __webpack_require__ } from "./937.js";
-import "./937.js";
+import { __webpack_require__ } from "./198.js";
+import "./198.js";
 __webpack_require__.add({
     "./node_modules/.pnpm/launch-editor@2.13.2/node_modules/launch-editor/editor-info/linux.js" (module) {
         module.exports = {
@@ -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/0~serve-static.js

@@ -1,6 +1,6 @@
 /*! LICENSE: 0~serve-static.js.LICENSE.txt */
-import { __webpack_require__ } from "./937.js";
-import "./937.js";
+import { __webpack_require__ } from "./198.js";
+import "./198.js";
 import "./0~debug.js";
 __webpack_require__.add({
     "./node_modules/.pnpm/depd@2.0.0/node_modules/depd/index.js" (module, __unused_rspack_exports, __webpack_require__) {

package/dist/{937.js → 198.js}

@@ -85,8 +85,8 @@ var __webpack_require__temp = __webpack_require__;
 })();
 (()=>{
     var installedChunks = {
-        410: 0,
-        937: 0
+        198: 0,
+        410: 0
     };
     var installChunk = (data)=>{
         var __rspack_esm_ids = data.__rspack_esm_ids;
@@ -3701,9 +3701,6 @@ __webpack_require__.add({
             }
         }
     },
-    assert (module) {
-        module.exports = __rspack_createRequire_require("assert");
-    },
     async_hooks (module) {
         module.exports = __rspack_createRequire_require("async_hooks");
     },
@@ -3737,9 +3734,6 @@ __webpack_require__.add({
     path (module) {
         module.exports = __rspack_createRequire_require("path");
     },
-    querystring (module) {
-        module.exports = __rspack_createRequire_require("querystring");
-    },
     stream (module) {
         module.exports = __rspack_createRequire_require("stream");
     },
@@ -4721,7 +4715,7 @@ class Server {
             }
         });
         if (this.options.proxy) {
-            const { createProxyMiddleware } = await import("./0~http-proxy-middleware.js").then(__webpack_require__.t.bind(__webpack_require__, "./node_modules/.pnpm/http-proxy-middleware@3.0.5/node_modules/http-proxy-middleware/dist/index.js", 23));
+            const { createProxyMiddleware } = await import("./0~http-proxy-middleware.js");
             const getProxyMiddleware = (proxyConfig)=>{
                 const { context, ...proxyOptions } = proxyConfig;
                 const pathFilter = proxyOptions.pathFilter ?? context;

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/dist/index.js

@@ -1 +1 @@
-export { RspackDevServer } from "./937.js";
+export { RspackDevServer } from "./198.js";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@rspack/dev-server",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.1",
   "description": "Development server for Rspack",
-  "homepage": "https://rspack.rs",
+  "homepage": "https://github.com/rstackjs/rspack-dev-server",
   "bugs": "https://github.com/rstackjs/rspack-dev-server/issues",
   "repository": {
     "type": "git",
@@ -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": "^3.0.5",
+    "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"
   },