chore: reduce

Author: 2heal1

crates/rspack_plugin_mf/src/container/container_entry_module.rs

@@ -73,6 +73,10 @@ impl ContainerEntryModule {
       enhanced,
     }
   }
+
+  pub fn exposes(&self) -> &[(String, ExposeOptions)] {
+    &self.exposes
+  }
 }
 
 impl Identifiable for ContainerEntryModule {

crates/rspack_plugin_mf/src/manifest/asset.rs

@@ -19,14 +19,15 @@ pub fn collect_assets_from_chunk(
 
   for cg in chunk.groups() {
     let group = compilation.chunk_group_by_ukey.expect_get(cg);
-    if let Some(name) = group.name() {
-      if !entry_point_names.contains(name) {
-        for file in group.get_files(&compilation.chunk_by_ukey) {
-          if file.ends_with(".css") {
-            css_sync.insert(file.to_string());
-          } else if !is_hot_file(&file) {
-            js_sync.insert(file);
-          }
+    if group
+      .name()
+      .is_some_and(|name| !entry_point_names.contains(name))
+    {
+      for file in group.get_files(&compilation.chunk_by_ukey) {
+        if file.ends_with(".css") {
+          css_sync.insert(file.to_string());
+        } else if !is_hot_file(&file) {
+          js_sync.insert(file);
         }
       }
     }
@@ -43,14 +44,15 @@ pub fn collect_assets_from_chunk(
     }
     for cg in async_chunk.groups() {
       let group = compilation.chunk_group_by_ukey.expect_get(cg);
-      if let Some(name) = group.name() {
-        if !entry_point_names.contains(name) {
-          for file in group.get_files(&compilation.chunk_by_ukey) {
-            if file.ends_with(".css") {
-              css_async.insert(file.to_string());
-            } else if !is_hot_file(&file) {
-              js_async.insert(file);
-            }
+      if group
+        .name()
+        .is_some_and(|name| !entry_point_names.contains(name))
+      {
+        for file in group.get_files(&compilation.chunk_by_ukey) {
+          if file.ends_with(".css") {
+            css_async.insert(file.to_string());
+          } else if !is_hot_file(&file) {
+            js_async.insert(file);
           }
         }
       }
@@ -104,8 +106,8 @@ pub fn collect_assets_for_module(
     return None;
   }
   let mut result = empty_assets_group();
-  for chunk_ukey in chunk_graph.get_module_chunks(*module_identifier).iter() {
-    let chunk_assets = collect_assets_from_chunk(compilation, &chunk_ukey, entry_point_names);
+  for chunk_ukey in chunk_graph.get_module_chunks(*module_identifier) {
+    let chunk_assets = collect_assets_from_chunk(compilation, chunk_ukey, entry_point_names);
     merge_assets_group(&mut result, chunk_assets);
   }
   normalize_assets_group(&mut result);
@@ -121,11 +123,11 @@ pub fn remove_assets(group: &mut StatsAssetsGroup, exclude: &HashSet<String>) {
 }
 
 pub fn promote_primary_assets_to_sync(group: &mut StatsAssetsGroup) {
-  if group.js.sync.is_empty() && !group.js.r#async.is_empty() {
-    group.js.sync.extend(group.js.r#async.drain(..));
+  if group.js.sync.is_empty() {
+    group.js.sync.append(&mut group.js.r#async);
   }
-  if group.css.sync.is_empty() && !group.css.r#async.is_empty() {
-    group.css.sync.extend(group.css.r#async.drain(..));
+  if group.css.sync.is_empty() {
+    group.css.sync.append(&mut group.css.r#async);
   }
   normalize_assets_group(group);
 }

crates/rspack_plugin_mf/src/manifest/data.rs

@@ -1,22 +1,13 @@
 use serde::Serialize;
 
-#[derive(Debug, Serialize, Clone)]
+#[derive(Debug, Serialize, Clone, Default)]
 pub struct StatsAssetsGroup {
   #[serde(default)]
   pub js: AssetsSplit,
   #[serde(default)]
   pub css: AssetsSplit,
 }
 
-impl Default for StatsAssetsGroup {
-  fn default() -> Self {
-    Self {
-      js: AssetsSplit::default(),
-      css: AssetsSplit::default(),
-    }
-  }
-}
-
 #[derive(Debug, Serialize, Clone, Default)]
 pub struct AssetsSplit {
   #[serde(default)]

crates/rspack_plugin_mf/src/manifest/mod.rs

@@ -29,11 +29,10 @@ use rspack_hook::{plugin, plugin_hook};
 use rspack_util::fx_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use utils::{
   collect_expose_requirements, compose_id_with_separator, ensure_shared_entry, is_hot_file,
-  parse_consume_shared_identifier, parse_container_exposes_from_identifier,
-  parse_provide_shared_identifier, record_shared_usage, strip_ext,
+  parse_consume_shared_identifier, parse_provide_shared_identifier, record_shared_usage, strip_ext,
 };
 
-use crate::container::remote_module::RemoteModule;
+use crate::container::{container_entry_module::ContainerEntryModule, remote_module::RemoteModule};
 
 #[plugin]
 #[derive(Debug)]
@@ -198,54 +197,47 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     (exposes, shared, remote_list)
   } else {
     let module_graph = compilation.get_module_graph();
-    let context = &compilation.options.context;
 
     let mut exposes_map: HashMap<String, StatsExpose> = HashMap::default();
     let mut shared_map: HashMap<String, StatsShared> = HashMap::default();
     let mut shared_usage_links: Vec<(String, String)> = Vec::new();
     let mut consume_module_ids: HashMap<String, Vec<ModuleIdentifier>> = HashMap::default();
     let mut remote_module_ids: Vec<ModuleIdentifier> = Vec::new();
     let mut container_entry_module: Option<ModuleIdentifier> = None;
-    let mut module_ids_by_name: HashMap<String, ModuleIdentifier> = HashMap::default();
-    let mut self_issued_module_ids: HashMap<String, ModuleIdentifier> = HashMap::default();
+    for (_, module) in module_graph.modules().into_iter() {
+      let module_identifier = module.identifier();
 
-    for (module_id, module) in module_graph.modules().into_iter() {
-      let module_identifier = module_id;
-      let module_name = module.readable_identifier(context).to_string();
-      if !module_name.is_empty() {
-        module_ids_by_name.insert(module_name.clone(), module_identifier);
-        if let Some(issuer_module) = module_graph.get_issuer(&module_identifier) {
-          let issuer_name = issuer_module.readable_identifier(context).to_string();
-          if issuer_name == module_name {
-            self_issued_module_ids.insert(issuer_name, module_identifier);
-          }
+      if let Some(container_entry) = module
+        .as_ref()
+        .as_any()
+        .downcast_ref::<ContainerEntryModule>()
+      {
+        container_entry_module = Some(module_identifier);
+        for (expose_key, options) in container_entry.exposes() {
+          let expose_name = options
+            .name
+            .clone()
+            .filter(|name| !name.is_empty())
+            .unwrap_or_else(|| expose_key.trim_start_matches("./").to_string());
+          let Some(import) = options.import.iter().find(|request| !request.is_empty()) else {
+            continue;
+          };
+          let id_comp = compose_id_with_separator(&container_name, &expose_name);
+          let expose_file_key = strip_ext(import);
+          exposes_map.entry(expose_file_key).or_insert(StatsExpose {
+            path: expose_key.clone(),
+            id: id_comp,
+            name: expose_name,
+            requires: Vec::new(),
+            assets: StatsAssetsGroup::default(),
+          });
         }
+        continue;
       }
 
       let module_type = module.module_type();
       let identifier = module_identifier.to_string();
 
-      if identifier.starts_with("container entry") {
-        container_entry_module = Some(module_identifier);
-        if let Some(exposes) = parse_container_exposes_from_identifier(&identifier) {
-          for (expose_key, import_name, import_file) in exposes {
-            let expose_name = import_name
-              .filter(|name| !name.is_empty())
-              .unwrap_or_else(|| expose_key.trim_start_matches("./").to_string());
-            let id_comp = compose_id_with_separator(&container_name, &expose_name);
-            let expose_file_key = strip_ext(&import_file);
-            exposes_map.entry(expose_file_key).or_insert(StatsExpose {
-              path: expose_key.clone(),
-              id: id_comp,
-              name: expose_name,
-              requires: Vec::new(),
-              assets: StatsAssetsGroup::default(),
-            });
-          }
-        }
-        continue;
-      }
-
       if matches!(module_type, ModuleType::Remote) {
         remote_module_ids.push(module_identifier);
       }
@@ -271,12 +263,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         if let Some((pkg, required)) = parse_consume_shared_identifier(&identifier) {
           let mut target_ids: Vec<ModuleIdentifier> = Vec::new();
           if let Some(issuer_module) = module_graph.get_issuer(&module_identifier) {
-            let issuer_name = issuer_module.readable_identifier(context).to_string();
-            if let Some(target) = self_issued_module_ids.get(&issuer_name) {
-              target_ids.push(*target);
-            } else if let Some(target) = module_ids_by_name.get(&issuer_name) {
-              target_ids.push(*target);
-            }
+            target_ids.push(issuer_module.identifier());
           }
           if target_ids.is_empty() {
             target_ids.push(module_identifier);

crates/rspack_plugin_mf/src/manifest/utils.rs

@@ -2,7 +2,6 @@ use std::path::Path;
 
 use rspack_core::{Compilation, ModuleGraph, ModuleIdentifier};
 use rspack_util::fx_hash::FxHashMap as HashMap;
-use serde_json::Value;
 
 use super::data::{StatsExpose, StatsShared};
 
@@ -32,55 +31,6 @@ pub fn strip_ext(path: &str) -> String {
   }
 }
 
-pub fn parse_container_exposes_from_identifier(
-  identifier: &str,
-) -> Option<Vec<(String, Option<String>, String)>> {
-  let start = identifier.find('[')?;
-  let slice = &identifier[start..];
-  let mut depth = 0_usize;
-  let mut end_idx = None;
-  for (i, ch) in slice.char_indices() {
-    match ch {
-      '[' => depth += 1,
-      ']' => {
-        depth -= 1;
-        if depth == 0 {
-          end_idx = Some(i);
-          break;
-        }
-      }
-      _ => {}
-    }
-  }
-  let end = end_idx?;
-  let json_str = &slice[..=end];
-  let val: Value = serde_json::from_str(json_str).ok()?;
-  let arr = val.as_array()?;
-  let mut ret: Vec<(String, Option<String>, String)> = Vec::new();
-  for item in arr {
-    if let Some(tuple) = item.as_array() {
-      if tuple.len() == 2 {
-        let expose_key = tuple[0].as_str().unwrap_or_default().to_string();
-        if let Some(obj) = tuple[1].as_object() {
-          let import = obj
-            .get("import")
-            .and_then(|v| v.as_array())
-            .and_then(|a| a.first())
-            .and_then(|v| v.as_str())
-            .unwrap_or_default()
-            .to_string();
-          let name = obj
-            .get("name")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string());
-          ret.push((expose_key, name, import));
-        }
-      }
-    }
-  }
-  Some(ret)
-}
-
 pub fn ensure_shared_entry<'a>(
   shared_map: &'a mut HashMap<String, StatsShared>,
   container_name: &str,