@rsbuild/core 2.2.4 → 2.2.5

package/compiled/@rstackjs/load-config/index.d.ts

@@ -43,24 +43,45 @@ type LoadConfigOptions<Params extends unknown[] = []> = {
      */
     fresh?: boolean;
 };
+type ConfigFileMeta = {
+    /**
+     * Absolute path of the actual configuration file.
+     * Use `null` when no underlying configuration file was found.
+     */
+    filePath: string | null;
+    /**
+     * Absolute paths of additional configuration dependencies.
+     * These are merged with the adapter file and its collected dependencies.
+     */
+    dependencies?: readonly string[];
+};
 type LoadConfigResult<Config = unknown> = {
     /**
      * The loaded configuration object.
      */
     content: Config;
     /**
-     * The path to the loaded configuration file.
-     * Return `null` if the configuration file is not found.
+     * The path to the loaded configuration file, or the source set by `withConfigMeta`.
+     * Returns `null` if no configuration file was found, including an explicit
+     * `null` source set by `withConfigMeta`.
      */
     filePath: string | null;
     /**
-     * Absolute file paths of statically imported (relative) dependencies of the
-     * config file.
+     * Absolute paths of collected configuration dependencies. When `withConfigMeta`
+     * is used, also includes explicit dependencies and the loaded adapter file,
+     * with duplicates removed.
      */
     dependencies: string[];
 };
 
+/**
+ * Attach file metadata in place and return the original configuration object.
+ * Repeated calls replace the metadata. Requires an extensible, unfrozen object.
+ * Call this after merging the config: object spread does not preserve metadata.
+ */
+declare function withConfigMeta<Config extends object>(config: Config, meta: ConfigFileMeta): Config;
+
 declare function loadConfig<Config = unknown, Params extends unknown[] = []>({ cwd, path, configFileNames, loader, exportName, configParams, fresh, }?: LoadConfigOptions<Params>): Promise<LoadConfigResult<Config>>;
 
-export { loadConfig };
-export type { ConfigDefinition, ConfigLoader, LoadConfigOptions, LoadConfigResult };
+export { loadConfig, withConfigMeta };
+export type { ConfigDefinition, ConfigFileMeta, ConfigLoader, LoadConfigOptions, LoadConfigResult };

package/compiled/@rstackjs/load-config/package.json

@@ -1 +1 @@
-{"name":"@rstackjs/load-config","version":"0.1.2","license":"MIT","types":"index.d.ts","type":"module"}
+{"name":"@rstackjs/load-config","version":"1.0.0","license":"MIT","types":"index.d.ts","type":"module"}

package/dist/626.js

@@ -3425,7 +3425,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig, logger, loadConfigResult) {
     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, hooks = initHooks();
     return {
-        version: "2.2.4",
+        version: "2.2.5",
         rootPath,
         configFile: loadConfigResult?.filePath ?? userConfig._privateMeta?.configFilePath,
         configFileDependencies: loadConfigResult?.dependencies ?? userConfig._privateMeta?.configFileDependencies ?? [],
@@ -5261,11 +5261,36 @@ function pluginExternals() {
         }
     };
 }
-async function gzipSize(input) {
+function getCompression(compressed) {
+    let { type = 'gzip', level = 6 } = 'object' == typeof compressed ? compressed : {};
+    return 'brotli' === type ? {
+        type,
+        level,
+        header: 'Br',
+        label: 'brotli',
+        sizeKey: 'brotliSize',
+        totalKey: 'totalBrotliSize'
+    } : {
+        type,
+        level,
+        header: 'Gzip',
+        label: 'gzipped',
+        sizeKey: 'gzippedSize',
+        totalKey: 'totalGzipSize'
+    };
+}
+async function calcCompressedSize(input, type, level) {
     return (await new Promise((resolve, reject)=>{
-        node_zlib.gzip(input, (err, result)=>{
+        let callback = (err, result)=>{
             err ? reject(err) : resolve(result);
-        });
+        };
+        'brotli' === type ? node_zlib.brotliCompress(input, {
+            params: {
+                [node_zlib.constants.BROTLI_PARAM_QUALITY]: level
+            }
+        }, callback) : node_zlib.gzip(input, {
+            level
+        }, callback);
     })).length;
 }
 function getSnapshotPath(dir, snapshotHash) {
@@ -5298,7 +5323,7 @@ let EXCLUDE_ASSET_REGEX = /\.(?:map|LICENSE\.txt|d\.(?:ts|mts|cts))$/, isSignifi
         length: label.length
     };
 }, getAssetColor = (size)=>size > 300000 ? color.red : size > 100000 ? color.yellow : (input)=>input;
-function getHeader(maxFileLength, maxSizeLength, fileHeader, showGzipHeader) {
+function getHeader(maxFileLength, maxSizeLength, fileHeader, compressionHeader) {
     let lengths = [
         maxFileLength,
         maxSizeLength
@@ -5306,7 +5331,7 @@ function getHeader(maxFileLength, maxSizeLength, fileHeader, showGzipHeader) {
         fileHeader,
         'Size'
     ];
-    showGzipHeader && rowTypes.push('Gzip');
+    compressionHeader && rowTypes.push(compressionHeader);
     let headerRow = rowTypes.reduce((prev, cur, index)=>{
         let length = lengths[index], curLabel = cur;
         return length && (curLabel = cur.length < length ? cur + ' '.repeat(length - cur.length) : cur), `${prev + curLabel}   `;
@@ -5321,30 +5346,31 @@ let calcFileSize = (len)=>{
     return -1 === queryIndex ? assetName : assetName.slice(0, queryIndex);
 };
 async function printFileSizes(options, stats, rootPath, distPath, environmentName, previousSizes, saveSnapshot) {
-    let logs = [], showDetail = !1 !== options.detail, showDiff = !1 !== options.diff && null !== previousSizes, showTotal = !1 !== options.total;
+    let logs = [], compression = getCompression(options.compressed), prev = previousSizes?.[environmentName], showDetail = !1 !== options.detail, showDiff = !1 !== options.diff && null !== previousSizes, prevType = prev?.compressionType ?? (!!prev?.totalGzipSize && 'gzip'), showCompressedDiff = showDiff && prevType === compression.type, showTotal = !1 !== options.total;
     if (!showTotal && !showDetail) return {
         logs
     };
     let relativeDistPath = node_path.relative(rootPath, distPath), rootFolderLabel = `${relativeDistPath || '.'}${node_path.sep}`, snapshot = saveSnapshot ? {
         files: {},
         totalSize: 0,
-        totalGzipSize: 0
-    } : null, formatAsset = (filePath, size, gzippedSize)=>{
+        totalGzipSize: 0,
+        compressionType: !!options.compressed && compression.type
+    } : null, formatAsset = (filePath, size, compressedSize)=>{
         let normalizedPath = '';
         (snapshot || showDiff) && (normalizedPath = normalizeFilePath(filePath), snapshot && (snapshot.files[normalizedPath] = {
             size,
-            gzippedSize: gzippedSize ?? void 0
+            [compression.sizeKey]: compressedSize ?? void 0
         }));
-        let sizeLabel = calcFileSize(size), sizeLabelLength = sizeLabel.length, gzipSizeLabel = gzippedSize ? getAssetColor(gzippedSize)(calcFileSize(gzippedSize)) : null;
+        let sizeLabel = calcFileSize(size), sizeLabelLength = sizeLabel.length, compressedSizeLabel = compressedSize ? getAssetColor(compressedSize)(calcFileSize(compressedSize)) : null;
         if (showDiff) {
-            let sizeData = previousSizes[environmentName]?.files[normalizedPath], sizeDiff = size - (sizeData?.size ?? 0);
+            let sizeData = prev?.files[normalizedPath], sizeDiff = size - (sizeData?.size ?? 0);
             if (isSignificantDiff(sizeDiff)) {
                 let { label, length } = formatDiff(sizeDiff);
                 sizeLabel += ` ${label}`, sizeLabelLength += length + 1;
             }
-            if (null !== gzippedSize) {
-                let gzipDiff = gzippedSize - (sizeData?.gzippedSize ?? 0);
-                isSignificantDiff(gzipDiff) && (gzipSizeLabel += ` ${formatDiff(gzipDiff).label}`);
+            if (null !== compressedSize && showCompressedDiff) {
+                let compressedDiff = compressedSize - (sizeData?.[compression.sizeKey] ?? 0);
+                isSignificantDiff(compressedDiff) && (compressedSizeLabel += ` ${formatDiff(compressedDiff).label}`);
             }
         }
         let separatorIndex = filePath.lastIndexOf('/'), folderLabel = -1 === separatorIndex ? rootFolderLabel : `${node_path.join(relativeDistPath, filePath.slice(0, separatorIndex))}${node_path.sep}`, filename = -1 === separatorIndex ? filePath : filePath.slice(separatorIndex + 1);
@@ -5355,8 +5381,8 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
             size,
             sizeLabel,
             sizeLabelLength,
-            gzippedSize,
-            gzipSizeLabel
+            compressedSize,
+            compressedSizeLabel
         };
     }, getAssets = async ()=>{
         let { exclude, include } = options, formattedAssets = [], compilationAssets = stats.compilation.assets;
@@ -5371,7 +5397,7 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
                 };
                 if (exclude?.(publicAsset) || include && !include(publicAsset)) continue;
             }
-            void 0 === content ? formattedAssets.push(formatAsset(filePath, size, null)) : formattedAssets.push(gzipSize(content).then((gzippedSize)=>formatAsset(filePath, size, gzippedSize)));
+            void 0 === content ? formattedAssets.push(formatAsset(filePath, size, null)) : formattedAssets.push(calcCompressedSize(content, compression.type, compression.level).then((compressedSize)=>formatAsset(filePath, size, compressedSize)));
         }
         return (await Promise.all(formattedAssets)).sort((a, b)=>a.size - b.size);
     }, assets = await getAssets();
@@ -5379,15 +5405,15 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
         logs
     };
     logs.push(''), showDetail && 1 === assets.length && (showTotal = !1);
-    let { totalSize, totalGzipSize } = ((assets, compressed)=>{
-        let totalSize = 0, totalGzipSize = 0;
-        for (let { size, gzippedSize } of assets)totalSize += size, compressed && (totalGzipSize += gzippedSize ?? size);
+    let { totalSize, totalCompressedSize } = ((assets, compressed)=>{
+        let totalSize = 0, totalCompressedSize = 0;
+        for (let { size, compressedSize } of assets)totalSize += size, compressed && (totalCompressedSize += compressedSize ?? size);
         return {
             totalSize,
-            totalGzipSize
+            totalCompressedSize
         };
-    })(assets, options.compressed);
-    snapshot && (snapshot.totalSize = totalSize, snapshot.totalGzipSize = totalGzipSize);
+    })(assets, !!options.compressed);
+    snapshot && (snapshot.totalSize = totalSize, options.compressed && (snapshot[compression.totalKey] = totalCompressedSize));
     let fileHeader = showDetail ? `File (${environmentName})` : '', { totalSizeTitle, totalSizeLabel, totalSizeLabelLength } = (()=>{
         if (!showTotal) return {
             totalSizeTitle: '',
@@ -5396,7 +5422,7 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
         };
         let totalSizeTitle = showDetail ? 'Total:' : `Total size (${environmentName}):`, totalSizeLabel = calcFileSize(totalSize), totalSizeLabelLength = totalSizeLabel.length;
         if (showDiff) {
-            let totalSizeDiff = totalSize - (previousSizes[environmentName]?.totalSize ?? 0);
+            let totalSizeDiff = totalSize - (prev?.totalSize ?? 0);
             if (isSignificantDiff(totalSizeDiff)) {
                 let { label, length } = formatDiff(totalSizeDiff);
                 totalSizeLabel += ` ${label}`, totalSizeLabelLength += length + 1;
@@ -5407,7 +5433,11 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
             totalSizeLabel,
             totalSizeLabelLength
         };
-    })(), getCustomTotal = ()=>'function' == typeof options.total ? options.total({
+    })(), getCompressedTotalDiff = ()=>{
+        if (!showCompressedDiff) return '';
+        let diff = totalCompressedSize - (prev?.[compression.totalKey] ?? 0);
+        return isSignificantDiff(diff) ? ` ${formatDiff(diff).label}` : '';
+    }, getCustomTotal = ()=>'function' == typeof options.total ? options.total({
             environmentName,
             distPath: relativeDistPath,
             assets: assets.map((asset)=>({
@@ -5415,17 +5445,18 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
                     size: asset.size
                 })),
             totalSize,
-            totalGzipSize
+            totalGzipSize: 'gzip' === compression.type ? totalCompressedSize : 0,
+            totalBrotliSize: options.compressed && 'brotli' === compression.type ? totalCompressedSize : void 0
         }) : null;
     if (showDetail) {
-        let maxFileLength = Math.max(showTotal ? totalSizeTitle.length : 0, fileHeader.length), maxSizeLength = totalSizeLabelLength, hasGzipSize = !1;
-        for (let asset of assets)asset.filenameLength > maxFileLength && (maxFileLength = asset.filenameLength), asset.sizeLabelLength > maxSizeLength && (maxSizeLength = asset.sizeLabelLength), null !== asset.gzippedSize && (hasGzipSize = !0);
-        let showGzipHeader = !!(options.compressed && hasGzipSize);
-        for (let asset of (logs.push(getHeader(maxFileLength, maxSizeLength, fileHeader, showGzipHeader)), assets)){
-            let { sizeLabel, filenameLabel } = asset, { sizeLabelLength, gzipSizeLabel, filenameLength } = asset;
+        let maxFileLength = Math.max(showTotal ? totalSizeTitle.length : 0, fileHeader.length), maxSizeLength = totalSizeLabelLength, hasCompressedSize = !1;
+        for (let asset of assets)asset.filenameLength > maxFileLength && (maxFileLength = asset.filenameLength), asset.sizeLabelLength > maxSizeLength && (maxSizeLength = asset.sizeLabelLength), null !== asset.compressedSize && (hasCompressedSize = !0);
+        let showCompressedHeader = !!(options.compressed && hasCompressedSize);
+        for (let asset of (logs.push(getHeader(maxFileLength, maxSizeLength, fileHeader, showCompressedHeader && compression.header)), assets)){
+            let { sizeLabel, filenameLabel } = asset, { sizeLabelLength, compressedSizeLabel, filenameLength } = asset;
             sizeLabelLength < maxSizeLength && (sizeLabel += ' '.repeat(maxSizeLength - sizeLabelLength)), filenameLength < maxFileLength && (filenameLabel += ' '.repeat(maxFileLength - filenameLength));
             let log = `${filenameLabel}   ${sizeLabel}`;
-            gzipSizeLabel && (log += `   ${gzipSizeLabel}`), logs.push(log);
+            compressedSizeLabel && (log += `   ${compressedSizeLabel}`), logs.push(log);
         }
         if (showTotal) {
             logs.push('');
@@ -5434,11 +5465,8 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
             else {
                 let log = '';
                 if (log += ' '.repeat(maxFileLength - totalSizeTitle.length), log += color.magenta(totalSizeTitle), log += `   ${totalSizeLabel}`, options.compressed) {
-                    let colorFn = getAssetColor(totalGzipSize / assets.length);
-                    if (log += ' '.repeat(maxSizeLength - totalSizeLabelLength), log += `   ${colorFn(calcFileSize(totalGzipSize))}`, showDiff) {
-                        let totalGzipSizeDiff = totalGzipSize - (previousSizes[environmentName]?.totalGzipSize ?? 0);
-                        isSignificantDiff(totalGzipSizeDiff) && (log += ` ${formatDiff(totalGzipSizeDiff).label}`);
-                    }
+                    let colorFn = getAssetColor(totalCompressedSize / assets.length);
+                    log += ' '.repeat(maxSizeLength - totalSizeLabelLength), log += `   ${colorFn(calcFileSize(totalCompressedSize))}${getCompressedTotalDiff()}`;
                 }
                 logs.push(log);
             }
@@ -5448,7 +5476,7 @@ async function printFileSizes(options, stats, rootPath, distPath, environmentNam
         if (customTotal) logs.push(customTotal);
         else {
             let log = `${color.magenta(totalSizeTitle)} ${totalSizeLabel}`;
-            options.compressed && (log += color.green(` (${calcFileSize(totalGzipSize)} gzipped)`)), logs.push(log);
+            options.compressed && (log += color.green(` (${calcFileSize(totalCompressedSize)}${getCompressedTotalDiff()} ${compression.label})`)), logs.push(log);
         }
     }
     return logs.push(''), {
@@ -10068,7 +10096,11 @@ let canReadExport = (module)=>null !== module && ('object' == typeof module || '
         configExport: getConfigExport(await jiti.import(configPath), exportName, configPath),
         dependencies: []
     };
-}, JS_CONFIG_REGEXP = /\.(?:js|mjs|cjs)$/, loadWithNative = async (configPath, fresh)=>{
+}, CONFIG_META = Symbol.for('@rstackjs/load-config/meta');
+function getConfigMeta(config) {
+    if (null !== config && 'object' == typeof config && Object.hasOwn(config, CONFIG_META)) return config[CONFIG_META];
+}
+let JS_CONFIG_REGEXP = /\.(?:js|mjs|cjs)$/, loadWithNative = async (configPath, fresh)=>{
     let configFileURL = pathToFileURL(configPath).href;
     if (!fresh) return {
         configModule: await import(configFileURL),
@@ -10084,7 +10116,7 @@ let canReadExport = (module)=>null !== module && ('object' == typeof module || '
     };
 };
 async function dist_loadConfig({ cwd = process.cwd(), path, configFileNames = [], loader = 'auto', exportName = 'default', configParams = [], fresh = !1 } = {}) {
-    let loadedConfig;
+    let loadedConfig, content;
     if (!path && 0 === configFileNames.length) throw Error('Either `path` or at least one `configFileNames` entry must be provided.');
     let configPath = ((root, customConfig, configFileNames = [])=>{
         if (customConfig) {
@@ -10120,17 +10152,20 @@ async function dist_loadConfig({ cwd = process.cwd(), path, configFileNames = []
     if ('function' == typeof configExport) {
         let result = await configExport(...configParams);
         if (void 0 === result) throw Error('The config function must return a config object.');
-        return {
-            content: result,
-            filePath: configPath,
-            dependencies
-        };
-    }
-    return {
-        content: configExport,
+        content = result;
+    } else content = configExport;
+    let meta = getConfigMeta(content), result = {
+        content,
         filePath: configPath,
         dependencies
     };
+    return meta && (result.filePath = meta.filePath, result.dependencies = [
+        ...new Set([
+            ...meta.dependencies ?? [],
+            configPath,
+            ...dependencies
+        ])
+    ]), result;
 }
 function defineConfig(config) {
     return config;
@@ -10226,7 +10261,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands(argv) {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.2.4"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.2.5"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--dist-path <dir>', 'Set the root directory of output files').option('--source-map', 'Enable source map').option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -10291,7 +10326,7 @@ function setupCommands(argv) {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.2.4\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.2.5\n`);
 }
 function setupLogLevel(argv) {
     if (argv.length <= 3) return;
@@ -10313,5 +10348,5 @@ function runCLI({ argv = process.argv } = {}) {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.2.4";
+let src_version = "2.2.5";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, mrmime_lookup, runCLI, src_logger as logger, src_version as version };

package/dist/types/config.d.ts

@@ -497,16 +497,28 @@ export type PrintFileSizeOptions = {
         assets: PrintFileSizeAsset[];
         totalSize: number;
         totalGzipSize: number;
+        totalBrotliSize?: number;
     }) => string);
     /**
    * Whether to print the size of each static asset.
    * @default true
    */ detail?: boolean;
     /**
-   * Whether to print the gzip-compressed size of each static asset.
-   * Disable this option can save some gzip computation time for large projects.
+   * Whether to print the compressed size of each static asset.
+   * Set to `true` to use gzip, or specify `type` to select gzip or Brotli.
+   * Disabling this option saves compression computation time for large projects.
    * @default true
-   */ compressed?: boolean;
+   */ compressed?: boolean | {
+        /**
+         * The compression algorithm used to calculate file sizes.
+         * @default 'gzip'
+         */ type?: 'gzip' | 'brotli';
+        /**
+         * The compression level: an integer from 0 to 9 for gzip, or 0 to 11 for Brotli.
+         * Higher levels generally produce smaller sizes but take longer to calculate.
+         * @default 6
+         */ level?: number;
+    };
     /**
    * A filter function to determine which static assets to print.
    * If returned `false`, the static asset will be excluded and not included in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "2.2.4",
+  "version": "2.2.5",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -41,7 +41,7 @@
   "devDependencies": {
     "@jridgewell/remapping": "^2.3.5",
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@rstackjs/load-config": "^0.1.2",
+    "@rstackjs/load-config": "^1.0.0",
     "@types/cors": "^2.8.19",
     "@types/node": "^24.13.3",
     "@types/on-finished": "2.3.5",