@rsbuild/core 0.2.0 → 0.2.2

package/bin/rsbuild.js

@@ -3,10 +3,12 @@ const { prepareCli } = require('../dist/cli/prepare');
 
 async function main() {
   prepareCli();
+
   try {
     const { runCli } = require('../dist/cli/commands');
     runCli();
   } catch (err) {
+    const { logger } = require('@rsbuild/shared/rslog');
     logger.error(err);
   }
 }

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.0");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.2");
   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.0"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.2"}`}
 `);
 }
 // 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/provider/core/createCompiler.js

@@ -102,7 +102,8 @@ async function createCompiler({
     }
     if ((0, import_shared.isDev)()) {
       await context.hooks.onDevCompileDoneHook.call({
-        isFirstCompile
+        isFirstCompile,
+        stats
       });
     }
     isCompiling = false;

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.0",
+    version: "0.2.2",
     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

@@ -1,14 +1,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import type { Server } from 'http';
-import { EventEmitter } from 'events';
+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 extends EventEmitter {
+export default class DevMiddleware {
   middleware?: DevMiddlewareAPI;
   private devOptions;
   private devMiddleware?;
@@ -19,7 +19,8 @@ export default class DevMiddleware extends EventEmitter {
     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

@@ -31,7 +31,6 @@ __export(compiler_dev_middleware_exports, {
   default: () => DevMiddleware
 });
 module.exports = __toCommonJS(compiler_dev_middleware_exports);
-var import_events = require("events");
 var import_socketServer = __toESM(require("./socketServer"));
 const noop = () => {
 };
@@ -43,24 +42,24 @@ function getHMRClientPath(client) {
   const clientEntry = `${require.resolve("@rsbuild/core/client/hmr")}?${host}${path}${port}${protocol}`;
   return clientEntry;
 }
-class DevMiddleware extends import_events.EventEmitter {
+class DevMiddleware {
   constructor({ dev, devMiddleware, publicPaths }) {
-    super();
     this.devOptions = dev;
     this.publicPaths = publicPaths;
     this.socketServer = new import_socketServer.default(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();
@@ -77,7 +76,6 @@ class DevMiddleware extends import_events.EventEmitter {
       },
       onDone: (stats) => {
         this.socketServer.updateStats(stats);
-        this.emit("change", stats);
       }
     };
     const enableHMR = this.devOptions.hmr;

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

@@ -1,16 +1,18 @@
 /// <reference types="node" />
-import type { Server } from 'http';
+/// <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 {
   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

@@ -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);
     });

package/dist/server/devMiddlewares.d.ts

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

package/dist/server/devMiddlewares.js

@@ -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,9 +124,13 @@ 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({
     dev: options.dev,
@@ -134,8 +139,7 @@ const getMiddlewares = async (options, app) => {
   });
   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/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);
@@ -37,7 +37,8 @@ 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_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_devMiddlewares.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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -60,7 +60,7 @@
     "core-js": "~3.32.2",
     "html-webpack-plugin": "npm:html-rspack-plugin@5.5.7",
     "postcss": "8.4.31",
-    "@rsbuild/shared": "0.2.0"
+    "@rsbuild/shared": "0.2.2"
   },
   "devDependencies": {
     "@types/node": "16.x",