feat(splitChunks): support splitChunks.minSizeReduction (#9341)

* feat(splitChunks): support splitChunks.minSizeReduction

* Update website/docs/zh/plugins/webpack/split-chunks-plugin.mdx

Co-authored-by: neverland <[email protected]>

* Update website/docs/en/plugins/webpack/split-chunks-plugin.mdx

Co-authored-by: neverland <[email protected]>

* chore: correct descriptions

---------

Co-authored-by: neverland <[email protected]>

crates/node_binding/binding.d.ts

@@ -1396,6 +1396,7 @@ export interface RawCacheGroupOptions {
   automaticNameDelimiter?: string
   minChunks?: number
   minSize?: number | RawSplitChunkSizes
+  minSizeReduction?: number | RawSplitChunkSizes
   maxSize?: number | RawSplitChunkSizes
   maxAsyncSize?: number | RawSplitChunkSizes
   maxInitialSize?: number | RawSplitChunkSizes
@@ -2230,6 +2231,7 @@ export interface RawSplitChunksOptions {
   minChunks?: number
   hidePathInfo?: boolean
   minSize?: number | RawSplitChunkSizes
+  minSizeReduction?: number | RawSplitChunkSizes
   enforceSizeThreshold?: number
   minRemainingSize?: number | RawSplitChunkSizes
   maxSize?: number | RawSplitChunkSizes

crates/node_binding/src/raw_options/raw_split_chunks/mod.rs

@@ -47,6 +47,7 @@ pub struct RawSplitChunksOptions {
   pub min_chunks: Option<u32>,
   pub hide_path_info: Option<bool>,
   pub min_size: Option<Either<f64, RawSplitChunkSizes>>,
+  pub min_size_reduction: Option<Either<f64, RawSplitChunkSizes>>,
   //   pub min_size_reduction: usize,
   pub enforce_size_threshold: Option<f64>,
   pub min_remaining_size: Option<Either<f64, RawSplitChunkSizes>>,
@@ -84,6 +85,7 @@ pub struct RawCacheGroupOptions {
   //   pub max_initial_requests: usize,
   pub min_chunks: Option<u32>,
   pub min_size: Option<Either<f64, RawSplitChunkSizes>>,
+  pub min_size_reduction: Option<Either<f64, RawSplitChunkSizes>>,
   //   pub min_size_reduction: usize,
   //   pub enforce_size_threshold: usize,
   //   pub min_remaining_size: usize,
@@ -134,6 +136,8 @@ impl From<RawSplitChunksOptions> for rspack_plugin_split_chunks::PluginOptions {
 
     let overall_min_size = create_sizes(raw_opts.min_size);
 
+    let overall_min_size_reduction = create_sizes(raw_opts.min_size_reduction);
+
     let overall_max_size = create_sizes(raw_opts.max_size);
 
     let overall_max_async_size = create_sizes(raw_opts.max_async_size).merge(&overall_max_size);
@@ -158,6 +162,12 @@ impl From<RawSplitChunksOptions> for rspack_plugin_split_chunks::PluginOptions {
             &overall_min_size
           });
 
+          let min_size_reduction = create_sizes(v.min_size_reduction).merge(if enforce {
+            &empty_sizes
+          } else {
+            &overall_min_size_reduction
+          });
+
           let max_size = create_sizes(v.max_size);
 
           let max_async_size = create_sizes(v.max_async_size)
@@ -214,6 +224,7 @@ impl From<RawSplitChunksOptions> for rspack_plugin_split_chunks::PluginOptions {
             }),
             min_chunks,
             min_size,
+            min_size_reduction,
             automatic_name_delimiter: v
               .automatic_name_delimiter
               .unwrap_or(overall_automatic_name_delimiter.clone()),

crates/rspack_plugin_split_chunks/src/options/cache_group.rs

@@ -31,6 +31,7 @@ pub struct CacheGroup {
   pub name: ChunkNameGetter,
   pub priority: f64,
   pub min_size: SplitChunkSizes,
+  pub min_size_reduction: SplitChunkSizes,
   pub reuse_existing_chunk: bool,
   /// number of referenced chunks
   pub min_chunks: u32,

crates/rspack_plugin_split_chunks/src/plugin/min_size.rs

@@ -3,9 +3,33 @@ use std::ops::Deref;
 use rspack_core::{Compilation, SourceType};
 
 use super::ModuleGroupMap;
-use crate::{module_group::ModuleGroup, CacheGroup, SplitChunksPlugin};
+use crate::{module_group::ModuleGroup, CacheGroup, SplitChunkSizes, SplitChunksPlugin};
 
 impl SplitChunksPlugin {
+  pub(crate) fn check_min_size_reduction(
+    sizes: &SplitChunkSizes,
+    min_size_reduction: &SplitChunkSizes,
+    chunk_count: usize,
+  ) -> bool {
+    for (ty, min_reduction_size) in min_size_reduction.iter() {
+      if *min_reduction_size == 0.0f64 {
+        continue;
+      }
+
+      let Some(size) = sizes.get(ty) else {
+        continue;
+      };
+      if *size == 0.0f64 {
+        continue;
+      }
+      if size * (chunk_count as f64) < *min_reduction_size {
+        return false;
+      }
+    }
+
+    true
+  }
+
   /// Return `true` if the `ModuleGroup` become empty.
   pub(crate) fn remove_min_size_violating_modules(
     module_group_key: &str,
@@ -14,7 +38,7 @@ impl SplitChunksPlugin {
     cache_group: &CacheGroup,
   ) -> bool {
     // Find out what `SourceType`'s size is not fit the min_size
-    let violating_source_types = module_group
+    let violating_source_types: Box<[SourceType]> = module_group
     .sizes
     .iter()
     .filter_map(|(module_group_ty, module_group_ty_size)| {
@@ -95,6 +119,10 @@ impl SplitChunksPlugin {
           compilation,
           module_group,
           cache_group,
+        ) || !Self::check_min_size_reduction(
+          &module_group.sizes,
+          &cache_group.min_size_reduction,
+          module_group.chunks.len(),
         ) {
           Some(module_group_key.clone())
         } else {

crates/rspack_plugin_split_chunks/src/plugin/module_group.rs

@@ -566,7 +566,8 @@ impl SplitChunksPlugin {
         }
 
         // Validate `min_size` again
-        if Self::remove_min_size_violating_modules(key, compilation, other_module_group, cache_group) {
+        if Self::remove_min_size_violating_modules(key, compilation, other_module_group, cache_group)
+          || !Self::check_min_size_reduction(&other_module_group.sizes, &cache_group.min_size_reduction, other_module_group.chunks.len()) {
           tracing::trace!(
             "{key} is deleted for violating min_size {:#?}",
             cache_group.min_size,

packages/rspack/etc/core.api.md

@@ -10203,6 +10203,7 @@ type SharedOptimizationSplitChunksCacheGroup = {
     name?: false | OptimizationSplitChunksName;
     filename?: Filename;
     minSize?: OptimizationSplitChunksSizes;
+    minSizeReduction?: OptimizationSplitChunksSizes;
     maxSize?: OptimizationSplitChunksSizes;
     maxAsyncSize?: OptimizationSplitChunksSizes;
     maxInitialSize?: OptimizationSplitChunksSizes;

packages/rspack/src/builtin-plugin/SplitChunksPlugin.ts

@@ -92,6 +92,7 @@ function toRawSplitChunksOptions(
 		cacheGroups = {},
 		fallbackCacheGroup,
 		minSize,
+		minSizeReduction,
 		maxSize,
 		maxAsyncSize,
 		maxInitialSize,
@@ -112,6 +113,7 @@ function toRawSplitChunksOptions(
 					name,
 					chunks,
 					minSize,
+					minSizeReduction,
 					maxSize,
 					maxAsyncSize,
 					maxInitialSize,
@@ -123,6 +125,7 @@ function toRawSplitChunksOptions(
 					name: getName(name),
 					chunks: getChunks(chunks),
 					minSize: JsSplitChunkSizes.__to_binding(minSize),
+					minSizeReduction: JsSplitChunkSizes.__to_binding(minSizeReduction),
 					maxSize: JsSplitChunkSizes.__to_binding(maxSize),
 					maxAsyncSize: JsSplitChunkSizes.__to_binding(maxAsyncSize),
 					maxInitialSize: JsSplitChunkSizes.__to_binding(maxInitialSize),
@@ -135,6 +138,7 @@ function toRawSplitChunksOptions(
 			...fallbackCacheGroup
 		},
 		minSize: JsSplitChunkSizes.__to_binding(minSize),
+		minSizeReduction: JsSplitChunkSizes.__to_binding(minSizeReduction),
 		maxSize: JsSplitChunkSizes.__to_binding(maxSize),
 		maxAsyncSize: JsSplitChunkSizes.__to_binding(maxAsyncSize),
 		maxInitialSize: JsSplitChunkSizes.__to_binding(maxInitialSize),

packages/rspack/src/config/types.ts

@@ -2162,6 +2162,8 @@ type SharedOptimizationSplitChunksCacheGroup = {
 	 */
 	minSize?: OptimizationSplitChunksSizes;
 
+	minSizeReduction?: OptimizationSplitChunksSizes;
+
 	/** Maximum size, in bytes, for a chunk to be generated. */
 	maxSize?: OptimizationSplitChunksSizes;
 

tests/webpack-test/__snapshots__/StatsTestCases.basictest.js.snap

@@ -2397,16 +2397,18 @@ Rspack x.x.x compiled successfully"
 `;
 
 exports[`StatsTestCases should print correct stats for split-chunks-min-size-reduction 1`] = `
-"Entrypoint main 9.58 KiB = default/main.js
+"Entrypoint main 9.49 KiB = default/main.js
 chunk (runtime: main) default/async-c.js (async-c) 50 bytes <{909}> ={44}= [rendered]
   > ./c ./index.js 3:0-47
   ./c.js 50 bytes [built] [code generated]
-chunk (runtime: main) default/async-a.js (async-a) 50 bytes <{909}> ={728}= [rendered]
+chunk (runtime: main) default/async-a.js (async-a) 176 bytes <{909}> [rendered]
   > ./a ./index.js 1:0-47
   ./a.js 50 bytes [built] [code generated]
-chunk (runtime: main) default/async-b.js (async-b) 50 bytes <{909}> ={728}= [rendered]
+  ./node_modules/shared.js?1 126 bytes [dependent] [built] [code generated]
+chunk (runtime: main) default/async-b.js (async-b) 176 bytes <{909}> [rendered]
   > ./b ./index.js 2:0-47
   ./b.js 50 bytes [built] [code generated]
+  ./node_modules/shared.js?1 126 bytes [dependent] [built] [code generated]
 chunk (runtime: main) default/async-e.js (async-e) 50 bytes <{909}> ={44}= [rendered]
   > ./e ./index.js 5:0-47
   ./e.js 50 bytes [built] [code generated]
@@ -2418,11 +2420,7 @@ chunk (runtime: main) default/44.js (id hint: vendors) 126 bytes <{909}> ={172}=
 chunk (runtime: main) default/async-d.js (async-d) 50 bytes <{909}> ={44}= [rendered]
   > ./d ./index.js 4:0-47
   ./d.js 50 bytes [built] [code generated]
-chunk (runtime: main) default/728.js (id hint: vendors) 126 bytes <{909}> ={250}= ={262}= [rendered] split chunk (cache group: defaultVendors)
-  > ./a ./index.js 1:0-47
-  > ./b ./index.js 2:0-47
-  ./node_modules/shared.js?1 126 bytes [built] [code generated]
-chunk (runtime: main) default/main.js (main) 245 bytes (javascript) 7.39 KiB (runtime) >{172}< >{250}< >{262}< >{407}< >{44}< >{602}< >{728}< [entry] [rendered]
+chunk (runtime: main) default/main.js (main) 245 bytes (javascript) 7.39 KiB (runtime) >{172}< >{250}< >{262}< >{407}< >{44}< >{602}< [entry] [rendered]
   > ./ main
   ./index.js 245 bytes [built] [code generated]
 Rspack x.x.x compiled successfully"

website/components/PluginSupportStatusTable.tsx

@@ -142,11 +142,7 @@ const pluginSupportStatusList: PluginSupportStatus[] = [
   {
     name: 'SplitChunksPlugin',
     url: '/plugins/webpack/split-chunks-plugin',
-    status: SupportStatus.PartiallySupported,
-    notes: {
-      en: '`minSizeReduction`, `usedExports` options not supported',
-      zh: '不支持 `minSizeReduction`、`usedExports` 选项',
-    },
+    status: SupportStatus.FullySupported,
   },
   {
     name: 'WatchIgnorePlugin',

website/docs/en/plugins/webpack/split-chunks-plugin.mdx

@@ -147,10 +147,65 @@ Prevents exposing path info when creating names for parts splitted by maxSize.
 
 ### splitChunks.minSize
 
+#### splitChunks.cacheGroups.\{cacheGroup\}.minSize
+
 - **Type:** `number | Record<string, number>`
 - **Default:** `20000` in production and `10000` in others
 
-Minimum size, in bytes, for a chunk to be generated.
+When using the `number` type of configuration, the same `minSize` will be configured for all module types defined in [`splitChunks.defaultSizeTypes`](/plugins/webpack/split-chunks-plugin#splitchunksdefaultsizetypes).
+
+```js title="rspack.config.mjs"
+export default {
+  //...
+  optimization: {
+    splitChunks: {
+      minSize: 100 * 1000,
+    },
+  },
+};
+```
+
+When configured with the object form, different `minSize` can be set for different types of module types defined in `splitChunks.defaultSizeTypes`.
+
+```js title="rspack.config.mjs"
+export default {
+  //...
+  optimization: {
+    splitChunks: {
+      minSize: {
+        javascript: 100 * 1000,
+        css: 300 * 1000,
+      },
+    },
+  },
+};
+```
+
+For example, the above configuration means that the minimum size of javascript modules in the split chunks needs to be at least 100KB, and the minimum size of css modules needs to be at least 300KB.
+
+### splitChunks.minSizeReduction
+
+#### splitChunks.cacheGroups.\{cacheGroup\}.minSizeReduction
+
+- **Type: ** `number | Record<string, number>`
+- **Default:** `0`
+
+If there are several small modules in the build output, developers may not want to generate separate chunks for them even if their total size exceeds the `minSize` threshold. In this case, you can use the `minSizeReduction` parameter to set the minimum size reduction threshold required for module splitting.
+
+The calculation rule for this parameter is: splitting will only occur when the total size reduction across all parent chunks after splitting the module is not less than the specified value.
+
+Assuming the following scenario, suppose there is a 40KB module that is referenced by 2 chunks, and we set `minSizeReduction: 100`. If we were to split this module, each parent chunk would be reduced by 40KB, resulting in a total reduction of `40KB × 2 = 80KB`. As this is less than 100KB, the split will not be triggered.
+
+```js title="rspack.config.mjs"
+export default {
+  //...
+  optimization: {
+    splitChunks: {
+      minSizeReduction: 100 * 1000,
+    },
+  },
+};
+```
 
 ### splitChunks.maxSize
 
@@ -302,9 +357,22 @@ chunk baz
 
 ### splitChunks.defaultSizeTypes
 
-- **Types:** `string[]`
+- **Type:** `string[]`
+- **Default:** `["javascript", "unknown"]`, and if `experiments.css` is enabled, it will also include `"css"`
+
+When calculating the size of chunks, only the sizes of javascript modules and built-in css modules are taken into account by default. For example, when configuring `minSize: 300`, both javascript modules and css modules need to meet the requirement in order to be split.
 
-Sets the size types which are used when a number is used for sizes.
+You can configure additional module types, for example, if you want WebAssembly modules to be split as well:
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      defaultSizeTypes: ['wasm', '...'],
+    },
+  },
+};
+```
 
 ### splitChunks.cacheGroups