@rsbuild/core 0.2.1 → 0.2.3

package/dist/cli/commands.js

@@ -84,7 +84,7 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.1");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.3");
   import_commander.program.command("dev").option("--open", "open the page in browser on startup").option(
     "--port <port>",
     "specify a port number for Rsbuild Server to listen"

package/dist/cli/prepare.js

@@ -34,7 +34,7 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.1"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.3"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/createRsbuild.d.ts

@@ -1,7 +1,6 @@
 import { type RsbuildInstance, type RsbuildProvider, type CreateRsbuildOptions } from '@rsbuild/shared';
 import type { RsbuildConfig } from './types';
 export declare function createRsbuild(options: CreateRsbuildOptions & {
-  rsbuildConfig: RsbuildConfig;
   provider?: ({
     rsbuildConfig
   }: {

package/dist/createRsbuild.js

@@ -40,10 +40,11 @@ const getRspackProvider = async (rsbuildConfig) => {
   });
 };
 async function createRsbuild(options) {
-  const { rsbuildConfig } = options;
+  const { rsbuildConfig = {} } = options;
   const provider = options.provider ? options.provider({ rsbuildConfig }) : await getRspackProvider(rsbuildConfig);
   const rsbuildOptions = {
     cwd: process.cwd(),
+    rsbuildConfig,
     ...options
   };
   const pluginStore = (0, import_shared.createPluginStore)();
@@ -55,7 +56,7 @@ async function createRsbuild(options) {
     initConfigs,
     inspectConfig,
     createCompiler,
-    createDevServer,
+    getServerAPIs,
     startDevServer,
     applyDefaultPlugins
   } = await provider({
@@ -88,7 +89,7 @@ async function createRsbuild(options) {
     createCompiler,
     initConfigs,
     inspectConfig,
-    createDevServer,
+    getServerAPIs,
     startDevServer,
     context: publicContext
   };

package/dist/loadEnv.js

@@ -39,6 +39,7 @@ const getEnvFiles = () => {
   const { NODE_ENV } = process.env;
   return [".env", ".env.local", `.env.${NODE_ENV}`, `.env.${NODE_ENV}.local`];
 };
+let lastParsed;
 async function loadEnv({
   cwd = process.cwd(),
   prefixes = ["PUBLIC_"]
@@ -50,6 +51,13 @@ async function loadEnv({
   envPaths.forEach((envPath) => {
     Object.assign(parsed, parse(import_fs.default.readFileSync(envPath)));
   });
+  if (lastParsed) {
+    Object.keys(lastParsed).forEach((key) => {
+      if (process.env[key] === lastParsed[key]) {
+        delete process.env[key];
+      }
+    });
+  }
   expand({ parsed });
   const publicVars = {};
   Object.keys(process.env).forEach((key) => {
@@ -58,6 +66,7 @@ async function loadEnv({
       publicVars[`process.env.${key}`] = JSON.stringify(val);
     }
   });
+  lastParsed = parsed;
   return {
     parsed,
     publicVars

package/dist/provider/core/createContext.js

@@ -59,7 +59,7 @@ function createContextByConfig(options, bundlerType, config = {}) {
   const context = {
     entry: config.source?.entry || getDefaultEntry(rootPath),
     targets: config.output?.targets || [],
-    version: "0.2.1",
+    version: "0.2.3",
     rootPath,
     distPath,
     cachePath,

package/dist/provider/provider.js

@@ -67,11 +67,11 @@ function rspackProvider({
           rspackConfigs
         });
       },
-      async createDevServer(options) {
-        const { createDevServer } = await Promise.resolve().then(() => __toESM(require("../server/devServer")));
+      async getServerAPIs(options) {
+        const { getServerAPIs } = await Promise.resolve().then(() => __toESM(require("../server/devServer")));
         const { createDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
         await (0, import_initConfigs.initRsbuildConfig)({ context, pluginStore });
-        return createDevServer(
+        return getServerAPIs(
           { context, pluginStore, rsbuildOptions },
           createDevMiddleware,
           options

package/dist/server/{compiler-dev-middleware/index.d.ts → compilerDevMiddleware.d.ts}

@@ -1,12 +1,19 @@
 /// <reference types="node" />
-import type { Server } from 'http';
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import type { Socket } from 'net';
 import type { RsbuildDevMiddlewareOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
 type Options = {
   publicPaths: string[];
   dev: RsbuildDevMiddlewareOptions['dev'];
   devMiddleware?: CustomDevMiddleware;
 };
-export default class DevMiddleware {
+/**
+ * Setup compiler-related logic:
+ * 1. setup webpack-dev-middleware
+ * 2. establish webSocket connect
+ */
+export declare class CompilerDevMiddleware {
   middleware?: DevMiddlewareAPI;
   private devOptions;
   private devMiddleware?;
@@ -17,7 +24,8 @@ export default class DevMiddleware {
     devMiddleware,
     publicPaths
   }: Options);
-  init(app: Server): void;
+  init(): void;
+  upgrade(req: IncomingMessage, sock: Socket, head: any): void;
   close(): void;
   sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
   private setupDevMiddleware;

package/dist/server/{compiler-dev-middleware/index.js → compilerDevMiddleware.js}

@@ -26,12 +26,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var compiler_dev_middleware_exports = {};
-__export(compiler_dev_middleware_exports, {
-  default: () => DevMiddleware
+var compilerDevMiddleware_exports = {};
+__export(compilerDevMiddleware_exports, {
+  CompilerDevMiddleware: () => CompilerDevMiddleware
 });
-module.exports = __toCommonJS(compiler_dev_middleware_exports);
-var import_socketServer = __toESM(require("./socketServer"));
+module.exports = __toCommonJS(compilerDevMiddleware_exports);
+var import_socketServer = require("./socketServer");
 const noop = () => {
 };
 function getHMRClientPath(client) {
@@ -42,23 +42,24 @@ function getHMRClientPath(client) {
   const clientEntry = `${require.resolve("@rsbuild/core/client/hmr")}?${host}${path}${port}${protocol}`;
   return clientEntry;
 }
-class DevMiddleware {
+class CompilerDevMiddleware {
   constructor({ dev, devMiddleware, publicPaths }) {
     this.devOptions = dev;
     this.publicPaths = publicPaths;
-    this.socketServer = new import_socketServer.default(dev);
+    this.socketServer = new import_socketServer.SocketServer(dev);
     this.devMiddleware = devMiddleware;
   }
-  init(app) {
+  init() {
     if (this.devMiddleware) {
       this.middleware = this.setupDevMiddleware(
         this.devMiddleware,
         this.publicPaths
       );
     }
-    app.on("listening", () => {
-      this.socketServer.prepare(app);
-    });
+    this.socketServer.prepare();
+  }
+  upgrade(req, sock, head) {
+    this.socketServer.upgrade(req, sock, head);
   }
   close() {
     this.socketServer.close();
@@ -88,7 +89,7 @@ class DevMiddleware {
       writeToDisk: devOptions.writeToDisk
     });
     const warp = async (req, res, next) => {
-      const url = req.url;
+      const { url } = req;
       const assetPrefix = url && publicPaths.find((prefix) => url.startsWith(prefix));
       if (assetPrefix && assetPrefix !== "/") {
         req.url = url.slice(assetPrefix.length - 1);
@@ -104,3 +105,7 @@ class DevMiddleware {
     return warp;
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompilerDevMiddleware
+});

package/dist/server/devServer.d.ts

@@ -1,13 +1,13 @@
-import { CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult, DevServerAPI } from '@rsbuild/shared';
+import { CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult, DevServerAPIs } from '@rsbuild/shared';
 import type { Context } from '../types';
-export declare function createDevServer<Options extends {
+export declare function getServerAPIs<Options extends {
   context: Context;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {
   compiler: customCompiler,
   getPortSilently
 }?: StartDevServerOptions & {
   defaultPort?: number;
-}): Promise<DevServerAPI>;
+}): Promise<DevServerAPIs>;
 export declare function startDevServer<Options extends {
   context: Context;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {

package/dist/server/devServer.js

@@ -28,7 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var devServer_exports = {};
 __export(devServer_exports, {
-  createDevServer: () => createDevServer,
+  getServerAPIs: () => getServerAPIs,
   startDevServer: () => startDevServer
 });
 module.exports = __toCommonJS(devServer_exports);
@@ -36,8 +36,9 @@ var import_shared = require("@rsbuild/shared");
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
 var import_restart = require("./restart");
 var import_httpServer = require("./httpServer");
-var import_devMiddlewares = require("./devMiddlewares");
-async function createDevServer(options, createDevMiddleware, {
+var import_getDevMiddlewares = require("./getDevMiddlewares");
+var import_middlewares = require("./middlewares");
+async function getServerAPIs(options, createDevMiddleware, {
   compiler: customCompiler,
   getPortSilently
 } = {}) {
@@ -65,31 +66,28 @@ async function createDevServer(options, createDevMiddleware, {
   );
   const publicPaths = compiler.compilers ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
   return {
-    resolvedConfig: { devServerConfig, port, host, https, defaultRoutes },
+    config: { devServerConfig, port, host, https, defaultRoutes },
     beforeStart: async () => {
       await options.context.hooks.onBeforeStartDevServerHook.call();
     },
-    afterStart: async ({ port: port2, routes }) => {
+    afterStart: async (params = {}) => {
       await options.context.hooks.onAfterStartDevServerHook.call({
-        port: port2,
-        routes
+        port: params.port || port,
+        routes: params.routes || defaultRoutes
       });
     },
-    getMiddlewares: async ({
-      dev,
-      app
-    }) => await (0, import_devMiddlewares.getMiddlewares)(
-      {
-        pwd: options.context.rootPath,
-        devMiddleware,
-        dev,
-        output: {
-          distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
-          publicPaths
-        }
+    getMiddlewares: async (overrides = {}) => await (0, import_getDevMiddlewares.getMiddlewares)({
+      pwd: options.context.rootPath,
+      devMiddleware,
+      dev: {
+        ...devServerConfig,
+        ...overrides
       },
-      app
-    )
+      output: {
+        distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
+        publicPaths
+      }
+    })
   };
 }
 async function startDevServer(options, createDevMiddleware, {
@@ -99,15 +97,15 @@ async function startDevServer(options, createDevMiddleware, {
   getPortSilently
 } = {}) {
   (0, import_shared.debug)("create dev server");
-  const rsbuildServer = await createDevServer(options, createDevMiddleware, {
+  const serverAPIs = await getServerAPIs(options, createDevMiddleware, {
     compiler,
     printURLs,
     logger: customLogger,
     getPortSilently
   });
   const {
-    resolvedConfig: { devServerConfig, port, host, https, defaultRoutes }
-  } = rsbuildServer;
+    config: { devServerConfig, port, host, https, defaultRoutes }
+  } = serverAPIs;
   const logger = customLogger ?? import_shared.logger;
   const middlewares = (0, import_connect.default)();
   const httpServer = await (0, import_httpServer.createHttpServer)({
@@ -115,7 +113,7 @@ async function startDevServer(options, createDevMiddleware, {
     middlewares
   });
   (0, import_shared.debug)("create dev server done");
-  await rsbuildServer.beforeStart();
+  await serverAPIs.beforeStart();
   const protocol = https ? "https" : "http";
   let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
   if (printURLs) {
@@ -127,12 +125,11 @@ async function startDevServer(options, createDevMiddleware, {
     }
     (0, import_shared.printServerURLs)(urls, defaultRoutes, logger);
   }
-  const devMiddlewares = await rsbuildServer.getMiddlewares({
-    dev: devServerConfig,
-    app: httpServer
-  });
+  const devMiddlewares = await serverAPIs.getMiddlewares();
   devMiddlewares.middlewares.forEach((m) => middlewares.use(m));
+  middlewares.use(import_middlewares.notFoundMiddleware);
   (0, import_shared.debug)("listen dev server");
+  httpServer.on("upgrade", devMiddlewares.onUpgrade);
   return new Promise((resolve) => {
     httpServer.listen(
       {
@@ -144,10 +141,7 @@ async function startDevServer(options, createDevMiddleware, {
           throw err;
         }
         (0, import_shared.debug)("listen dev server done");
-        await rsbuildServer.afterStart({
-          port,
-          routes: defaultRoutes
-        });
+        await serverAPIs.afterStart();
         const onClose = async () => {
           await devMiddlewares.close();
           httpServer.close();
@@ -168,6 +162,6 @@ async function startDevServer(options, createDevMiddleware, {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDevServer,
+  getServerAPIs,
   startDevServer
 });

package/dist/server/getDevMiddlewares.d.ts

@@ -0,0 +1,6 @@
+import type { UpgradeEvent, RequestHandler, RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
+export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<{
+  close: () => Promise<void>;
+  onUpgrade: UpgradeEvent;
+  middlewares: RequestHandler[];
+}>;

package/dist/server/{devMiddlewares.js → getDevMiddlewares.js}

@@ -26,13 +26,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var devMiddlewares_exports = {};
-__export(devMiddlewares_exports, {
+var getDevMiddlewares_exports = {};
+__export(getDevMiddlewares_exports, {
   getMiddlewares: () => getMiddlewares
 });
-module.exports = __toCommonJS(devMiddlewares_exports);
+module.exports = __toCommonJS(getDevMiddlewares_exports);
 var import_url = __toESM(require("url"));
-var import_compiler_dev_middleware = __toESM(require("./compiler-dev-middleware"));
+var import_compilerDevMiddleware = require("./compilerDevMiddleware");
 var import_middlewares = require("./middlewares");
 var import_path = require("path");
 const applySetupMiddlewares = (dev, devMiddleware) => {
@@ -54,13 +54,13 @@ const applySetupMiddlewares = (dev, devMiddleware) => {
   return { before, after };
 };
 const applyDefaultMiddlewares = async ({
-  app,
   middlewares,
   dev,
   devMiddleware,
   output,
   pwd
 }) => {
+  const upgradeEvents = [];
   if (dev.compress) {
     const { default: compression } = await Promise.resolve().then(() => __toESM(require("../../compiled/http-compression")));
     middlewares.push((req, res, next) => {
@@ -86,16 +86,17 @@ const applyDefaultMiddlewares = async ({
   });
   if (dev.proxy) {
     const { createProxyMiddleware } = await Promise.resolve().then(() => __toESM(require("./proxy")));
-    const { middlewares: proxyMiddlewares } = createProxyMiddleware(
-      dev.proxy,
-      app
+    const { middlewares: proxyMiddlewares, upgrade } = createProxyMiddleware(
+      dev.proxy
     );
+    upgradeEvents.push(upgrade);
     proxyMiddlewares.forEach((middleware) => {
       middlewares.push(middleware);
     });
   }
-  devMiddleware.init(app);
+  devMiddleware.init();
   devMiddleware.middleware && middlewares.push(devMiddleware.middleware);
+  upgradeEvents.push(devMiddleware.upgrade.bind(devMiddleware));
   if (dev.publicDir && dev.publicDir.name) {
     const { default: sirv } = await Promise.resolve().then(() => __toESM(require("../../compiled/sirv")));
     const { name } = dev.publicDir;
@@ -123,19 +124,22 @@ const applyDefaultMiddlewares = async ({
     devMiddleware.middleware && middlewares.push(devMiddleware.middleware);
   }
   middlewares.push(import_middlewares.faviconFallbackMiddleware);
-  middlewares.push(import_middlewares.notFoundMiddleware);
+  return {
+    onUpgrade: (...args) => {
+      upgradeEvents.forEach((cb) => cb(...args));
+    }
+  };
 };
-const getMiddlewares = async (options, app) => {
+const getMiddlewares = async (options) => {
   const middlewares = [];
-  const devMiddleware = new import_compiler_dev_middleware.default({
+  const devMiddleware = new import_compilerDevMiddleware.CompilerDevMiddleware({
     dev: options.dev,
     publicPaths: options.output.publicPaths,
     devMiddleware: options.devMiddleware
   });
   const { before, after } = applySetupMiddlewares(options.dev, devMiddleware);
   before.forEach((fn) => middlewares.push(fn));
-  await applyDefaultMiddlewares({
-    app,
+  const { onUpgrade } = await applyDefaultMiddlewares({
     middlewares,
     dev: options.dev,
     devMiddleware,
@@ -147,6 +151,7 @@ const getMiddlewares = async (options, app) => {
     close: async () => {
       devMiddleware.close();
     },
+    onUpgrade,
     middlewares
   };
 };

package/dist/server/httpServer.js

@@ -32,15 +32,12 @@ __export(httpServer_exports, {
 });
 module.exports = __toCommonJS(httpServer_exports);
 const createHttpServer = async (options) => {
-  let app;
   if (options.https) {
-    const { createServer } = await Promise.resolve().then(() => __toESM(require("https")));
-    app = createServer(options.https, options.middlewares);
-  } else {
-    const { createServer } = await Promise.resolve().then(() => __toESM(require("http")));
-    app = createServer(options.middlewares);
+    const { createServer: createServer2 } = await Promise.resolve().then(() => __toESM(require("https")));
+    return createServer2(options.https, options.middlewares);
   }
-  return app;
+  const { createServer } = await Promise.resolve().then(() => __toESM(require("http")));
+  return createServer(options.middlewares);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/index.d.ts

@@ -1,2 +1,2 @@
-export { startDevServer, createDevServer } from './devServer';
+export { startDevServer, getServerAPIs } from './devServer';
 export { startProdServer } from './prodServer';

package/dist/server/index.js

@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
-  createDevServer: () => import_devServer.createDevServer,
+  getServerAPIs: () => import_devServer.getServerAPIs,
   startDevServer: () => import_devServer.startDevServer,
   startProdServer: () => import_prodServer.startProdServer
 });
@@ -27,7 +27,7 @@ var import_devServer = require("./devServer");
 var import_prodServer = require("./prodServer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDevServer,
+  getServerAPIs,
   startDevServer,
   startProdServer
 });

package/dist/server/prodServer.js

@@ -69,10 +69,11 @@ class RsbuildProdServer {
     }
     if (proxy) {
       const { createProxyMiddleware } = await Promise.resolve().then(() => __toESM(require("./proxy")));
-      const { middlewares } = createProxyMiddleware(proxy, this.app);
+      const { middlewares, upgrade } = createProxyMiddleware(proxy);
       middlewares.forEach((middleware) => {
         this.middlewares.use(middleware);
       });
+      this.app.on("upgrade", upgrade);
     }
     this.applyStaticAssetMiddleware();
     if (historyApiFallback) {

package/dist/server/proxy.d.ts

@@ -1,9 +1,6 @@
-/// <reference types="node" />
-import http from 'http';
-import { RequestHandler } from '@rsbuild/shared/http-proxy-middleware';
-import { type ProxyDetail, type RequestHandler as Middleware, type ProxyOptions } from '@rsbuild/shared';
+import { type ProxyDetail, type RequestHandler as Middleware, type ProxyOptions, type UpgradeEvent } from '@rsbuild/shared';
 export declare function formatProxyOptions(proxyOptions: ProxyOptions): ProxyDetail[];
-export type HttpUpgradeHandler = NonNullable<RequestHandler['upgrade']>;
-export declare const createProxyMiddleware: (proxyOptions: ProxyOptions, app: http.Server) => {
+export declare const createProxyMiddleware: (proxyOptions: ProxyOptions) => {
   middlewares: Middleware[];
+  upgrade: UpgradeEvent;
 };

package/dist/server/proxy.js

@@ -51,7 +51,7 @@ function formatProxyOptions(proxyOptions) {
   }
   return ret;
 }
-const createProxyMiddleware = (proxyOptions, app) => {
+const createProxyMiddleware = (proxyOptions) => {
   const formattedOptionsList = formatProxyOptions(proxyOptions);
   const proxyMiddlewares = [];
   const middlewares = [];
@@ -79,8 +79,10 @@ const createProxyMiddleware = (proxyOptions, app) => {
       }
     }
   };
-  app.on("upgrade", handleUpgrade);
-  return { middlewares };
+  return {
+    middlewares,
+    upgrade: handleUpgrade
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/{compiler-dev-middleware/socketServer.d.ts → socketServer.d.ts}

@@ -1,16 +1,18 @@
 /// <reference types="node" />
-import type { Server } from 'http';
-import ws from '../../../compiled/ws';
+/// <reference types="node" />
+import type { IncomingMessage } from 'http';
+import type { Socket } from 'net';
+import ws from '../../compiled/ws';
 import { type Stats, type RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
-export default class SocketServer {
+export declare class SocketServer {
   private wsServer;
   private readonly sockets;
   private readonly options;
-  private app?;
   private stats?;
   private timer;
   constructor(options: RsbuildDevMiddlewareOptions['dev']);
-  prepare(app: Server): void;
+  upgrade(req: IncomingMessage, sock: Socket, head: any): void;
+  prepare(): void;
   updateStats(stats: Stats): void;
   sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
   singleWrite(socket: ws, type: string, data?: Record<string, any> | string | boolean): void;

package/dist/server/{compiler-dev-middleware/socketServer.js → socketServer.js}

@@ -28,10 +28,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var socketServer_exports = {};
 __export(socketServer_exports, {
-  default: () => SocketServer
+  SocketServer: () => SocketServer
 });
 module.exports = __toCommonJS(socketServer_exports);
-var import_ws = __toESM(require("../../../compiled/ws"));
+var import_ws = __toESM(require("../../compiled/ws"));
 var import_shared = require("@rsbuild/shared");
 class SocketServer {
   constructor(options) {
@@ -39,21 +39,20 @@ class SocketServer {
     this.timer = null;
     this.options = options;
   }
+  upgrade(req, sock, head) {
+    if (!this.wsServer.shouldHandle(req)) {
+      return;
+    }
+    this.wsServer.handleUpgrade(req, sock, head, (connection) => {
+      this.wsServer.emit("connection", connection, req);
+    });
+  }
   // create socket, install socket handler, bind socket event
-  prepare(app) {
-    this.app = app;
+  prepare() {
     this.wsServer = new import_ws.default.Server({
       noServer: true,
       path: this.options.client?.path
     });
-    this.app.on("upgrade", (req, sock, head) => {
-      if (!this.wsServer.shouldHandle(req)) {
-        return;
-      }
-      this.wsServer.handleUpgrade(req, sock, head, (connection) => {
-        this.wsServer.emit("connection", connection, req);
-      });
-    });
     this.wsServer.on("error", (err) => {
       import_shared.logger.error(err);
     });
@@ -147,11 +146,11 @@ class SocketServer {
     this.sockWrite("hash", stats.hash);
     if (stats.errors && stats.errors.length > 0) {
       return this.sockWrite("errors", stats.errors);
-    } else if (stats.warnings && stats.warnings.length > 0) {
+    }
+    if (stats.warnings && stats.warnings.length > 0) {
       return this.sockWrite("warnings", stats.warnings);
-    } else {
-      return this.sockWrite("ok");
     }
+    return this.sockWrite("ok");
   }
   // send message to connecting socket
   send(connection, message) {
@@ -161,3 +160,7 @@ class SocketServer {
     connection.send(message);
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SocketServer
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -56,11 +56,11 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "0.4.2",
+    "@rspack/core": "0.4.3",
     "core-js": "~3.32.2",
     "html-webpack-plugin": "npm:html-rspack-plugin@5.5.7",
     "postcss": "8.4.31",
-    "@rsbuild/shared": "0.2.1"
+    "@rsbuild/shared": "0.2.3"
   },
   "devDependencies": {
     "@types/node": "16.x",

package/dist/server/devMiddlewares.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-import { Server } from 'http';
-import { RequestHandler, RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
-export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions, app: Server) => Promise<{
-  close: () => Promise<void>;
-  middlewares: RequestHandler[];
-}>;