@rsbuild/core 0.2.3 → 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.3");
+  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.3"}`}
+  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/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.3",
+    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/compilerDevMiddleware.d.ts

@@ -2,11 +2,11 @@
 /// <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;
 };
 /**
  * Setup compiler-related logic:
@@ -14,9 +14,9 @@ type Options = {
  * 2. establish webSocket connect
  */
 export declare class CompilerDevMiddleware {
-  middleware?: DevMiddlewareAPI;
+  middleware: DevMiddlewareAPI;
   private devOptions;
-  private devMiddleware?;
+  private devMiddleware;
   private publicPaths;
   private socketServer;
   constructor({

package/dist/server/compilerDevMiddleware.js

@@ -50,12 +50,10 @@ class CompilerDevMiddleware {
     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) {

package/dist/server/devServer.js

@@ -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_getDevMiddlewares.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

@@ -1,4 +1,12 @@
-import type { UpgradeEvent, RequestHandler, RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
+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;

package/dist/server/getDevMiddlewares.js

@@ -32,13 +32,12 @@ __export(getDevMiddlewares_exports, {
 });
 module.exports = __toCommonJS(getDevMiddlewares_exports);
 var import_url = __toESM(require("url"));
-var import_compilerDevMiddleware = require("./compilerDevMiddleware");
 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_compilerDevMiddleware.CompilerDevMiddleware({
-    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/socketServer.d.ts

@@ -3,14 +3,14 @@
 import type { IncomingMessage } from 'http';
 import type { Socket } from 'net';
 import ws from '../../compiled/ws';
-import { type Stats, type RsbuildDevMiddlewareOptions } from '@rsbuild/shared';
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "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.3"
+    "@rsbuild/shared": "0.2.4"
   },
   "devDependencies": {
     "@types/node": "16.x",