fix: export interop default symbol and ensure import required chunks

Author: JSerFeng

crates/rspack_plugin_esm_library/src/chunk_link.rs

@@ -70,6 +70,7 @@ pub struct ExternalInterop {
   pub from_module: IdentifierSet,
   pub required_symbol: Option<Atom>,
   pub default_access: Option<Atom>,
+  pub default_exported: Option<Atom>,
   pub namespace_object: Option<Atom>,
   pub namespace_object2: Option<Atom>,
   pub property_access: FxIndexMap<Atom, Atom>,
@@ -152,6 +153,24 @@ impl ExternalInterop {
     }
   }
 
+  pub fn default_exported(&mut self, used_names: &mut FxHashSet<Atom>) -> Atom {
+    if self.required_symbol.is_none() {
+      let new_name = find_new_name("", used_names, &vec![]);
+      used_names.insert(new_name.clone());
+      self.required_symbol = Some(new_name);
+    }
+
+    if let Some(default_exported) = &self.default_exported {
+      return default_exported.clone();
+    }
+
+    let default_access_symbol = self.default_access(used_names);
+    let default_exported_symbol = find_new_name(&default_access_symbol, used_names, &vec![]);
+    used_names.insert(default_exported_symbol.clone());
+    self.default_exported = Some(default_exported_symbol.clone());
+    default_exported_symbol
+  }
+
   pub fn property_access(&mut self, atom: &Atom, used_names: &mut FxHashSet<Atom>) -> Atom {
     self.property_access.get(atom).cloned().unwrap_or_else(|| {
       let local_name = find_new_name(atom, used_names, &vec![]);
@@ -207,6 +226,12 @@ impl ExternalInterop {
           RuntimeGlobals::COMPAT_GET_DEFAULT_EXPORT,
           name
         )));
+
+        if let Some(default_exported_symbol) = &self.default_exported {
+          source.add(RawStringSource::from(format!(
+            "var {default_exported_symbol} = {default_access}();\n",
+          )));
+        }
       }
 
       for (s, local) in &self.property_access {

crates/rspack_plugin_esm_library/src/link.rs

@@ -871,6 +871,7 @@ impl EsmLibraryPlugin {
       from_module: Default::default(),
       required_symbol: None,
       default_access: None,
+      default_exported: None,
       namespace_object: None,
       namespace_object2: None,
       property_access: Default::default(),
@@ -905,7 +906,7 @@ impl EsmLibraryPlugin {
     current: ModuleIdentifier,
     current_chunk: ChunkUkey,
     compilation: &Compilation,
-    concate_modules_map: &IdentifierIndexMap<ModuleInfo>,
+    concate_modules_map: &mut IdentifierIndexMap<ModuleInfo>,
     required: &mut IdentifierIndexMap<ExternalInterop>,
     link: &mut UkeyMap<ChunkUkey, ChunkLinkContext>,
     module_graph: &ModuleGraph,
@@ -1002,14 +1003,17 @@ impl EsmLibraryPlugin {
                 required,
               );
               let ref_chunk = Self::get_module_chunk(ref_module, compilation);
-
-              let default_access_symbol = interop_info.default_access(&mut chunk_link.used_names);
+              let info = concate_modules_map
+                .get_mut(&ref_module)
+                .expect("should have info");
+              info.set_interop_default_access_used(true);
+              let default_exported = interop_info.default_exported(&mut chunk_link.used_names);
               // ensure we import this chunk
               entry_imports.entry(ref_module).or_default();
 
               let exported = Self::add_chunk_export(
                 ref_chunk,
-                default_access_symbol,
+                default_exported.clone(),
                 mode.name.clone(),
                 exports,
                 ref_chunk == current_chunk,
@@ -1029,10 +1033,11 @@ impl EsmLibraryPlugin {
           rspack_core::ExportMode::ReexportNamedDefault(mode) => {
             // export { default as n } from './foo.cjs'
             let ref_info = concate_modules_map
-              .get(&ref_module)
+              .get_mut(&ref_module)
               .expect("should have info");
             match ref_info {
               ModuleInfo::External(ref_info) => {
+                ref_info.interop_default_access_used = true;
                 // var foo_default = /*#__PURE__*/ __webpack_require__.n(m3);
                 let interop_info = Self::add_require(
                   ref_module,
@@ -1042,14 +1047,15 @@ impl EsmLibraryPlugin {
                   required,
                 );
 
-                let default_access_symbol = interop_info.default_access(&mut chunk_link.used_names);
+                let default_exported_symbol =
+                  interop_info.default_exported(&mut chunk_link.used_names);
 
                 // ensure we import this chunk
                 entry_imports.entry(ref_module).or_default();
 
                 Self::add_chunk_export(
                   current_chunk,
-                  default_access_symbol,
+                  default_exported_symbol,
                   mode.name.clone(),
                   exports,
                   true,
@@ -1157,7 +1163,7 @@ impl EsmLibraryPlugin {
 
               let chunk_link = link.get_mut(&current_chunk).expect("should have link");
 
-              let mut export_info = item
+              let export_info = item
                 .ids
                 .first()
                 .and_then(|id| exports_info.as_data(module_graph).named_exports(id))
@@ -1178,18 +1184,17 @@ impl EsmLibraryPlugin {
                   continue;
                 };
                 ref_module = *module;
-
-                let exports_info = module_graph.get_exports_info(module).as_data(module_graph);
-                if let Some(target) =
-                  exports_info.named_exports(item.ids.first().unwrap_or(&item.name))
-                {
-                  export_info = target;
-                }
               }
 
-              let Some(used_name) = export_info.get_used_name(None, None) else {
-                continue;
-              };
+              let exports_info = module_graph
+                .get_prefetched_exports_info(&ref_module, PrefetchExportsInfoMode::Default);
+              let export_info =
+                exports_info.get_read_only_export_info(item.ids.first().unwrap_or(&item.name));
+
+              let used_name = export_info.get_used_name(None, None).unwrap_or_else(|| {
+                // dynamic export
+                UsedNameItem::Str(item.name.clone())
+              });
 
               if let UsedNameItem::Inlined(inlined) = used_name {
                 let new_name = find_new_name(&item.name, &chunk_link.used_names, &vec![]);
@@ -1882,9 +1887,9 @@ impl EsmLibraryPlugin {
         ExportsType::Dynamic => match export_name.first().map(|atom| atom.as_str()) {
           Some("default") => {
             // shadowing the previous immutable ref to avoid violating rustc borrow rules
+            info.set_interop_default_access_used(true);
             let symbol = match info {
               ModuleInfo::External(info) => {
-                info.interop_default_access_used = true;
                 let required_info = Self::add_require(
                   *info_id,
                   from,
@@ -1894,13 +1899,10 @@ impl EsmLibraryPlugin {
                 );
                 required_info.default_access(all_used_names)
               }
-              ModuleInfo::Concatenated(info) => {
-                info.interop_default_access_used = true;
-                info
-                  .interop_default_access_name
-                  .clone()
-                  .expect("should already set interop namespace")
-              }
+              ModuleInfo::Concatenated(info) => info
+                .interop_default_access_name
+                .clone()
+                .expect("should already set interop namespace"),
             };
 
             export_name = export_name[1..].to_vec();

crates/rspack_plugin_esm_library/src/render.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, sync::Arc};
 
 use regex::Regex;
-use rspack_collections::{IdentifierSet, UkeyIndexMap, UkeySet};
+use rspack_collections::{IdentifierIndexSet, UkeyIndexMap, UkeySet};
 use rspack_core::{
   AssetInfo, Chunk, ChunkGraph, ChunkRenderContext, ChunkUkey, CodeGenerationDataFilename,
   Compilation, ConcatenatedModuleInfo, DependencyId, InitFragment, ModuleIdentifier, PathData,
@@ -181,6 +181,8 @@ impl EsmLibraryPlugin {
     let mut export_specifiers: FxIndexSet<Cow<str>> = Default::default();
     let mut export_default = None;
     let mut imported_chunks = UkeyIndexMap::<ChunkUkey, FxHashMap<Atom, Atom>>::default();
+    let mut runtime_requirements =
+      *ChunkGraph::get_chunk_runtime_requirements(compilation, chunk_ukey);
 
     // render webpack runtime
     if chunk.has_runtime(&compilation.chunk_group_by_ukey) {
@@ -210,7 +212,7 @@ impl EsmLibraryPlugin {
       render_source.add(RawStringSource::from(format!("{namespace}\n")));
     }
 
-    let mut already_rendered = IdentifierSet::default();
+    let mut already_required = IdentifierIndexSet::default();
     for m in &chunk_link.hoisted_modules {
       let info = concatenated_modules_map
         .get(m)
@@ -245,7 +247,7 @@ impl EsmLibraryPlugin {
         *m,
         compilation,
         chunk_link,
-        &mut already_rendered,
+        &mut already_required,
       ));
       render_source.add(source);
       render_source.add(RawSource::from_static("\n"));
@@ -299,7 +301,8 @@ impl EsmLibraryPlugin {
     }
 
     for (m, required_info) in &chunk_link.required {
-      if already_rendered.insert(*m) {
+      if already_required.insert(*m) {
+        runtime_requirements.insert(RuntimeGlobals::REQUIRE);
         render_source.add(required_info.render(compilation));
         render_source.add(RawSource::from_static("\n"));
       }
@@ -308,7 +311,14 @@ impl EsmLibraryPlugin {
     // render imports and exports to other chunks
     let mut final_source = ConcatSource::default();
 
-    let runtime_requirements = ChunkGraph::get_chunk_runtime_requirements(compilation, chunk_ukey);
+    for required_module in already_required {
+      runtime_requirements.insert(RuntimeGlobals::REQUIRE);
+      let target_chunk = Self::get_module_chunk(required_module, compilation);
+      if &target_chunk != chunk_ukey {
+        imported_chunks.entry(target_chunk).or_default();
+      }
+    }
+
     if !runtime_requirements.is_empty() {
       let runtime_chunk = Self::get_runtime_chunk(*chunk_ukey, compilation);
       if &runtime_chunk != chunk_ukey && runtime_requirements.contains(RuntimeGlobals::REQUIRE) {
@@ -355,49 +365,49 @@ impl EsmLibraryPlugin {
       final_source.add(RawStringSource::from(import_str));
     }
 
-    if !chunk_link.imports.is_empty() {
-      for (id, imports) in &chunk_link.imports {
-        let chunk = Self::get_module_chunk(*id, compilation);
-        if &chunk == chunk_ukey {
-          // ignore self import
-          continue;
-        }
-
-        let imported_symbols = imported_chunks.entry(chunk).or_default();
-        if imports.is_empty() {
-          continue;
-        }
+    for (id, imports) in &chunk_link.imports {
+      let chunk = Self::get_module_chunk(*id, compilation);
+      if &chunk == chunk_ukey {
+        // ignore self import
+        continue;
+      }
 
-        for (imported, local) in imports {
-          imported_symbols.insert(imported.clone(), local.clone());
-        }
+      let imported_symbols = imported_chunks.entry(chunk).or_default();
+      if imports.is_empty() {
+        continue;
       }
 
-      for (chunk, imported) in &imported_chunks {
-        final_source.add(RawStringSource::from(format!(
-          "import {}\"__RSPACK_ESM_CHUNK_{}\";\n",
-          if imported.is_empty() {
-            String::new()
-          } else {
-            format!(
-              "{{ {} }} from ",
-              imported
-                .iter()
-                .map(|(imported, local)| {
-                  if imported == local {
-                    Cow::Borrowed(imported.as_str())
-                  } else {
-                    Cow::Owned(format!("{imported} as {local}"))
-                  }
-                })
-                .collect::<Vec<_>>()
-                .join(", ")
-            )
-          },
-          chunk.as_u32()
-        )));
+      for (imported, local) in imports {
+        imported_symbols.insert(imported.clone(), local.clone());
       }
+    }
+
+    for (chunk, imported) in &imported_chunks {
+      final_source.add(RawStringSource::from(format!(
+        "import {}\"__RSPACK_ESM_CHUNK_{}\";\n",
+        if imported.is_empty() {
+          String::new()
+        } else {
+          format!(
+            "{{ {} }} from ",
+            imported
+              .iter()
+              .map(|(imported, local)| {
+                if imported == local {
+                  Cow::Borrowed(imported.as_str())
+                } else {
+                  Cow::Owned(format!("{imported} as {local}"))
+                }
+              })
+              .collect::<Vec<_>>()
+              .join(", ")
+          )
+        },
+        chunk.as_u32()
+      )));
+    }
 
+    if !imported_chunks.is_empty() || !chunk_link.raw_import_stmts.is_empty() {
       final_source.add(RawSource::from_static("\n"));
     }
 
@@ -695,7 +705,7 @@ impl EsmLibraryPlugin {
     root: ModuleIdentifier,
     compilation: &Compilation,
     chunk_link: &ChunkLinkContext,
-    already_required: &mut IdentifierSet,
+    already_required: &mut IdentifierIndexSet,
   ) -> ConcatSource {
     let mut source = ConcatSource::default();
 

crates/rspack_plugin_remove_empty_chunks/src/lib.rs

@@ -22,6 +22,9 @@ impl RemoveEmptyChunksPlugin {
         chunk_graph.get_number_of_chunk_modules(&chunk.ukey()) == 0
           && !chunk.has_runtime(&compilation.chunk_group_by_ukey)
           && chunk_graph.get_number_of_entry_modules(&chunk.ukey()) == 0
+          && chunk
+            .get_entry_options(&compilation.chunk_group_by_ukey)
+            .is_none()
       })
       .map(|chunk| chunk.ukey())
       .collect::<Vec<_>>();

tests/rspack-test/esmOutputCases/dynamic-import/basic/__snapshots__/esm.snap.txt

@@ -19,7 +19,6 @@ __webpack_require__.d(__webpack_exports__, {
 
 ```mjs title=main.mjs
 import { __webpack_require__ } from "./runtime.mjs";
-
 __webpack_require__.add({
 "./index.js": 
 /*!******************!*\

tests/rspack-test/esmOutputCases/interop/correct-order/__snapshots__/esm.snap.txt

@@ -1,6 +1,5 @@
 ```mjs title=main.mjs
 import { __webpack_require__ } from "./runtime.mjs";
-
 __webpack_require__.add({
 "./bar.cjs": 
 /*!*****************!*\