@rspack/dev-server 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/131.js

@@ -1,3 +1,4 @@
+import * as __rspack_external_zlib from "zlib";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import node_fs, { lstatSync, promises, readFileSync, realpathSync, statSync, unlinkSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -8,6 +9,94 @@ import { deprecate, promisify, styleText } from "node:util";
 import ipaddr from "ipaddr.js";
 import { createServer } from "node:net";
 import { WebSocketServer } from "ws";
+__webpack_require__.add({
+    "./node_modules/.pnpm/http-compression@1.1.2/node_modules/http-compression/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        const zlib = __webpack_require__("zlib");
+        const MIMES = /text|javascript|\/json|xml/i;
+        const noop = ()=>{};
+        const getChunkSize = (chunk, enc)=>chunk ? Buffer.byteLength(chunk, enc) : 0;
+        module.exports = ({ threshold = 1024, level = {
+            brotli: 0,
+            gzip: 1
+        }, brotli = true, gzip = true, mimes = MIMES } = {})=>{
+            const brotliOpts = 'object' == typeof brotli && brotli || {};
+            const gzipOpts = 'object' == typeof gzip && gzip || {};
+            if (brotli && !zlib.createBrotliCompress) brotli = false;
+            return (req, res, next = noop)=>{
+                const accept = req.headers['accept-encoding'];
+                const encoding = accept && (brotli && accept.match(/\bbr\b/) || gzip && accept.match(/\bgzip\b/) || [])[0];
+                if ('HEAD' === req.method || !encoding) return next();
+                let compress;
+                let pendingStatus;
+                let pendingListeners = [];
+                let started = false;
+                let size = 0;
+                function start() {
+                    started = true;
+                    size = 0 | res.getHeader('Content-Length') || size;
+                    const compressible = mimes.test(String(res.getHeader('Content-Type') || 'text/plain'));
+                    const cleartext = !res.getHeader('Content-Encoding');
+                    const listeners = pendingListeners || [];
+                    if (compressible && cleartext && size >= threshold) {
+                        res.setHeader('Content-Encoding', encoding);
+                        res.removeHeader('Content-Length');
+                        compress = 'br' === encoding ? zlib.createBrotliCompress({
+                            params: Object.assign({
+                                [zlib.constants.BROTLI_PARAM_QUALITY]: level.brotli,
+                                [zlib.constants.BROTLI_PARAM_SIZE_HINT]: size
+                            }, brotliOpts)
+                        }) : zlib.createGzip(Object.assign({
+                            level: level.gzip
+                        }, gzipOpts));
+                        compress.on('data', (chunk)=>false === write.call(res, chunk) && compress.pause());
+                        on.call(res, 'drain', ()=>compress.resume());
+                        compress.on('end', ()=>end.call(res));
+                        listeners.forEach((p)=>compress.on.apply(compress, p));
+                    } else {
+                        pendingListeners = null;
+                        listeners.forEach((p)=>on.apply(res, p));
+                    }
+                    writeHead.call(res, pendingStatus || res.statusCode);
+                }
+                const { end, write, on, writeHead } = res;
+                res.writeHead = function(status, reason, headers) {
+                    if ('string' != typeof reason) [headers, reason] = [
+                        reason,
+                        headers
+                    ];
+                    if (headers) for(const i in headers)res.setHeader(i, headers[i]);
+                    pendingStatus = status;
+                    return this;
+                };
+                res.write = function(chunk, enc) {
+                    size += getChunkSize(chunk, enc);
+                    if (!started) start();
+                    if (!compress) return write.apply(this, arguments);
+                    return compress.write.apply(compress, arguments);
+                };
+                res.end = function(chunk, enc) {
+                    if (arguments.length > 0 && 'function' != typeof chunk) size += getChunkSize(chunk, enc);
+                    if (!started) start();
+                    if (!compress) return end.apply(this, arguments);
+                    return compress.end.apply(compress, arguments);
+                };
+                res.on = function(type, listener) {
+                    if (pendingListeners && 'drain' === type) if (compress) compress.on(type, listener);
+                    else pendingListeners.push([
+                        type,
+                        listener
+                    ]);
+                    else on.call(this, type, listener);
+                    return this;
+                };
+                next();
+            };
+        };
+    },
+    zlib (module) {
+        module.exports = __rspack_external_zlib;
+    }
+});
 var external_node_util_namespaceObject = {};
 __webpack_require__.r(external_node_util_namespaceObject);
 __webpack_require__.d(external_node_util_namespaceObject, {
@@ -127,6 +216,8 @@ class WebsocketServer extends servers_BaseServer {
         });
     }
 }
+const src = __webpack_require__("./node_modules/.pnpm/http-compression@1.1.2/node_modules/http-compression/src/index.js");
+var src_default = /*#__PURE__*/ __webpack_require__.n(src);
 const { styleText: server_styleText } = external_node_util_namespaceObject;
 const server_require = createRequire(import.meta.url);
 if (!process.env.WEBPACK_SERVE) process.env.WEBPACK_SERVE = 'true';
@@ -146,6 +237,7 @@ const getConnect = async ()=>{
     const { connect } = await import("connect-next");
     return connect;
 };
+const getChokidar = memoize(()=>import("chokidar"));
 const getServeStatic = memoize(()=>server_require('serve-static'));
 const encodeOverlaySettings = (setting)=>'function' == typeof setting ? encodeURIComponent(setting.toString()) : setting;
 const DEFAULT_ALLOWED_PROTOCOLS = /^(file|.+-extension):/i;
@@ -261,7 +353,7 @@ class Server {
         if ('3' === process.versions.pnp) return external_node_path_resolve(dir, '.yarn/.cache/rspack-dev-server');
         return external_node_path_resolve(dir, 'node_modules/.cache/rspack-dev-server');
     }
-    addAdditionalEntries(compiler) {
+    #addAdditionalEntries(compiler) {
         const additionalEntries = [];
         const isWebTarget = Boolean(compiler.platform.web);
         if (this.options.client && isWebTarget) {
@@ -312,7 +404,7 @@ class Server {
             name: void 0
         }).apply(compiler);
     }
-    getCompilerOptions() {
+    #getCompilerOptions() {
         if (void 0 !== this.compiler.compilers) {
             if (1 === this.compiler.compilers.length) return this.compiler.compilers[0].options;
             const compilerWithDevServer = this.compiler.compilers.find((config)=>config.options.devServer);
@@ -323,14 +415,14 @@ class Server {
         }
         return this.compiler.options;
     }
-    shouldLogInfrastructureInfo() {
-        const compilerOptions = this.getCompilerOptions();
+    #shouldLogInfrastructureInfo() {
+        const compilerOptions = this.#getCompilerOptions();
         const { level = 'info' } = compilerOptions.infrastructureLogging || {};
         return 'info' === level || 'log' === level || 'verbose' === level;
     }
-    async normalizeOptions() {
+    async #normalizeOptions() {
         const { options } = this;
-        const compilerOptions = this.getCompilerOptions();
+        const compilerOptions = this.#getCompilerOptions();
         const compilerWatchOptions = compilerOptions.watchOptions;
         const getWatchOptions = (watchOptions = {})=>{
             const getPolling = ()=>{
@@ -346,7 +438,7 @@ class Server {
             };
             const usePolling = getPolling();
             const interval = getInterval();
-            const { poll, ...rest } = watchOptions;
+            const { poll: _poll, ...rest } = watchOptions;
             return {
                 ignoreInitial: true,
                 persistent: true,
@@ -355,8 +447,9 @@ class Server {
                 alwaysStat: true,
                 ignorePermissionErrors: true,
                 usePolling,
-                interval,
-                ignored: watchOptions.ignored,
+                ...void 0 !== interval ? {
+                    interval
+                } : {},
                 ...rest
             };
         };
@@ -367,9 +460,6 @@ class Server {
                     publicPath: [
                         '/'
                     ],
-                    serveIndex: {
-                        icons: true
-                    },
                     watch: getWatchOptions()
                 });
             let item;
@@ -389,10 +479,6 @@ class Server {
                     publicPath: void 0 !== optionsForStatic.publicPath ? Array.isArray(optionsForStatic.publicPath) ? optionsForStatic.publicPath : [
                         optionsForStatic.publicPath
                     ] : def.publicPath,
-                    serveIndex: void 0 !== optionsForStatic.serveIndex ? 'boolean' == typeof optionsForStatic.serveIndex && optionsForStatic.serveIndex ? def.serveIndex : 'object' == typeof optionsForStatic.serveIndex ? {
-                        ...def.serveIndex,
-                        ...optionsForStatic.serveIndex
-                    } : optionsForStatic.serveIndex : def.serveIndex,
                     watch: void 0 !== optionsForStatic.watch ? 'boolean' == typeof optionsForStatic.watch ? optionsForStatic.watch ? def.watch : false : getWatchOptions(optionsForStatic.watch) : def.watch
                 };
             }
@@ -708,7 +794,7 @@ class Server {
         }
         else options.webSocketServer = false;
     }
-    getClientTransport() {
+    #getClientTransport() {
         let clientImplementation;
         let clientImplementationFound = true;
         const isKnownWebSocketServerImplementation = this.options.webSocketServer && 'string' == typeof this.options.webSocketServer.type && 'ws' === this.options.webSocketServer.type;
@@ -730,7 +816,7 @@ class Server {
         if (!clientImplementationFound) throw new Error(`${!isKnownWebSocketServerImplementation ? 'When you use custom web socket implementation you must explicitly specify client.webSocketTransport. ' : ''}client.webSocketTransport must be a string denoting a default implementation (e.g. 'ws') or a full path to a JS file via require.resolve(...) which exports a class `);
         return clientImplementation;
     }
-    getServerTransport() {
+    #getServerTransport() {
         let implementation;
         let implementationFound = true;
         switch(typeof this.options.webSocketServer.type){
@@ -759,7 +845,7 @@ class Server {
         if ('only' === this.options.hot) return server_require.resolve('@rspack/core/hot/only-dev-server');
         if (this.options.hot) return server_require.resolve('@rspack/core/hot/dev-server');
     }
-    setupProgressPlugin() {
+    #setupProgressPlugin() {
         const { ProgressPlugin } = this.compiler.compilers ? this.compiler.compilers[0].webpack : this.compiler.webpack;
         new ProgressPlugin((percent, msg)=>{
             const percentValue = Math.floor(100 * percent);
@@ -773,7 +859,7 @@ class Server {
             if (this.server) this.server.emit('progress-update', payload);
         }).apply(this.compiler);
     }
-    async initialize() {
+    async #initialize() {
         const compilers = isMultiCompiler(this.compiler) ? this.compiler.compilers : [
             this.compiler
         ];
@@ -787,19 +873,19 @@ class Server {
                 };
             }
         }
-        this.setupHooks();
-        await this.setupApp();
-        await this.createServer();
+        this.#setupHooks();
+        await this.#setupApp();
+        await this.#createServer();
         if (this.options.webSocketServer) {
             const compilers = this.compiler.compilers || [
                 this.compiler
             ];
             for (const compiler of compilers){
                 if (false === compiler.options.devServer) continue;
-                this.addAdditionalEntries(compiler);
+                this.#addAdditionalEntries(compiler);
                 const { ProvidePlugin, HotModuleReplacementPlugin } = compiler.rspack;
                 new ProvidePlugin({
-                    __rspack_dev_server_client__: this.getClientTransport()
+                    __rspack_dev_server_client__: this.#getClientTransport()
                 }).apply(compiler);
                 if (this.options.hot) {
                     const HMRPluginExists = compiler.options.plugins.find((plugin)=>plugin && plugin.constructor === HotModuleReplacementPlugin);
@@ -810,11 +896,11 @@ class Server {
                     }
                 }
             }
-            if (this.options.client && this.options.client.progress) this.setupProgressPlugin();
+            if (this.options.client && this.options.client.progress) this.#setupProgressPlugin();
         }
-        this.setupWatchFiles();
-        this.setupWatchStaticFiles();
-        await this.setupMiddlewares();
+        await this.#setupWatchFiles();
+        await this.#setupWatchStaticFiles();
+        await this.#setupMiddlewares();
         if (this.options.setupExitSignals) {
             const signals = [
                 'SIGINT',
@@ -843,35 +929,35 @@ class Server {
         const webSocketProxies = this.webSocketProxies;
         for (const webSocketProxy of webSocketProxies)this.server.on('upgrade', webSocketProxy.upgrade);
     }
-    async setupApp() {
+    async #setupApp() {
         this.app = 'function' == typeof this.options.app ? await this.options.app() : (await getConnect())();
     }
-    getStats(statsObj) {
+    #getStats(statsObj) {
         const stats = Server.DEFAULT_STATS;
-        const compilerOptions = this.getCompilerOptions();
+        const compilerOptions = this.#getCompilerOptions();
         if (compilerOptions.stats && compilerOptions.stats.warningsFilter) stats.warningsFilter = compilerOptions.stats.warningsFilter;
         return statsObj.toJson(stats);
     }
-    setupHooks() {
+    #setupHooks() {
         this.compiler.hooks.invalid.tap('rspack-dev-server', ()=>{
             if (this.webSocketServer) this.sendMessage(this.webSocketServer.clients, 'invalid');
         });
         this.compiler.hooks.done.tap('rspack-dev-server', (stats)=>{
-            if (this.webSocketServer) this.sendStats(this.webSocketServer.clients, this.getStats(stats));
+            if (this.webSocketServer) this.#sendStats(this.webSocketServer.clients, this.#getStats(stats));
             this.stats = stats;
         });
     }
-    setupWatchStaticFiles() {
+    async #setupWatchStaticFiles() {
         const watchFiles = this.options.static;
         if (watchFiles.length > 0) {
-            for (const item of watchFiles)if (item.watch) this.watchFiles(item.directory, item.watch);
+            for (const item of watchFiles)if (item.watch) await this.watchFiles(item.directory, item.watch);
         }
     }
-    setupWatchFiles() {
+    async #setupWatchFiles() {
         const watchFiles = this.options.watchFiles;
-        if (watchFiles.length > 0) for (const item of watchFiles)this.watchFiles(item.paths, item.options);
+        if (watchFiles.length > 0) for (const item of watchFiles)await this.watchFiles(item.paths, item.options);
     }
-    async setupMiddlewares() {
+    async #setupMiddlewares() {
         let middlewares = [];
         middlewares.push({
             name: 'host-header-check',
@@ -910,16 +996,13 @@ class Server {
                 next();
             }
         });
-        if (this.options.compress) {
-            const { default: compression } = await import("compression");
-            middlewares.push({
-                name: 'compression',
-                middleware: compression()
-            });
-        }
+        if (this.options.compress) middlewares.push({
+            name: 'compression',
+            middleware: src_default()()
+        });
         if (void 0 !== this.options.headers) middlewares.push({
             name: 'set-headers',
-            middleware: this.setHeaders.bind(this)
+            middleware: this.#setHeaders.bind(this)
         });
         middlewares.push({
             name: 'webpack-dev-middleware',
@@ -1056,17 +1139,6 @@ class Server {
                 middleware: getServeStatic()(staticOption.directory, staticOption.staticOptions)
             });
         }
-        if (staticOptions.length > 0) {
-            const serveIndex = server_require('serve-index');
-            for (const staticOption of staticOptions)for (const publicPath of staticOption.publicPath)if (staticOption.serveIndex) middlewares.push({
-                name: 'serve-index',
-                path: publicPath,
-                middleware: (req, res, next)=>{
-                    if ('GET' !== req.method && 'HEAD' !== req.method) return next();
-                    serveIndex(staticOption.directory, staticOption.serveIndex)(req, res, next);
-                }
-            });
-        }
         middlewares.push({
             name: 'options-middleware',
             middleware: (req, res, next)=>{
@@ -1095,7 +1167,7 @@ class Server {
         else if (void 0 !== middleware.path) this.app.use(middleware.path, middleware.middleware);
         else this.app.use(middleware.middleware);
     }
-    async createServer() {
+    async #createServer() {
         const { type, options } = this.options.server;
         if ('function' == typeof type) this.server = await type(options, this.app);
         else {
@@ -1116,12 +1188,12 @@ class Server {
             throw error;
         });
     }
-    createWebSocketServer() {
-        this.webSocketServer = new (this.getServerTransport())(this);
+    #createWebSocketServer() {
+        this.webSocketServer = new (this.#getServerTransport())(this);
         (this.webSocketServer?.implementation).on('connection', (client, request)=>{
             const headers = void 0 !== request ? request.headers : void 0;
             if (!headers) this.logger.warn('webSocketServer implementation must pass headers for the "connection" event');
-            if (!headers || !this.isValidHost(headers, 'host') || !this.isValidHost(headers, 'origin') || !this.isSameOrigin(headers)) {
+            if (!headers || !this.isValidHost(headers, 'host') || !this.isValidHost(headers, 'origin') || !this.#isSameOrigin(headers)) {
                 this.sendMessage([
                     client
                 ], 'error', 'Invalid Host/Origin header');
@@ -1152,12 +1224,12 @@ class Server {
                 } : overlayConfig);
             }
             if (!this.stats) return;
-            this.sendStats([
+            this.#sendStats([
                 client
-            ], this.getStats(this.stats), true);
+            ], this.#getStats(this.stats), true);
         });
     }
-    async openBrowser(defaultOpenTarget) {
+    async #openBrowser(defaultOpenTarget) {
         const { default: open } = await import("./0~open.js").then((mod)=>({
                 default: mod.node_modules_open
             }));
@@ -1170,7 +1242,7 @@ class Server {
             });
         }));
     }
-    async logStatus() {
+    async #logStatus() {
         const server = this.server;
         if (this.options.ipc) this.logger.info(`Project is running at: "${server?.address()}"`);
         else {
@@ -1219,14 +1291,14 @@ class Server {
                 'white',
                 'dim'
             ], 'Network:')}  ${server_styleText('cyan', networkUrlIPv6)}`);
-            if (urlLogs.length && this.shouldLogInfrastructureInfo()) console.log(`${urlLogs.join('\n')}\n`);
+            if (urlLogs.length && this.#shouldLogInfrastructureInfo()) console.log(`${urlLogs.join('\n')}\n`);
             if (this.options.open?.length > 0) {
                 const openTarget = prettyPrintURL(this.options.host && '0.0.0.0' !== this.options.host && '::' !== this.options.host ? this.options.host : 'localhost');
-                await this.openBrowser(openTarget);
+                await this.#openBrowser(openTarget);
             }
         }
     }
-    setHeaders(req, res, next) {
+    #setHeaders(req, res, next) {
         let { headers } = this.options;
         if (headers) {
             if ('function' == typeof headers) headers = headers(req, res, this.middleware ? this.middleware.context : void 0);
@@ -1242,7 +1314,7 @@ class Server {
         }
         next();
     }
-    isHostAllowed(value) {
+    #isHostAllowed(value) {
         const { allowedHosts } = this.options;
         if ('all' === allowedHosts) return true;
         if (Array.isArray(allowedHosts) && allowedHosts.length > 0) for (const allowedHost of allowedHosts){
@@ -1259,24 +1331,24 @@ class Server {
         if (DEFAULT_ALLOWED_PROTOCOLS.test(header)) return true;
         const hostname = parseHostnameFromHeader(header);
         if (null === hostname) return false;
-        if (this.isHostAllowed(hostname)) return true;
+        if (this.#isHostAllowed(hostname)) return true;
         const isValidHostname = validateHost ? ipaddr.IPv4.isValid(hostname) || ipaddr.IPv6.isValid(hostname) || 'localhost' === hostname || hostname.endsWith('.localhost') || hostname === this.options.host : false;
         return isValidHostname;
     }
-    isSameOrigin(headers) {
+    #isSameOrigin(headers) {
         if ('all' === this.options.allowedHosts) return true;
         const originHeader = headers.origin;
         if (!originHeader) return 'all' === this.options.allowedHosts;
         if (DEFAULT_ALLOWED_PROTOCOLS.test(originHeader)) return true;
         const origin = parseHostnameFromHeader(originHeader);
         if (null === origin) return false;
-        if (this.isHostAllowed(origin)) return true;
+        if (this.#isHostAllowed(origin)) return true;
         const hostHeader = headers.host;
         if (!hostHeader) return 'all' === this.options.allowedHosts;
         if (DEFAULT_ALLOWED_PROTOCOLS.test(hostHeader)) return true;
         const host = parseHostnameFromHeader(hostHeader);
         if (null === host) return false;
-        if (this.isHostAllowed(host)) return true;
+        if (this.#isHostAllowed(host)) return true;
         return origin === host;
     }
     sendMessage(clients, type, data, params) {
@@ -1286,7 +1358,7 @@ class Server {
             params
         }));
     }
-    sendStats(clients, stats, force) {
+    #sendStats(clients, stats, force) {
         if (!stats) return;
         const shouldEmit = !force && stats && (!stats.errors || 0 === stats.errors.length) && (!stats.warnings || 0 === stats.warnings.length) && this.currentHash === stats.hash;
         if (shouldEmit) return void this.sendMessage(clients, 'still-ok');
@@ -1304,9 +1376,9 @@ class Server {
             if (stats.errors?.length > 0) this.sendMessage(clients, 'errors', stats.errors);
         } else this.sendMessage(clients, 'ok');
     }
-    watchFiles(watchPath, watchOptions) {
-        const chokidar = server_require('chokidar');
-        const watcher = chokidar.watch(watchPath, watchOptions);
+    async watchFiles(watchPath, watchOptions) {
+        const { watch } = await getChokidar();
+        const watcher = watch(watchPath, watchOptions);
         if (this.options.liveReload) watcher.on('change', (item)=>{
             if (this.webSocketServer) this.sendMessage(this.webSocketServer.clients, 'static-changed', item);
         });
@@ -1316,7 +1388,7 @@ class Server {
         if (this.middleware) this.middleware.invalidate(callback);
     }
     async start() {
-        await this.normalizeOptions();
+        await this.#normalizeOptions();
         if (this.options.ipc) await new Promise((resolve, reject)=>{
             const net = server_require('node:net');
             const socket = new net.Socket();
@@ -1339,7 +1411,7 @@ class Server {
             this.options.host = await Server.getHostname(this.options.host);
             this.options.port = await Server.getFreePort(this.options.port, this.options.host);
         }
-        await this.initialize();
+        await this.#initialize();
         const listenOptions = this.options.ipc ? {
             path: this.options.ipc
         } : {
@@ -1355,8 +1427,8 @@ class Server {
             const READ_WRITE = 438;
             await promises.chmod(this.options.ipc, READ_WRITE);
         }
-        if (this.options.webSocketServer) this.createWebSocketServer();
-        await this.logStatus();
+        if (this.options.webSocketServer) this.#createWebSocketServer();
+        await this.#logStatus();
         if ('function' == typeof this.options.onListening) this.options.onListening(this);
     }
     startCallback(callback = ()=>{}) {

package/dist/rslib-runtime.js

@@ -15,6 +15,15 @@ __webpack_require__.m = __webpack_modules__;
         Object.assign(__webpack_require__.m, modules);
     };
 })();
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     var getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
     var leafPrototypes;

package/dist/server.d.ts

@@ -7,9 +7,9 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
  */
-import type { BasicApplication, ClientConfiguration, ClientConnection, Compiler, ConnectHistoryApiFallbackOptions, DevMiddlewareContext, DevMiddlewareOptions, DevServer, EXPECTED_ANY, FSWatcher, HTTPServer, Headers, Host, LiteralUnion, Middleware, MultiCompiler, MultiStats, NextFunction, Open, Port, ProxyConfigArray, Request, RequestHandler, Response, ServerConfiguration, ServerType, Socket, Static, Stats, StatsCompilation, StatsOptions, WatchFiles, WatchOptions, WebSocketServerConfiguration, WebSocketServerImplementation } from './types';
+import type { BasicApplication, BasicServer, ClientConfiguration, ClientConnection, Compiler, ConnectHistoryApiFallbackOptions, DevMiddlewareContext, DevMiddlewareOptions, DevServer, EXPECTED_ANY, FSWatcher, HTTPServer, Headers, Host, LiteralUnion, Middleware, MultiCompiler, MultiStats, Open, Port, ProxyConfigArray, Request, RequestHandler, Response, ServerConfiguration, ServerType, Socket, Static, Stats, StatsOptions, WatchFiles, WatchOptions, WebSocketServerConfiguration, WebSocketServerImplementation } from './types';
 import type { ConnectApplication } from './types';
-export interface Configuration<A extends BasicApplication = ConnectApplication, S extends HTTPServer = HTTPServer> {
+export interface Configuration<A extends BasicApplication = ConnectApplication, S extends BasicServer = HTTPServer> {
     ipc?: boolean | string;
     host?: Host;
     port?: Port;
@@ -32,7 +32,8 @@ export interface Configuration<A extends BasicApplication = ConnectApplication,
     onListening?: (devServer: Server<A, S>) => void;
     setupMiddlewares?: (middlewares: Middleware[], devServer: Server<A, S>) => Middleware[];
 }
-declare class Server<A extends BasicApplication = ConnectApplication, S extends import('http').Server = HTTPServer> {
+declare class Server<A extends BasicApplication = ConnectApplication, S extends BasicServer = HTTPServer> {
+    #private;
     compiler: Compiler | MultiCompiler;
     logger: ReturnType<Compiler['getInfrastructureLogger']>;
     options: Configuration<A, S>;
@@ -57,49 +58,11 @@ declare class Server<A extends BasicApplication = ConnectApplication, S extends
     static getHostname(hostname: Host): Promise<string>;
     static getFreePort(port: string, host: string): Promise<string | number>;
     static findCacheDir(): string;
-    addAdditionalEntries(compiler: Compiler): void;
-    /**
-     * @private
-     * @returns {Compiler["options"]} compiler options
-     */
-    getCompilerOptions(): import("@rspack/core").RspackOptionsNormalized;
-    shouldLogInfrastructureInfo(): boolean;
-    normalizeOptions(): Promise<void>;
-    /**
-     * @private
-     * @returns {string} client transport
-     */
-    getClientTransport(): string;
-    getServerTransport(): unknown;
     getClientEntry(): string;
     getClientHotEntry(): string | undefined;
-    setupProgressPlugin(): void;
-    /**
-     * @private
-     * @returns {Promise<void>}
-     */
-    initialize(): Promise<void>;
-    setupApp(): Promise<void>;
-    getStats(statsObj: Stats | MultiStats): StatsCompilation;
-    setupHooks(): void;
-    setupWatchStaticFiles(): void;
-    setupWatchFiles(): void;
-    setupMiddlewares(): Promise<void>;
-    /**
-     * @private
-     * @returns {Promise<void>}
-     */
-    createServer(): Promise<void>;
-    createWebSocketServer(): void;
-    openBrowser(defaultOpenTarget: string): Promise<void>;
-    logStatus(): Promise<void>;
-    setHeaders(req: Request, res: Response, next: NextFunction): void;
-    isHostAllowed(value: string): boolean;
     isValidHost(headers: Record<string, string | undefined>, headerToCheck: string, validateHost?: boolean): boolean;
-    isSameOrigin(headers: Record<string, string | undefined>): boolean;
     sendMessage(clients: ClientConnection[], type: string, data?: EXPECTED_ANY, params?: EXPECTED_ANY): void;
-    sendStats(clients: ClientConnection[], stats: StatsCompilation, force?: boolean): void;
-    watchFiles(watchPath: string | string[], watchOptions?: WatchOptions): void;
+    watchFiles(watchPath: string | string[], watchOptions?: WatchOptions): Promise<void>;
     invalidate(callback?: import('webpack-dev-middleware').Callback): void;
     start(): Promise<void>;
     startCallback(callback?: (err?: Error) => void): void;

package/dist/types.d.ts

@@ -1,22 +1,18 @@
 import type { Server as HTTPServer, IncomingMessage, ServerResponse } from 'node:http';
-export type { HTTPServer, IncomingMessage };
+import type { ServerOptions } from 'node:https';
+import type { FSWatcher, ChokidarOptions as WatchOptions } from 'chokidar';
+import type { Options as ConnectHistoryApiFallbackOptions } from 'connect-history-api-fallback';
+import type { Server as ConnectApplication, IncomingMessage as ConnectIncomingMessage } from 'connect-next';
+import type { Options as HttpProxyMiddlewareOptions, Filter as HttpProxyMiddlewareOptionsFilter, RequestHandler } from 'http-proxy-middleware';
+import type { ServeStaticOptions } from 'serve-static';
+export type { FSWatcher, WatchOptions, RequestHandler, BasicServer, HTTPServer, ServerOptions, IncomingMessage, ConnectApplication, ConnectHistoryApiFallbackOptions, };
+export type { IPv6 } from 'ipaddr.js';
 export type { Socket } from 'node:net';
 export type { AddressInfo } from 'node:net';
 export type { NetworkInterfaceInfo } from 'node:os';
 export type { Compiler, DevServer, MultiCompiler, MultiStats, Stats, StatsCompilation, StatsOptions, } from '@rspack/core';
-import type { FSWatcher, WatchOptions } from 'chokidar';
-export type { FSWatcher, WatchOptions };
-import type { Server as ConnectApplication, IncomingMessage as ConnectIncomingMessage } from 'connect-next';
-export type { ConnectApplication };
-import type { Options as ConnectHistoryApiFallbackOptions } from 'connect-history-api-fallback';
-export type { ConnectHistoryApiFallbackOptions };
-import type { Options as HttpProxyMiddlewareOptions, Filter as HttpProxyMiddlewareOptionsFilter, RequestHandler } from 'http-proxy-middleware';
-export type { RequestHandler };
-export type { IPv6 } from 'ipaddr.js';
-import type { Options as ServeIndexOptions } from 'serve-index';
-export type { ServeIndexOptions };
-import type { ServeStaticOptions } from 'serve-static';
 export type EXPECTED_ANY = any;
+type BasicServer = import('node:net').Server | import('node:tls').Server;
 /** https://github.com/microsoft/TypeScript/issues/29729 */
 export type LiteralUnion<T extends U, U> = T | (U & Record<never, never>);
 export type NextFunction = (err?: EXPECTED_ANY) => void;
@@ -24,7 +20,6 @@ export type SimpleHandleFunction = (req: IncomingMessage, res: ServerResponse) =
 export type NextHandleFunction = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
 export type ErrorHandleFunction = (err: EXPECTED_ANY, req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
 export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
-export type ServerOptions = import('https').ServerOptions;
 export type Request<T extends BasicApplication = ConnectApplication> = T extends ConnectApplication ? ConnectIncomingMessage : IncomingMessage;
 export type Response = ServerResponse;
 export type DevMiddlewareOptions<T extends Request, U extends Response> = import('webpack-dev-middleware').Options<T, U>;
@@ -35,30 +30,23 @@ export interface WatchFiles {
     paths: string | string[];
     options?: WatchOptions & {
         aggregateTimeout?: number;
-        ignored?: WatchOptions['ignored'];
         poll?: number | boolean;
     };
 }
 export interface Static {
     directory?: string;
     publicPath?: string | string[];
-    serveIndex?: boolean | ServeIndexOptions;
     staticOptions?: ServeStaticOptions;
-    watch?: boolean | (WatchOptions & {
-        aggregateTimeout?: number;
-        ignored?: WatchOptions['ignored'];
-        poll?: number | boolean;
-    });
+    watch?: boolean | NonNullable<WatchFiles['options']>;
 }
 export interface NormalizedStatic {
     directory: string;
     publicPath: string[];
-    serveIndex: false | ServeIndexOptions;
     staticOptions: ServeStaticOptions;
     watch: false | WatchOptions;
 }
-export type ServerType<A extends BasicApplication = ConnectApplication, S extends import('http').Server = import('http').Server> = LiteralUnion<'http' | 'https' | 'http2', string> | ((serverOptions: ServerOptions, application: A) => S);
-export interface ServerConfiguration<A extends BasicApplication = ConnectApplication, S extends import('http').Server = import('http').Server> {
+export type ServerType<A extends BasicApplication, S extends BasicServer> = LiteralUnion<'http' | 'https' | 'http2', string> | ((serverOptions: ServerOptions, application: A) => S);
+export interface ServerConfiguration<A extends BasicApplication = ConnectApplication, S extends BasicServer = HTTPServer> {
     type?: ServerType<A, S>;
     options?: ServerOptions;
 }
@@ -125,7 +113,6 @@ export interface MiddlewareObject {
     middleware: MiddlewareHandler;
 }
 export type Middleware = MiddlewareObject | MiddlewareHandler;
-export type BasicServer = import('net').Server | import('tls').Server;
 export type OverlayMessageOptions = boolean | ((error: Error) => void);
 declare function useFn(fn: NextHandleFunction): BasicApplication;
 declare function useFn(fn: HandleFunction): BasicApplication;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/dev-server",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.5",
   "description": "Development server for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/rstackjs/rspack-dev-server/issues",
@@ -46,16 +46,14 @@
   },
   "dependencies": {
     "@types/connect-history-api-fallback": "^1.5.4",
-    "@types/serve-index": "^1.9.4",
     "@types/serve-static": "^2.2.0",
     "@types/ws": "^8.18.1",
-    "chokidar": "^3.6.0",
-    "connect-next": "^4.0.0",
+    "chokidar": "^5.0.0",
     "connect-history-api-fallback": "^2.0.0",
+    "connect-next": "^4.0.0",
     "http-proxy-middleware": "^3.0.5",
     "ipaddr.js": "^2.3.0",
     "serve-static": "^2.2.1",
-    "serve-index": "^1.9.2",
     "webpack-dev-middleware": "^7.4.5",
     "ws": "^8.19.0"
   },
@@ -66,17 +64,16 @@
     "@rspack/core": "2.0.0-beta.5",
     "@rspack/plugin-react-refresh": "1.6.1",
     "@rstest/core": "^0.9.0",
-    "@types/compression": "^1.8.1",
     "@types/mime-types": "3.0.1",
     "@types/node": "^24.12.0",
     "@types/node-forge": "^1.3.14",
     "@types/trusted-types": "^2.0.7",
     "@types/ws": "8.18.1",
-    "express": "^5.2.1",
-    "compression": "^1.8.1",
     "cross-env": "^10.1.0",
     "css-loader": "^7.1.4",
+    "express": "^5.2.1",
     "hono": "^4.12.5",
+    "http-compression": "^1.1.2",
     "http-proxy": "^1.18.1",
     "launch-editor": "^2.13.1",
     "nano-staged": "^0.9.0",