perf: JsUtf16Buffer

Author: SyMind

crates/node_binding/binding.d.ts

@@ -737,15 +737,15 @@ export interface JsLoaderContext {
   _module: JsModule
   hot: Readonly<boolean>
   /** Content maybe empty in pitching stage */
-  content: null | Buffer | string
+  content: null | Buffer | JsUtf16Buffer
   additionalData?: any
-  __internal__parseMeta: Record<string, string>
+  __internal__parseMeta: Record<string, JsUtf16Buffer>
   sourceMap?: JsSourceMap
   cacheable: boolean
-  fileDependencies: Array<string>
-  contextDependencies: Array<string>
-  missingDependencies: Array<string>
-  buildDependencies: Array<string>
+  fileDependencies: Array<JsUtf16Buffer>
+  contextDependencies: Array<JsUtf16Buffer>
+  missingDependencies: Array<JsUtf16Buffer>
+  buildDependencies: Array<JsUtf16Buffer>
   loaderItems: Array<JsLoaderItem>
   loaderIndex: number
   loaderState: Readonly<JsLoaderState>
@@ -871,12 +871,12 @@ export interface JsRuntimeRequirementInTreeResult {
 
 export interface JsSourceMap {
   version: number
-  file?: string
-  sources: Array<string>
-  sourcesContent?: Array<string>
-  names: Array<string>
-  mappings: string
-  sourceRoot?: string
+  file?: JsUtf16Buffer
+  sources: Array<JsUtf16Buffer>
+  sourcesContent?: Array<JsUtf16Buffer>
+  names: Array<JsUtf16Buffer>
+  mappings: JsUtf16Buffer
+  sourceRoot?: JsUtf16Buffer
 }
 
 export interface JsStatsAsset {

crates/node_binding/src/plugins/js_loader/context.rs

@@ -1,65 +1,43 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
 
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
 use rspack_core::{rspack_sources::SourceMap, LoaderContext, RunnerContext};
 use rspack_loader_runner::{LoaderItem, State as LoaderState};
-use rspack_napi::{
-  napi::JsString, string::JsStringExt, threadsafe_js_value_ref::ThreadsafeJsValueRef,
-};
+use rspack_napi::{threadsafe_js_value_ref::ThreadsafeJsValueRef, JsUtf16Buffer};
 
 use crate::{JsModuleWrapper, JsResourceData, JsRspackError};
 
 #[napi(object)]
 pub struct JsSourceMap {
   pub version: u8,
-  pub file: Option<JsString>,
-  pub sources: Vec<JsString>,
-  pub sources_content: Option<Vec<JsString>>,
-  pub names: Vec<JsString>,
-  pub mappings: JsString,
-  pub source_root: Option<JsString>,
+  pub file: Option<JsUtf16Buffer>,
+  pub sources: Vec<JsUtf16Buffer>,
+  pub sources_content: Option<Vec<JsUtf16Buffer>>,
+  pub names: Vec<JsUtf16Buffer>,
+  pub mappings: JsUtf16Buffer,
+  pub source_root: Option<JsUtf16Buffer>,
 }
 
-pub struct JsSourceMapWrapper(SourceMap);
+impl From<&SourceMap> for JsSourceMap {
+  fn from(value: &SourceMap) -> Self {
+    let file = value.file().map(Into::into);
 
-impl JsSourceMapWrapper {
-  pub fn new(source_map: SourceMap) -> Self {
-    Self(source_map)
-  }
+    let sources = value.sources().iter().map(Into::into).collect::<Vec<_>>();
 
-  pub fn take(self) -> SourceMap {
-    self.0
-  }
-}
+    let sources_content = value
+      .sources_content()
+      .iter()
+      .map(Into::into)
+      .collect::<Vec<_>>();
 
-impl ToNapiValue for JsSourceMapWrapper {
-  unsafe fn to_napi_value(env: sys::napi_env, val: Self) -> Result<sys::napi_value> {
-    let env_wrapper = Env::from_raw(env);
-
-    let file = match val.0.file() {
-      Some(s) => Some(env_wrapper.create_string(s)?),
-      None => None,
-    };
-    let mut sources = Vec::with_capacity(val.0.sources().len());
-    for source in val.0.sources() {
-      sources.push(env_wrapper.create_string(source)?);
-    }
-    let mut sources_content = Vec::with_capacity(val.0.sources_content().len());
-    for source_content in val.0.sources_content() {
-      sources_content.push(env_wrapper.create_string(source_content)?);
-    }
-    let mut names = Vec::with_capacity(val.0.sources_content().len());
-    for name in val.0.names() {
-      names.push(env_wrapper.create_string(name)?);
-    }
-    let mappings = env_wrapper.create_string(val.0.mappings())?;
-    let source_root = match val.0.source_root() {
-      Some(s) => Some(env_wrapper.create_string(s)?),
-      None => None,
-    };
+    let names = value.names().iter().map(Into::into).collect::<Vec<_>>();
 
-    let js_source_map = JsSourceMap {
+    let mappings = value.mappings().into();
+
+    let source_root = value.source_root().map(Into::into);
+
+    Self {
       version: 3,
       file,
       sources,
@@ -71,37 +49,55 @@ impl ToNapiValue for JsSourceMapWrapper {
       names,
       mappings,
       source_root,
-    };
-    ToNapiValue::to_napi_value(env, js_source_map)
+    }
   }
 }
 
-impl FromNapiValue for JsSourceMapWrapper {
-  unsafe fn from_napi_value(env: sys::napi_env, napi_val: sys::napi_value) -> Result<Self> {
-    let js_source_map: JsSourceMap = FromNapiValue::from_napi_value(env, napi_val)?;
-
-    let sources_content = match js_source_map.sources_content {
-      Some(sources_content) => sources_content
-        .into_iter()
-        .map(|source| source.into_string())
-        .collect::<Vec<_>>(),
-      None => vec![],
-    };
+impl From<&JsSourceMap> for SourceMap {
+  fn from(value: &JsSourceMap) -> Self {
+    let file = value.file.as_ref().map(|file| file.to_string());
 
-    Ok(JsSourceMapWrapper(SourceMap::new(
-      js_source_map.mappings.into_string(),
-      js_source_map
+    let sources = Arc::from(
+      value
         .sources
-        .into_iter()
-        .map(|source| source.into_string())
+        .iter()
+        .map(|source| source.to_string())
         .collect::<Vec<_>>(),
-      sources_content,
-      js_source_map
+    );
+
+    let sources_content = Arc::from(
+      value
+        .sources_content
+        .as_ref()
+        .map(|sources_content| {
+          sources_content
+            .iter()
+            .map(|source_content| source_content.to_string())
+            .collect::<Vec<_>>()
+        })
+        .unwrap_or_default(),
+    );
+
+    let names = Arc::from(
+      value
         .names
-        .into_iter()
-        .map(|source| source.into_string())
+        .iter()
+        .map(|name| name.to_string())
         .collect::<Vec<_>>(),
-    )))
+    );
+
+    let mappings = Arc::from(value.mappings.to_string());
+
+    let source_root = value
+      .source_root
+      .as_ref()
+      .map(|source_root| Arc::from(source_root.to_string()));
+
+    let mut source_map = Self::new(mappings, sources, sources_content, names);
+    source_map.set_file(file);
+    source_map.set_source_root(source_root);
+
+    source_map
   }
 }
 
@@ -159,18 +155,18 @@ pub struct JsLoaderContext {
   pub hot: bool,
 
   /// Content maybe empty in pitching stage
-  pub content: Either3<Null, Buffer, String>,
+  pub content: Either3<Null, Buffer, JsUtf16Buffer>,
   #[napi(ts_type = "any")]
   pub additional_data: Option<ThreadsafeJsValueRef<Unknown>>,
   #[napi(js_name = "__internal__parseMeta")]
-  pub parse_meta: HashMap<String, String>,
+  pub parse_meta: HashMap<String, JsUtf16Buffer>,
   #[napi(ts_type = "JsSourceMap")]
-  pub source_map: Option<JsSourceMapWrapper>,
+  pub source_map: Option<JsSourceMap>,
   pub cacheable: bool,
-  pub file_dependencies: Vec<String>,
-  pub context_dependencies: Vec<String>,
-  pub missing_dependencies: Vec<String>,
-  pub build_dependencies: Vec<String>,
+  pub file_dependencies: Vec<JsUtf16Buffer>,
+  pub context_dependencies: Vec<JsUtf16Buffer>,
+  pub missing_dependencies: Vec<JsUtf16Buffer>,
+  pub build_dependencies: Vec<JsUtf16Buffer>,
 
   pub loader_items: Vec<JsLoaderItem>,
   pub loader_index: i32,
@@ -199,37 +195,42 @@ impl TryFrom<&mut LoaderContext<RunnerContext>> for JsLoaderContext {
       hot: cx.hot,
       content: match cx.content() {
         Some(c) => match c {
-          rspack_core::Content::String(s) => Either3::C(s.to_string()),
+          rspack_core::Content::String(s) => Either3::C(s.into()),
           rspack_core::Content::Buffer(vec) => Either3::B(vec.clone().into()),
         },
         None => Either3::A(Null),
       },
-      parse_meta: cx.parse_meta.clone().into_iter().collect(),
+      parse_meta: cx
+        .parse_meta
+        .clone()
+        .into_iter()
+        .map(|(key, value)| (key, (&value).into()))
+        .collect(),
       additional_data: cx
         .additional_data()
         .and_then(|data| data.get::<ThreadsafeJsValueRef<Unknown>>())
         .cloned(),
-      source_map: cx.source_map().cloned().map(JsSourceMapWrapper::new),
+      source_map: cx.source_map().map(Into::into),
       cacheable: cx.cacheable,
       file_dependencies: cx
         .file_dependencies
         .iter()
-        .map(|i| i.to_string_lossy().to_string())
+        .map(|i| JsUtf16Buffer::from(i.to_string_lossy().as_ref()))
         .collect(),
       context_dependencies: cx
         .context_dependencies
         .iter()
-        .map(|i| i.to_string_lossy().to_string())
+        .map(|i| JsUtf16Buffer::from(i.to_string_lossy().as_ref()))
         .collect(),
       missing_dependencies: cx
         .missing_dependencies
         .iter()
-        .map(|i| i.to_string_lossy().to_string())
+        .map(|i| JsUtf16Buffer::from(i.to_string_lossy().as_ref()))
         .collect(),
       build_dependencies: cx
         .build_dependencies
         .iter()
-        .map(|i| i.to_string_lossy().to_string())
+        .map(|i| JsUtf16Buffer::from(i.to_string_lossy().as_ref()))
         .collect(),
 
       loader_items: cx.loader_items.iter().map(Into::into).collect(),

crates/node_binding/src/plugins/js_loader/scheduler.rs

@@ -50,39 +50,59 @@ pub(crate) fn merge_loader_context(
         error.message,
         error.stack,
         error.hide_stack,
-        from.file_dependencies,
-        from.context_dependencies,
-        from.missing_dependencies,
-        from.build_dependencies,
+        from
+          .file_dependencies
+          .into_iter()
+          .map(|i| i.to_string())
+          .collect::<Vec<_>>(),
+        from
+          .context_dependencies
+          .into_iter()
+          .map(|i| i.to_string())
+          .collect::<Vec<_>>(),
+        from
+          .missing_dependencies
+          .into_iter()
+          .map(|i| i.to_string())
+          .collect::<Vec<_>>(),
+        from
+          .build_dependencies
+          .into_iter()
+          .map(|i| i.to_string())
+          .collect::<Vec<_>>(),
       )
       .into(),
     );
   }
 
   to.cacheable = from.cacheable;
-  to.file_dependencies = from.file_dependencies.into_iter().map(Into::into).collect();
+  to.file_dependencies = from
+    .file_dependencies
+    .into_iter()
+    .map(|i| Into::into(i.to_string()))
+    .collect();
   to.context_dependencies = from
     .context_dependencies
     .into_iter()
-    .map(Into::into)
+    .map(|i| Into::into(i.to_string()))
     .collect();
   to.missing_dependencies = from
     .missing_dependencies
     .into_iter()
-    .map(Into::into)
+    .map(|i| Into::into(i.to_string()))
     .collect();
   to.build_dependencies = from
     .build_dependencies
     .into_iter()
-    .map(Into::into)
+    .map(|i| Into::into(i.to_string()))
     .collect();
 
   let content = match from.content {
     Either3::A(_) => None,
     Either3::B(c) => Some(rspack_core::Content::from(Into::<Vec<u8>>::into(c))),
-    Either3::C(s) => Some(rspack_core::Content::from(s)),
+    Either3::C(s) => Some(rspack_core::Content::from(s.to_string())),
   };
-  let source_map = from.source_map.map(|s| s.take());
+  let source_map = from.source_map.as_ref().map(Into::into);
   let additional_data = from.additional_data.take().map(|data| {
     let mut additional = AdditionalData::default();
     additional.insert(data);
@@ -109,7 +129,11 @@ pub(crate) fn merge_loader_context(
     })
     .collect();
   to.loader_index = from.loader_index;
-  to.parse_meta = from.parse_meta.into_iter().collect();
+  to.parse_meta = from
+    .parse_meta
+    .into_iter()
+    .map(|(key, value)| (key, value.to_string()))
+    .collect();
 
   Ok(())
 }