feat: support custom parser for json type

crates/node_binding/binding.d.ts

@@ -1581,6 +1581,7 @@ export interface RawJavascriptParserOptions {
 
 export interface RawJsonParserOptions {
   exportsDepth?: number
+  parse?: (source: string) => string
 }
 
 export interface RawLazyCompilationOption {

crates/rspack/src/options/builder.rs

@@ -9,9 +9,9 @@ use rspack_core::{
   Filename, FilenameTemplate, GeneratorOptions, GeneratorOptionsMap, JavascriptParserOptions,
   JavascriptParserOrder, JavascriptParserUrl, JsonParserOptions, LibraryName, LibraryNonUmdObject,
   LibraryOptions, LibraryType, Mode, ModuleNoParseRules, ModuleOptions, ModuleRule,
-  ModuleRuleEffect, OutputOptions, ParserOptions, ParserOptionsMap, PathInfo, PublicPath, Resolve,
-  RspackFuture, RuleSetCondition, RuleSetLogicalConditions, TrustedTypes, WasmLoading,
-  WasmLoadingType,
+  ModuleRuleEffect, OutputOptions, ParseOption, ParserOptions, ParserOptionsMap, PathInfo,
+  PublicPath, Resolve, RspackFuture, RuleSetCondition, RuleSetLogicalConditions, TrustedTypes,
+  WasmLoading, WasmLoadingType,
 };
 use rspack_hash::{HashDigest, HashFunction, HashSalt};
 use rspack_paths::{AssertUtf8, Utf8PathBuf};
@@ -642,6 +642,7 @@ impl ModuleOptionsBuilder {
           } else {
             Some(u32::MAX)
           },
+          parse: ParseOption::None,
         }),
       );
     }

crates/rspack_binding_values/src/raw_options/raw_module/mod.rs

@@ -15,7 +15,7 @@ use rspack_core::{
   JavascriptParserOptions, JavascriptParserOrder, JavascriptParserUrl, JsonParserOptions,
   ModuleNoParseRule, ModuleNoParseRules, ModuleNoParseTestFn, ModuleOptions, ModuleRule,
   ModuleRuleEffect, ModuleRuleEnforce, ModuleRuleUse, ModuleRuleUseLoader, OverrideStrict,
-  ParserOptions, ParserOptionsMap,
+  ParseOption, ParserOptions, ParserOptionsMap,
 };
 use rspack_error::error;
 use rspack_napi::threadsafe_function::ThreadsafeFunction;
@@ -188,7 +188,7 @@ pub struct RawModuleRule {
 }
 
 #[derive(Debug, Default)]
-#[napi(object)]
+#[napi(object, object_to_js = false)]
 pub struct RawParserOptions {
   #[napi(
     ts_type = r#""asset" | "css" | "css/auto" | "css/module" | "javascript" | "javascript/auto" | "javascript/dynamic" | "javascript/esm" | "json""#
@@ -441,15 +441,23 @@ impl From<RawCssModuleParserOptions> for CssModuleParserOptions {
 }
 
 #[derive(Debug, Default)]
-#[napi(object)]
+#[napi(object, object_to_js = false)]
 pub struct RawJsonParserOptions {
   pub exports_depth: Option<u32>,
+  #[napi(ts_type = "(source: string) => string")]
+  pub parse: Option<ThreadsafeFunction<String, String>>,
 }
 
 impl From<RawJsonParserOptions> for JsonParserOptions {
   fn from(value: RawJsonParserOptions) -> Self {
+    let parse = match value.parse {
+      Some(f) => ParseOption::Func(Arc::new(move |s: String| f.blocking_call_with_sync(s))),
+      _ => ParseOption::None,
+    };
+
     Self {
       exports_depth: value.exports_depth,
+      parse,
     }
   }
 }

crates/rspack_core/src/normal_module_factory.rs

@@ -738,6 +738,7 @@ impl NormalModuleFactory {
           | ParserOptions::JavascriptDynamic(b)
           | ParserOptions::JavascriptEsm(b),
         ) => ParserOptions::Javascript(a.merge_from(b)),
+        (ParserOptions::Json(a), ParserOptions::Json(b)) => ParserOptions::Json(a.merge_from(b)),
         (global, _) => global,
       },
     );

crates/rspack_core/src/options/module.rs

@@ -306,10 +306,43 @@ pub struct CssModuleParserOptions {
   pub named_exports: Option<bool>,
 }
 
+pub type JsonParseFn = Arc<dyn Fn(String) -> Result<String> + Sync + Send>;
+
+#[cacheable]
+pub enum ParseOption {
+  Func(#[cacheable(with=Unsupported)] JsonParseFn),
+  None,
+}
+
+impl Debug for ParseOption {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+      Self::Func(_) => write!(f, "ParseOption::Func(...)"),
+      _ => write!(f, "ParseOption::None"),
+    }
+  }
+}
+
+impl Clone for ParseOption {
+  fn clone(&self) -> Self {
+    match self {
+      Self::Func(f) => Self::Func(f.clone()),
+      Self::None => Self::None,
+    }
+  }
+}
+
+impl MergeFrom for ParseOption {
+  fn merge_from(self, other: &Self) -> Self {
+    other.clone()
+  }
+}
+
 #[cacheable]
 #[derive(Debug, Clone, MergeFrom)]
 pub struct JsonParserOptions {
   pub exports_depth: Option<u32>,
+  pub parse: ParseOption,
 }
 
 #[derive(Debug, Default)]

crates/rspack_plugin_json/src/lib.rs

@@ -16,8 +16,8 @@ use rspack_core::{
   diagnostics::ModuleParseError,
   rspack_sources::{BoxSource, RawStringSource, Source, SourceExt},
   BuildMetaDefaultObject, BuildMetaExportsType, ChunkGraph, CompilerOptions, ExportsInfo,
-  GenerateContext, Module, ModuleGraph, ParserAndGenerator, Plugin, RuntimeGlobals, RuntimeSpec,
-  SourceType, UsageState, NAMESPACE_OBJECT_EXPORT,
+  GenerateContext, Module, ModuleGraph, ParseOption, ParserAndGenerator, Plugin, RuntimeGlobals,
+  RuntimeSpec, SourceType, UsageState, NAMESPACE_OBJECT_EXPORT,
 };
 use rspack_error::{
   miette::diagnostic, DiagnosticExt, DiagnosticKind, IntoTWithDiagnosticArray, Result,
@@ -34,6 +34,7 @@ mod utils;
 #[derive(Debug)]
 struct JsonParserAndGenerator {
   pub exports_depth: u32,
+  pub parse: ParseOption,
 }
 
 #[cacheable_dyn]
@@ -55,54 +56,68 @@ impl ParserAndGenerator for JsonParserAndGenerator {
       build_info,
       build_meta,
       loaders,
+      module_parser_options,
       ..
     } = parse_context;
     let source = box_source.source();
     let strip_bom_source = source.strip_prefix('\u{feff}');
     let need_strip_bom = strip_bom_source.is_some();
+    let strip_bom_source = strip_bom_source.unwrap_or(&source);
 
-    let parse_result = json::parse(strip_bom_source.unwrap_or(&source)).map_err(|e| {
-      match e {
-        UnexpectedCharacter { ch, line, column } => {
-          let rope = ropey::Rope::from_str(&source);
-          let line_offset = rope.try_line_to_byte(line - 1).expect("TODO:");
-          let start_offset = source[line_offset..]
-            .chars()
-            .take(column)
-            .fold(line_offset, |acc, cur| acc + cur.len_utf8());
-          let start_offset = if need_strip_bom {
-            start_offset + 1
-          } else {
-            start_offset
-          };
-          TraceableError::from_file(
-            source.into_owned(),
-            // one character offset
-            start_offset,
-            start_offset + 1,
-            "Json parsing error".to_string(),
-            format!("Unexpected character {ch}"),
-          )
-          .with_kind(DiagnosticKind::Json)
-          .boxed()
+    // If there is a custom parse, execute it to obtain the returned string.
+    let parse_result_str = module_parser_options
+      .and_then(|p| p.get_json())
+      .and_then(|p| match &p.parse {
+        ParseOption::Func(p) => {
+          let parse_result = p(strip_bom_source.to_string());
+          parse_result.ok()
         }
-        ExceededDepthLimit | WrongType(_) | FailedUtf8Parsing => diagnostic!("{e}").boxed(),
-        UnexpectedEndOfJson => {
-          // End offset of json file
-          let length = source.len();
-          let offset = if length > 0 { length - 1 } else { length };
-          TraceableError::from_file(
-            source.into_owned(),
-            offset,
-            offset,
-            "Json parsing error".to_string(),
-            format!("{e}"),
-          )
-          .with_kind(DiagnosticKind::Json)
-          .boxed()
+        _ => None,
+      });
+
+    let parse_result = json::parse(parse_result_str.as_deref().unwrap_or(strip_bom_source))
+      .map_err(|e| {
+        match e {
+          UnexpectedCharacter { ch, line, column } => {
+            let rope = ropey::Rope::from_str(&source);
+            let line_offset = rope.try_line_to_byte(line - 1).expect("TODO:");
+            let start_offset = source[line_offset..]
+              .chars()
+              .take(column)
+              .fold(line_offset, |acc, cur| acc + cur.len_utf8());
+            let start_offset = if need_strip_bom {
+              start_offset + 1
+            } else {
+              start_offset
+            };
+            TraceableError::from_file(
+              source.into_owned(),
+              // one character offset
+              start_offset,
+              start_offset + 1,
+              "Json parsing error".to_string(),
+              format!("Unexpected character {ch}"),
+            )
+            .with_kind(DiagnosticKind::Json)
+            .boxed()
+          }
+          ExceededDepthLimit | WrongType(_) | FailedUtf8Parsing => diagnostic!("{e}").boxed(),
+          UnexpectedEndOfJson => {
+            // End offset of json file
+            let length = source.len();
+            let offset = if length > 0 { length - 1 } else { length };
+            TraceableError::from_file(
+              source.into_owned(),
+              offset,
+              offset,
+              "Json parsing error".to_string(),
+              format!("{e}"),
+            )
+            .with_kind(DiagnosticKind::Json)
+            .boxed()
+          }
         }
-      }
-    });
+      });
 
     let (diagnostics, data) = match parse_result {
       Ok(data) => (vec![], Some(data)),
@@ -236,6 +251,7 @@ impl Plugin for JsonPlugin {
 
         Box::new(JsonParserAndGenerator {
           exports_depth: p.exports_depth.expect("should have exports_depth"),
+          parse: p.parse.clone(),
         })
       }),
     );