@rsbuild/core 1.2.7 → 1.2.8

package/dist/index.js

@@ -1617,7 +1617,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.7",
+        version: "1.2.8",
         rootPath,
         distPath: '',
         cachePath,
@@ -1944,7 +1944,7 @@ async function validateWebpackCache(cacheDirectory, buildDependencies) {
         recursive: !0
     }), await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.default.promises.writeFile(configFile, JSON.stringify(buildDependencies));
 }
-async function getBuildDependencies(context, config, environmentContext) {
+async function getBuildDependencies(context, config, environmentContext, userBuildDependencies) {
     var _config__privateMeta;
     let rootPackageJson = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(context.rootPath, 'package.json'), browserslistConfig = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(context.rootPath, '.browserslistrc'), buildDependencies = {};
     await isFileExists(rootPackageJson) && (buildDependencies.packageJson = [
@@ -1966,7 +1966,10 @@ async function getBuildDependencies(context, config, environmentContext) {
     ].map((ext)=>(0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(context.rootPath, `tailwind.config.${ext}`)));
     return tailwindConfig && (buildDependencies.tailwindcss = [
         tailwindConfig
-    ]), buildDependencies;
+    ]), {
+        ...buildDependencies,
+        ...userBuildDependencies
+    };
 }
 let pluginCache = ()=>({
         name: 'rsbuild:cache',
@@ -1979,7 +1982,9 @@ let pluginCache = ()=>({
                 cacheEnabled = !0;
                 let { context } = api, cacheConfig = 'boolean' == typeof buildCache ? {} : buildCache, cacheDirectory = function({ cacheDirectory }, context) {
                     return cacheDirectory ? (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.isAbsolute)(cacheDirectory) ? cacheDirectory : (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(context.rootPath, cacheDirectory) : (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(context.cachePath, context.bundlerType);
-                }(cacheConfig, context), buildDependencies = await getBuildDependencies(context, config, environment);
+                }(cacheConfig, context), buildDependencies = await getBuildDependencies(context, config, environment, cacheConfig.buildDependencies ? {
+                    userBuildDependencies: cacheConfig.buildDependencies
+                } : {});
                 'webpack' === bundlerType && await validateWebpackCache(cacheDirectory, buildDependencies);
                 let cacheVersion = Array.isArray(cacheConfig.cacheDigest) && cacheConfig.cacheDigest.length ? `${environment.name}-${env}-${digest = cacheConfig.cacheDigest, __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__.default.createHash('md5').update(JSON.stringify(digest)).digest('hex').slice(0, 8)}` : `${environment.name}-${env}`;
                 'rspack' === bundlerType ? (chain.cache(!0), chain.experiments({
@@ -2271,7 +2276,7 @@ let isPostcssPluginCreator = (plugin)=>'function' == typeof plugin && !0 === plu
 async function gzipSize(input) {
     return (await fileSize_gzip(input)).length;
 }
-let excludeAsset = (asset)=>/\.(?:map|LICENSE\.txt)$/.test(asset.name), getAssetColor = (size)=>size > 300000 ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.red : size > 100000 ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow : __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.green, calcFileSize = (len)=>{
+let EXCLUDE_ASSET_REGEX = /\.(?:map|LICENSE\.txt|d\.ts)$/, excludeAsset = (asset)=>EXCLUDE_ASSET_REGEX.test(asset.name), getAssetColor = (size)=>size > 300000 ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.red : size > 100000 ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow : __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.green, calcFileSize = (len)=>{
     let val = len / 1000;
     return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
 }, coloringAssetName = (assetName)=>JS_REGEX.test(assetName) ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.cyan(assetName) : CSS_REGEX.test(assetName) ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow(assetName) : HTML_REGEX.test(assetName) ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.green(assetName) : __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.magenta(assetName), COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest)$/i, isCompressible = (assetName)=>COMPRESSIBLE_REGEX.test(assetName);
@@ -2330,7 +2335,7 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
     let totalSize = 0, totalGzipSize = 0;
     for (let asset of assets){
         let { sizeLabel } = asset, { name, folder, gzipSizeLabel } = asset, fileNameLength = (folder + __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.sep + name).length, sizeLength = sizeLabel.length;
-        if (totalSize += asset.size, asset.gzippedSize && (totalGzipSize += asset.gzippedSize), !1 !== options.detail) {
+        if (totalSize += asset.size, options.compressed && (totalGzipSize += asset.gzippedSize ?? asset.size), !1 !== options.detail) {
             sizeLength < longestLabelLength && (sizeLabel += ' '.repeat(longestLabelLength - sizeLength));
             let fileNameLabel = __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.dim(asset.folder + __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.sep) + coloringAssetName(asset.name);
             fileNameLength < longestFileLength && (fileNameLabel += ' '.repeat(longestFileLength - fileNameLength));
@@ -3450,7 +3455,8 @@ function HtmlPreloadOrPrefetchPlugin_define_property(obj, key, value) {
     }) : obj[key] = value, obj;
 }
 let HtmlPreloadOrPrefetchPlugin_defaultOptions = {
-    type: 'async-chunks'
+    type: 'async-chunks',
+    dedupe: !0
 };
 class HtmlPreloadOrPrefetchPlugin {
     apply(compiler) {
@@ -3527,7 +3533,7 @@ class HtmlPreloadOrPrefetchPlugin {
                 if (this.resourceHints) {
                     var resourceHints, scripts;
                     htmlPluginData.assetTags.styles = [
-                        ...(resourceHints = this.resourceHints, scripts = htmlPluginData.assetTags.scripts, resourceHints.filter((resourceHint)=>!scripts.find((script)=>script.attributes.src === resourceHint.attributes.href))),
+                        ...this.options.dedupe ? (resourceHints = this.resourceHints, scripts = htmlPluginData.assetTags.scripts, resourceHints.filter((resourceHint)=>!scripts.find((script)=>script.attributes.src === resourceHint.attributes.href))) : this.resourceHints,
                         ...htmlPluginData.assetTags.styles
                     ];
                 }
@@ -4879,15 +4885,12 @@ class BasicRunner {
             content: `module.exports = (${modulePath.map((arg)=>`require(${JSON.stringify(`./${arg}`)})`).join(', ')});`,
             subPath: ''
         };
-        if (isRelativePath(modulePath)) {
-            let p = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.join(currentDirectory, modulePath);
-            return {
-                path: p,
-                content: this._options.readFileSync(p),
-                subPath: getSubPath(modulePath)
-            };
-        }
-        return null;
+        let joinedPath = isRelativePath(modulePath) ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.join(currentDirectory, modulePath) : modulePath;
+        return this._options.isBundleOutput(joinedPath) ? {
+            path: joinedPath,
+            content: this._options.readFileSync(joinedPath),
+            subPath: getSubPath(modulePath)
+        } : null;
     }
     preExecute(_code, _file) {}
     postExecute(_m, _file) {}
@@ -4941,7 +4944,14 @@ class CommonJsRunner extends BasicRunner {
         this.requirers.set('miss', this.createMissRequirer()), this.requirers.set('entry', this.createCjsRequirer());
     }
     createMissRequirer() {
-        return (_currentDirectory, modulePath, _context = {})=>cjs_require(modulePath.startsWith('node:') ? modulePath.slice(5) : modulePath);
+        return (_currentDirectory, modulePath, _context = {})=>{
+            let resolvedPath = cjs_require.resolve(modulePath, {
+                paths: [
+                    _currentDirectory
+                ]
+            });
+            return cjs_require(resolvedPath.startsWith('node:') ? resolvedPath.slice(5) : resolvedPath);
+        };
     }
     createCjsRequirer() {
         let requireCache = Object.create(null);
@@ -4963,10 +4973,12 @@ class CommonJsRunner extends BasicRunner {
 var type_EsmMode = ((EsmMode = {})[EsmMode.Unknown = 0] = "Unknown", EsmMode[EsmMode.Evaluated = 1] = "Evaluated", EsmMode[EsmMode.Unlinked = 2] = "Unlinked", EsmMode);
 class EsmRunner extends CommonJsRunner {
     createRunner() {
-        super.createRunner(), this.requirers.set('cjs', this.getRequire()), this.requirers.set('esm', this.createEsmRequirer()), this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
-            var _this__options_compilerOptions_experiments;
+        var _this__options_compilerOptions_experiments;
+        super.createRunner(), this.requirers.set('cjs', this.getRequire()), this.requirers.set('esm', this.createEsmRequirer());
+        let outputModule = null === (_this__options_compilerOptions_experiments = this._options.compilerOptions.experiments) || void 0 === _this__options_compilerOptions_experiments ? void 0 : _this__options_compilerOptions_experiments.outputModule;
+        this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
             let file = this.getFile(modulePath, currentDirectory);
-            return file ? file.path.endsWith('.mjs') && (null === (_this__options_compilerOptions_experiments = this._options.compilerOptions.experiments) || void 0 === _this__options_compilerOptions_experiments ? void 0 : _this__options_compilerOptions_experiments.outputModule) ? this.requirers.get('esm')(currentDirectory, modulePath, {
+            return file ? outputModule && !file.path.endsWith('.cjs') ? this.requirers.get('esm')(currentDirectory, modulePath, {
                 ...context,
                 file
             }) : this.requirers.get('cjs')(currentDirectory, modulePath, {
@@ -5008,16 +5020,14 @@ class EsmRunner extends CommonJsRunner {
     }
 }
 class BasicRunnerFactory {
-    create(compilerOptions, dist, readFileSync) {
-        return this.createRunner(compilerOptions, dist, readFileSync);
+    create(options) {
+        return this.createRunner(options);
     }
-    createRunner(compilerOptions, dist, readFileSync) {
+    createRunner(options) {
         let runnerOptions = {
             name: this.name,
-            dist,
-            compilerOptions,
-            readFileSync
-        };
+            ...options
+        }, { compilerOptions } = options;
         if ('web' === compilerOptions.target || 'webworker' === compilerOptions.target) throw Error(`[rsbuild:runner] Not support run "${compilerOptions.target}" resource in Rsbuild server`);
         return new EsmRunner(runnerOptions);
     }
@@ -5031,7 +5041,7 @@ class BasicRunnerFactory {
         }) : this[key] = value, this.name = name;
     }
 }
-let runner_run = async (bundlePath, outputPath, compilerOptions, readFileSync)=>new BasicRunnerFactory(bundlePath).create(compilerOptions, outputPath, readFileSync).run(bundlePath), loadBundle = async (stats, entryName, utils)=>{
+let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>new BasicRunnerFactory(bundlePath).create(runnerFactoryOptions).run(bundlePath), loadBundle = async (stats, entryName, utils)=>{
     let { chunks, entrypoints, outputPath } = stats.toJson({
         all: !1,
         chunks: !0,
@@ -5048,7 +5058,14 @@ let runner_run = async (bundlePath, outputPath, compilerOptions, readFileSync)=>
     }, []);
     if (0 === files.length) throw Error(`[rsbuild:loadBundle] Failed to get bundle by entryName: "${entryName}"`);
     if (files.length > 1) throw Error(`[rsbuild:loadBundle] Only support load single entry chunk, but got ${files.length}: ${files.join(',')}`);
-    return await runner_run(files[0], outputPath, stats.compilation.options, utils.readFileSync);
+    let allChunkFiles = (null == chunks ? void 0 : chunks.flatMap((c)=>c.files).map((file)=>(0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(outputPath, file))) || [];
+    return await runner_run({
+        bundlePath: files[0],
+        dist: outputPath,
+        compilerOptions: stats.compilation.options,
+        readFileSync: utils.readFileSync,
+        isBundleOutput: (modulePath)=>allChunkFiles.includes(modulePath)
+    });
 }, getTransformedHtml = async (entryName, utils)=>{
     let { htmlPaths, distPath } = utils.environment, htmlPath = htmlPaths[entryName];
     if (!htmlPath) throw Error(`[rsbuild:getTransformedHtml] Failed to get HTML file by entryName: "${entryName}"`);
@@ -5359,11 +5376,11 @@ let runner_run = async (bundlePath, outputPath, compilerOptions, readFileSync)=>
     return createServer(middlewares);
 }, devServer_formatDevConfig = (config, port)=>('<port>' === config.client.port && (config.client.port = String(port)), config);
 async function devServer_createDevServer(options, createCompiler, config, { compiler: customCompiler, getPortSilently, runCompile = !0 } = {}) {
-    let lastStats;
+    let lastStats, fileWatcher, devMiddlewares;
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('create dev server');
     let { port, host, https, portTip } = await getServerConfig({
         config
-    }), devConfig = devServer_formatDevConfig(config.dev, port), routes = getRoutes(options.context);
+    }), devConfig = devServer_formatDevConfig(config.dev, port), routes = getRoutes(options.context), root = options.context.rootPath;
     options.context.devServer = {
         hostname: host,
         port,
@@ -5397,11 +5414,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
         protocol,
         port,
         host
-    });
-    await options.context.hooks.onBeforeStartDevServer.call({
-        environments: options.context.environments
-    });
-    let cliShortcutsEnabled = isCliShortcutsEnabled(devConfig), printUrls = ()=>printServerURLs({
+    }), cliShortcutsEnabled = isCliShortcutsEnabled(devConfig), printUrls = ()=>printServerURLs({
             urls,
             port,
             routes,
@@ -5416,7 +5429,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             clearCache: !0
         }), closeServer = async ()=>{
         await options.context.hooks.onCloseDevServer.call(), await Promise.all([
-            devMiddlewares.close(),
+            null == devMiddlewares ? void 0 : devMiddlewares.close(),
             null == fileWatcher ? void 0 : fileWatcher.close()
         ]);
     }, beforeCreateCompiler = ()=>{
@@ -5434,14 +5447,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             options.context.hooks.onCloseDevServer.tap(cleanup);
         }
         !getPortSilently && portTip && __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.info(portTip);
-    };
-    runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
-    let compileMiddlewareAPI = runCompile ? await startCompile() : void 0, root = options.context.rootPath, fileWatcher = await setupWatchFiles({
-        dev: devConfig,
-        server: config.server,
-        compileMiddlewareAPI,
-        root
-    }), readFileSync = (fileName)=>'readFileSync' in outputFileSystem ? outputFileSystem.readFileSync(fileName, 'utf-8') : __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.default.readFileSync(fileName, 'utf-8'), cacheableLoadBundle = createCacheableFunction(loadBundle), cacheableTransformedHtml = createCacheableFunction((_stats, entryName, utils)=>getTransformedHtml(entryName, utils)), environmentAPI = Object.fromEntries(Object.entries(options.context.environments).map(([name, environment])=>[
+    }, readFileSync = (fileName)=>'readFileSync' in outputFileSystem ? outputFileSystem.readFileSync(fileName, 'utf-8') : __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.default.readFileSync(fileName, 'utf-8'), cacheableLoadBundle = createCacheableFunction(loadBundle), cacheableTransformedHtml = createCacheableFunction((_stats, entryName, utils)=>getTransformedHtml(entryName, utils)), environmentAPI = Object.fromEntries(Object.entries(options.context.environments).map(([name, environment])=>[
             name,
             {
                 getStats: async ()=>{
@@ -5457,19 +5463,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
                         environment
                     }))
             }
-        ])), devMiddlewares = await getMiddlewares({
-        pwd: root,
-        compileMiddlewareAPI,
-        dev: devConfig,
-        server: config.server,
-        environments: environmentAPI,
-        output: {
-            distPath: options.context.distPath || ROOT_DIST_DIR
-        },
-        outputFileSystem
-    }), { default: connect } = await import("../compiled/connect/index.js"), middlewares = connect();
-    for (let item of devMiddlewares.middlewares)Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
-    let devServerAPI = {
+        ])), { default: connect } = await import("../compiled/connect/index.js"), middlewares = connect(), devServerAPI = {
         port,
         middlewares,
         environments: environmentAPI,
@@ -5484,7 +5478,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
                     port
                 }, async (err)=>{
                     if (err) throw err;
-                    middlewares.use(notFoundMiddleware), 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(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: {
@@ -5502,12 +5496,33 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             });
         },
         connectWebSocket: ({ server })=>{
-            server.on('upgrade', devMiddlewares.onUpgrade);
+            devMiddlewares && server.on('upgrade', devMiddlewares.onUpgrade);
         },
         close: closeServer,
         printUrls,
         open: openPage
     };
+    await options.context.hooks.onBeforeStartDevServer.call({
+        server: devServerAPI,
+        environments: options.context.environments
+    }), runCompile ? options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler) : beforeCreateCompiler();
+    let compileMiddlewareAPI = runCompile ? await startCompile() : void 0;
+    for (let item of (fileWatcher = await setupWatchFiles({
+        dev: devConfig,
+        server: config.server,
+        compileMiddlewareAPI,
+        root
+    }), (devMiddlewares = await getMiddlewares({
+        pwd: root,
+        compileMiddlewareAPI,
+        dev: devConfig,
+        server: config.server,
+        environments: environmentAPI,
+        output: {
+            distPath: options.context.distPath || ROOT_DIST_DIR
+        },
+        outputFileSystem
+    })).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) {
@@ -6504,7 +6519,7 @@ class CAC extends __WEBPACK_EXTERNAL_MODULE_events__.EventEmitter {
         }), actionArgs.push(options), command.commandAction.apply(this, actionArgs);
     }
 }
-let cac_dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
+let dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
     cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
         default: 'jiti'
     }).option('-r, --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('-m, --mode <mode>', 'specify the build mode, can be `development`, `production` or `none`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
@@ -6528,12 +6543,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.7\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.8\n`);
     }();
     try {
         !function() {
-            let cli = cac_dist('rsbuild');
-            cli.help(), cli.version("1.2.7"), applyCommonOptions(cli);
+            let cli = dist('rsbuild');
+            cli.help(), cli.version("1.2.8"), 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 {
@@ -6584,6 +6599,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.7";
+let src_version = "1.2.8";
 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/createRsbuild.d.ts

@@ -1,2 +1,5 @@
 import type { CreateRsbuildOptions, RsbuildInstance } from './types';
+/**
+ * Create an Rsbuild instance.
+ */
 export declare function createRsbuild(options?: CreateRsbuildOptions): Promise<RsbuildInstance>;

package/dist-types/rspack/preload/HtmlPreloadOrPrefetchPlugin.d.ts

@@ -16,15 +16,15 @@
  * limitations under the License.
  */
 import type { Compiler, RspackPluginInstance } from '@rspack/core';
-import type { HtmlRspackPlugin, PreloadOrPreFetchOption } from '../../types';
+import type { HtmlRspackPlugin, PreloadOrPrefetchOption } from '../../types';
 type LinkType = 'preload' | 'prefetch';
 export declare class HtmlPreloadOrPrefetchPlugin implements RspackPluginInstance {
-    readonly options: PreloadOrPreFetchOption;
+    readonly options: PreloadOrPrefetchOption;
     name: string;
     resourceHints: HtmlRspackPlugin.HtmlTagObject[];
     type: LinkType;
     HTMLCount: number;
-    constructor(options: true | PreloadOrPreFetchOption, type: LinkType, HTMLCount: number);
+    constructor(options: true | PreloadOrPrefetchOption, type: LinkType, HTMLCount: number);
     apply(compiler: Compiler): void;
 }
 export {};

package/dist-types/rspack/preload/helpers/doesChunkBelongToHtml.d.ts

@@ -16,13 +16,13 @@
  * limitations under the License.
  */
 import type { Chunk, Compilation } from '@rspack/core';
-import type { PreloadOrPreFetchOption } from '../../../types';
+import type { PreloadOrPrefetchOption } from '../../../types';
 import type { BeforeAssetTagGenerationHtmlPluginData } from './type';
 interface DoesChunkBelongToHtmlOptions {
     chunk: Chunk;
     compilation?: Compilation;
     htmlPluginData: BeforeAssetTagGenerationHtmlPluginData;
-    pluginOptions?: PreloadOrPreFetchOption;
+    pluginOptions?: PreloadOrPrefetchOption;
 }
 export declare function recursiveChunkEntryNames(chunk: Chunk): string[];
 export declare function doesChunkBelongToHtml({ chunk, htmlPluginData, }: DoesChunkBelongToHtmlOptions): boolean;

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

@@ -18,8 +18,9 @@ export type RsbuildDevMiddlewareOptions = {
     };
 };
 export type Middlewares = Array<RequestHandler | [string, RequestHandler]>;
-export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<{
+export type GetMiddlewaresResult = {
     close: () => Promise<void>;
     onUpgrade: UpgradeEvent;
     middlewares: Middlewares;
-}>;
+};
+export declare const getMiddlewares: (options: RsbuildDevMiddlewareOptions) => Promise<GetMiddlewaresResult>;

package/dist-types/server/runner/basic.d.ts

@@ -2,6 +2,7 @@ import type { CompilerOptions, Runner } from './type';
 import type { BasicGlobalContext, BasicModuleScope, BasicRunnerFile, ModuleObject, RunnerRequirer } from './type';
 export interface IBasicRunnerOptions {
     name: string;
+    isBundleOutput: (modulePath: string) => boolean;
     runInNewContext?: boolean;
     readFileSync: (path: string) => string;
     dist: string;
@@ -18,6 +19,11 @@ export declare abstract class BasicRunner implements Runner {
     protected abstract createGlobalContext(): BasicGlobalContext;
     protected abstract createBaseModuleScope(): BasicModuleScope;
     protected abstract createModuleScope(requireFn: RunnerRequirer, m: ModuleObject, file: BasicRunnerFile): BasicModuleScope;
+    /**
+     * Get the file information for a given module path.
+     *
+     * @returns An object containing the file path, content, and subPath, or null if the module is not an rspack output.
+     */
     protected getFile(modulePath: string[] | string, currentDirectory: string): BasicRunnerFile | null;
     protected preExecute(_code: string, _file: BasicRunnerFile): void;
     protected postExecute(_m: Record<string, any>, _file: BasicRunnerFile): void;

package/dist-types/server/runner/index.d.ts

@@ -1,8 +1,10 @@
-import type { CompilerOptions, Runner, RunnerFactory } from './type';
+import type { Runner, RunnerFactory, RunnerFactoryOptions } from './type';
 export declare class BasicRunnerFactory implements RunnerFactory {
     protected name: string;
     constructor(name: string);
-    create(compilerOptions: CompilerOptions, dist: string, readFileSync: (path: string) => string): Runner;
-    protected createRunner(compilerOptions: CompilerOptions, dist: string, readFileSync: (path: string) => string): Runner;
+    create(options: RunnerFactoryOptions): Runner;
+    protected createRunner(options: RunnerFactoryOptions): Runner;
 }
-export declare const run: <T>(bundlePath: string, outputPath: string, compilerOptions: CompilerOptions, readFileSync: (path: string) => string) => Promise<T>;
+export declare const run: <T>({ bundlePath, ...runnerFactoryOptions }: RunnerFactoryOptions & {
+    bundlePath: string;
+}) => Promise<T>;

package/dist-types/server/runner/type.d.ts

@@ -31,6 +31,12 @@ export interface Runner {
     run(file: string): Promise<unknown>;
     getRequire(): RunnerRequirer;
 }
+export type RunnerFactoryOptions = {
+    dist: string;
+    compilerOptions: CompilerOptions;
+    readFileSync: (path: string) => string;
+    isBundleOutput: (modulePath: string) => boolean;
+};
 export interface RunnerFactory {
-    create(compilerOptions: CompilerOptions, dist: string, readFileSync: (fileName: string) => string): Runner;
+    create(options: RunnerFactoryOptions): Runner;
 }

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

@@ -7,8 +7,9 @@ type WatchFilesOptions = {
     compileMiddlewareAPI?: CompileMiddlewareAPI;
     root: string;
 };
-export declare function setupWatchFiles(options: WatchFilesOptions): Promise<{
+export type WatchFilesResult = {
     close(): Promise<void>;
-} | undefined>;
+};
+export declare function setupWatchFiles(options: WatchFilesOptions): Promise<WatchFilesResult | undefined>;
 export declare function createChokidar(pathOrGlobs: string[], root: string, options: ChokidarOptions): Promise<FSWatcher>;
 export {};

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

@@ -336,6 +336,11 @@ export type BuildCacheOptions = {
      * @default undefined
      */
     cacheDigest?: Array<string | undefined>;
+    /**
+     * An array of files containing build dependencies.
+     * Rspack will use the hash of each of these files to invalidate the persistent cache.
+     */
+    buildDependencies?: string[];
 };
 export type PrintFileSizeAsset = {
     /**
@@ -393,11 +398,14 @@ export type Preconnect = Array<string | PreconnectOption>;
 export type DnsPrefetch = string[];
 export type PreloadIncludeType = 'async-chunks' | 'initial' | 'all-assets' | 'all-chunks';
 export type Filter = Array<string | RegExp> | ((filename: string) => boolean);
-export interface PreloadOrPreFetchOption {
+export interface PreloadOrPrefetchOption {
     type?: PreloadIncludeType;
     include?: Filter;
     exclude?: Filter;
+    dedupe?: boolean;
 }
+export type PreloadOption = PreloadOrPrefetchOption;
+export type PrefetchOption = Omit<PreloadOrPrefetchOption, 'dedupe'>;
 export interface PerformanceConfig {
     /**
      * Whether to remove `console.[methodName]` in production build.
@@ -441,14 +449,14 @@ export interface PerformanceConfig {
      *
      * Specifies that the user agent must preemptively fetch and cache the target resource for current navigation.
      */
-    preload?: true | PreloadOrPreFetchOption;
+    preload?: true | PreloadOption;
     /**
      * Used to control resource `Prefetch`.
      *
      * Specifies that the user agent should preemptively fetch and cache the target resource as it
      * is likely to be required for a followup navigation.
      */
-    prefetch?: true | PreloadOrPreFetchOption;
+    prefetch?: true | PrefetchOption;
     /**
      * Whether capture timing information for each module,
      * same as the [profile](https://webpack.js.org/configuration/other-options/#profile) config of webpack.

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

@@ -1,5 +1,6 @@
 import type { ChainIdentifier } from '..';
 import type RspackChain from '../../compiled/rspack-chain/index.js';
+import type { RsbuildDevServer } from '../server/devServer';
 import type { EnvironmentConfig, HtmlBasicTag, MergedEnvironmentConfig, NormalizedEnvironmentConfig, RsbuildConfig } from './config';
 import type { RsbuildEntry, RsbuildTarget } from './rsbuild';
 import type { Rspack } from './rspack';
@@ -33,6 +34,13 @@ export type OnDevCompileDoneFn = (params: {
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnBeforeStartDevServerFn = (params: {
+    /**
+     * The dev server instance, the same as the return value of `createDevServer`.
+     */
+    server: RsbuildDevServer;
+    /**
+     * A read-only object that provides some context information about different environments.
+     */
     environments: Record<string, EnvironmentContext>;
 }) => MaybePromise<void>;
 export type OnBeforeStartProdServerFn = () => MaybePromise<void>;