@rsbuild/core 0.0.18 → 0.0.20

package/bin/rsbuild.js

@@ -1,7 +1,18 @@
 #!/usr/bin/env node
 const { logger } = require('rslog');
 
+function initNodeEnv() {
+  if (!process.env.NODE_ENV) {
+    const command = process.argv[2];
+    process.env.NODE_ENV = ['build', 'preview'].includes(command)
+      ? 'production'
+      : 'development';
+  }
+}
+
 async function main() {
+  initNodeEnv();
+
   const { version } = require('../package.json');
 
   // If not called through a package manager,

package/dist/plugins/asset.d.ts

@@ -1,3 +1,3 @@
 import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
 export declare function getRegExpForExts(exts: string[]): RegExp;
-export declare const pluginAsset: (assetType: 'image' | 'media' | 'font' | 'svg', exts: string[]) => DefaultRsbuildPlugin;
+export declare const pluginAsset: () => DefaultRsbuildPlugin;

package/dist/plugins/asset.js

@@ -41,22 +41,28 @@ function getRegExpForExts(exts) {
     "i"
   );
 }
-const pluginAsset = (assetType, exts) => ({
-  name: `plugin-${assetType}`,
+const pluginAsset = () => ({
+  name: "plugin-asset",
   setup(api) {
     api.modifyBundlerChain((chain, { isProd }) => {
       const config = api.getNormalizedConfig();
-      const regExp = getRegExpForExts(exts);
-      const distDir = (0, import_shared.getDistPath)(config.output, assetType);
-      const filename = (0, import_shared.getFilename)(config.output, assetType, isProd);
-      const maxSize = config.output.dataUriLimit[assetType];
-      const rule = chain.module.rule(assetType).test(regExp);
-      (0, import_shared.chainStaticAssetRule)({
-        rule,
-        maxSize,
-        filename: import_path.default.posix.join(distDir, filename),
-        assetType
-      });
+      const createAssetRule = (assetType, exts) => {
+        const regExp = getRegExpForExts(exts);
+        const distDir = (0, import_shared.getDistPath)(config.output, assetType);
+        const filename = (0, import_shared.getFilename)(config.output, assetType, isProd);
+        const maxSize = config.output.dataUriLimit[assetType];
+        const rule = chain.module.rule(assetType).test(regExp);
+        (0, import_shared.chainStaticAssetRule)({
+          rule,
+          maxSize,
+          filename: import_path.default.posix.join(distDir, filename),
+          assetType
+        });
+      };
+      createAssetRule("image", import_shared.IMAGE_EXTENSIONS);
+      createAssetRule("svg", ["svg"]);
+      createAssetRule("media", import_shared.MEDIA_EXTENSIONS);
+      createAssetRule("font", import_shared.FONT_EXTENSIONS);
     });
   }
 });

package/dist/plugins/index.d.ts

@@ -1,2 +1,2 @@
-import { Plugins } from '@rsbuild/shared';
+import type { Plugins } from '@rsbuild/shared';
 export declare const plugins: Plugins;

package/dist/plugins/index.js

@@ -31,7 +31,6 @@ __export(plugins_exports, {
   plugins: () => plugins
 });
 module.exports = __toCommonJS(plugins_exports);
-var import_shared = require("@rsbuild/shared");
 const plugins = {
   html: () => Promise.resolve().then(() => __toESM(require("./html"))).then((m) => m.pluginHtml()),
   cleanOutput: () => Promise.resolve().then(() => __toESM(require("./cleanOutput"))).then((m) => m.pluginCleanOutput()),
@@ -46,10 +45,7 @@ const plugins = {
   splitChunks: () => Promise.resolve().then(() => __toESM(require("./splitChunks"))).then((m) => m.pluginSplitChunks()),
   inlineChunk: () => Promise.resolve().then(() => __toESM(require("./inlineChunk"))).then((m) => m.pluginInlineChunk()),
   bundleAnalyzer: () => Promise.resolve().then(() => __toESM(require("./bundleAnalyzer"))).then((m) => m.pluginBundleAnalyzer()),
-  svg: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("svg", ["svg"])),
-  font: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("font", import_shared.FONT_EXTENSIONS)),
-  image: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("image", import_shared.IMAGE_EXTENSIONS)),
-  media: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("media", import_shared.MEDIA_EXTENSIONS)),
+  asset: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset()),
   rem: () => Promise.resolve().then(() => __toESM(require("./rem"))).then((m) => m.pluginRem()),
   wasm: () => Promise.resolve().then(() => __toESM(require("./wasm"))).then((m) => m.pluginWasm()),
   moment: () => Promise.resolve().then(() => __toESM(require("./moment"))).then((m) => m.pluginMoment()),

package/dist/plugins/inlineChunk.js

@@ -43,7 +43,6 @@ const pluginInlineChunk = () => ({
         }
         const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
         const {
-          disableInlineRuntimeChunk,
           enableInlineStyles,
           // todo: not support enableInlineScripts in Rspack yet, which will take unknown build error
           enableInlineScripts
@@ -60,12 +59,8 @@ const pluginInlineChunk = () => ({
             enableInlineStyles === true ? import_shared.CSS_REGEX : enableInlineStyles
           );
         }
-        if (!disableInlineRuntimeChunk) {
-          scriptTests.push(
-            // RegExp like /bundler-runtime([.].+)?\.js$/
-            // matches bundler-runtime.js and bundler-runtime.123456.js
-            new RegExp(`${import_shared.RUNTIME_CHUNK_NAME}([.].+)?\\.js$`)
-          );
+        if (!scriptTests.length && !styleTests.length) {
+          return;
         }
         chain.plugin(CHAIN_ID.PLUGIN.INLINE_HTML).use(InlineChunkHtmlPlugin, [
           HtmlPlugin,

package/dist/plugins/splitChunks.js

@@ -226,11 +226,6 @@ function pluginSplitChunks() {
             polyfill: config.output.polyfill
           });
           chain.optimization.splitChunks(splitChunksOptions);
-          if (chunkSplit.strategy !== "all-in-one") {
-            chain.optimization.runtimeChunk({
-              name: import_shared.RUNTIME_CHUNK_NAME
-            });
-          }
         }
       );
     }

package/dist/plugins/startUrl.js

@@ -106,8 +106,12 @@ function pluginStartUrl() {
         }
         const urls = [];
         if (startUrl === true || !startUrl) {
+          const { entry } = api.context;
+          const routes = (0, import_shared.formatRoutes)(entry);
           const protocol = https ? "https" : "http";
-          urls.push(`${protocol}://localhost:${port}`);
+          urls.push(
+            (0, import_shared.normalizeUrl)(`${protocol}://localhost:${port}/${routes[0].route}`)
+          );
         } else {
           urls.push(
             ...(0, import_shared.castArray)(startUrl).map(

package/dist/rspack-provider/core/createCompiler.d.ts

@@ -1,4 +1,6 @@
 import { type RspackConfig } from '@rsbuild/shared';
+import { type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import { type InitConfigsOptions } from './initConfigs';
 import type { Context } from '../types';
 export declare function createCompiler({
   context,
@@ -6,4 +8,5 @@ export declare function createCompiler({
 }: {
   context: Context;
   rspackConfigs: RspackConfig[];
-}): Promise<import("@rspack/core").MultiCompiler>;
+}): Promise<import("@rspack/core").MultiCompiler>;
+export declare function startDevCompile(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").DevMiddleware>;

package/dist/rspack-provider/core/createCompiler.js

@@ -28,10 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var createCompiler_exports = {};
 __export(createCompiler_exports, {
-  createCompiler: () => createCompiler
+  createCompiler: () => createCompiler,
+  startDevCompile: () => startDevCompile
 });
 module.exports = __toCommonJS(createCompiler_exports);
 var import_shared = require("@rsbuild/shared");
+var import_devMiddleware = require("./devMiddleware");
+var import_initConfigs = require("./initConfigs");
 async function createCompiler({
   context,
   rspackConfigs
@@ -79,7 +82,21 @@ async function createCompiler({
   (0, import_shared.debug)("create compiler done");
   return compiler;
 }
+async function startDevCompile(options, customCompiler) {
+  let compiler;
+  if (customCompiler) {
+    compiler = customCompiler;
+  } else {
+    const { rspackConfigs } = await (0, import_initConfigs.initConfigs)(options);
+    compiler = await createCompiler({
+      context: options.context,
+      rspackConfigs
+    });
+  }
+  return (0, import_devMiddleware.getDevMiddleware)(compiler);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createCompiler
+  createCompiler,
+  startDevCompile
 });

package/dist/rspack-provider/core/initHooks.d.ts

@@ -1,5 +1,5 @@
-import { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn, ModifyBundlerChainFn, type RspackConfig } from '@rsbuild/shared';
-import type { RsbuildConfig, ModifyRspackConfigFn } from '../types';
+import { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn, ModifyBundlerChainFn, type RspackConfig, type ModifyRspackConfigFn } from '@rsbuild/shared';
+import type { RsbuildConfig } from '../types';
 export declare function initHooks(): {
   /** parameters are not bundler-related */
   onExitHook: import("@rsbuild/shared").AsyncHook<OnExitFn>;

package/dist/rspack-provider/core/initPlugins.js

@@ -73,7 +73,11 @@ function getPluginAPI({
     onAfterCreateCompiler: hooks.onAfterCreateCompilerHook.tap,
     onBeforeCreateCompiler: hooks.onBeforeCreateCompilerHook.tap,
     onAfterStartDevServer: hooks.onAfterStartDevServerHook.tap,
-    onBeforeStartDevServer: hooks.onBeforeStartDevServerHook.tap
+    onBeforeStartDevServer: hooks.onBeforeStartDevServerHook.tap,
+    modifyWebpackChain: () => {
+    },
+    modifyWebpackConfig: () => {
+    }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/rspack-provider/index.d.ts

@@ -1,5 +1,5 @@
 export { getRspackVersion } from './shared/rspackVersion';
 export { rspackProvider } from './provider';
 export type { RspackProvider } from './provider';
-export type { RsbuildConfig, NormalizedConfig, ModifyRspackConfigFn, RsbuildPluginAPI } from './types';
+export type { RsbuildConfig, NormalizedConfig, RsbuildPluginAPI } from './types';
 export type { Rspack, RspackConfig } from '@rsbuild/shared';

package/dist/rspack-provider/provider.js

@@ -73,10 +73,10 @@ function rspackProvider({
         });
       },
       async startDevServer(options) {
-        const { createDevServer } = await Promise.resolve().then(() => __toESM(require("./core/startDevServer")));
-        return (0, import_shared.startDevServer)(
+        const { startDevCompile } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+        return (0, import_server.startDevServer)(
           { context, pluginStore, rsbuildOptions },
-          createDevServer,
+          startDevCompile,
           options
         );
       },

package/dist/rspack-provider/shared/plugin.js

@@ -44,10 +44,7 @@ const applyDefaultPlugins = (plugins) => (0, import_shared.awaitableGetter)([
   plugins.fileSize(),
   // cleanOutput plugin should before the html plugin
   plugins.cleanOutput(),
-  plugins.font(),
-  plugins.image(),
-  plugins.media(),
-  plugins.svg(),
+  plugins.asset(),
   plugins.html(),
   plugins.wasm(),
   plugins.moment(),

package/dist/rspack-provider/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './hooks';
 export * from './plugin';
 export * from './context';
 export type { RsbuildConfig, NormalizedConfig, DevConfig, HtmlConfig, ToolsConfig, SourceConfig, OutputConfig, SecurityConfig, PerformanceConfig, NormalizedDevConfig, NormalizedHtmlConfig, NormalizedToolsConfig, NormalizedSourceConfig, NormalizedOutputConfig, NormalizedSecurityConfig, NormalizedPerformanceConfig } from '@rsbuild/shared';

package/dist/rspack-provider/types/index.js

@@ -15,12 +15,10 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
 module.exports = __toCommonJS(types_exports);
-__reExport(types_exports, require("./hooks"), module.exports);
 __reExport(types_exports, require("./plugin"), module.exports);
 __reExport(types_exports, require("./context"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./hooks"),
   ...require("./plugin"),
   ...require("./context")
 });

package/dist/rspack-provider/types/plugin.d.ts

@@ -1,7 +1,4 @@
 import type { RsbuildConfig, NormalizedConfig, DefaultRsbuildPluginAPI, RsbuildPlugin as BaseRsbuildPlugin } from '@rsbuild/shared';
-import type { ModifyRspackConfigFn } from './hooks';
 import type { RspackConfig, RspackCompiler, RspackMultiCompiler } from '@rsbuild/shared';
-export interface RsbuildPluginAPI extends DefaultRsbuildPluginAPI<RsbuildConfig, NormalizedConfig, RspackConfig, RspackCompiler | RspackMultiCompiler> {
-  modifyRspackConfig: (fn: ModifyRspackConfigFn) => void;
-}
+export interface RsbuildPluginAPI extends DefaultRsbuildPluginAPI<RsbuildConfig, NormalizedConfig, RspackConfig, RspackCompiler | RspackMultiCompiler> {}
 export type RsbuildPlugin = BaseRsbuildPlugin<RsbuildPluginAPI>;

package/dist/server/dev-middleware/hmr-client/createSocketUrl.d.ts

@@ -1,7 +1,7 @@
 /**
  * hmr socket connect path
  */
-export declare const HMR_SOCK_PATH = "/webpack-hmr";
+export declare const HMR_SOCK_PATH = "/rsbuild-hmr";
 export declare function createSocketUrl(resourceQuery: string): string;
 export declare function formatURL({
   port,

package/dist/server/dev-middleware/hmr-client/createSocketUrl.js

@@ -23,7 +23,7 @@ __export(createSocketUrl_exports, {
   formatURL: () => formatURL
 });
 module.exports = __toCommonJS(createSocketUrl_exports);
-const HMR_SOCK_PATH = "/webpack-hmr";
+const HMR_SOCK_PATH = "/rsbuild-hmr";
 function createSocketUrl(resourceQuery) {
   const searchParams = resourceQuery.substr(1).split("&");
   const options = {};

package/dist/server/dev-middleware/index.d.ts

@@ -2,9 +2,9 @@
 /// <reference types="node" />
 import { Server } from 'http';
 import { EventEmitter } from 'events';
-import type { DevServerOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
+import type { DevConfig, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
 type Options = {
-  dev: DevServerOptions;
+  dev: DevConfig;
   devMiddleware?: CustomDevMiddleware;
 };
 export default class DevMiddleware extends EventEmitter {

package/dist/server/dev-middleware/index.js

@@ -76,7 +76,7 @@ class DevMiddleware extends import_events.EventEmitter {
         this.emit("change", stats);
       }
     };
-    const enableHMR = this.devOptions.hot || this.devOptions.liveReload;
+    const enableHMR = this.devOptions.hmr;
     const middleware = devMiddleware({
       headers: devOptions.headers,
       stats: false,

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Server } from 'http';
 import ws from 'ws';
-import { Stats, DevServerOptions } from '@rsbuild/shared';
+import { Stats, DevConfig } from '@rsbuild/shared';
 export default class SocketServer {
   private wsServer;
   private readonly sockets;
@@ -9,7 +9,7 @@ export default class SocketServer {
   private app?;
   private stats?;
   private timer;
-  constructor(options: DevServerOptions);
+  constructor(options: DevConfig);
   prepare(app: Server): void;
   updateStats(stats: Stats): void;
   sockWrite(type: string, data?: Record<string, any> | string | boolean): void;

package/dist/server/dev-middleware/socketServer.js

@@ -112,12 +112,9 @@ class SocketServer {
         this.sockets.splice(idx, 1);
       }
     });
-    if (this.options.hot || this.options.hot === "only") {
+    if (this.options.hmr) {
       this.singleWrite(connection, "hot");
     }
-    if (this.options.liveReload) {
-      this.singleWrite(connection, "liveReload");
-    }
     if (this.stats) {
       this.sendStats(true);
     }

package/dist/server/devServer.d.ts

@@ -3,21 +3,32 @@
 /// <reference types="node" />
 import { Server } from 'http';
 import type { ListenOptions } from 'net';
-import { RsbuildDevServerOptions, CreateDevServerOptions, ServerApi } from '@rsbuild/shared';
+import { RsbuildDevServerOptions, CreateDevServerOptions, DevServerContext, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
 import connect from 'connect';
 export declare class RsbuildDevServer {
   private readonly dev;
   private readonly devMiddleware;
   private pwd;
   private app;
+  private output;
   middlewares: connect.Server;
   constructor(options: RsbuildDevServerOptions);
-  private getDevOptions;
   private applySetupMiddlewares;
   onInit(app: Server): Promise<void>;
   private applyDefaultMiddlewares;
   createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
-  listen(options?: number | ListenOptions | undefined, listener?: () => void): void;
+  listen(options?: number | ListenOptions | undefined, listener?: (err?: Error) => Promise<void>): void;
   close(): void;
 }
-export declare function createDevServer(options: CreateDevServerOptions): Promise<ServerApi>;
+export declare function startDevServer<Options extends {
+  context: DevServerContext;
+}>(options: Options, startDevCompile: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevServerOptions['devMiddleware']>, {
+  open,
+  compiler,
+  printURLs,
+  strictPort,
+  logger: customLogger,
+  getPortSilently
+}?: StartDevServerOptions & {
+  defaultPort?: number;
+}): Promise<StartServerResult>;

package/dist/server/devServer.js

@@ -29,32 +29,29 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var devServer_exports = {};
 __export(devServer_exports, {
   RsbuildDevServer: () => RsbuildDevServer,
-  createDevServer: () => createDevServer
+  startDevServer: () => startDevServer
 });
 module.exports = __toCommonJS(devServer_exports);
 var import_http = require("http");
 var import_https = require("https");
 var import_url = __toESM(require("url"));
 var import_shared = require("@rsbuild/shared");
-var import_constants = require("./constants");
 var import_dev_middleware = __toESM(require("./dev-middleware"));
-var import_deepmerge = require("@rsbuild/shared/deepmerge");
 var import_connect = __toESM(require("connect"));
+var import_proxy = require("./proxy");
+var import_middlewares = require("./middlewares");
+var import_path = require("path");
 class RsbuildDevServer {
   constructor(options) {
     this.middlewares = (0, import_connect.default)();
     this.pwd = options.pwd;
-    this.dev = this.getDevOptions(options);
+    this.dev = options.dev;
+    this.output = options.output;
     this.devMiddleware = new import_dev_middleware.default({
       dev: this.dev,
       devMiddleware: options.devMiddleware
     });
   }
-  getDevOptions(options) {
-    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
-    const defaultOptions = (0, import_constants.getDefaultDevOptions)();
-    return (0, import_deepmerge.deepmerge)(defaultOptions, devOptions);
-  }
   applySetupMiddlewares() {
     const setupMiddlewares = this.dev.setupMiddlewares || [];
     const serverOptions = {
@@ -106,8 +103,22 @@ class RsbuildDevServer {
       }
       next();
     });
+    if (dev.proxy) {
+      const { middlewares, handleUpgrade } = (0, import_proxy.createProxyMiddleware)(dev.proxy);
+      app && handleUpgrade(app);
+      middlewares.forEach((middleware) => {
+        this.middlewares.use(middleware);
+      });
+    }
     devMiddleware.init(app);
     devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
+    this.middlewares.use(
+      (0, import_middlewares.getHtmlFallbackMiddleware)({
+        distPath: (0, import_path.join)(this.pwd, this.output.distPath),
+        assetPrefix: this.output.assetPrefix,
+        callback: devMiddleware.middleware
+      })
+    );
     if (dev.historyApiFallback) {
       const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("connect-history-api-fallback")));
       const historyApiFallbackMiddleware = connectHistoryApiFallback(
@@ -117,6 +128,8 @@ class RsbuildDevServer {
       this.middlewares.use(historyApiFallbackMiddleware);
       devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
     }
+    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
+    this.middlewares.use(import_middlewares.notFoundMiddleware);
   }
   async createHTTPServer() {
     const { dev } = this;
@@ -143,30 +156,85 @@ class RsbuildDevServer {
     this.app.close();
   }
 }
-async function createDevServer(options) {
-  var _a;
-  const { server: serverOptions = {}, ...devOptions } = options;
-  const logger = (_a = serverOptions.logger) != null ? _a : import_shared.logger;
-  const devServer = new RsbuildDevServer(devOptions);
-  const httpServer = serverOptions.customApp || await devServer.createHTTPServer();
-  const server = {
-    middlewares: devServer.middlewares,
-    init: async () => {
-      await devServer.onInit(httpServer);
-    },
-    // resolvedConfig,
-    listen: (options2, cb) => {
-      devServer.listen(options2, cb);
-    },
-    logger,
-    close: () => {
-      devServer.close();
-    }
+async function startDevServer(options, startDevCompile, {
+  open,
+  compiler,
+  printURLs = true,
+  strictPort = false,
+  logger: customLogger,
+  getPortSilently
+} = {}) {
+  var _a, _b, _c;
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "development";
+  }
+  const rsbuildConfig = options.context.config;
+  const logger = customLogger != null ? customLogger : import_shared.logger;
+  const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
+    rsbuildConfig,
+    strictPort,
+    getPortSilently
+  });
+  options.context.devServer = {
+    hostname: host,
+    port,
+    https,
+    open
   };
-  return server;
+  const protocol = https ? "https" : "http";
+  let urls = (0, import_shared.getAddressUrls)(protocol, port, (_a = rsbuildConfig.dev) == null ? void 0 : _a.host);
+  if (printURLs) {
+    if ((0, import_shared.isFunction)(printURLs)) {
+      urls = printURLs(urls);
+      if (!Array.isArray(urls)) {
+        throw new Error("Please return an array in the `printURLs` function.");
+      }
+    }
+    (0, import_shared.printServerURLs)(urls, options.context.entry, logger);
+  }
+  (0, import_shared.debug)("create dev server");
+  const devMiddleware = await startDevCompile(options, compiler);
+  const server = new RsbuildDevServer({
+    pwd: options.context.rootPath,
+    devMiddleware,
+    dev: devServerConfig,
+    output: {
+      distPath: ((_c = (_b = rsbuildConfig.output) == null ? void 0 : _b.distPath) == null ? void 0 : _c.root) || import_shared.ROOT_DIST_DIR,
+      assetPrefix: typeof devServerConfig.assetPrefix === "string" && !(0, import_shared.isURL)(devServerConfig.assetPrefix) ? devServerConfig.assetPrefix : ""
+    }
+  });
+  (0, import_shared.debug)("create dev server done");
+  await options.context.hooks.onBeforeStartDevServerHook.call();
+  const httpServer = await server.createHTTPServer();
+  await server.onInit(httpServer);
+  (0, import_shared.debug)("listen dev server");
+  return new Promise((resolve) => {
+    server.listen(
+      {
+        host,
+        port
+      },
+      async (err) => {
+        if (err) {
+          throw err;
+        }
+        (0, import_shared.debug)("listen dev server done");
+        await options.context.hooks.onAfterStartDevServerHook.call({ port });
+        resolve({
+          port,
+          urls: urls.map((item) => item.url),
+          server: {
+            close: () => {
+              server.close();
+            }
+          }
+        });
+      }
+    );
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RsbuildDevServer,
-  createDevServer
+  startDevServer
 });

package/dist/server/index.d.ts

@@ -1,2 +1,2 @@
-export { createDevServer } from './devServer';
+export { startDevServer } 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,
+  startDevServer: () => import_devServer.startDevServer,
   startProdServer: () => import_prodServer.startProdServer
 });
 module.exports = __toCommonJS(server_exports);
@@ -26,6 +26,6 @@ var import_devServer = require("./devServer");
 var import_prodServer = require("./prodServer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDevServer,
+  startDevServer,
   startProdServer
 });

package/dist/server/middlewares.d.ts

@@ -0,0 +1,8 @@
+import { RequestHandler as Middleware } from '@rsbuild/shared';
+export declare const faviconFallbackMiddleware: Middleware;
+export declare const notFoundMiddleware: Middleware;
+export declare const getHtmlFallbackMiddleware: (params: {
+  distPath: string;
+  assetPrefix: string;
+  callback?: Middleware;
+}) => Middleware;

package/dist/server/middlewares.js

@@ -0,0 +1,103 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+__export(middlewares_exports, {
+  faviconFallbackMiddleware: () => faviconFallbackMiddleware,
+  getHtmlFallbackMiddleware: () => getHtmlFallbackMiddleware,
+  notFoundMiddleware: () => notFoundMiddleware
+});
+module.exports = __toCommonJS(middlewares_exports);
+var import_shared = require("@rsbuild/shared");
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+const faviconFallbackMiddleware = (req, res, next) => {
+  if (req.url === "/favicon.ico") {
+    res.statusCode = 204;
+    res.end();
+  } else {
+    next();
+  }
+};
+const notFoundMiddleware = (_req, res, _next) => {
+  res.statusCode = 404;
+  res.end();
+};
+const getHtmlFallbackMiddleware = ({ assetPrefix, distPath, callback }) => {
+  return (req, res, next) => {
+    if (
+      // Only accept GET or HEAD
+      req.method !== "GET" && req.method !== "HEAD" || // Require Accept header
+      !req.headers || typeof req.headers.accept !== "string" || // Ignore JSON requests
+      req.headers.accept.includes("application/json") || // Require Accept: text/html or */*
+      !(req.headers.accept.includes("text/html") || req.headers.accept.includes("*/*")) || !req.url
+    ) {
+      return next();
+    }
+    const { url } = req;
+    const pathname = decodeURIComponent(url);
+    let outputFileSystem = import_fs.default;
+    if (res.locals.webpack) {
+      const { devMiddleware } = res.locals.webpack;
+      outputFileSystem = devMiddleware.outputFileSystem;
+    }
+    const tryRewrite = (filePath, newUrl) => {
+      var _a;
+      if (outputFileSystem.existsSync(filePath) && callback) {
+        newUrl = (0, import_shared.urlJoin)(assetPrefix, newUrl);
+        (_a = import_shared.debug) == null ? void 0 : _a(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+        req.url = newUrl;
+        return callback(req, res, (...args) => {
+          req.url = url;
+          next(...args);
+        });
+      }
+    };
+    if (pathname.endsWith("/")) {
+      const newUrl = url + "index.html";
+      const filePath = import_path.default.join(distPath, pathname, "index.html");
+      tryRewrite(filePath, newUrl);
+    } else if (
+      // '/main' => '/main.html'
+      !pathname.endsWith(".html")
+    ) {
+      const newUrl = url + ".html";
+      const filePath = import_path.default.join(distPath, pathname + ".html");
+      tryRewrite(filePath, newUrl);
+    } else {
+      tryRewrite(import_path.default.join(distPath, pathname), url);
+    }
+    next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  faviconFallbackMiddleware,
+  getHtmlFallbackMiddleware,
+  notFoundMiddleware
+});

package/dist/server/prodServer.d.ts

@@ -18,6 +18,7 @@ export declare class RsbuildProdServer {
   constructor(options: RsbuildProdServerOptions);
   onInit(app: Server): Promise<void>;
   private applyDefaultMiddlewares;
+  private applyStaticAssetMiddleware;
   createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
   listen(options?: number | ListenOptions | undefined, listener?: () => void): void;
   close(): void;

package/dist/server/prodServer.js

@@ -37,6 +37,7 @@ var import_connect = __toESM(require("connect"));
 var import_path = require("path");
 var import_sirv = __toESM(require("sirv"));
 var import_shared = require("@rsbuild/shared");
+var import_middlewares = require("./middlewares");
 class RsbuildProdServer {
   constructor(options) {
     this.middlewares = (0, import_connect.default)();
@@ -48,6 +49,10 @@ class RsbuildProdServer {
     await this.applyDefaultMiddlewares();
   }
   async applyDefaultMiddlewares() {
+    this.applyStaticAssetMiddleware();
+    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
+  }
+  applyStaticAssetMiddleware() {
     const {
       output: { path, assetPrefix },
       pwd
@@ -110,16 +115,14 @@ async function startProdServer(context, rsbuildConfig) {
       },
       () => {
         const urls = (0, import_shared.getAddressUrls)("http", port);
-        (0, import_shared.printServerURLs)(urls);
+        (0, import_shared.printServerURLs)(urls, context.entry);
         resolve({
           port,
           urls: urls.map((item) => item.url),
           server: {
-            middlewares: server.middlewares,
             close: () => {
               server.close();
             }
-            // TODO: decouple with Modern.js server
           }
         });
       }

package/dist/server/proxy.d.ts

@@ -0,0 +1,9 @@
+import http from 'http';
+import { RequestHandler } from 'http-proxy-middleware';
+import { ProxyDetail, RequestHandler as Middleware, RsbuildProxyOptions } from '@rsbuild/shared';
+export declare function formatProxyOptions(proxyOptions: RsbuildProxyOptions): ProxyDetail[];
+export type HttpUpgradeHandler = NonNullable<RequestHandler['upgrade']>;
+export declare const createProxyMiddleware: (proxyOptions: RsbuildProxyOptions) => {
+  middlewares: Middleware[];
+  handleUpgrade: (server: http.Server) => void;
+};

package/dist/server/proxy.js

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxy_exports = {};
+__export(proxy_exports, {
+  createProxyMiddleware: () => createProxyMiddleware,
+  formatProxyOptions: () => formatProxyOptions
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_http_proxy_middleware2 = require("http-proxy-middleware/dist/http-proxy-middleware");
+function formatProxyOptions(proxyOptions) {
+  var _a;
+  const ret = [];
+  if (Array.isArray(proxyOptions)) {
+    ret.push(...proxyOptions);
+  } else if ("target" in proxyOptions) {
+    ret.push(proxyOptions);
+  } else {
+    for (const [context, options] of Object.entries(proxyOptions)) {
+      const opts = {
+        context,
+        changeOrigin: true,
+        logLevel: "warn"
+      };
+      if (typeof options === "string") {
+        opts.target = options;
+      } else {
+        Object.assign(opts, options);
+      }
+      ret.push(opts);
+    }
+  }
+  const handleError = (err, _req, _res, _target) => {
+    console.error(err);
+  };
+  for (const opts of ret) {
+    (_a = opts.onError) != null ? _a : opts.onError = handleError;
+  }
+  return ret;
+}
+const createProxyMiddleware = (proxyOptions) => {
+  const formattedOptionsList = formatProxyOptions(proxyOptions);
+  const proxies = [];
+  const middlewares = [];
+  for (const opts of formattedOptionsList) {
+    const proxy = new import_http_proxy_middleware2.HttpProxyMiddleware(opts.context, opts);
+    const middleware = async (req, res, next) => {
+      const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
+      if (typeof bypassUrl === "boolean") {
+        res.statusCode = 404;
+        next();
+      } else if (typeof bypassUrl === "string") {
+        req.url = bypassUrl;
+        next();
+      } else {
+        proxy.middleware(req, res, next);
+      }
+    };
+    proxies.push(proxy);
+    middlewares.push(middleware);
+  }
+  const handleUpgrade = (server) => {
+    for (const proxy of proxies) {
+      const raw = proxy;
+      if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
+        server.on("upgrade", raw.handleUpgrade);
+        raw.wsInternalSubscribed = true;
+      }
+    }
+  };
+  return { middlewares, handleUpgrade };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProxyMiddleware,
+  formatProxyOptions
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -86,8 +86,9 @@
     "core-js": "~3.32.2",
     "filesize": "^8.0.7",
     "gzip-size": "^6.0.0",
-    "html-webpack-plugin": "5.5.3",
+    "html-webpack-plugin": "npm:html-rspack-plugin@5.5.4",
     "http-compression": "1.0.6",
+    "http-proxy-middleware": "^2.0.1",
     "jiti": "^1.20.0",
     "lodash": "^4.17.21",
     "open": "^8.4.0",
@@ -97,7 +98,7 @@
     "sirv": "^2.0.3",
     "strip-ansi": "^6.0.1",
     "ws": "^8.2.0",
-    "@rsbuild/shared": "0.0.18"
+    "@rsbuild/shared": "0.0.20"
   },
   "devDependencies": {
     "@types/connect": "3.4.35",

package/types.d.ts

@@ -5,99 +5,139 @@ declare module '*.bmp' {
   const src: string;
   export default src;
 }
-declare module '*.bmp?url' {
+declare module '*.gif' {
   const src: string;
   export default src;
 }
-declare module '*.bmp?inline' {
+declare module '*.jpg' {
   const src: string;
   export default src;
 }
-declare module '*.gif' {
+declare module '*.jpeg' {
   const src: string;
   export default src;
 }
-declare module '*.gif?url' {
+declare module '*.png' {
   const src: string;
   export default src;
 }
-declare module '*.gif?inline' {
+declare module '*.ico' {
   const src: string;
   export default src;
 }
-declare module '*.jpg' {
+declare module '*.webp' {
   const src: string;
   export default src;
 }
-declare module '*.jpg?url' {
+declare module '*.svg' {
   const src: string;
   export default src;
 }
-declare module '*.jpg?inline' {
+declare module '*.apng' {
   const src: string;
   export default src;
 }
-declare module '*.jpeg' {
+declare module '*.avif' {
   const src: string;
   export default src;
 }
-declare module '*.jpeg?url' {
+declare module '*.tiff' {
   const src: string;
   export default src;
 }
-declare module '*.jpeg?inline' {
+
+/**
+ * Font assets
+ */
+declare module '*.woff' {
   const src: string;
   export default src;
 }
-declare module '*.png' {
+declare module '*.woff2' {
   const src: string;
   export default src;
 }
-declare module '*.png?url' {
+declare module '*.eot' {
   const src: string;
   export default src;
 }
-declare module '*.png?inline' {
+declare module '*.ttf' {
   const src: string;
   export default src;
 }
-declare module '*.ico' {
+declare module '*.otf' {
+  const src: string;
+  export default src;
+}
+declare module '*.ttc' {
   const src: string;
   export default src;
 }
-declare module '*.ico?url' {
+
+/**
+ * Media assets
+ */
+declare module '*.mp4' {
   const src: string;
   export default src;
 }
-declare module '*.ico?inline' {
+declare module '*.webm' {
   const src: string;
   export default src;
 }
-declare module '*.webp' {
+declare module '*.ogg' {
   const src: string;
   export default src;
 }
-declare module '*.webp?url' {
+declare module '*.mp3' {
   const src: string;
   export default src;
 }
-declare module '*.webp?inline' {
+declare module '*.wav' {
   const src: string;
   export default src;
 }
-declare module '*.svg' {
+declare module '*.flac' {
   const src: string;
   export default src;
 }
-declare module '*.svg?url' {
+declare module '*.aac' {
   const src: string;
   export default src;
 }
-declare module '*.svg?inline' {
+declare module '*.mov' {
   const src: string;
   export default src;
 }
 
+/**
+ * Configuration files
+ */
+declare module '*.yaml' {
+  const content: Record<string, any>;
+  export default content;
+}
+declare module '*.yml' {
+  const content: Record<string, any>;
+  export default content;
+}
+declare module '*.toml' {
+  const content: Record<string, any>;
+  export default content;
+}
+
+/**
+ * Queries
+ */
+declare module '*?url' {
+  const content: string;
+  export default content;
+}
+declare module '*?inline' {
+  const content: string;
+  export default content;
+}
+
 /**
  * CSS Modules
  */

package/dist/rspack-provider/core/startDevServer.d.ts

@@ -1,5 +0,0 @@
-import { StartDevServerOptions, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
-import { type InitConfigsOptions } from './initConfigs';
-type ServerOptions = Exclude<StartDevServerOptions['serverOptions'], undefined>;
-export declare function createDevServer(options: InitConfigsOptions, port: number, serverOptions: ServerOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").ServerApi>;
-export {};

package/dist/rspack-provider/core/startDevServer.js

@@ -1,59 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var startDevServer_exports = {};
-__export(startDevServer_exports, {
-  createDevServer: () => createDevServer
-});
-module.exports = __toCommonJS(startDevServer_exports);
-var import_shared = require("@rsbuild/shared");
-var import_createCompiler = require("./createCompiler");
-var import_devMiddleware = require("./devMiddleware");
-var import_initConfigs = require("./initConfigs");
-var import_server = require("../../server");
-async function createDevServer(options, port, serverOptions, customCompiler) {
-  let compiler;
-  if (customCompiler) {
-    compiler = customCompiler;
-  } else {
-    const { rspackConfigs } = await (0, import_initConfigs.initConfigs)(options);
-    compiler = await (0, import_createCompiler.createCompiler)({
-      context: options.context,
-      rspackConfigs
-    });
-  }
-  (0, import_shared.debug)("create dev server");
-  const rsbuildConfig = options.context.config;
-  const { devConfig } = await (0, import_shared.getDevServerOptions)({
-    rsbuildConfig,
-    serverOptions,
-    port
-  });
-  const server = await (0, import_server.createDevServer)({
-    pwd: options.context.rootPath,
-    devMiddleware: (0, import_devMiddleware.getDevMiddleware)(compiler),
-    ...serverOptions,
-    dev: devConfig
-  });
-  (0, import_shared.debug)("create dev server done");
-  return server;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createDevServer
-});

package/dist/rspack-provider/types/hooks.d.ts

@@ -1,3 +0,0 @@
-import type { ModifyRspackConfigUtils } from '@rsbuild/shared';
-import type { RspackConfig } from '@rsbuild/shared';
-export type ModifyRspackConfigFn = (config: RspackConfig, utils: ModifyRspackConfigUtils) => Promise<RspackConfig | void> | RspackConfig | void;

package/dist/rspack-provider/types/hooks.js

@@ -1,16 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var hooks_exports = {};
-module.exports = __toCommonJS(hooks_exports);

package/dist/server/constants.d.ts

@@ -1,6 +0,0 @@
-import type { DevServerOptions } from '@rsbuild/shared';
-/**
- * hmr socket connect path
- */
-export declare const HMR_SOCK_PATH = "/webpack-hmr";
-export declare const getDefaultDevOptions: () => DevServerOptions;

package/dist/server/constants.js

@@ -1,49 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constants_exports = {};
-__export(constants_exports, {
-  HMR_SOCK_PATH: () => HMR_SOCK_PATH,
-  getDefaultDevOptions: () => getDefaultDevOptions
-});
-module.exports = __toCommonJS(constants_exports);
-const HMR_SOCK_PATH = "/webpack-hmr";
-const getDefaultDevOptions = () => {
-  return {
-    client: {
-      path: HMR_SOCK_PATH,
-      // By default it is set to the port number of the dev server
-      port: "",
-      // By default it is set to "location.hostname"
-      host: "",
-      // By default it is set to "location.protocol === 'https:' ? 'wss' : 'ws'""
-      protocol: ""
-    },
-    https: false,
-    devMiddleware: { writeToDisk: true },
-    watch: true,
-    hot: true,
-    compress: true,
-    liveReload: true
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  HMR_SOCK_PATH,
-  getDefaultDevOptions
-});