@rspack/dev-server 1.1.4 → 1.2.0

package/dist/servers/BaseServer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+import type Server from '../server';
+import type { ClientConnection } from '../types';
+declare class BaseServer {
+    server: Server;
+    clients: ClientConnection[];
+    constructor(server: Server);
+}
+export default BaseServer;

package/dist/servers/BaseServer.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// base class that users should extend if they are making their own
+// server implementation
+class BaseServer {
+    constructor(server) {
+        this.server = server;
+        this.clients = [];
+    }
+}
+exports.default = BaseServer;

package/dist/servers/SockJSServer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+export {};

package/dist/servers/SockJSServer.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sockjs = __importStar(require("sockjs"));
+const BaseServer_1 = __importDefault(require("./BaseServer"));
+// Workaround for sockjs@~0.3.19
+// sockjs will remove Origin header, however Origin header is required for checking host.
+// See https://github.com/webpack/webpack-dev-server/issues/1604 for more information
+{
+    const SockjsSession = require('sockjs/lib/transport').Session;
+    const { decorateConnection } = SockjsSession.prototype;
+    // eslint-disable-next-line func-names
+    SockjsSession.prototype.decorateConnection = function (req) {
+        decorateConnection.call(this, req);
+        const { connection } = this;
+        if (connection.headers &&
+            !('origin' in connection.headers) &&
+            'origin' in req.headers) {
+            connection.headers.origin = req.headers.origin;
+        }
+    };
+}
+class SockJSServer extends BaseServer_1.default {
+    // options has: error (function), debug (function), server (http/s server), path (string)
+    constructor(server) {
+        super(server);
+        const webSocketServerOptions = this.server.options.webSocketServer.options;
+        const getSockjsUrl = (options) => {
+            if (typeof options.sockjsUrl !== 'undefined') {
+                return options.sockjsUrl;
+            }
+            return '/__webpack_dev_server__/sockjs.bundle.js';
+        };
+        this.implementation = sockjs.createServer({
+            // Use provided up-to-date sockjs-client
+            // eslint-disable-next-line camelcase
+            sockjs_url: getSockjsUrl(webSocketServerOptions),
+            // Default logger is very annoy. Limit useless logs.
+            log: (severity, line) => {
+                if (severity === 'error') {
+                    this.server.logger.error(line);
+                }
+                else if (severity === 'info') {
+                    this.server.logger.log(line);
+                }
+                else {
+                    this.server.logger.debug(line);
+                }
+            },
+        });
+        const getPrefix = (options) => {
+            if (typeof options.prefix !== 'undefined') {
+                return options.prefix;
+            }
+            return options.path;
+        };
+        const options = {
+            ...webSocketServerOptions,
+            prefix: getPrefix(webSocketServerOptions),
+        };
+        this.implementation.installHandlers(this.server.server, options);
+        this.implementation.on('connection', (client) => {
+            // Implement the the same API as for `ws`
+            client.send = client.write;
+            client.terminate = client.close;
+            this.clients.push(client);
+            client.on('close', () => {
+                this.clients.splice(this.clients.indexOf(client), 1);
+            });
+        });
+        this.implementation.close = (callback) => {
+            callback();
+        };
+    }
+}
+module.exports = SockJSServer;

package/dist/servers/WebsocketServer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+export {};

package/dist/servers/WebsocketServer.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack-dev-server
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-server/blob/main/LICENSE
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = __importDefault(require("ws"));
+const BaseServer_1 = __importDefault(require("./BaseServer"));
+class WebsocketServer extends BaseServer_1.default {
+    constructor(server) {
+        super(server);
+        const options = {
+            ...this.server.options.webSocketServer
+                .options,
+            clientTracking: false,
+        };
+        const isNoServerMode = typeof options.port === 'undefined' &&
+            typeof options.server === 'undefined';
+        if (isNoServerMode) {
+            options.noServer = true;
+        }
+        this.implementation = new ws_1.default.Server(options);
+        this.server.server.on('upgrade', (req, sock, head) => {
+            if (!this.implementation.shouldHandle(req)) {
+                return;
+            }
+            this.implementation.handleUpgrade(req, sock, head, (connection) => {
+                this.implementation.emit('connection', connection, req);
+            });
+        });
+        this.implementation.on('error', (err) => {
+            this.server.logger.error(err.message);
+        });
+        const interval = setInterval(() => {
+            for (const client of this.clients) {
+                if (client.isAlive === false) {
+                    client.terminate();
+                    continue;
+                }
+                client.isAlive = false;
+                client.ping(() => { });
+            }
+        }, WebsocketServer.heartbeatInterval);
+        this.implementation.on('connection', (client) => {
+            this.clients.push(client);
+            client.isAlive = true;
+            client.on('pong', () => {
+                client.isAlive = true;
+            });
+            client.on('close', () => {
+                this.clients.splice(this.clients.indexOf(client), 1);
+            });
+            // TODO: add a test case for this - https://github.com/webpack/webpack-dev-server/issues/5018
+            client.on('error', (err) => {
+                this.server.logger.error(err.message);
+            });
+        });
+        this.implementation.on('close', () => {
+            clearInterval(interval);
+        });
+    }
+}
+WebsocketServer.heartbeatInterval = 1000;
+module.exports = WebsocketServer;

package/dist/types.d.ts

@@ -0,0 +1,158 @@
+/// <reference types="node" />
+import type { Server as HTTPServer, IncomingMessage, ServerResponse } from 'node:http';
+export type { HTTPServer, IncomingMessage };
+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 { Bonjour, Service as BonjourOptions } from 'bonjour-service';
+export type { Bonjour, BonjourOptions };
+import type { FSWatcher, WatchOptions } from 'chokidar';
+export type { FSWatcher, WatchOptions };
+import type { Options as ConnectHistoryApiFallbackOptions } from 'connect-history-api-fallback';
+export type { ConnectHistoryApiFallbackOptions };
+import type { Application as ExpressApplication, ErrorRequestHandler as ExpressErrorRequestHandler, Request as ExpressRequest, RequestHandler as ExpressRequestHandler, Response as ExpressResponse } from 'express';
+export type { ExpressApplication };
+import type { Options as HttpProxyMiddlewareOptions, Filter as HttpProxyMiddlewareOptionsFilter, RequestHandler } from 'http-proxy-middleware';
+export type { RequestHandler };
+export type { IPv6 } from 'ipaddr.js';
+export type { Schema } from 'schema-utils/declarations/validate';
+import type { Options as ServeIndexOptions } from 'serve-index';
+export type { ServeIndexOptions };
+import type { ServeStaticOptions } from 'serve-static';
+export type EXPECTED_ANY = any;
+export type NextFunction = (err?: EXPECTED_ANY) => void;
+export type SimpleHandleFunction = (req: IncomingMessage, res: ServerResponse) => void;
+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 & {
+    spdy?: {
+        plain?: boolean;
+        ssl?: boolean;
+        'x-forwarded-for'?: string;
+        protocol?: string;
+        protocols?: string[];
+    };
+};
+export type Request<T extends BasicApplication = ExpressApplication> = T extends ExpressApplication ? ExpressRequest : IncomingMessage;
+export type Response<T extends BasicApplication = ExpressApplication> = T extends ExpressApplication ? ExpressResponse : ServerResponse;
+export type DevMiddlewareOptions<T extends Request, U extends Response> = import('webpack-dev-middleware').Options<T, U>;
+export type DevMiddlewareContext<T extends Request, U extends Response> = import('webpack-dev-middleware').Context<T, U>;
+export type Host = 'local-ip' | 'local-ipv4' | 'local-ipv6' | string;
+export type Port = number | string | 'auto';
+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;
+    });
+}
+export interface NormalizedStatic {
+    directory: string;
+    publicPath: string[];
+    serveIndex: false | ServeIndexOptions;
+    staticOptions: ServeStaticOptions;
+    watch: false | WatchOptions;
+}
+export type ServerType<A extends BasicApplication = ExpressApplication, S extends import('http').Server = import('http').Server> = 'http' | 'https' | 'spdy' | 'http2' | string | ((serverOptions: ServerOptions, application: A) => S);
+export interface ServerConfiguration<A extends BasicApplication = ExpressApplication, S extends import('http').Server = import('http').Server> {
+    type?: ServerType<A, S>;
+    options?: ServerOptions;
+}
+export interface WebSocketServerConfiguration {
+    type?: 'sockjs' | 'ws' | string | (() => WebSocketServerConfiguration);
+    options?: Record<string, EXPECTED_ANY>;
+}
+export type ClientConnection = (import('ws').WebSocket | (import('sockjs').Connection & {
+    send: import('ws').WebSocket['send'];
+    terminate: import('ws').WebSocket['terminate'];
+    ping: import('ws').WebSocket['ping'];
+})) & {
+    isAlive?: boolean;
+};
+export type WebSocketServer = import('ws').WebSocketServer | (import('sockjs').Server & {
+    close: import('ws').WebSocketServer['close'];
+});
+export interface WebSocketServerImplementation {
+    implementation: WebSocketServer;
+    clients: ClientConnection[];
+}
+export type ByPass<Req = Request, Res = Response, ProxyConfig = ProxyConfigArrayItem> = (req: Req, res: Res, proxyConfig: ProxyConfig) => void;
+export type ProxyConfigArrayItem = {
+    path?: HttpProxyMiddlewareOptionsFilter;
+    context?: HttpProxyMiddlewareOptionsFilter;
+    bypass?: ByPass;
+} & HttpProxyMiddlewareOptions;
+export type ProxyConfigArray = Array<ProxyConfigArrayItem | ((req?: Request | undefined, res?: Response | undefined, next?: NextFunction | undefined) => ProxyConfigArrayItem)>;
+export interface OpenApp {
+    name?: string;
+    arguments?: string[];
+}
+export interface Open {
+    app?: string | string[] | OpenApp;
+    target?: string | string[];
+}
+export interface NormalizedOpen {
+    target: string;
+    options: OpenOptions;
+}
+export interface WebSocketURL {
+    hostname?: string;
+    password?: string;
+    pathname?: string;
+    port?: number | string;
+    protocol?: string;
+    username?: string;
+}
+export interface ClientConfiguration {
+    logging?: 'log' | 'info' | 'warn' | 'error' | 'none' | 'verbose';
+    overlay?: boolean | {
+        warnings?: OverlayMessageOptions;
+        errors?: OverlayMessageOptions;
+        runtimeErrors?: OverlayMessageOptions;
+    };
+    progress?: boolean;
+    reconnect?: boolean | number;
+    webSocketTransport?: 'ws' | 'sockjs' | string;
+    webSocketURL?: string | WebSocketURL;
+}
+export type Headers = Array<{
+    key: string;
+    value: string;
+}> | Record<string, string | string[]>;
+export type MiddlewareHandler<T extends BasicApplication = ExpressApplication> = T extends ExpressApplication ? ExpressRequestHandler | ExpressErrorRequestHandler : HandleFunction;
+export interface MiddlewareObject<T extends BasicApplication = ExpressApplication> {
+    name?: string;
+    path?: string;
+    middleware: MiddlewareHandler<T>;
+}
+export type Middleware<T extends BasicApplication = ExpressApplication> = MiddlewareObject<T> | MiddlewareHandler<T>;
+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;
+declare function useFn(route: string, fn: NextHandleFunction): BasicApplication;
+declare function useFn(route: string, fn: HandleFunction): BasicApplication;
+export type BasicApplication = {
+    use: typeof useFn;
+};
+export type OpenOptions = {
+    readonly wait?: boolean;
+    readonly background?: boolean;
+    readonly newInstance?: boolean;
+    readonly app?: OpenApp | readonly OpenApp[];
+    readonly allowNonzeroExitCode?: boolean;
+};

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function useFn(routeOrFn, fn) {
+    return {};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/dev-server",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "license": "MIT",
   "description": "Development server for rspack",
   "main": "./dist/index.js",
@@ -13,16 +13,37 @@
     ".": {
       "default": "./dist/index.js"
     },
+    "./getPort": "./getPort.js",
+    "./servers/*": "./servers/*.js",
+    "./servers/*.js": "./servers/*.js",
     "./client/*": "./client/*.js",
     "./client/*.js": "./client/*.js",
     "./package.json": "./package.json"
   },
+  "scripts": {
+    "build": "pnpm run build:server && pnpm run build:client && pnpm run build:client-modules",
+    "build:server": "tsc -b ./tsconfig.build.json",
+    "build:client": "tsc -b ./tsconfig.client.json",
+    "build:client-modules": "node ./scripts/build-client-modules.cjs",
+    "dev": "tsc -b -w",
+    "lint": "biome check .",
+    "lint:write": "biome check . --write",
+    "format": "prettier --write .",
+    "prettier:ci": "prettier --check .",
+    "test:install": "cross-env ./node_modules/.bin/puppeteer browsers install chrome",
+    "test": "pnpm run test:install && pnpm run build && cross-env NO_COLOR=1 node --expose-gc --max-old-space-size=8192 --experimental-vm-modules ./node_modules/jest-cli/bin/jest --colors",
+    "bump": "npx bumpp"
+  },
   "simple-git-hooks": {
     "pre-commit": "npx nano-staged"
   },
   "nano-staged": {
+    "*.{yaml,yml,json,md,json5}": [
+      "npm rum format"
+    ],
     "*.{js,jsx,ts,tsx,mjs,cjs}": [
-      "biome check --write --no-errors-on-unmatched"
+      "npm run format",
+      "biome lint --write --no-errors-on-unmatched"
     ]
   },
   "files": [
@@ -32,28 +53,33 @@
   "engines": {
     "node": ">= 18.12.0"
   },
-  "homepage": "https://rspack.dev",
-  "bugs": "https://github.com/web-infra-dev/rspack-dev-server/issues",
+  "packageManager": "pnpm@10.27.0",
+  "homepage": "https://rspack.rs",
+  "bugs": "https://github.com/rstackjs/rspack-dev-server/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/web-infra-dev/rspack-dev-server"
+    "url": "https://github.com/rstackjs/rspack-dev-server"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.8.3",
     "@jest/reporters": "29.7.0",
     "@jest/test-sequencer": "^29.7.0",
-    "@rspack/core": "npm:@rspack-canary/core@1.4.3-canary-98b815e4-20250703091256",
+    "@rspack/core": "1.7.1",
     "@rspack/plugin-react-refresh": "1.0.0",
-    "@types/express": "4.17.21",
+    "@types/express": "5.0.6",
     "@types/jest": "29.5.12",
-    "@types/mime-types": "2.1.4",
+    "@types/mime-types": "3.0.1",
     "@types/ws": "8.5.10",
+    "@types/compression": "^1.7.2",
+    "@types/graceful-fs": "^4.1.9",
+    "@types/node": "^24.0.14",
+    "@types/node-forge": "^1.3.1",
+    "@types/sockjs-client": "^1.5.1",
+    "@types/trusted-types": "^2.0.7",
     "@hono/node-server": "^1.13.3",
     "cross-env": "^7.0.3",
     "css-loader": "^7.1.2",
     "connect": "^3.7.0",
-    "execa": "9.3.0",
-    "fs-extra": "11.2.0",
     "graceful-fs": "4.2.10",
     "http-proxy": "^1.18.1",
     "hono": "^4.6.8",
@@ -63,42 +89,53 @@
     "jest-serializer-path": "^0.1.15",
     "nano-staged": "^0.8.0",
     "prettier": "3.2.5",
-    "puppeteer": "^23.2.2",
+    "puppeteer": "^24.34.0",
     "react-refresh": "0.14.0",
     "require-from-string": "^2.0.2",
-    "semver": "7.6.3",
     "simple-git-hooks": "^2.11.1",
     "sockjs-client": "^1.6.1",
-    "style-loader": "^3.3.3",
+    "style-loader": "^4.0.0",
     "supertest": "^6.1.3",
     "tcp-port-used": "^1.0.2",
     "ts-jest": "29.1.2",
     "typescript": "5.0.2",
     "wait-for-expect": "^3.0.2",
     "webpack": "^5.94.0",
+    "webpack-merge": "^6.0.1",
     "webpack-dev-middleware": "^7.4.2",
-    "express": "^4.21.2"
+    "express": "^5.2.1"
   },
   "dependencies": {
     "chokidar": "^3.6.0",
     "http-proxy-middleware": "^2.0.9",
     "p-retry": "^6.2.0",
-    "webpack-dev-server": "5.2.2",
-    "ws": "^8.18.0"
+    "ws": "^8.18.0",
+    "@types/bonjour": "^3.5.13",
+    "@types/connect-history-api-fallback": "^1.5.4",
+    "@types/express": "^4.17.25",
+    "@types/express-serve-static-core": "^4.17.21",
+    "@types/serve-index": "^1.9.4",
+    "@types/serve-static": "^1.15.5",
+    "@types/sockjs": "^0.3.36",
+    "@types/ws": "^8.5.10",
+    "ansi-html-community": "^0.0.8",
+    "bonjour-service": "^1.2.1",
+    "colorette": "^2.0.10",
+    "compression": "^1.8.1",
+    "connect-history-api-fallback": "^2.0.0",
+    "express": "^4.22.1",
+    "graceful-fs": "^4.2.6",
+    "ipaddr.js": "^2.1.0",
+    "launch-editor": "^2.6.1",
+    "open": "^10.0.3",
+    "schema-utils": "^4.2.0",
+    "selfsigned": "^2.4.1",
+    "serve-index": "^1.9.1",
+    "sockjs": "^0.3.24",
+    "spdy": "^4.0.2",
+    "webpack-dev-middleware": "^7.4.2"
   },
   "peerDependencies": {
     "@rspack/core": "*"
-  },
-  "scripts": {
-    "build": "pnpm run build:server && pnpm run build:client",
-    "build:server": "tsc -b ./tsconfig.build.json",
-    "build:client": "tsc -b ./tsconfig.client.json",
-    "dev": "tsc -b -w",
-    "lint": "biome check .",
-    "lint:write": "biome check . --write",
-    "format": "node ./node_modules/prettier/bin/prettier.cjs \"packages/**/src/**/*.{ts,tsx,js}\" \"crates/rspack_plugin_runtime/**/*.{ts,js}\" \"x.mjs\" --check",
-    "test:install": "cross-env ./node_modules/.bin/puppeteer browsers install chrome",
-    "test": "pnpm run test:install && pnpm run build && cross-env NO_COLOR=1 node --expose-gc --max-old-space-size=8192 --experimental-vm-modules ./node_modules/jest-cli/bin/jest --colors",
-    "release": "node ./scripts/release.mjs"
   }
-}
+}

package/dist/patch.d.ts

@@ -1,3 +0,0 @@
-declare function restoreDevServerPatch(): void;
-declare function applyDevServerPatch(): typeof restoreDevServerPatch;
-export { applyDevServerPatch };

package/dist/patch.js

@@ -1,32 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyDevServerPatch = void 0;
-const webpack_dev_server_1 = __importDefault(require("webpack-dev-server"));
-let old;
-function restoreDevServerPatch() {
-    // @ts-expect-error private API
-    webpack_dev_server_1.default.prototype.sendStats = old;
-}
-// Patch webpack-dev-server to prevent it from failing to send stats.
-// See https://github.com/web-infra-dev/rspack/pull/4028 for details.
-function applyDevServerPatch() {
-    if (old)
-        return restoreDevServerPatch;
-    // @ts-expect-error private API
-    old = webpack_dev_server_1.default.prototype.sendStats;
-    // @ts-expect-error private API
-    webpack_dev_server_1.default.prototype.sendStats = function sendStats__rspack_patched(
-    // @ts-expect-error
-    ...args) {
-        const stats = args[1];
-        if (!stats) {
-            return;
-        }
-        return old.apply(this, args);
-    };
-    return restoreDevServerPatch;
-}
-exports.applyDevServerPatch = applyDevServerPatch;