@rsbuild/core 1.2.8 → 1.2.10

package/dist/index.js

@@ -519,38 +519,39 @@ function formatMessage(stats, verbose) {
     return !verbose && message.includes(innerError) && (message = message.split(innerError)[0]), (message = (message = hintNodePolyfill(message = function(message) {
         let hint = 'You may need an appropriate loader to handle this file type.';
         if (-1 === message.indexOf(hint)) return message;
+        let createPluginHint = (packageName, keyword)=>`To enable support for ${keyword}, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow(`@rsbuild/plugin-${packageName}`)}" ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.dim(`(https://www.npmjs.com/package/@rsbuild/plugin-${packageName})`)}.`;
         for (let plugin of [
             {
                 test: /File: .+\.s(c|a)ss/,
-                hint: `To enable support for Sass, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-sass')}".`
+                hint: createPluginHint('sass', 'Sass')
             },
             {
                 test: /File: .+\.less/,
-                hint: `To enable support for Less, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-less')}".`
+                hint: createPluginHint('less', 'Less')
             },
             {
                 test: /File: .+\.styl(us)?/,
-                hint: `To enable support for Stylus, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-stylus')}".`
+                hint: createPluginHint('stylus', 'Stylus')
             },
             {
                 test: /File: .+\.vue?/,
-                hint: `To enable support for Vue, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-vue')}".`
+                hint: createPluginHint('vue', 'Vue')
             },
             {
                 test: /File: .+\.svelte?/,
-                hint: `To enable support for Svelte, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-svelte')}".`
+                hint: createPluginHint('svelte', 'Svelte')
             },
             {
                 test: /File: .+\.mdx/,
-                hint: `To enable support for MDX, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-mdx')}".`
+                hint: createPluginHint('mdx', 'MDX')
             },
             {
                 test: /File: .+\.toml/,
-                hint: `To enable support for TOML, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-toml')}".`
+                hint: createPluginHint('toml', 'TOML')
             },
             {
                 test: /File: .+\.yaml/,
-                hint: `To enable support for YAML, use "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('@rsbuild/plugin-yaml')}".`
+                hint: createPluginHint('yaml', 'YAML')
             }
         ])if (plugin.test.test(message)) return message.replace(hint, plugin.hint);
         return message;
@@ -827,7 +828,7 @@ let configCache = {}, OVERRIDE_PATHS = [
 async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
     cliOptions && (commonOpts = cliOptions);
     try {
-        var _config_server, _config_dev;
+        var _config_server, _config_dev, _config_performance;
         let cwd = process.cwd(), root = commonOpts.root ? getAbsolutePath(cwd, commonOpts.root) : cwd, envs = loadEnv({
             cwd: getEnvDir(root, commonOpts.envDir),
             mode: commonOpts.envMode
@@ -837,10 +838,15 @@ async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
             envMode: commonOpts.envMode,
             loader: commonOpts.configLoader
         });
-        config.source ||= {}, config.source.define = {
+        if (config.source ||= {}, config.source.define = {
             ...envs.publicVars,
             ...config.source.define
-        }, commonOpts.base && (config.server ||= {}, config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), !commonOpts.open || (null === (_config_server = config.server) || void 0 === _config_server ? void 0 : _config_server.open) || (config.server ||= {}, config.server.open = commonOpts.open), commonOpts.host && (config.server ||= {}, config.server.host = commonOpts.host), commonOpts.port && (config.server ||= {}, config.server.port = commonOpts.port), (null === (_config_dev = config.dev) || void 0 === _config_dev ? void 0 : _config_dev.cliShortcuts) === void 0 && (config.dev ||= {}, config.dev.cliShortcuts = !0);
+        }, commonOpts.base && (config.server ||= {}, config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), !commonOpts.open || (null === (_config_server = config.server) || void 0 === _config_server ? void 0 : _config_server.open) || (config.server ||= {}, config.server.open = commonOpts.open), commonOpts.host && (config.server ||= {}, config.server.host = commonOpts.host), commonOpts.port && (config.server ||= {}, config.server.port = commonOpts.port), (null === (_config_dev = config.dev) || void 0 === _config_dev ? void 0 : _config_dev.cliShortcuts) === void 0 && (config.dev ||= {}, config.dev.cliShortcuts = !0), (null === (_config_performance = config.performance) || void 0 === _config_performance ? void 0 : _config_performance.buildCache) && envs.filePaths.length > 0) {
+            let { buildCache } = config.performance;
+            !0 === buildCache ? config.performance.buildCache = {
+                buildDependencies: envs.filePaths
+            } : (buildCache.buildDependencies ||= [], buildCache.buildDependencies.push(...envs.filePaths));
+        }
         let rsbuild = await createRsbuild({
             cwd: root,
             rsbuildConfig: config,
@@ -1343,7 +1349,7 @@ function createEnvironmentAsyncHook() {
         tap: (handler)=>tapEnvironment({
                 handler
             }),
-        callInEnvironment: async ({ environment, args: params })=>{
+        callChain: async ({ environment, args: params })=>{
             for (let callback of [
                 ...preGroup,
                 ...defaultGroup,
@@ -1354,6 +1360,19 @@ function createEnvironmentAsyncHook() {
                 void 0 !== result && (params[0] = result);
             }
             return params;
+        },
+        callBatch: async ({ environment, args: params })=>{
+            let results = [];
+            for (let callback of [
+                ...preGroup,
+                ...defaultGroup,
+                ...postGroup
+            ]){
+                if (callback.environment && environment && !isPluginMatchEnvironment(callback.environment, environment)) continue;
+                let result = await callback.handler(...params);
+                results.push(result);
+            }
+            return results;
         }
     };
 }
@@ -1363,7 +1382,7 @@ function createAsyncHook() {
         tap: (cb)=>{
             isFunction(cb) ? defaultGroup.push(cb) : 'pre' === cb.order ? preGroup.push(cb.handler) : 'post' === cb.order ? postGroup.push(cb.handler) : defaultGroup.push(cb.handler);
         },
-        call: async (...params)=>{
+        callChain: async (...params)=>{
             for (let callback of [
                 ...preGroup,
                 ...defaultGroup,
@@ -1373,6 +1392,18 @@ function createAsyncHook() {
                 void 0 !== result && (params[0] = result);
             }
             return params;
+        },
+        callBatch: async (...params)=>{
+            let results = [];
+            for (let callback of [
+                ...preGroup,
+                ...defaultGroup,
+                ...postGroup
+            ]){
+                let result = await callback(...params);
+                results.push(result);
+            }
+            return results;
         }
     };
 }
@@ -1410,7 +1441,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
     });
 }, registerBuildHook = ({ context, isWatch, compiler, bundlerConfigs, MultiStatsCtor })=>{
     let isFirstCompile = !0, environmentList = Object.values(context.environments).reduce((prev, curr)=>(prev[curr.index] = curr, prev), []), onDone = async (stats)=>{
-        let p = context.hooks.onAfterBuild.call({
+        let p = context.hooks.onAfterBuild.callBatch({
             isFirstCompile,
             stats,
             environments: context.environments,
@@ -1418,7 +1449,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
         });
         isFirstCompile = !1, await p;
     }, onEnvironmentDone = async (buildIndex, stats)=>{
-        await context.hooks.onAfterEnvironmentCompile.callInEnvironment({
+        await context.hooks.onAfterEnvironmentCompile.callBatch({
             environment: environmentList[buildIndex].name,
             args: [
                 {
@@ -1432,13 +1463,13 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
     };
     onBeforeCompile({
         compiler,
-        beforeCompile: async ()=>await context.hooks.onBeforeBuild.call({
+        beforeCompile: async ()=>await context.hooks.onBeforeBuild.callBatch({
                 bundlerConfigs,
                 environments: context.environments,
                 isWatch,
                 isFirstCompile
             }),
-        beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callInEnvironment({
+        beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
@@ -1458,14 +1489,14 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
     });
 }, registerDevHook = ({ context, compiler, bundlerConfigs, MultiStatsCtor })=>{
     let isFirstCompile = !0, environmentList = Object.values(context.environments).reduce((prev, curr)=>(prev[curr.index] = curr, prev), []), onDone = async (stats)=>{
-        let p = context.hooks.onDevCompileDone.call({
+        let p = context.hooks.onDevCompileDone.callBatch({
             isFirstCompile,
             stats,
             environments: context.environments
         });
         isFirstCompile = !1, await p;
     }, onEnvironmentDone = async (buildIndex, stats)=>{
-        await context.hooks.onAfterEnvironmentCompile.callInEnvironment({
+        await context.hooks.onAfterEnvironmentCompile.callBatch({
             environment: environmentList[buildIndex].name,
             args: [
                 {
@@ -1479,7 +1510,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
     };
     onBeforeCompile({
         compiler,
-        beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callInEnvironment({
+        beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
@@ -1617,7 +1648,7 @@ async function updateEnvironmentContext(context, configs) {
 async function createContext(options, userConfig, bundlerType) {
     let { cwd } = options, rootPath = userConfig.root ? getAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "1.2.8",
+        version: "1.2.10",
         rootPath,
         distPath: '',
         cachePath,
@@ -1750,7 +1781,7 @@ let pluginAppIcon = ()=>({
 async function modifyBundlerChain(context, utils) {
     var _utils_environment_config_tools;
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify bundler chain');
-    let bundlerChain = new __WEBPACK_EXTERNAL_MODULE__compiled_rspack_chain_index_js_b67fefbd__.default(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callInEnvironment({
+    let bundlerChain = new __WEBPACK_EXTERNAL_MODULE__compiled_rspack_chain_index_js_b67fefbd__.default(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callChain({
         environment: utils.environment.name,
         args: [
             bundlerChain,
@@ -3282,7 +3313,7 @@ let getJsAsyncPath = (jsPath, isServer, jsAsync)=>void 0 !== jsAsync ? jsAsync :
             api.modifyBundlerChain(async (chain, { CHAIN_ID, target, isProd, isServer, environment })=>{
                 let { distPath, config } = environment, publicPath = function({ isProd, config, context }) {
                     var _context_devServer, _context_devServer1, _context_devServer2;
-                    let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX, port = (null === (_context_devServer = context.devServer) || void 0 === _context_devServer ? void 0 : _context_devServer.port) || 3000;
+                    let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX, port = (null === (_context_devServer = context.devServer) || void 0 === _context_devServer ? void 0 : _context_devServer.port) || server.port || 3000;
                     if (isProd) 'string' == typeof output.assetPrefix && (publicPath = output.assetPrefix);
                     else if ('string' == typeof dev.assetPrefix) publicPath = dev.assetPrefix;
                     else if (!0 === dev.assetPrefix) {
@@ -4094,7 +4125,7 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
 async function modifyRspackConfig(context, rspackConfig, utils) {
     var _utils_environment_config_tools;
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rspack config');
-    let [modifiedConfig] = await context.hooks.modifyRspackConfig.callInEnvironment({
+    let [modifiedConfig] = await context.hooks.modifyRspackConfig.callChain({
         environment: utils.environment.name,
         args: [
             rspackConfig,
@@ -4172,14 +4203,14 @@ async function generateRspackConfig({ target, context, environment }) {
 }
 async function modifyRsbuildConfig(context) {
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rsbuild config');
-    let [modified] = await context.hooks.modifyRsbuildConfig.call(context.config, {
+    let [modified] = await context.hooks.modifyRsbuildConfig.callChain(context.config, {
         mergeRsbuildConfig: mergeRsbuildConfig
     });
     context.config = modified, __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rsbuild config done');
 }
 async function modifyEnvironmentConfig(context, config, name) {
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug(`modify Rsbuild environment(${name}) config`);
-    let [modified] = await context.hooks.modifyEnvironmentConfig.callInEnvironment({
+    let [modified] = await context.hooks.modifyEnvironmentConfig.callChain({
         environment: name,
         args: [
             config,
@@ -5128,6 +5159,12 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunne
     };
 }, notFoundMiddleware = (_req, res, _next)=>{
     res.statusCode = 404, res.end();
+}, optionsFallbackMiddleware = (req, res, next)=>{
+    if ('OPTIONS' === req.method) {
+        res.statusCode = 204, res.setHeader('Content-Length', '0'), res.end();
+        return;
+    }
+    next();
 }, middlewares_isFileExists = async (filePath, outputFileSystem)=>new Promise((resolve)=>{
         outputFileSystem.stat(filePath, (_error, stats)=>{
             resolve(null == stats ? void 0 : stats.isFile());
@@ -5246,12 +5283,11 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunne
             let opts = {
                 context,
                 changeOrigin: !0,
-                logLevel: 'warn'
+                logLevel: 'warn',
+                logProvider: ()=>__WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger
             };
             'string' == typeof options ? opts.target = options : Object.assign(opts, options), ret.push(opts);
         }
-        let handleError = (err)=>__WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.error(err);
-        for (let opts of ret)opts.onError ??= handleError;
         return ret;
     }(proxyOptions), proxyMiddlewares = [], middlewares = [], { createProxyMiddleware: baseMiddleware } = await import("../compiled/http-proxy-middleware/index.js");
     for (let opts of formattedOptions){
@@ -5280,7 +5316,7 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunne
         before,
         after
     };
-}, applyDefaultMiddlewares = async ({ middlewares, server, compileMiddlewareAPI, output, pwd, outputFileSystem, environments })=>{
+}, applyDefaultMiddlewares = async ({ middlewares, server, compileMiddlewareAPI, output, pwd, outputFileSystem, environments, postCallbacks })=>{
     let upgradeEvents = [];
     if (server.compress && middlewares.push(gzipMiddleware()), middlewares.push((req, res, next)=>{
         var _parseUrl;
@@ -5323,6 +5359,7 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunne
         });
         middlewares.push(assetMiddleware);
     }
+    for (let callback of postCallbacks)callback();
     if (compileMiddlewareAPI && middlewares.push(getHtmlFallbackMiddleware({
         distPath,
         callback: compileMiddlewareAPI.middleware,
@@ -5332,13 +5369,7 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunne
         let { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js"), historyApiFallbackMiddleware = connectHistoryApiFallback(!0 === server.historyApiFallback ? {} : server.historyApiFallback);
         middlewares.push(historyApiFallbackMiddleware), (null == compileMiddlewareAPI ? void 0 : compileMiddlewareAPI.middleware) && middlewares.push(compileMiddlewareAPI.middleware);
     }
-    return middlewares.push(faviconFallbackMiddleware), middlewares.push((req, res, next)=>{
-        if ('OPTIONS' === req.method) {
-            res.statusCode = 204, res.setHeader('Content-Length', '0'), res.end();
-            return;
-        }
-        next();
-    }), {
+    return middlewares.push(faviconFallbackMiddleware), {
         onUpgrade: (...args)=>{
             for (let cb of upgradeEvents)cb(...args);
         }
@@ -5428,7 +5459,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             config,
             clearCache: !0
         }), closeServer = async ()=>{
-        await options.context.hooks.onCloseDevServer.call(), await Promise.all([
+        await options.context.hooks.onCloseDevServer.callBatch(), await Promise.all([
             null == devMiddlewares ? void 0 : devMiddlewares.close(),
             null == fileWatcher ? void 0 : fileWatcher.close()
         ]);
@@ -5463,22 +5494,23 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
                         environment
                     }))
             }
-        ])), { default: connect } = await import("../compiled/connect/index.js"), middlewares = connect(), devServerAPI = {
+        ])), { default: connect } = await import("../compiled/connect/index.js"), middlewares = connect(), httpServer = await createHttpServer({
+        serverConfig: config.server,
+        middlewares
+    }), devServerAPI = {
         port,
         middlewares,
         environments: environmentAPI,
+        httpServer,
         listen: async ()=>{
-            let httpServer = await createHttpServer({
-                serverConfig: config.server,
-                middlewares
-            }), serverTerminator = getServerTerminator(httpServer);
+            let serverTerminator = getServerTerminator(httpServer);
             return __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('listen dev server'), options.context.hooks.onCloseDevServer.tap(serverTerminator), new Promise((resolve)=>{
                 httpServer.listen({
                     host,
                     port
                 }, async (err)=>{
                     if (err) throw err;
-                    middlewares.use(notFoundMiddleware), devMiddlewares && httpServer.on('upgrade', devMiddlewares.onUpgrade), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('listen dev server done'), await devServerAPI.afterListen(), onBeforeRestartServer(devServerAPI.close), resolve({
+                    middlewares.use(optionsFallbackMiddleware), middlewares.use(notFoundMiddleware), devMiddlewares && httpServer.on('upgrade', devMiddlewares.onUpgrade), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('listen dev server done'), await devServerAPI.afterListen(), onBeforeRestartServer(devServerAPI.close), resolve({
                         port,
                         urls: urls.map((item)=>item.url),
                         server: {
@@ -5489,7 +5521,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             });
         },
         afterListen: async ()=>{
-            await options.context.hooks.onAfterStartDevServer.call({
+            await options.context.hooks.onAfterStartDevServer.callBatch({
                 port,
                 routes,
                 environments: options.context.environments
@@ -5501,11 +5533,11 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
         close: closeServer,
         printUrls,
         open: openPage
-    };
-    await options.context.hooks.onBeforeStartDevServer.call({
+    }, postCallbacks = (await options.context.hooks.onBeforeStartDevServer.callBatch({
         server: devServerAPI,
         environments: options.context.environments
-    }), runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
+    })).filter((item)=>'function' == typeof item);
+    runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
     let compileMiddlewareAPI = runCompile ? await startCompile() : void 0;
     for (let item of (fileWatcher = await setupWatchFiles({
         dev: devConfig,
@@ -5521,14 +5553,15 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
         output: {
             distPath: options.context.distPath || ROOT_DIST_DIR
         },
-        outputFileSystem
+        outputFileSystem,
+        postCallbacks
     })).middlewares))Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
     return __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('create dev server done'), devServerAPI;
 }
 async function createCompiler_createCompiler(options) {
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('create compiler');
     let { context } = options, { rspackConfigs } = await initConfigs(options);
-    if (await context.hooks.onBeforeCreateCompiler.call({
+    if (await context.hooks.onBeforeCreateCompiler.callBatch({
         bundlerConfigs: rspackConfigs,
         environments: context.environments
     }), !await isSatisfyRspackVersion(__WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack.rspackVersion)) throw Error(`[rsbuild] The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.green(rspackMinVersion)}`);
@@ -5567,7 +5600,7 @@ async function createCompiler_createCompiler(options) {
         compiler,
         bundlerConfigs: rspackConfigs,
         MultiStatsCtor: __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack.MultiStats
-    }), await context.hooks.onAfterCreateCompiler.call({
+    }), await context.hooks.onAfterCreateCompiler.callBatch({
         compiler,
         environments: context.environments
     }), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('create compiler done'), {
@@ -5697,7 +5730,7 @@ class RsbuildProdServer {
             let { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js"), historyApiFallbackMiddleware = connectHistoryApiFallback(!0 === historyApiFallback ? {} : historyApiFallback);
             this.middlewares.use(historyApiFallbackMiddleware), await this.applyStaticAssetMiddleware();
         }
-        this.middlewares.use(faviconFallbackMiddleware);
+        this.middlewares.use(faviconFallbackMiddleware), this.middlewares.use(optionsFallbackMiddleware), this.middlewares.use(notFoundMiddleware);
     }
     async applyStaticAssetMiddleware() {
         let { output: { path, assetPrefixes }, serverConfig: { htmlFallback } } = this.options, { default: sirv } = await import("../compiled/sirv/index.js"), assetMiddleware = sirv(path, {
@@ -5731,7 +5764,7 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
         },
         serverConfig
     }, middlewares);
-    await context.hooks.onBeforeStartProdServer.call();
+    await context.hooks.onBeforeStartProdServer.callBatch();
     let httpServer = await createHttpServer({
         serverConfig,
         middlewares: server.middlewares
@@ -5742,7 +5775,7 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
             port
         }, async ()=>{
             let routes = getRoutes(context);
-            await context.hooks.onAfterStartProdServer.call({
+            await context.hooks.onAfterStartProdServer.callBatch({
                 port,
                 routes,
                 environments: context.environments
@@ -5801,7 +5834,7 @@ async function applyDefaultPlugins(pluginManager, context) {
         pluginFileSize(),
         pluginCleanOutput(),
         pluginAsset(),
-        pluginHtml((environment)=>async (...args)=>(await context.hooks.modifyHTMLTags.callInEnvironment({
+        pluginHtml((environment)=>async (...args)=>(await context.hooks.modifyHTMLTags.callChain({
                     environment,
                     args
                 }))[0]),
@@ -6071,7 +6104,7 @@ async function createRsbuild(options = {}) {
                 });
             }, onExitListened = !1, onExit = (cb)=>{
             onExitListened || (process.on('exit', ()=>{
-                hooks.onExit.call();
+                hooks.onExit.callBatch();
             }), onExitListened = !0), hooks.onExit.tap(cb);
         };
         return (environment)=>({
@@ -6149,7 +6182,7 @@ async function createRsbuild(options = {}) {
             return {
                 ...buildInstance,
                 close: async ()=>{
-                    await context.hooks.onCloseBuild.call(), await buildInstance.close();
+                    await context.hooks.onCloseBuild.callBatch(), await buildInstance.close();
                 }
             };
         },
@@ -6543,12 +6576,12 @@ async function runCLI() {
             }
         }(), process.title = 'rsbuild-node';
         let { npm_execpath } = process.env;
-        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.greet(`  Rsbuild v1.2.8\n`);
+        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.greet(`  Rsbuild v1.2.10\n`);
     }();
     try {
         !function() {
             let cli = dist('rsbuild');
-            cli.help(), cli.version("1.2.8"), applyCommonOptions(cli);
+            cli.help(), cli.version("1.2.10"), applyCommonOptions(cli);
             let devCommand = cli.command('dev', 'starting the dev server'), buildCommand = cli.command('build', 'build the app for production'), previewCommand = cli.command('preview', 'preview the production build locally'), inspectCommand = cli.command('inspect', 'inspect the Rspack and Rsbuild configs');
             applyServerOptions(devCommand), applyServerOptions(previewCommand), devCommand.action(async (options)=>{
                 try {
@@ -6599,6 +6632,6 @@ async function runCLI() {
         __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.error('Failed to start Rsbuild CLI.'), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.error(err);
     }
 }
-let src_version = "1.2.8";
+let src_version = "1.2.10";
 var __webpack_exports__logger = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger, __webpack_exports__rspack = __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack;
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defineConfig, ensureAssetPrefix, config_loadConfig as loadConfig, loadEnv, mergeRsbuildConfig, runCLI, src_version as version, __webpack_exports__logger as logger, __webpack_exports__rspack as rspack };

package/dist-types/server/devServer.d.ts

@@ -5,7 +5,17 @@ import type { CreateCompiler, CreateDevServerOptions, EnvironmentAPI, InternalCo
 type HTTPServer = Server | Http2SecureServer;
 export type RsbuildDevServer = {
     /**
-     * Listen the Rsbuild server.
+     * The `connect` app instance.
+     * Can be used to attach custom middlewares to the dev server.
+     */
+    middlewares: Connect.Server;
+    /**
+     * The Node.js HTTP server instance.
+     * Will be `Http2SecureServer` if `server.https` config is used.
+     */
+    httpServer: import('node:http').Server | import('node:http2').Http2SecureServer | null;
+    /**
+     * Start listening on the Rsbuild dev server.
      * Do not call this method if you are using a custom server.
      */
     listen: () => Promise<{
@@ -24,11 +34,6 @@ export type RsbuildDevServer = {
      * By default, Rsbuild server listens on port `3000` and automatically increments the port number if the port is occupied.
      */
     port: number;
-    /**
-     * The `connect` app instance.
-     * Can be used to attach custom middlewares to the dev server.
-     */
-    middlewares: Connect.Server;
     /**
      * Notify that the Rsbuild server has been started.
      * Rsbuild will trigger `onAfterStartDevServer` hook in this stage.

package/dist-types/server/getDevMiddlewares.d.ts

@@ -16,6 +16,10 @@ export type RsbuildDevMiddlewareOptions = {
     output: {
         distPath: string;
     };
+    /**
+     * Callbacks returned by the `onBeforeStartDevServer` hook.
+     */
+    postCallbacks: (() => void)[];
 };
 export type Middlewares = Array<RequestHandler | [string, RequestHandler]>;
 export type GetMiddlewaresResult = {

package/dist-types/server/middlewares.d.ts

@@ -3,6 +3,7 @@ import type { EnvironmentAPI, HtmlFallback, RequestHandler as Middleware, Rspack
 export declare const faviconFallbackMiddleware: Middleware;
 export declare const getRequestLoggerMiddleware: () => Promise<Connect.NextHandleFunction>;
 export declare const notFoundMiddleware: Middleware;
+export declare const optionsFallbackMiddleware: Middleware;
 /**
  * Support access HTML without suffix
  */

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

@@ -42,7 +42,7 @@ export type OnBeforeStartDevServerFn = (params: {
      * A read-only object that provides some context information about different environments.
      */
     environments: Record<string, EnvironmentContext>;
-}) => MaybePromise<void>;
+}) => MaybePromise<(() => void) | void>;
 export type OnBeforeStartProdServerFn = () => MaybePromise<void>;
 export type Routes = Array<{
     entryName: string;

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

@@ -14,27 +14,82 @@ export type HookDescriptor<T extends (...args: any[]) => any> = {
     handler: T;
     order: HookOrder;
 };
-export type EnvironmentAsyncHook<Callback extends (...args: any[]) => any> = {
+export type EnvironmentAsyncHook<Callback extends (...args: any[]) => T, T = any> = {
+    /**
+     * Registers a callback function to be executed when the hook is triggered.
+     * The callback can be a plain function or a HookDescriptor that includes execution order.
+     * The callback will be executed in all environments by default.
+     * If you need to specify the environment, please use `tapEnvironment`
+     * @param cb The callback function or hook descriptor to register
+     */
+    tap: (cb: Callback | HookDescriptor<Callback>) => void;
+    /**
+     * Registers a callback function to be executed when the hook is triggered.
+     * The callback will only be executed under the specified environment.
+     */
     tapEnvironment: (params: {
         /**
-         * Specify that the callback will only be executed under the specified environment
+         * Specify the environment that the callback will be executed under.
          */
         environment?: string;
+        /**
+         * The callback function or hook descriptor to register
+         */
         handler: Callback | HookDescriptor<Callback>;
     }) => void;
     /**
-     *  Triggered in all environments by default.
-     *  If you need to specify the environment, please use `tapEnvironment`
+     * Executes callbacks in sequence independently and collects all their results into an array.
+     * Each callback receives the original parameters, and their results don't affect subsequent callbacks.
+     * @returns A promise that resolves with an array containing the results of all callbacks
      */
-    tap: (cb: Callback | HookDescriptor<Callback>) => void;
-    callInEnvironment: (params: {
+    callChain: (params: {
+        /**
+         * Specify the environment for filtering callbacks.
+         */
         environment?: string;
+        /**
+         * The parameters to pass to each callback
+         */
         args: Parameters<Callback>;
     }) => Promise<Parameters<Callback>>;
+    /**
+     * Executes callbacks in sequence independently and collects all their results into an array.
+     * Each callback receives the original parameters, and their results don't affect subsequent callbacks.
+     * @returns A promise that resolves with an array containing the results of all callbacks
+     */
+    callBatch: (params: {
+        /**
+         * Specify the environment for filtering callbacks.
+         */
+        environment?: string;
+        /**
+         * The parameters to pass to each callback
+         */
+        args: Parameters<Callback>;
+    }) => Promise<Awaited<ReturnType<Callback>>[]>;
 };
-export type AsyncHook<Callback extends (...args: any[]) => any> = {
+export type AsyncHook<Callback extends (...args: any[]) => T, T = any> = {
+    /**
+     * Registers a callback function to be executed when the hook is triggered.
+     * The callback can be a plain function or a HookDescriptor that includes execution order.
+     * @param cb The callback function or hook descriptor to register
+     */
     tap: (cb: Callback | HookDescriptor<Callback>) => void;
-    call: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+    /**
+     * Executes callbacks in sequence, passing the result of each callback as the first argument
+     * to the next callback in the chain. If a callback returns undefined, the original arguments
+     * will be passed to the next callback.
+     * @param params The initial parameters to pass to the first callback
+     * @returns A promise that resolves with the final parameters after all callbacks have executed
+     */
+    callChain: (...args: Parameters<Callback>) => Promise<Parameters<Callback>>;
+    /**
+     * Executes callbacks in sequence independently and collects all their results into an array.
+     * Each callback receives the original parameters, and their results don't affect subsequent callbacks.
+     * @param params The parameters to pass to each callback
+     * @returns A promise that resolves with an array containing the results of all callbacks
+     */
+    callBatch: (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>[]>;
 };
 export type ModifyRspackConfigFn = (config: Rspack.Configuration, utils: ModifyRspackConfigUtils) => MaybePromise<Rspack.Configuration | void>;
 export type ModifyWebpackChainUtils = ModifyChainUtils & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -46,7 +46,7 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "1.2.3",
+    "@rspack/core": "1.2.5",
     "@rspack/lite-tapable": "~1.0.1",
     "@swc/helpers": "^0.5.15",
     "core-js": "~3.40.0"
@@ -54,7 +54,7 @@
   "devDependencies": {
     "@rslib/core": "0.4.1",
     "@types/connect": "3.4.38",
-    "@types/node": "^22.13.1",
+    "@types/node": "^22.13.4",
     "@types/on-finished": "2.3.4",
     "@types/webpack-bundle-analyzer": "4.7.0",
     "@types/ws": "^8.5.14",
@@ -71,7 +71,7 @@
     "html-rspack-plugin": "6.0.2",
     "http-proxy-middleware": "^2.0.6",
     "jiti": "^1.21.7",
-    "launch-editor-middleware": "^2.9.1",
+    "launch-editor-middleware": "^2.10.0",
     "mrmime": "^2.0.0",
     "on-finished": "2.4.1",
     "open": "^8.4.0",