fix(loader): fix JS loader type detection for issue #11129 (#11361)

* fix(loader): fix JS loader type detection for issue #11129

- Refactor JsLoader to separate module type from identifier
- Add exports-loader test case with inline and object configurations
- Include exports-loader dependency for testing

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

* fix(loader): improve JS loader type detection for issue #11129

Updates resolver and loader runner to better handle JS loader type detection,
addressing edge cases in the module loading process.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

---------

Co-authored-by: Claude <[email protected]>

Author: h-a-n-a

crates/rspack_binding_api/src/plugins/js_loader/resolver.rs

@@ -1,6 +1,9 @@
-use std::sync::Arc;
+use std::{borrow::Cow, sync::Arc};
 
-use rspack_cacheable::{cacheable, cacheable_dyn};
+use rspack_cacheable::{
+  cacheable, cacheable_dyn,
+  with::{AsOption, AsRefStr},
+};
 use rspack_collections::{Identifiable, Identifier};
 use rspack_core::{
   BoxLoader, Context, Loader, ModuleRuleUseLoader, NormalModuleFactoryResolveLoader, ResolveResult,
@@ -14,10 +17,17 @@ use super::{JsLoaderRspackPlugin, JsLoaderRspackPluginInner};
 
 #[cacheable]
 #[derive(Debug)]
-pub struct JsLoader(pub Identifier);
+pub struct JsLoader(
+  pub Identifier,
+  /* LoaderType */ #[cacheable(with=AsOption<AsRefStr>)] pub Option<Cow<'static, str>>,
+);
 
 #[cacheable_dyn]
-impl Loader<RunnerContext> for JsLoader {}
+impl Loader<RunnerContext> for JsLoader {
+  fn r#type(&self) -> Option<&str> {
+    self.1.as_deref()
+  }
+}
 
 impl Identifiable for JsLoader {
   fn identifier(&self) -> Identifier {
@@ -88,13 +98,16 @@ pub(crate) async fn resolve_loader(
       let path = path.as_str();
 
       let r#type = if path.ends_with(".mjs") {
-        Some("module")
+        Some(Cow::Borrowed("module"))
       } else if path.ends_with(".cjs") {
-        Some("commonjs")
+        Some(Cow::Borrowed("commonjs"))
       } else {
-        description_data
-          .as_ref()
-          .and_then(|data| data.json().get("type").and_then(|t| t.as_str()))
+        description_data.as_ref().and_then(|data| {
+          data
+            .json()
+            .get("type")
+            .and_then(|t| t.as_str().map(|t| Cow::Owned(t.to_owned())))
+        })
       };
       // favor explicit loader query over aliased query, see webpack issue-3320
       let resource = if let Some(rest) = rest
@@ -104,12 +117,7 @@ pub(crate) async fn resolve_loader(
       } else {
         format!("{path}{query}")
       };
-      let ident = if let Some(ty) = r#type {
-        format!("{ty}|{resource}")
-      } else {
-        resource
-      };
-      Ok(Some(Arc::new(JsLoader(ident.into()))))
+      Ok(Some(Arc::new(JsLoader(resource.into(), r#type))))
     }
     ResolveResult::Ignored => Ok(None),
   }

crates/rspack_loader_runner/src/loader.rs

@@ -193,31 +193,40 @@ where
     loader_context.current_loader().set_finish_called();
     Ok(())
   }
+
   async fn pitch(&self, _loader_context: &mut LoaderContext<Context>) -> Result<()> {
     // noop
     Ok(())
   }
+
+  /// Returns the loader type based on the module's package.json type field or file extension.
+  /// This affects how the loader context interprets the module (e.g., "commonjs", "module").
+  fn r#type(&self) -> Option<&str> {
+    None
+  }
 }
 
 impl<C> From<Arc<dyn Loader<C>>> for LoaderItem<C>
 where
   C: Send,
 {
   fn from(loader: Arc<dyn Loader<C>>) -> Self {
-    if let Some((r#type, ident)) = loader.identifier().split_once('|') {
+    let ident = &**loader.identifier();
+    if let Some(r#type) = loader.r#type() {
       let ResourceParsedData {
         path,
         query,
         fragment,
       } = parse_resource(ident).expect("identifier should be valid");
+      let ty = r#type.to_string();
       return Self {
         loader,
         request: ident.into(),
         path,
         query,
         fragment,
         data: serde_json::Value::Null,
-        r#type: r#type.to_string(),
+        r#type: ty,
         pitch_executed: AtomicBool::new(false),
         normal_executed: AtomicBool::new(false),
         finish_called: AtomicBool::new(false),

packages/rspack-test-tools/package.json

@@ -110,7 +110,8 @@
     "terser": "5.43.1",
     "typescript": "^5.9.2",
     "wast-loader": "^1.14.1",
-    "worker-rspack-loader": "^3.1.2"
+    "worker-rspack-loader": "^3.1.2",
+    "exports-loader": "^5.0.0"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"

packages/rspack-test-tools/tests/configCases/loader/issue-11129/index.js

@@ -0,0 +1,7 @@
+it("should handle exports-loader with inline-style options", function () {
+	const inlineResult = require("./lib.js?inline");
+	const objectResult = require("./lib.js?object");
+
+	expect(inlineResult).toBeDefined();
+	expect(objectResult).toBeDefined();
+});

packages/rspack-test-tools/tests/configCases/loader/issue-11129/lib.js

@@ -0,0 +1,3 @@
+function noop() {}
+
+var lamejs = noop;

packages/rspack-test-tools/tests/configCases/loader/issue-11129/rspack.config.js

@@ -0,0 +1,25 @@
+const path = require("path");
+
+/** @type {import("@rspack/core").Configuration} */
+module.exports = {
+	module: {
+		rules: [
+			{
+				test: path.resolve(__dirname, "lib.js"),
+				resourceQuery: /inline/,
+				use: "exports-loader?type=commonjs&exports=single|lamejs"
+			},
+			{
+				test: path.resolve(__dirname, "lib.js"),
+				resourceQuery: /object/,
+				use: {
+					loader: "exports-loader",
+					options: {
+						type: "commonjs",
+						exports: "single|lamejs"
+					}
+				}
+			}
+		]
+	}
+};