docs: improve splitChunks.chunks and update glossary (#10990)

* docs: improve `splitChunks.chunks` and update glossary

* docs: fix

Author: chenjiahan

website/docs/en/misc/glossary.mdx

@@ -12,6 +12,10 @@ An "asset module" is a special module type used to process static assets, such a
 
 - [Asset modules](/guide/features/asset-module)
 
+## async chunk
+
+An async chunk refers to a [chunk](#chunk) that is loaded asynchronously. When you use dynamic imports, Rspack will bundle the module into an async chunk.
+
 ## bundle
 
 Historically bundlers produced a single output file called a "bundle." The concept of chunks was introduced later as part of a feature for automatically decomposing bundles into smaller files that can be loaded on demand.
@@ -49,6 +53,10 @@ Code splitting is a technique that allows you to split your code into multiple c
 
 Dependency is parsed from the transformed code of a module. It is used to store the import relationships of modules for recursively generating the module graph. When code generation, it can inject code of module imports and exports. It can also be used for code replacement and injecting runtime requirements.
 
+## initial chunk
+
+Initial chunk is a [chunk](#chunk) that is loaded synchronously, including the entry module of the page and the modules imported statically.
+
 ## loader
 
 In bundling terminology, a loader is like a plugin but specifically tasked with transforming module content. For example, we can use a loader to transform a TypeScript module into a JavaScript module, or to transform a CSS module into a JavaScript module that injects the CSS into the page.

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

@@ -5,9 +5,13 @@ import { ApiMeta } from '../../../../components/ApiMeta';
 
 # SplitChunksPlugin
 
-## Default
+SplitChunksPlugin is a built-in plugin that splits code into multiple [chunks](/misc/glossary#chunk) to optimize application loading performance and achieve better caching strategies and parallel loading.
 
-Out of the box `SplitChunksPlugin` should work well for most users.
+SplitChunksPlugin can be configured through the [optimization.splitChunks](/config/optimization#optimizationsplitchunks) option, and you typically don't need to manually register this plugin.
+
+## Default behavior
+
+Rspack has a built-in configuration for `SplitChunksPlugin` that works well for most scenarios.
 
 By default it only affects on-demand chunks, because changing initial chunks would affect the script tags the HTML file should include to run the project.
 
@@ -92,20 +96,29 @@ export default {
 
 #### splitChunks.cacheGroups.\{cacheGroup\}.chunks
 
-- **Type:** `'initial' | 'all' | 'async' | RegExp | ((chunk: Chunk) => bool)`
-- **Default:** `'async'`
+- **Type:**
 
-This indicates which chunks will be selected for optimization.
+```ts
+type OptimizationSplitChunksChunks =
+  | 'initial'
+  | 'async'
+  | 'all'
+  | RegExp
+  | ((chunk: Chunk) => boolean);
+```
 
-When a string is provided, valid values are `all`, `async`, and `initial`. Providing `all` can be particularly powerful, because it means that chunks can be shared even between async and non-async chunks.
+- **Default:** `'async'`
+
+This option controls which chunks should be selected for code splitting. When a string is provided, the possible values are `all`, `async` and `initial`.
 
-Alternatively, you may provide a function for more control. The return value will indicate whether to include each chunk.
+- `all`: Split all types of chunks, including [initial chunks](/misc/glossary#initial-chunk) and [async chunks](/misc/glossary#async-chunk).
+- `initial`: Only split initial chunks.
+- `async`: Only split async chunks.
 
-You can also pass a regular expression, which is a short for `(chunk) => typeof chunk.name === "string" && regex.test(chunk.name)`.
+Generally, setting it to `all` can help reduce duplicate modules being bundled, as it means chunks can be shared between initial chunks and async chunks.
 
 ```js title="rspack.config.mjs"
 export default {
-  //...
   optimization: {
     splitChunks: {
       // include all types of chunks
@@ -115,6 +128,64 @@ export default {
 };
 ```
 
+:::tip
+When using [Module Federation](/guide/features/module-federation), if the application uses `exposes` to expose remote modules, `chunks: 'all'` cannot be used as it would break the remote module splitting.
+:::
+
+The `chunks` option can be set to a regular expression, which is a shorthand for `(chunk) => typeof chunk.name === "string" && regex.test(chunk.name)`.
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      // equivalent to `chunks: (chunk) => typeof chunk.name === "string" && /foo/.test(chunk.name)`
+      chunks: /foo/,
+    },
+  },
+};
+```
+
+The `chunks` option can be set to a function for more fine-grained control. The function receives a `chunk` parameter, and returning `true` means the chunk participates in splitting (modules within it may be extracted into new chunks), while returning `false` means the chunk doesn't participate in splitting (remains as is).
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      chunks(chunk) {
+        // exclude `foo` chunk
+        return chunk.name !== 'foo';
+      },
+    },
+  },
+};
+```
+
+:::warning
+Using the function type of `chunks` will significantly reduce build performance, as the function needs to be called for each module, resulting in huge cross-language communication overhead between Rust and JavaScript. Therefore, we do not recommend using the function type.
+:::
+
+You can configure `chunks` individually for each cacheGroup, for example:
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      cacheGroups: {
+        groupA: {
+          chunks: 'all',
+        },
+        groupB: {
+          chunks: 'initial',
+        },
+        groupC: {
+          chunks: 'async',
+        },
+      },
+    },
+  },
+};
+```
+
 ### splitChunks.maxAsyncRequests
 
 - **Type:** `number`

website/docs/zh/misc/glossary.mdx

@@ -12,6 +12,10 @@ Asset 模块是一种特殊的模块类型，用来处理静态资源，例如
 
 - [资源模块](/guide/features/asset-module)
 
+## async chunk
+
+Async chunk 指的是被异步加载的 [chunk](#chunk)，当你使用动态导入时，Rspack 会将该模块打包到 async chunk 中。
+
 ## bundle splitting
 
 Bundle splitting 是一种允许你将代码分割或合并到多个 bundle 的技术，这对于并行请求和更好的浏览器缓存很有用，它不用于减少初始化 bundle 的大小。
@@ -29,7 +33,7 @@ Rspack 中的内置模块类型指的是那些不需要依赖 loader 和 plugin
 
 ## chunk
 
-Chunk 是一组绑定在一起的模块。rspack 会将相互关联的模块打包成一个 chunk，然后生成对应的文件。
+Chunk 是一组绑定在一起的模块。Rspack 会将相互关联的模块打包成一个 chunk，然后生成对应的文件。
 
 ## chunk graph（chunk 图）
 
@@ -45,6 +49,10 @@ Code splitting 是一种技术，它允许你将你的代码分割成多个块
 
 Dependency 是从模块编译后的代码解析出来的，它用于存储模块的导入关系，以便递归生成模块图。在生成产物代码时，它可以注入模块的导入和导出相关代码，也可以用于代码替换和注入运行时依赖。
 
+## initial chunk
+
+Initial chunk 是被同步加载的 [chunk](#chunk)，包含页面的入口模块和被静态导入的模块。
+
 ## loader
 
 Loader 是用来转换模块内容的。例如，我们可以使用 loader 将 TypeScript 模块转化为 JavaScript 模块，或者将 CSS 模块转化为 JavaScript 模块，将 CSS 注入到页面中。

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

@@ -5,13 +5,17 @@ import { ApiMeta } from '../../../../components/ApiMeta';
 
 # SplitChunksPlugin
 
-## 默认值
+SplitChunksPlugin 是一个内置插件，用于将代码拆分成多个 [chunk](/misc/glossary#chunk)，以优化应用的加载性能，实现更好的缓存策略和并行加载效果。
 
-开箱即用的 `SplitChunksPlugin` 对于大部分用户来说非常友好。
+SplitChunksPlugin 可以通过 [optimization.splitChunks](/config/optimization#optimizationsplitchunks) 选项进行配置，通常你不需要手动注册该插件。
+
+## 默认行为
+
+Rspack 内置了开箱即用的 `SplitChunksPlugin` 配置，适用于大部分场景。
 
 默认情况下，它只会影响到按需加载的 chunk，因为初始 chunk 会影响到项目的 HTML 文件中的脚本标签。
 
-rspack 将根据以下条件自动拆分 chunk：
+Rspack 将根据以下条件自动拆分 chunk：
 
 - 新的 chunk 可以被共享，或者模块来自于 `node_modules` 文件夹
 - 新的 chunk 体积大于 20kb（在进行 min+gz 之前的体积）
@@ -20,7 +24,7 @@ rspack 将根据以下条件自动拆分 chunk：
 
 ## 配置
 
-rspack 为希望对该功能进行更多控制的开发者提供了一组选项。
+Rspack 为希望对该功能进行更多控制的开发者提供了一组选项。
 
 :::warning
 Rspack 的默认配置符合 Web 性能最佳实践，但是项目的最佳策略可能有所不同。如果要更改配置，则应评估所做更改的影响，以确保有真正的收益。
@@ -90,18 +94,29 @@ export default {
 
 #### splitChunks.cacheGroups.\{cacheGroup\}.chunks
 
-- **类型：** `string 'initial' | 'all' | 'async'`
+- **类型：**
+
+```ts
+type OptimizationSplitChunksChunks =
+  | 'initial'
+  | 'async'
+  | 'all'
+  | RegExp
+  | ((chunk: Chunk) => boolean);
+```
+
 - **默认值：** `'async'`
 
-这表明将选择哪些 chunk 进行优化。当提供一个字符串，有效值为 `all` ，`async` 和 `initial`。设置为 `all` 可能会更强大，因为这意味着 chunk 可以在异步和非异步 chunk 之间共享。
+此选项用于控制哪些 chunk 参与代码拆分。当传入字符串时，可选值包括 `all`、`async` 和 `initial`。
 
-或者，也可以提供一个函数来进行更多控制。返回值将显示是否包含该 Chunk。
+- `all`：拆分所有类型的 chunks，包括 [initial chunks](/misc/glossary#initial-chunk) 和 [async chunks](/misc/glossary#async-chunk)。
+- `initial`：仅拆分 initial chunks。
+- `async`：仅拆分 async chunks。
 
-还可以传递正则表达式，它是 `(chunk) => typeof chunk.name === "string" && regex.test(chunk.name)` 的缩写。
+通常来说，设置为 `all` 会有助于减少被重复打包的模块，因为这意味着 chunks 可以被 initial chunks 和 async chunks 共享。
 
 ```js title="rspack.config.mjs"
 export default {
-  //...
   optimization: {
     splitChunks: {
       // include all types of chunks
@@ -111,6 +126,64 @@ export default {
 };
 ```
 
+:::tip
+在使用 [模块联邦](/guide/features/module-federation) 时，如果应用使用了 `exposes` 来暴露出远程模块，则无法使用 `chunks: 'all'`，因为这会破坏远程模块的拆分。
+:::
+
+`chunks` 选项可以设置为正则表达式，它是 `(chunk) => typeof chunk.name === "string" && regex.test(chunk.name)` 的缩写。
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      // 等价于 `chunks: (chunk) => typeof chunk.name === "string" && /foo/.test(chunk.name)`
+      chunks: /foo/,
+    },
+  },
+};
+```
+
+`chunks` 选项可以设置为函数来进行更细粒度的控制。该函数接收一个 `chunk` 参数，返回值为 `true` 表示该 chunk 参与拆分（其中的模块可能被提取到新的 chunk 中），返回值为 `false` 表示该 chunk 不参与拆分（保持原样）。
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      chunks(chunk) {
+        // exclude `foo` chunk
+        return chunk.name !== 'foo';
+      },
+    },
+  },
+};
+```
+
+:::warning
+使用函数形式的 `chunks` 会显著降低构建性能，因为该函数需要对每个模块进行调用，从而产生大量的 Rust 与 JavaScript 之间的跨语言通信开销。因此我们不推荐使用函数形式。
+:::
+
+你可以为每个 cacheGroup 单独配置 `chunks`，例如：
+
+```js title="rspack.config.mjs"
+export default {
+  optimization: {
+    splitChunks: {
+      cacheGroups: {
+        groupA: {
+          chunks: 'all',
+        },
+        groupB: {
+          chunks: 'initial',
+        },
+        groupC: {
+          chunks: 'async',
+        },
+      },
+    },
+  },
+};
+```
+
 ### splitChunks.maxAsyncRequests
 
 - **类型：** `number`
@@ -399,7 +472,7 @@ export default {
 控制此缓存组选择的模块。省略它会选择所有模块。它可以匹配绝对模块资源路径或 chunk 名称。匹配 chunk 名称时，将选择 chunk 中的所有模块。
 
 :::warning
-使用函数形式的 `test` 会显著降低构建性能，因为该函数需要对每个 module 进行调用，从而产生大量的 Rust 与 JavaScript 之间的跨语言通信开销。因此我们不推荐使用函数形式。
+使用函数形式的 `test` 会显著降低构建性能，因为该函数需要对每个模块进行调用，从而产生大量的 Rust 与 JavaScript 之间的跨语言通信开销。因此我们不推荐使用函数形式。
 :::
 
 #### splitChunks.cacheGroups.\{cacheGroup\}.enforce