@rsbuild/core 0.2.2 → 0.2.4

package/dist/cli/commands.js

@@ -72,8 +72,7 @@ async function init({
     }
     return await createRsbuild({
       cwd: root,
-      rsbuildConfig: config,
-      provider: config.provider
+      rsbuildConfig: config
     });
   } catch (err) {
     if (isRestart) {
@@ -84,7 +83,7 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.2");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.4");
   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/config.d.ts

@@ -1,10 +1,4 @@
-import { type RsbuildConfig as BaseRsbuildConfig } from '@rsbuild/shared';
-export type RsbuildConfig = BaseRsbuildConfig & {
-  /**
-   * @private only for testing
-   */
-  provider?: any;
-};
+import { type RsbuildConfig } from '@rsbuild/shared';
 export type ConfigParams = {
   env: string;
   command: string;

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.2"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.4"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/createRsbuild.d.ts

@@ -1,9 +1,2 @@
-import { type RsbuildInstance, type RsbuildProvider, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { RsbuildConfig } from './types';
-export declare function createRsbuild(options: CreateRsbuildOptions & {
-  provider?: ({
-    rsbuildConfig
-  }: {
-    rsbuildConfig: RsbuildConfig;
-  }) => RsbuildProvider;
-}): Promise<RsbuildInstance>;
+import { type RsbuildInstance, type CreateRsbuildOptions } from '@rsbuild/shared';
+export declare function createRsbuild(options: CreateRsbuildOptions): Promise<RsbuildInstance>;

package/dist/createRsbuild.js

@@ -33,15 +33,13 @@ __export(createRsbuild_exports, {
 module.exports = __toCommonJS(createRsbuild_exports);
 var import_shared = require("@rsbuild/shared");
 var import_plugins = require("./plugins");
-const getRspackProvider = async (rsbuildConfig) => {
+const getRspackProvider = async () => {
   const { rspackProvider } = await Promise.resolve().then(() => __toESM(require("./provider")));
-  return rspackProvider({
-    rsbuildConfig
-  });
+  return rspackProvider;
 };
 async function createRsbuild(options) {
   const { rsbuildConfig = {} } = options;
-  const provider = options.provider ? options.provider({ rsbuildConfig }) : await getRspackProvider(rsbuildConfig);
+  const provider = rsbuildConfig.provider || await getRspackProvider();
   const rsbuildOptions = {
     cwd: process.cwd(),
     rsbuildConfig,
@@ -60,9 +58,9 @@ async function createRsbuild(options) {
     startDevServer,
     applyDefaultPlugins
   } = await provider({
+    plugins: import_plugins.plugins,
     pluginStore,
-    rsbuildOptions,
-    plugins: import_plugins.plugins
+    rsbuildOptions
   });
   (0, import_shared.debug)("add default plugins");
   await applyDefaultPlugins(pluginStore);

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.2",
+    version: "0.2.4",
     rootPath,
     distPath,
     cachePath,

package/dist/provider/plugins/css.js

@@ -96,9 +96,10 @@ async function applyBaseCSSRule({
     rule.type("css");
   }
   if (!isServer && !isWebWorker) {
-    const postcssLoaderOptions = (0, import_shared.getPostcssConfig)({
+    const postcssLoaderOptions = await (0, import_shared.getPostcssLoaderOptions)({
       browserslist,
-      config
+      config,
+      root: context.rootPath
     });
     rule.use(CHAIN_ID.USE.POSTCSS).loader((0, import_shared.getSharedPkgCompiledPath)("postcss-loader")).options(postcssLoaderOptions).end();
   }

package/dist/provider/plugins/swc.js

@@ -33,7 +33,7 @@ __export(swc_exports, {
 });
 module.exports = __toCommonJS(swc_exports);
 var import_shared = require("@rsbuild/shared");
-var path = __toESM(require("path"));
+var import_path = __toESM(require("path"));
 const builtinSwcLoaderName = "builtin:swc-loader";
 async function getDefaultSwcConfig(config, rootPath, target) {
   return {
@@ -106,7 +106,7 @@ const pluginSwc = () => ({
 async function applyCoreJs(swcConfig, chain, polyfillMode) {
   const coreJsPath = require.resolve("core-js/package.json");
   const version = (0, import_shared.getCoreJsVersion)(coreJsPath);
-  const coreJsDir = path.dirname(coreJsPath);
+  const coreJsDir = import_path.default.dirname(coreJsPath);
   swcConfig.env.coreJs = version;
   if (polyfillMode === "usage") {
     swcConfig.env.shippedProposals = true;

package/dist/provider/provider.d.ts

@@ -1,7 +1,2 @@
 import { type RsbuildProvider } from '@rsbuild/shared';
-import type { RsbuildConfig } from '../types';
-export declare function rspackProvider({
-  rsbuildConfig: originalRsbuildConfig
-}: {
-  rsbuildConfig: RsbuildConfig;
-}): RsbuildProvider;
+export declare const rspackProvider: RsbuildProvider;

package/dist/provider/provider.js

@@ -36,90 +36,86 @@ var import_createContext = require("./core/createContext");
 var import_initConfigs = require("./core/initConfigs");
 var import_initPlugins = require("./core/initPlugins");
 var import_shared2 = require("./shared");
-function rspackProvider({
-  rsbuildConfig: originalRsbuildConfig
-}) {
-  const rsbuildConfig = (0, import_shared.pickRsbuildConfig)(originalRsbuildConfig);
-  return async ({ pluginStore, rsbuildOptions, plugins }) => {
-    const context = await (0, import_createContext.createContext)(
-      rsbuildOptions,
-      rsbuildConfig,
-      "rspack"
-    );
-    const pluginAPI = (0, import_initPlugins.getPluginAPI)({ context, pluginStore });
-    context.pluginAPI = pluginAPI;
-    return {
-      bundler: "rspack",
-      pluginAPI,
-      publicContext: (0, import_createContext.createPublicContext)(context),
-      async applyDefaultPlugins() {
-        pluginStore.addPlugins(await (0, import_shared2.applyDefaultPlugins)(plugins));
-      },
-      async createCompiler() {
-        const { createCompiler } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
-        const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
-          context,
-          pluginStore,
-          rsbuildOptions
-        });
-        return createCompiler({
-          context,
-          rspackConfigs
-        });
-      },
-      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 getServerAPIs(
-          { context, pluginStore, rsbuildOptions },
-          createDevMiddleware,
-          options
-        );
-      },
-      async startDevServer(options) {
-        const { startDevServer } = 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 startDevServer(
-          { context, pluginStore, rsbuildOptions },
-          createDevMiddleware,
-          options
-        );
-      },
-      async preview(options) {
-        const { startProdServer } = await Promise.resolve().then(() => __toESM(require("../server/prodServer")));
-        await (0, import_initConfigs.initRsbuildConfig)({ context, pluginStore });
-        return startProdServer(context, context.config, options);
-      },
-      async build(options) {
-        const { build: buildImpl, rspackBuild } = await Promise.resolve().then(() => __toESM(require("./core/build")));
-        return buildImpl(
-          { context, pluginStore, rsbuildOptions },
-          options,
-          rspackBuild
-        );
-      },
-      async initConfigs() {
-        const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
-          context,
-          pluginStore,
-          rsbuildOptions
-        });
-        return rspackConfigs;
-      },
-      async inspectConfig(inspectOptions) {
-        const { inspectConfig } = await Promise.resolve().then(() => __toESM(require("./core/inspectConfig")));
-        return inspectConfig({
-          context,
-          pluginStore,
-          rsbuildOptions,
-          inspectOptions
-        });
-      }
-    };
+const rspackProvider = async ({
+  pluginStore,
+  rsbuildOptions,
+  plugins
+}) => {
+  const rsbuildConfig = (0, import_shared.pickRsbuildConfig)(rsbuildOptions.rsbuildConfig);
+  const context = await (0, import_createContext.createContext)(rsbuildOptions, rsbuildConfig, "rspack");
+  const pluginAPI = (0, import_initPlugins.getPluginAPI)({ context, pluginStore });
+  context.pluginAPI = pluginAPI;
+  return {
+    bundler: "rspack",
+    pluginAPI,
+    publicContext: (0, import_createContext.createPublicContext)(context),
+    async applyDefaultPlugins() {
+      pluginStore.addPlugins(await (0, import_shared2.applyDefaultPlugins)(plugins));
+    },
+    async createCompiler() {
+      const { createCompiler } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+      const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
+        context,
+        pluginStore,
+        rsbuildOptions
+      });
+      return createCompiler({
+        context,
+        rspackConfigs
+      });
+    },
+    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 getServerAPIs(
+        { context, pluginStore, rsbuildOptions },
+        createDevMiddleware,
+        options
+      );
+    },
+    async startDevServer(options) {
+      const { startDevServer } = 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 startDevServer(
+        { context, pluginStore, rsbuildOptions },
+        createDevMiddleware,
+        options
+      );
+    },
+    async preview(options) {
+      const { startProdServer } = await Promise.resolve().then(() => __toESM(require("../server/prodServer")));
+      await (0, import_initConfigs.initRsbuildConfig)({ context, pluginStore });
+      return startProdServer(context, context.config, options);
+    },
+    async build(options) {
+      const { build: buildImpl, rspackBuild } = await Promise.resolve().then(() => __toESM(require("./core/build")));
+      return buildImpl(
+        { context, pluginStore, rsbuildOptions },
+        options,
+        rspackBuild
+      );
+    },
+    async initConfigs() {
+      const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
+        context,
+        pluginStore,
+        rsbuildOptions
+      });
+      return rspackConfigs;
+    },
+    async inspectConfig(inspectOptions) {
+      const { inspectConfig } = await Promise.resolve().then(() => __toESM(require("./core/inspectConfig")));
+      return inspectConfig({
+        context,
+        pluginStore,
+        rsbuildOptions,
+        inspectOptions
+      });
+    }
   };
-}
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   rspackProvider

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

@@ -2,16 +2,21 @@
 /// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type { Socket } from 'net';
-import type { RsbuildDevMiddlewareOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
+import type { DevMiddlewaresConfig, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
 type Options = {
   publicPaths: string[];
-  dev: RsbuildDevMiddlewareOptions['dev'];
-  devMiddleware?: CustomDevMiddleware;
+  dev: DevMiddlewaresConfig;
+  devMiddleware: CustomDevMiddleware;
 };
-export default class DevMiddleware {
-  middleware?: DevMiddlewareAPI;
+/**
+ * Setup compiler-related logic:
+ * 1. setup webpack-dev-middleware
+ * 2. establish webSocket connect
+ */
+export declare class CompilerDevMiddleware {
+  middleware: DevMiddlewareAPI;
   private devOptions;
-  private devMiddleware?;
+  private devMiddleware;
   private publicPaths;
   private socketServer;
   constructor({

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,20 +42,18 @@ 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() {
-    if (this.devMiddleware) {
-      this.middleware = this.setupDevMiddleware(
-        this.devMiddleware,
-        this.publicPaths
-      );
-    }
+    this.middleware = this.setupDevMiddleware(
+      this.devMiddleware,
+      this.publicPaths
+    );
     this.socketServer.prepare();
   }
   upgrade(req, sock, head) {
@@ -89,7 +87,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);
@@ -105,3 +103,7 @@ class DevMiddleware {
     return warp;
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompilerDevMiddleware
+});

package/dist/server/devServer.js

@@ -36,7 +36,7 @@ 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");
+var import_getDevMiddlewares = require("./getDevMiddlewares");
 var import_middlewares = require("./middlewares");
 async function getServerAPIs(options, createDevMiddleware, {
   compiler: customCompiler,
@@ -60,11 +60,6 @@ async function getServerAPIs(options, createDevMiddleware, {
     port,
     https
   };
-  const { devMiddleware, compiler } = await createDevMiddleware(
-    options,
-    customCompiler
-  );
-  const publicPaths = compiler.compilers ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
   return {
     config: { devServerConfig, port, host, https, defaultRoutes },
     beforeStart: async () => {
@@ -76,18 +71,42 @@ async function getServerAPIs(options, createDevMiddleware, {
         routes: params.routes || defaultRoutes
       });
     },
-    getMiddlewares: async (overrides = {}) => await (0, import_devMiddlewares.getMiddlewares)({
-      pwd: options.context.rootPath,
-      devMiddleware,
-      dev: {
-        ...devServerConfig,
-        ...overrides
-      },
-      output: {
-        distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
-        publicPaths
-      }
-    })
+    startCompile: async () => {
+      const { devMiddleware, compiler } = await createDevMiddleware(
+        options,
+        customCompiler
+      );
+      const { CompilerDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./compilerDevMiddleware")));
+      const publicPaths = compiler.compilers ? compiler.compilers.map(
+        import_shared.getPublicPathFromCompiler
+      ) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
+      const compilerDevMiddleware = new CompilerDevMiddleware({
+        dev: devServerConfig,
+        publicPaths,
+        devMiddleware
+      });
+      compilerDevMiddleware.init();
+      return {
+        middleware: compilerDevMiddleware.middleware,
+        sockWrite: (...args) => compilerDevMiddleware.sockWrite(...args),
+        onUpgrade: (...args) => compilerDevMiddleware.upgrade(...args),
+        close: () => compilerDevMiddleware?.close()
+      };
+    },
+    getMiddlewares: async (params = {}) => {
+      const { compileMiddlewareAPI, overrides = {} } = params;
+      return (0, import_getDevMiddlewares.getMiddlewares)({
+        pwd: options.context.rootPath,
+        compileMiddlewareAPI,
+        dev: {
+          ...devServerConfig,
+          ...overrides
+        },
+        output: {
+          distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR
+        }
+      });
+    }
   };
 }
 async function startDevServer(options, createDevMiddleware, {
@@ -125,7 +144,10 @@ async function startDevServer(options, createDevMiddleware, {
     }
     (0, import_shared.printServerURLs)(urls, defaultRoutes, logger);
   }
-  const devMiddlewares = await serverAPIs.getMiddlewares();
+  const compileMiddlewareAPI = await serverAPIs.startCompile();
+  const devMiddlewares = await serverAPIs.getMiddlewares({
+    compileMiddlewareAPI
+  });
   devMiddlewares.middlewares.forEach((m) => middlewares.use(m));
   middlewares.use(import_middlewares.notFoundMiddleware);
   (0, import_shared.debug)("listen dev server");

package/dist/server/getDevMiddlewares.d.ts

@@ -0,0 +1,14 @@
+import type { UpgradeEvent, RequestHandler, DevMiddlewaresConfig, CompileMiddlewareAPI } from '@rsbuild/shared';
+export type RsbuildDevMiddlewareOptions = {
+  pwd: string;
+  dev: DevMiddlewaresConfig;
+  compileMiddlewareAPI?: CompileMiddlewareAPI;
+  output: {
+    distPath: string;
+  };
+};
+export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<{
+  close: () => Promise<void>;
+  onUpgrade: UpgradeEvent;
+  middlewares: RequestHandler[];
+}>;

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

@@ -26,19 +26,18 @@ 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_middlewares = require("./middlewares");
 var import_path = require("path");
-const applySetupMiddlewares = (dev, devMiddleware) => {
+const applySetupMiddlewares = (dev, compileMiddlewareAPI) => {
   const setupMiddlewares = dev.setupMiddlewares || [];
   const serverOptions = {
-    sockWrite: (type, data) => devMiddleware.sockWrite(type, data)
+    sockWrite: (type, data) => compileMiddlewareAPI?.sockWrite(type, data)
   };
   const before = [];
   const after = [];
@@ -56,7 +55,7 @@ const applySetupMiddlewares = (dev, devMiddleware) => {
 const applyDefaultMiddlewares = async ({
   middlewares,
   dev,
-  devMiddleware,
+  compileMiddlewareAPI,
   output,
   pwd
 }) => {
@@ -94,9 +93,12 @@ const applyDefaultMiddlewares = async ({
       middlewares.push(middleware);
     });
   }
-  devMiddleware.init();
-  devMiddleware.middleware && middlewares.push(devMiddleware.middleware);
-  upgradeEvents.push(devMiddleware.upgrade.bind(devMiddleware));
+  if (compileMiddlewareAPI) {
+    middlewares.push(compileMiddlewareAPI.middleware);
+    upgradeEvents.push(
+      compileMiddlewareAPI.onUpgrade.bind(compileMiddlewareAPI)
+    );
+  }
   if (dev.publicDir && dev.publicDir.name) {
     const { default: sirv } = await Promise.resolve().then(() => __toESM(require("../../compiled/sirv")));
     const { name } = dev.publicDir;
@@ -108,10 +110,10 @@ const applyDefaultMiddlewares = async ({
     middlewares.push(assetMiddleware);
   }
   const { distPath } = output;
-  middlewares.push(
+  compileMiddlewareAPI && middlewares.push(
     (0, import_middlewares.getHtmlFallbackMiddleware)({
       distPath: (0, import_path.isAbsolute)(distPath) ? distPath : (0, import_path.join)(pwd, distPath),
-      callback: devMiddleware.middleware,
+      callback: compileMiddlewareAPI.middleware,
       htmlFallback: dev.htmlFallback
     })
   );
@@ -121,7 +123,7 @@ const applyDefaultMiddlewares = async ({
       dev.historyApiFallback === true ? {} : dev.historyApiFallback
     );
     middlewares.push(historyApiFallbackMiddleware);
-    devMiddleware.middleware && middlewares.push(devMiddleware.middleware);
+    compileMiddlewareAPI?.middleware && middlewares.push(compileMiddlewareAPI.middleware);
   }
   middlewares.push(import_middlewares.faviconFallbackMiddleware);
   return {
@@ -132,24 +134,23 @@ const applyDefaultMiddlewares = async ({
 };
 const getMiddlewares = async (options) => {
   const middlewares = [];
-  const devMiddleware = new import_compiler_dev_middleware.default({
-    dev: options.dev,
-    publicPaths: options.output.publicPaths,
-    devMiddleware: options.devMiddleware
-  });
-  const { before, after } = applySetupMiddlewares(options.dev, devMiddleware);
+  const { compileMiddlewareAPI } = options;
+  const { before, after } = applySetupMiddlewares(
+    options.dev,
+    compileMiddlewareAPI
+  );
   before.forEach((fn) => middlewares.push(fn));
   const { onUpgrade } = await applyDefaultMiddlewares({
     middlewares,
     dev: options.dev,
-    devMiddleware,
+    compileMiddlewareAPI,
     output: options.output,
     pwd: options.pwd
   });
   after.forEach((fn) => middlewares.push(fn));
   return {
     close: async () => {
-      devMiddleware.close();
+      compileMiddlewareAPI?.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/{compiler-dev-middleware/socketServer.d.ts → socketServer.d.ts}

@@ -2,15 +2,15 @@
 /// <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 {
+import ws from '../../compiled/ws';
+import { type Stats, type DevMiddlewaresConfig } from '@rsbuild/shared';
+export declare class SocketServer {
   private wsServer;
   private readonly sockets;
   private readonly options;
   private stats?;
   private timer;
-  constructor(options: RsbuildDevMiddlewareOptions['dev']);
+  constructor(options: DevMiddlewaresConfig);
   upgrade(req: IncomingMessage, sock: Socket, head: any): void;
   prepare(): void;
   updateStats(stats: Stats): 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) {
@@ -146,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) {
@@ -160,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.2",
+  "version": "0.2.4",
   "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.2"
+    "@rsbuild/shared": "0.2.4"
   },
   "devDependencies": {
     "@types/node": "16.x",

package/dist/server/devMiddlewares.d.ts

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