fix: should re-export real exportInfo when export dynamic js

JSerFeng · JSerFeng · commit 5da6c87ada2f · 2025-09-28T17:06:08.000+08:00
diff --git a/crates/rspack_plugin_esm_library/src/chunk_link.rs b/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,13 @@ impl ExternalInterop {
           RuntimeGlobals::COMPAT_GET_DEFAULT_EXPORT,
           name
         )));
+
+        if let Some(default_exported_symbol) = &self.default_exported {
+          source.add(RawStringSource::from(format!(
+            "var {} = {}();\n",
+            default_exported_symbol, default_access
+          )));
+        }
       }
 
       for (s, local) in &self.property_access {
diff --git a/crates/rspack_plugin_esm_library/src/link.rs b/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,
@@ -1136,8 +1142,6 @@ impl EsmLibraryPlugin {
             );
           }
           rspack_core::ExportMode::NormalReexport(mode) => {
-            let exports_info = module_graph.get_exports_info(&ref_module);
-
             for item in &mode.items {
               // reset ref_module for each dep
               let mut ref_module = orig_ref_module;
@@ -1156,13 +1160,7 @@ impl EsmLibraryPlugin {
               }
 
               let chunk_link = link.get_mut(&current_chunk).expect("should have link");
-
-              let mut export_info = item
-                .ids
-                .first()
-                .and_then(|id| exports_info.as_data(module_graph).named_exports(id))
-                .unwrap_or(item.export_info.as_data(module_graph));
-
+              let export_info = item.export_info.as_data(module_graph);
               if export_info.is_reexport() {
                 // should point to the real export
                 let targets = export_info.get_max_target();
@@ -1178,18 +1176,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 +1879,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 +1891,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();
diff --git a/tests/rspack-test/esmOutputCases/interop/type-module/__snapshots__/esm.snap.txt b/tests/rspack-test/esmOutputCases/interop/type-module/__snapshots__/esm.snap.txt
@@ -0,0 +1,107 @@
+```mjs title=main.mjs
+import { __webpack_require__ } from "./runtime.mjs";
+
+__webpack_require__.add({
+"./cjs-unknown.cjs": 
+/*!*************************!*\
+  !*** ./cjs-unknown.cjs ***!
+  \*************************/
+(function (__unused_webpack_module, exports) {
+const exportSymbol = () => 'bar'
+
+exports[exportSymbol()] = () => 'bar'
+
+}),
+"./cjs.cjs": 
+/*!*****************!*\
+  !*** ./cjs.cjs ***!
+  \*****************/
+(function (__unused_webpack_module, exports) {
+exports.foo = () => 'foo'
+
+
+}),
+});
+// ./index.js
+const cjs = __webpack_require__("./cjs.cjs");
+var foo_1 = cjs.foo;
+const cjs_unknown = __webpack_require__("./cjs-unknown.cjs");
+var cjs_unknown_default = /*#__PURE__*/__webpack_require__.n(cjs_unknown);
+var cjs_unknown_default_0 = cjs_unknown_default();
+var bar_1 = cjs_unknown.bar;
+
+
+
+
+it('should have correct re-export', async () => {
+	const { foo, bar, default: defaultV } = await import(/*webpackIgnore: true*/ './main.mjs')
+	expect(foo()).toBe('foo')
+	expect(bar()).toBe('bar')
+	expect(defaultV.bar()).toBe('bar')
+})
+
+export { bar_1 as bar, foo_1 as foo };
+export default cjs_unknown_default_0;
+
+```
+
+```mjs title=runtime.mjs
+
+var __webpack_modules__ = {};
+// The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+}
+// expose the modules object (__webpack_modules__)
+__webpack_require__.m = __webpack_modules__;
+
+// esm library register module runtime
+(() => {
+__webpack_require__.add = function registerModules(modules) { Object.assign(__webpack_require__.m, modules) }
+
+})();
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+
+export { __webpack_require__ };
+
+```
diff --git a/tests/rspack-test/esmOutputCases/interop/type-module/cjs-unknown.cjs b/tests/rspack-test/esmOutputCases/interop/type-module/cjs-unknown.cjs
@@ -0,0 +1,3 @@
+const exportSymbol = () => 'bar'
+
+exports[exportSymbol()] = () => 'bar'
diff --git a/tests/rspack-test/esmOutputCases/interop/type-module/cjs.cjs b/tests/rspack-test/esmOutputCases/interop/type-module/cjs.cjs
@@ -0,0 +1 @@
+exports.foo = () => 'foo'
diff --git a/tests/rspack-test/esmOutputCases/interop/type-module/index.js b/tests/rspack-test/esmOutputCases/interop/type-module/index.js
@@ -0,0 +1,10 @@
+export { foo } from './cjs.cjs'
+export { bar } from './cjs-unknown.cjs'
+export { default } from './cjs-unknown.cjs'
+
+it('should have correct re-export', async () => {
+	const { foo, bar, default: defaultV } = await import(/*webpackIgnore: true*/ './main.mjs')
+	expect(foo()).toBe('foo')
+	expect(bar()).toBe('bar')
+	expect(defaultV.bar()).toBe('bar')
+})
diff --git a/tests/rspack-test/esmOutputCases/interop/type-module/package.json b/tests/rspack-test/esmOutputCases/interop/type-module/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+const exportSymbol = () => 'bar'`
	`2`	`+`
	`3`	`+exports[exportSymbol()] = () => 'bar'`