feat: split chunks add deps for esm module

Author: JSerFeng

crates/node_binding/napi-binding.d.ts

@@ -2106,6 +2106,7 @@ export interface RawEnvironment {
 
 export interface RawEsmLibraryPlugin {
   preserveModules?: string
+  splitChunks?: RawSplitChunksOptions
 }
 
 export interface RawEvalDevToolModulePluginOptions {

crates/rspack_binding_api/src/raw_options/raw_builtins/mod.rs

@@ -419,7 +419,7 @@ impl<'a> BuiltinPlugin<'a> {
         plugins.push(
           EsmLibraryPlugin::new(
             options.preserve_modules.as_deref().map(Into::into),
-            options.split_chunks.as_deref().map(Into::into),
+            options.split_chunks.map(Into::into),
           )
           .boxed(),
         );

crates/rspack_binding_api/src/raw_options/raw_builtins/raw_esm_lib.rs

@@ -3,77 +3,34 @@ use std::sync::Arc;
 use napi::bindgen_prelude::Either3;
 use rayon::iter::Either;
 use rspack_core::CompilerId;
+use rspack_error::ToStringResultToRspackResultExt;
 use rspack_napi::threadsafe_function::ThreadsafeFunction;
-use rspack_plugin_esm_library::{CacheGroup, EsmLibraryPlugin};
+use rspack_plugin_esm_library::EsmLibraryPlugin;
+use rspack_plugin_split_chunks::{CacheGroup, SplitChunksPlugin};
 use rspack_regex::RspackRegex;
 
-use crate::module::ModuleObject;
+use crate::{
+  module::ModuleObject,
+  raw_options::{self, RawSplitChunksOptions},
+};
 
 pub type RawNameGetter = Either<String, ThreadsafeFunction<ModuleObject, Option<String>>>;
 
 pub type RawCacheGroupTest =
   Either3<String, RspackRegex, ThreadsafeFunction<ModuleObject, Option<bool>>>;
 
 #[napi(object, object_to_js = false)]
-pub struct RawCacheGroup {
-  pub name: Option<RawNameGetter>,
-  pub test: Option<RawCacheGroupTest>,
-  pub key: String,
-  pub r#type: Option<String>,
-  pub filename: Option<String>,
-  pub priority: Option<f64>,
-  pub min_size: Option<f64>,
-}
-
-#[napi(object, object_to_js = false)]
-pub struct RawEsmLibraryPlugin {
+pub struct RawEsmLibraryPlugin<'a> {
   pub preserve_modules: Option<String>,
-  pub split_chunks: Option<Vec<RawCacheGroup>>,
+  pub split_chunks: Option<RawSplitChunksOptions<'a>>,
 }
 
-impl From<RawCacheGroup> for EsmLibraryPlugin::CacheGroup {
-  fn from(value: RawCacheGroup) -> Self {
-    CacheGroup {
-      name: match value.name {
-        Some(Either::Right(name_getter)) => {
-          Either::Right(Arc::new(async move |module, compilation| {
-            Box::pin(async move {
-              name_getter
-                .call_with_sync(ModuleObject::with_ref(module, compilation.compiler_id()))
-                .await
-            })
-          }))
-        }
-        Some(Either::Left(name)) => Either::Left(Some(name)),
-        None => Either::Left(None),
-      },
-      key: value.key,
-      test: match value.test {
-        Some(Either3::A(string)) => {
-          Arc::new(async move |module, _| module.identifier().contains(&string))
-        }
-        Some(Either3::B(regex)) => Arc::new(|module| regex.test(module.identifier().as_str())),
-        Some(Either3::C(test_fn)) => Arc::new(async |module, compilation| {
-          test_fn
-            .call_with_sync(ModuleObject::with_ref(module, compilation.compiler_id()))
-            .await
-            .unwrap_or(false)
-        }),
-        None => Arc::new(|_| true),
-      },
-      r#type: match value.r#type {
-        Some(raw) => crate::split_chunks::normalize_raw_cache_group_type(raw),
-        None => raw_split_chunks::default_cache_group_type(),
-      },
-      filename: value.filename,
-      priority: value.priority.unwrap_or(0.0),
-      min_size: value
-        .min_size
-        .map(|s| crate::split_chunks::SplitChunkSizes {
-          javascript: s,
-          ..Default::default()
-        }),
-      index: 0, // will be set later
-    }
+impl<'a> From<RawSplitChunksOptions<'a>> for Vec<CacheGroup> {
+  fn from(value: RawSplitChunksOptions<'a>) -> Self {
+    let mut groups = rspack_plugin_split_chunks::PluginOptions::from(value).cache_groups;
+
+    groups.sort_by(|a, b| a.priority.total_cmp(&b.priority));
+
+    groups
   }
 }

crates/rspack_plugin_esm_library/src/lib.rs

@@ -9,4 +9,4 @@ mod render;
 mod runtime;
 mod split_chunks;
 pub use plugin::EsmLibraryPlugin;
-pub use split_chunks::{CacheGroup, GetNameGetter, ModuleFilter, ModuleTypeFilter};
+pub use split_chunks::{GetNameGetter, ModuleFilter, ModuleTypeFilter};

crates/rspack_plugin_esm_library/src/plugin.rs

@@ -23,14 +23,15 @@ use rspack_plugin_javascript::{
   JavascriptModulesRenderChunkContent, JsPlugin, RenderSource,
   dependency::ImportDependencyTemplate, parser_and_generator::JavaScriptParserAndGenerator,
 };
+use rspack_plugin_split_chunks::CacheGroup;
 use rspack_util::fx_hash::FxHashMap;
 use sugar_path::SugarPath;
 use tokio::sync::RwLock;
 
 use crate::{
   chunk_link::ChunkLinkContext, dependency::dyn_import::DynamicImportDependencyTemplate,
   ensure_entry_exports::ensure_entry_exports, esm_lib_parser_plugin::EsmLibParserPlugin,
-  preserve_modules::preserve_modules, runtime::RegisterModuleRuntime, split_chunks::CacheGroup,
+  preserve_modules::preserve_modules, runtime::RegisterModuleRuntime,
 };
 
 pub static RSPACK_ESM_RUNTIME_CHUNK: &str = "RSPACK_ESM_RUNTIME";
@@ -487,13 +488,12 @@ async fn optimize_chunks(&self, compilation: &mut Compilation) -> Result<Option<
     if !errors.is_empty() {
       compilation.extend_diagnostics(errors);
     }
-  } else {
-    if let Some(cache_groups) = &self.split_chunks {
-      crate::split_chunks::split(cache_groups, compilation, true);
-    }
-    ensure_entry_exports(compilation);
+  } else if let Some(cache_groups) = &self.split_chunks {
+    crate::split_chunks::split(cache_groups, compilation).await?;
   }
 
+  ensure_entry_exports(compilation);
+
   Ok(None)
 }