@rsbuild/core 1.4.0 → 1.4.2

package/dist/index.js

@@ -1,5 +1,5 @@
 /*! For license information please see index.js.LICENSE.txt */
-let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin;
+let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult;
 import { rspack } from "@rspack/core";
 import { logger } from "../compiled/rslog/index.js";
 import node_path, { dirname, isAbsolute as external_node_path_isAbsolute, join, posix, relative, sep } from "node:path";
@@ -12,9 +12,12 @@ import node_os, { constants } from "node:os";
 import node_process from "node:process";
 import rspack_chain from "../compiled/rspack-chain/index.js";
 import { isPromise, isRegExp } from "node:util/types";
-import { promisify as external_node_util_promisify } from "node:util";
+import node_util, { promisify as external_node_util_promisify } from "node:util";
 import { lookup } from "../compiled/mrmime/index.js";
 import node_zlib from "node:zlib";
+import { Buffer as external_node_buffer_Buffer } from "node:buffer";
+import node_child_process, { execFile } from "node:child_process";
+import promises, { constants as promises_constants } from "node:fs/promises";
 var EsmMode, __webpack_modules__ = {
     "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         let clone = __webpack_require__("../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js"), typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"), isPlainObject = __webpack_require__("../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js");
@@ -2059,7 +2062,7 @@ async function updateEnvironmentContext(context, configs) {
 async function createContext(options, userConfig) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
     return {
-        version: "1.4.0",
+        version: "1.4.2",
         rootPath,
         distPath: '',
         cachePath,
@@ -2104,7 +2107,7 @@ let normalizePluginObject = (plugin)=>{
         setup () {}
     };
 };
-async function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfigs, inspectOptions, configType }) {
+async function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfigs, inspectOptions, rawExtraConfigs, configType }) {
     let { outputPath } = inspectOptions, files = [
         ...rawEnvironmentConfigs.map(({ name, content })=>1 === rawEnvironmentConfigs.length ? {
                 path: join(outputPath, 'rsbuild.config.mjs'),
@@ -2122,7 +2125,12 @@ async function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfi
                 label: `${upperFirst(configType)} Config (${name})`,
                 content
             };
-        })
+        }),
+        ...(rawExtraConfigs || []).map(({ name, content })=>({
+                path: join(outputPath, `${name}.config.mjs`),
+                label: `${upperFirst(name)} Config`,
+                content
+            }))
     ];
     await node_fs.promises.mkdir(outputPath, {
         recursive: !0
@@ -2168,10 +2176,14 @@ async function inspectConfig({ context, pluginManager, bundlerConfigs, inspectOp
         normalizedConfig: context.normalizedConfig,
         inspectOptions,
         pluginManager
-    }), outputPath = (context1 = context, (inspectOptions1 = inspectOptions).outputPath ? external_node_path_isAbsolute(inspectOptions1.outputPath) ? inspectOptions1.outputPath : join(context1.distPath, inspectOptions1.outputPath) : join(context1.distPath, RSBUILD_OUTPUTS_PATH));
+    }), outputPath = (context1 = context, (inspectOptions1 = inspectOptions).outputPath ? external_node_path_isAbsolute(inspectOptions1.outputPath) ? inspectOptions1.outputPath : join(context1.distPath, inspectOptions1.outputPath) : join(context1.distPath, RSBUILD_OUTPUTS_PATH)), rawExtraConfigs = inspectOptions.extraConfigs ? Object.entries(inspectOptions.extraConfigs).map(([name, content])=>({
+            name,
+            content: 'string' == typeof content ? content : stringifyConfig(content, inspectOptions.verbose)
+        })) : void 0;
     return inspectOptions.writeToDisk && await outputInspectConfigFiles({
         rawBundlerConfigs,
         rawEnvironmentConfigs,
+        rawExtraConfigs,
         inspectOptions: {
             ...inspectOptions,
             outputPath
@@ -3218,7 +3230,322 @@ let getInlineTests = (config)=>{
         scriptTests,
         styleTests
     };
-}, normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + removeLeadingSlash(s2) : s1 || s2 || '', stripBase = (path, base)=>{
+};
+function isInsideContainer() {
+    return void 0 === cachedResult && (cachedResult = (()=>{
+        try {
+            return node_fs.statSync('/run/.containerenv'), !0;
+        } catch  {
+            return !1;
+        }
+    })() || (void 0 === isDockerCached && (isDockerCached = function() {
+        try {
+            return node_fs.statSync('/.dockerenv'), !0;
+        } catch  {
+            return !1;
+        }
+    }() || function() {
+        try {
+            return node_fs.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+        } catch  {
+            return !1;
+        }
+    }()), isDockerCached)), cachedResult;
+}
+let isWsl = ()=>{
+    if ('linux' !== node_process.platform) return !1;
+    if (node_os.release().toLowerCase().includes('microsoft')) return !isInsideContainer();
+    try {
+        return !!node_fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') && !isInsideContainer();
+    } catch  {
+        return !1;
+    }
+}, is_wsl = node_process.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+function defineLazyProperty(object, propertyName, valueGetter) {
+    let define = (value)=>Object.defineProperty(object, propertyName, {
+            value,
+            enumerable: !0,
+            writable: !0
+        });
+    return Object.defineProperty(object, propertyName, {
+        configurable: !0,
+        enumerable: !0,
+        get () {
+            let result = valueGetter();
+            return define(result), result;
+        },
+        set (value) {
+            define(value);
+        }
+    }), object;
+}
+let execFileAsync = external_node_util_promisify(execFile);
+async function defaultBrowserId() {
+    if ('darwin' !== node_process.platform) throw Error('macOS only');
+    let { stdout } = await execFileAsync('defaults', [
+        'read',
+        'com.apple.LaunchServices/com.apple.launchservices.secure',
+        'LSHandlers'
+    ]), match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+    return match?.groups.id ?? 'com.apple.Safari';
+}
+let run_applescript_execFileAsync = external_node_util_promisify(execFile);
+async function runAppleScript(script, { humanReadableOutput = !0 } = {}) {
+    if ('darwin' !== node_process.platform) throw Error('macOS only');
+    let { stdout } = await run_applescript_execFileAsync("osascript", [
+        '-e',
+        script,
+        humanReadableOutput ? [] : [
+            '-ss'
+        ]
+    ]);
+    return stdout.trim();
+}
+async function bundleName(bundleId) {
+    return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+let windows_execFileAsync = external_node_util_promisify(execFile), windowsBrowserProgIds = {
+    AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+        name: 'Edge',
+        id: 'com.microsoft.edge.old'
+    },
+    MSEdgeDHTML: {
+        name: 'Edge',
+        id: 'com.microsoft.edge'
+    },
+    MSEdgeHTM: {
+        name: 'Edge',
+        id: 'com.microsoft.edge'
+    },
+    'IE.HTTP': {
+        name: 'Internet Explorer',
+        id: 'com.microsoft.ie'
+    },
+    FirefoxURL: {
+        name: 'Firefox',
+        id: 'org.mozilla.firefox'
+    },
+    ChromeHTML: {
+        name: 'Chrome',
+        id: 'com.google.chrome'
+    },
+    BraveHTML: {
+        name: 'Brave',
+        id: 'com.brave.Browser'
+    },
+    BraveBHTML: {
+        name: 'Brave Beta',
+        id: 'com.brave.Browser.beta'
+    },
+    BraveSSHTM: {
+        name: 'Brave Nightly',
+        id: 'com.brave.Browser.nightly'
+    }
+};
+class UnknownBrowserError extends Error {
+}
+async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
+    let { stdout } = await _execFileAsync('reg', [
+        'QUERY',
+        ' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
+        '/v',
+        'ProgId'
+    ]), match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+    if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+    let { id } = match.groups, browser = windowsBrowserProgIds[id];
+    if (!browser) throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+    return browser;
+}
+let default_browser_execFileAsync = external_node_util_promisify(execFile);
+async function default_browser_defaultBrowser() {
+    if ('darwin' === node_process.platform) {
+        let id = await defaultBrowserId();
+        return {
+            name: await bundleName(id),
+            id
+        };
+    }
+    if ('linux' === node_process.platform) {
+        let { stdout } = await default_browser_execFileAsync('xdg-mime', [
+            'query',
+            'default',
+            'x-scheme-handler/http'
+        ]), id = stdout.trim();
+        return {
+            name: id.replace(/.desktop$/, '').replace('-', ' ').toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase()),
+            id
+        };
+    }
+    if ('win32' === node_process.platform) return defaultBrowser();
+    throw Error('Only macOS, Linux, and Windows are supported');
+}
+let open_execFile = node_util.promisify(node_child_process.execFile), open_dirname = node_path.dirname(fileURLToPath(import.meta.url)), localXdgOpenPath = node_path.join(open_dirname, 'xdg-open'), { platform, arch } = node_process, getWslDrivesMountPoint = (()=>{
+    let mountPoint, defaultMountPoint = '/mnt/';
+    return async function() {
+        if (mountPoint) return mountPoint;
+        let configFilePath = '/etc/wsl.conf', isConfigFileExists = !1;
+        try {
+            await promises.access(configFilePath, promises_constants.F_OK), isConfigFileExists = !0;
+        } catch  {}
+        if (!isConfigFileExists) return defaultMountPoint;
+        let configContent = await promises.readFile(configFilePath, {
+            encoding: 'utf8'
+        }), configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+        return configMountPoint ? mountPoint = (mountPoint = configMountPoint.groups.mountPoint.trim()).endsWith('/') ? mountPoint : `${mountPoint}/` : defaultMountPoint;
+    };
+})(), getPowershellPathFromWsl = async ()=>{
+    let mountPoint = await getWslDrivesMountPoint();
+    return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+async function getWindowsDefaultBrowserFromWsl() {
+    let powershellPath = await getPowershellPathFromWsl(), encodedCommand = external_node_buffer_Buffer.from('(Get-ItemProperty -Path "HKCU:\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice").ProgId', 'utf16le').toString('base64'), { stdout } = await open_execFile(powershellPath, [
+        '-NoProfile',
+        '-NonInteractive',
+        '-ExecutionPolicy',
+        'Bypass',
+        '-EncodedCommand',
+        encodedCommand
+    ], {
+        encoding: 'utf8'
+    }), progId = stdout.trim(), browserMap = {
+        ChromeHTML: 'com.google.chrome',
+        MSEdgeHTM: 'com.microsoft.edge',
+        FirefoxURL: 'org.mozilla.firefox'
+    };
+    return browserMap[progId] ? {
+        id: browserMap[progId]
+    } : {};
+}
+let pTryEach = async (array, mapper)=>{
+    let latestError;
+    for (let item of array)try {
+        return await mapper(item);
+    } catch (error) {
+        latestError = error;
+    }
+    throw latestError;
+}, baseOpen = async (options)=>{
+    let command;
+    if (Array.isArray((options = {
+        wait: !1,
+        background: !1,
+        newInstance: !1,
+        allowNonzeroExitCode: !1,
+        ...options
+    }).app)) return pTryEach(options.app, (singleApp)=>baseOpen({
+            ...options,
+            app: singleApp
+        }));
+    let { name: app, arguments: appArguments = [] } = options.app ?? {};
+    if (appArguments = [
+        ...appArguments
+    ], Array.isArray(app)) return pTryEach(app, (appName)=>baseOpen({
+            ...options,
+            app: {
+                name: appName,
+                arguments: appArguments
+            }
+        }));
+    if ('browser' === app || 'browserPrivate' === app) {
+        let ids = {
+            'com.google.chrome': 'chrome',
+            'google-chrome.desktop': 'chrome',
+            'org.mozilla.firefox': 'firefox',
+            'firefox.desktop': 'firefox',
+            'com.microsoft.msedge': 'edge',
+            'com.microsoft.edge': 'edge',
+            'com.microsoft.edgemac': 'edge',
+            'microsoft-edge.desktop': 'edge'
+        }, browser = is_wsl ? await getWindowsDefaultBrowserFromWsl() : await default_browser_defaultBrowser();
+        if (browser.id in ids) {
+            let browserName = ids[browser.id];
+            return 'browserPrivate' === app && appArguments.push({
+                chrome: '--incognito',
+                firefox: '--private-window',
+                edge: '--inPrivate'
+            }[browserName]), baseOpen({
+                ...options,
+                app: {
+                    name: apps[browserName],
+                    arguments: appArguments
+                }
+            });
+        }
+        throw Error(`${browser.name} is not supported as a default browser`);
+    }
+    let cliArguments = [], childProcessOptions = {};
+    if ('darwin' === platform) command = 'open', options.wait && cliArguments.push('--wait-apps'), options.background && cliArguments.push('--background'), options.newInstance && cliArguments.push('--new'), app && cliArguments.push('-a', app);
+    else if ('win32' !== platform && (!is_wsl || isInsideContainer() || app)) {
+        if (app) command = app;
+        else {
+            let exeLocalXdgOpen = !1;
+            try {
+                await promises.access(localXdgOpenPath, promises_constants.X_OK), exeLocalXdgOpen = !0;
+            } catch  {}
+            command = node_process.versions.electron ?? ('android' === platform || !open_dirname || '/' === open_dirname || !exeLocalXdgOpen) ? 'xdg-open' : localXdgOpenPath;
+        }
+        appArguments.length > 0 && cliArguments.push(...appArguments), options.wait || (childProcessOptions.stdio = 'ignore', childProcessOptions.detached = !0);
+    } else {
+        command = is_wsl ? await getPowershellPathFromWsl() : `${node_process.env.SYSTEMROOT || node_process.env.windir || 'C:\\Windows'}\\System32\\WindowsPowerShell\\v1.0\\powershell`, cliArguments.push('-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand'), is_wsl || (childProcessOptions.windowsVerbatimArguments = !0);
+        let encodedArguments = [
+            'Start'
+        ];
+        options.wait && encodedArguments.push('-Wait'), app ? (encodedArguments.push(`"\`"${app}\`""`), options.target && appArguments.push(options.target)) : options.target && encodedArguments.push(`"${options.target}"`), appArguments.length > 0 && encodedArguments.push('-ArgumentList', (appArguments = appArguments.map((argument)=>`"\`"${argument}\`""`)).join(',')), options.target = external_node_buffer_Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+    }
+    'darwin' === platform && appArguments.length > 0 && cliArguments.push('--args', ...appArguments), options.target && cliArguments.push(options.target);
+    let subprocess = node_child_process.spawn(command, cliArguments, childProcessOptions);
+    return options.wait ? new Promise((resolve, reject)=>{
+        subprocess.once('error', reject), subprocess.once('close', (exitCode)=>{
+            if (!options.allowNonzeroExitCode && exitCode > 0) return void reject(Error(`Exited with code ${exitCode}`));
+            resolve(subprocess);
+        });
+    }) : (subprocess.unref(), subprocess);
+};
+function detectArchBinary(binary) {
+    if ('string' == typeof binary || Array.isArray(binary)) return binary;
+    let { [arch]: archBinary } = binary;
+    if (!archBinary) throw Error(`${arch} is not supported`);
+    return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+    if (wsl && is_wsl) return detectArchBinary(wsl);
+    if (!platformBinary) throw Error(`${platform} is not supported`);
+    return detectArchBinary(platformBinary);
+}
+let apps = {};
+defineLazyProperty(apps, 'chrome', ()=>detectPlatformBinary({
+        darwin: 'google chrome',
+        win32: 'chrome',
+        linux: [
+            'google-chrome',
+            'google-chrome-stable',
+            'chromium'
+        ]
+    }, {
+        wsl: {
+            ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+            x64: [
+                '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+                '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe'
+            ]
+        }
+    })), defineLazyProperty(apps, 'firefox', ()=>detectPlatformBinary({
+        darwin: 'firefox',
+        win32: 'C:\\Program Files\\Mozilla Firefox\\firefox.exe',
+        linux: 'firefox'
+    }, {
+        wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
+    })), defineLazyProperty(apps, 'edge', ()=>detectPlatformBinary({
+        darwin: 'microsoft edge',
+        win32: 'msedge',
+        linux: [
+            'microsoft-edge',
+            'microsoft-edge-dev'
+        ]
+    }, {
+        wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+    })), defineLazyProperty(apps, 'browser', ()=>'browser'), defineLazyProperty(apps, 'browserPrivate', ()=>'browserPrivate');
+let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + removeLeadingSlash(s2) : s1 || s2 || '', stripBase = (path, base)=>{
     if (path === base) return '/';
     let trailingSlashBase = addTrailingSlash(base);
     return path.startsWith(trailingSlashBase) ? path.slice(trailingSlashBase.length - 1) : path;
@@ -3403,19 +3730,27 @@ async function openBrowser(url) {
         }
     }
     try {
-        let { default: open } = await import("../compiled/open/index.js"), { apps } = open, options = browser ? {
+        let options = browser ? {
             app: {
                 name: apps[browser] ?? browser,
                 arguments: null == browserArgs ? void 0 : browserArgs.split(' ')
             }
         } : {};
-        return await open(url, options), !0;
+        return (await ((target, options)=>{
+            if ('string' != typeof target) throw TypeError('Expected a `target`');
+            return baseOpen({
+                ...options,
+                target
+            });
+        })(url, options)).on('error', (err)=>{
+            logger.error('Failed to launch browser in child process', err);
+        }), !0;
     } catch (err) {
-        return logger.error('Failed to open start URL.'), logger.error(err), !1;
+        return logger.error('Failed to launch browser.'), logger.error(err), !1;
     }
 }
 let openedURLs = [], replacePortPlaceholder = (url, port)=>url.replace(/<port>/g, String(port));
-async function open_open({ https, port, routes, config, clearCache }) {
+async function server_open_open({ https, port, routes, config, clearCache }) {
     let { targets, before } = ((config)=>{
         let { open } = config.server;
         return 'boolean' == typeof open ? {
@@ -3431,7 +3766,6 @@ async function open_open({ https, port, routes, config, clearCache }) {
             before: open.before
         };
     })(config);
-    if ('true' === process.env.CSB) return;
     clearCache && (openedURLs = []);
     let urls = [], host = await getHostInUrl(config.server.host), baseUrl = `${https ? 'https' : 'http'}://${host}:${port}`;
     for (let url of (targets.length ? urls.push(...targets.map((target)=>(function(str, base) {
@@ -4950,7 +5284,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             protocol,
             printUrls: config.server.printUrls,
             trailingLineBreak: !cliShortcutsEnabled
-        }), openPage = async ()=>open_open({
+        }), openPage = async ()=>server_open_open({
             https,
             port,
             routes,
@@ -5229,7 +5563,7 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
                     protocol,
                     printUrls: serverConfig.printUrls,
                     trailingLineBreak: !cliShortcutsEnabled
-                }), openPage = async ()=>open_open({
+                }), openPage = async ()=>server_open_open({
                     https,
                     port,
                     routes,
@@ -5287,7 +5621,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                         ...chain.get('experiments'),
                         rspackFuture: {
                             bundlerInfo: {
-                                force: !!config.security.sri.enable
+                                force: !1
                             }
                         }
                     }), process.env.RSPACK_CONFIG_VALIDATE ||= 'loose-silent';
@@ -6124,7 +6458,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let { config, browserslist } = environment, cacheRoot = node_path.join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto").dependency({
                             not: 'url'
                         }).resourceQuery({
-                            not: /raw|inline/
+                            not: /raw/
                         });
                         chain.module.rule(CHAIN_ID.RULE.JS_RAW).test(SCRIPT_REGEX).type('asset/source').resourceQuery(/raw/);
                         let dataUriRule = chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
@@ -6491,7 +6825,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     let config = api.getNormalizedConfig();
                     if (config.server.open) {
                         var _api_context_devServer;
-                        open_open({
+                        server_open_open({
                             https: null == (_api_context_devServer = api.context.devServer) ? void 0 : _api_context_devServer.https,
                             port,
                             routes,
@@ -7299,11 +7633,11 @@ async function runCLI() {
         ].includes(level) && (logger.level = level);
     }
     let { npm_execpath } = process.env;
-    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.0\n`);
+    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.2\n`);
     try {
         !function() {
             let cli = ((name = "")=>new CAC(name))('rsbuild');
-            cli.help(), cli.version("1.4.0"), 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`', {
+            cli.help(), cli.version("1.4.2"), 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('--log-level <level>', 'specify the log level, can be `info`, `warn`, `error` or `silent`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
                 type: [
@@ -7361,5 +7695,5 @@ async function runCLI() {
         logger.error('Failed to start Rsbuild CLI.'), logger.error(err);
     }
 }
-let src_version = "1.4.0";
+let src_version = "1.4.2";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger, mergeRsbuildConfig, rspack, runCLI, src_version as version };

package/dist-types/inspectConfig.d.ts

@@ -13,16 +13,15 @@ export declare const getRsbuildInspectConfig: ({ normalizedConfig, inspectOption
     }>;
     environmentConfigs: InspectConfigResult["origin"]["environmentConfigs"];
 };
-export declare function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfigs, inspectOptions, configType, }: {
+type RawConfig = {
+    name: string;
+    content: string;
+};
+export declare function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfigs, inspectOptions, rawExtraConfigs, configType, }: {
     configType: string;
-    rawEnvironmentConfigs: Array<{
-        name: string;
-        content: string;
-    }>;
-    rawBundlerConfigs: Array<{
-        name: string;
-        content: string;
-    }>;
+    rawExtraConfigs?: RawConfig[];
+    rawEnvironmentConfigs: RawConfig[];
+    rawBundlerConfigs: RawConfig[];
     inspectOptions: InspectConfigOptions & {
         outputPath: string;
     };
@@ -33,3 +32,4 @@ export declare function inspectConfig<B extends 'rspack' | 'webpack' = 'rspack'>
     bundlerConfigs: B extends 'rspack' ? Rspack.Configuration[] : WebpackConfig[];
     bundler?: 'rspack' | 'webpack';
 }): Promise<InspectConfigResult<B>>;
+export {};

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

@@ -85,6 +85,19 @@ export type InspectConfigOptions = {
      * @default false
      */
     writeToDisk?: boolean;
+    /**
+     * Extra configurations to be output.
+     * - key: The name of the configuration
+     * - value: The configuration object
+     * @example
+     * extraConfigs: {
+     *   // Output `rstest.config.mjs` file
+     *   'rstest': {
+     *     // ...
+     *   },
+     * }
+     */
+    extraConfigs?: Record<string, unknown>;
 };
 export type InspectConfigResult<B extends 'rspack' | 'webpack' = 'rspack'> = {
     rsbuildConfig: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -46,17 +46,17 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "1.4.0",
+    "@rspack/core": "1.4.1",
     "@rspack/lite-tapable": "~1.0.1",
     "@swc/helpers": "^0.5.17",
     "core-js": "~3.43.0",
     "jiti": "^2.4.2"
   },
   "devDependencies": {
-    "@rslib/core": "0.10.2",
+    "@rslib/core": "0.10.3",
     "@types/connect": "3.4.38",
     "@types/cors": "^2.8.19",
-    "@types/node": "^22.15.32",
+    "@types/node": "^22.15.33",
     "@types/on-finished": "2.3.5",
     "@types/webpack-bundle-analyzer": "4.7.0",
     "@types/ws": "^8.18.1",
@@ -74,15 +74,15 @@
     "launch-editor-middleware": "^2.10.0",
     "mrmime": "^2.0.1",
     "on-finished": "2.4.1",
-    "open": "^8.4.0",
+    "open": "^10.1.2",
     "picocolors": "^1.1.1",
     "postcss": "^8.5.6",
     "postcss-load-config": "6.0.1",
     "postcss-loader": "8.1.1",
-    "prebundle": "1.3.3",
+    "prebundle": "1.3.4",
     "reduce-configs": "^1.1.0",
     "rsbuild-dev-middleware": "0.3.0",
-    "rslog": "^1.2.7",
+    "rslog": "^1.2.8",
     "rspack-chain": "^1.2.6",
     "rspack-manifest-plugin": "5.0.3",
     "sirv": "^3.0.1",