Revert "perf: reuse js dependency" (#9389)

Revert "perf: reuse js dependency (#9352)"

This reverts commit 6032d46.

crates/node_binding/binding.d.ts

@@ -19,14 +19,9 @@ export declare class ExternalObject<T> {
     [K: symbol]: T
   }
 }
-export declare class Dependency {
-
-}
-export type JsDependency = Dependency
-
 export declare class EntryDataDto {
-  get dependencies(): Dependency[]
-  get includeDependencies(): Dependency[]
+  get dependencies(): JsDependency[]
+  get includeDependencies(): JsDependency[]
   get options(): EntryOptionsDto
 }
 export type EntryDataDTO = EntryDataDto
@@ -174,7 +169,7 @@ export declare class JsContextModuleFactoryAfterResolveData {
   set regExp(rawRegExp: RegExp | undefined)
   get recursive(): boolean
   set recursive(recursive: boolean)
-  get dependencies(): Dependency[]
+  get dependencies(): JsDependency[]
 }
 
 export declare class JsContextModuleFactoryBeforeResolveData {
@@ -204,10 +199,19 @@ export declare class JsDependencies {
 }
 
 export declare class JsDependenciesBlock {
-  get dependencies(): Dependency[]
+  get dependencies(): JsDependency[]
   get blocks(): JsDependenciesBlock[]
 }
 
+export declare class JsDependency {
+  get type(): string
+  get category(): string
+  get request(): string | undefined
+  get critical(): boolean
+  set critical(val: boolean)
+  get ids(): Array<string> | undefined
+}
+
 export declare class JsEntries {
   clear(): void
   get size(): number
@@ -240,7 +244,7 @@ export declare class JsModule {
   get type(): string
   get layer(): string | undefined
   get blocks(): JsDependenciesBlock[]
-  get dependencies(): Dependency[]
+  get dependencies(): JsDependency[]
   size(ty?: string | undefined | null): number
   get modules(): JsModule[] | undefined
   get useSourceMap(): boolean
@@ -251,21 +255,21 @@ export declare class JsModule {
 }
 
 export declare class JsModuleGraph {
-  getModule(jsDependency: Dependency): JsModule | null
-  getResolvedModule(jsDependency: Dependency): JsModule | null
+  getModule(jsDependency: JsDependency): JsModule | null
+  getResolvedModule(jsDependency: JsDependency): JsModule | null
   getUsedExports(jsModule: JsModule, jsRuntime: string | Array<string>): boolean | Array<string> | null
   getIssuer(module: JsModule): JsModule | null
   getExportsInfo(module: JsModule): JsExportsInfo
-  getConnection(dependency: Dependency): JsModuleGraphConnection | null
+  getConnection(dependency: JsDependency): JsModuleGraphConnection | null
   getOutgoingConnections(module: JsModule): JsModuleGraphConnection[]
   getIncomingConnections(module: JsModule): JsModuleGraphConnection[]
-  getParentModule(jsDependency: Dependency): JsModule | null
-  getParentBlockIndex(jsDependency: Dependency): number
+  getParentModule(jsDependency: JsDependency): JsModule | null
+  getParentBlockIndex(jsDependency: JsDependency): number
   isAsync(module: JsModule): boolean
 }
 
 export declare class JsModuleGraphConnection {
-  get dependency(): Dependency
+  get dependency(): JsDependency
   get module(): JsModule | null
   get resolvedModule(): JsModule | null
   get originModule(): JsModule | null

crates/node_binding/src/compilation/entries.rs

@@ -189,32 +189,32 @@ pub struct EntryDataDTO {
 
 #[napi]
 impl EntryDataDTO {
-  #[napi(getter, ts_return_type = "Dependency[]")]
+  #[napi(getter, ts_return_type = "JsDependency[]")]
   pub fn dependencies(&'static self) -> Vec<JsDependencyWrapper> {
     let module_graph = self.compilation.get_module_graph();
     self
       .entry_data
       .dependencies
       .iter()
-      .filter_map(|dependency_id| {
-        module_graph
-          .dependency_by_id(dependency_id)
-          .map(|dep| JsDependencyWrapper::from_id(*dep.id(), self.compilation.compiler_id()))
+      .map(|dependency_id| {
+        #[allow(clippy::unwrap_used)]
+        let dep = module_graph.dependency_by_id(dependency_id).unwrap();
+        JsDependencyWrapper::new(dep.as_ref(), self.compilation.id(), Some(self.compilation))
       })
       .collect::<Vec<_>>()
   }
 
-  #[napi(getter, ts_return_type = "Dependency[]")]
+  #[napi(getter, ts_return_type = "JsDependency[]")]
   pub fn include_dependencies(&'static self) -> Vec<JsDependencyWrapper> {
     let module_graph = self.compilation.get_module_graph();
     self
       .entry_data
       .include_dependencies
       .iter()
-      .filter_map(|dependency_id| {
-        module_graph
-          .dependency_by_id(dependency_id)
-          .map(|dep| JsDependencyWrapper::from_id(*dep.id(), self.compilation.compiler_id()))
+      .map(|dependency_id| {
+        #[allow(clippy::unwrap_used)]
+        let dep = module_graph.dependency_by_id(dependency_id).unwrap();
+        JsDependencyWrapper::new(dep.as_ref(), self.compilation.id(), Some(self.compilation))
       })
       .collect::<Vec<_>>()
   }

crates/node_binding/src/context_module_factory.rs

@@ -1,15 +1,11 @@
-use napi::{
-  bindgen_prelude::{
-    ClassInstance, Either, FromNapiValue, Object, ToNapiValue, TypeName, ValidateNapiValue,
-  },
-  Env,
+use napi::bindgen_prelude::{
+  ClassInstance, Either, FromNapiValue, ToNapiValue, TypeName, ValidateNapiValue,
 };
 use napi_derive::napi;
 use rspack_core::{AfterResolveData, BeforeResolveData};
 use rspack_regex::RspackRegex;
-use swc_core::common::util::take::Take;
 
-use crate::{JsDependency, JsDependencyWrapper};
+use crate::JsDependencyWrapper;
 
 #[napi]
 pub struct JsContextModuleFactoryBeforeResolveData(Box<BeforeResolveData>);
@@ -113,118 +109,74 @@ pub type JsContextModuleFactoryBeforeResolveResult =
   Either<bool, JsContextModuleFactoryBeforeResolveDataWrapper>;
 
 #[napi]
-pub struct JsContextModuleFactoryAfterResolveData {
-  data: Option<Box<AfterResolveData>>,
-  js_dependencies: Option<Vec<ClassInstance<'static, JsDependency>>>,
-}
-
-impl JsContextModuleFactoryAfterResolveData {
-  fn as_ref(&self) -> napi::Result<&AfterResolveData> {
-    match &self.data {
-        Some(data) => {
-          Ok(data.as_ref())
-        },
-        None => Err(napi::Error::from_reason(
-          "Unable to access context module factory after resolve data now. The data has been taken on the Rust side."
-        )),
-    }
-  }
-
-  fn as_mut(&mut self) -> napi::Result<&mut AfterResolveData> {
-    match &mut self.data {
-        Some(data) => {
-         Ok(data.as_mut())
-        },
-        None =>   Err(napi::Error::from_reason(
-          "Unable to modify context module factory after resolve data now. The data has been taken on the Rust side."
-        )),
-    }
-  }
-}
+pub struct JsContextModuleFactoryAfterResolveData(Box<AfterResolveData>);
 
 #[napi]
 impl JsContextModuleFactoryAfterResolveData {
   #[napi(getter)]
-  pub fn resource(&self) -> napi::Result<&str> {
-    let data = self.as_ref()?;
-    Ok(data.resource.as_str())
+  pub fn resource(&self) -> &str {
+    self.0.resource.as_str()
   }
 
   #[napi(setter)]
-  pub fn set_resource(&mut self, resource: String) -> napi::Result<()> {
-    let data = self.as_mut()?;
-    data.resource = resource.into();
-    Ok(())
+  pub fn set_resource(&mut self, resource: String) {
+    self.0.resource = resource.into();
   }
 
   #[napi(getter)]
-  pub fn context(&self) -> napi::Result<&str> {
-    let data = self.as_ref()?;
-    Ok(&data.context)
+  pub fn context(&self) -> &str {
+    &self.0.context
   }
 
   #[napi(setter)]
-  pub fn set_context(&mut self, context: String) -> napi::Result<()> {
-    let data = self.as_mut()?;
-    data.context = context;
-    Ok(())
+  pub fn set_context(&mut self, context: String) {
+    self.0.context = context;
   }
 
   #[napi(getter)]
-  pub fn request(&self) -> napi::Result<&str> {
-    let data = self.as_ref()?;
-    Ok(&data.request)
+  pub fn request(&self) -> &str {
+    &self.0.request
   }
 
   #[napi(setter)]
-  pub fn set_request(&mut self, request: String) -> napi::Result<()> {
-    let data = self.as_mut()?;
-    data.request = request;
-    Ok(())
+  pub fn set_request(&mut self, request: String) {
+    self.0.request = request;
   }
 
   #[napi(getter, ts_return_type = "RegExp | undefined")]
-  pub fn reg_exp(&self) -> napi::Result<Either<RspackRegex, ()>> {
-    let data = self.as_ref()?;
-    Ok(match &data.reg_exp {
+  pub fn reg_exp(&self) -> Either<RspackRegex, ()> {
+    match &self.0.reg_exp {
       Some(r) => Either::A(r.clone()),
       None => Either::B(()),
-    })
+    }
   }
 
   #[napi(setter, ts_args_type = "rawRegExp: RegExp | undefined")]
-  pub fn set_reg_exp(&mut self, raw_reg_exp: Either<RspackRegex, ()>) -> napi::Result<()> {
-    let data = self.as_mut()?;
-    data.reg_exp = match raw_reg_exp {
+  pub fn set_reg_exp(&mut self, raw_reg_exp: Either<RspackRegex, ()>) {
+    self.0.reg_exp = match raw_reg_exp {
       Either::A(regex) => Some(regex),
       Either::B(_) => None,
     };
-    Ok(())
   }
 
   #[napi(getter)]
-  pub fn recursive(&self) -> napi::Result<bool> {
-    let data = self.as_ref()?;
-    Ok(data.recursive)
+  pub fn recursive(&self) -> bool {
+    self.0.recursive
   }
 
   #[napi(setter)]
-  pub fn set_recursive(&mut self, recursive: bool) -> napi::Result<()> {
-    let data = self.as_mut()?;
-    data.recursive = recursive;
-    Ok(())
+  pub fn set_recursive(&mut self, recursive: bool) {
+    self.0.recursive = recursive;
   }
 
-  #[napi(getter, ts_return_type = "Dependency[]")]
-  pub fn dependencies(&self, env: Env) -> napi::Result<Vec<Object>> {
-    match &self.js_dependencies {
-      Some(js_dependencies) => {
-        Ok(js_dependencies.iter().map(|dep| dep.as_object(&env)).collect())
-      },
-      None => Err(napi::Error::from_reason(
-        "Unable to take dependencies in context module factory after resolve data now. The data has been taken on the Rust side."
-      )),
-    }
+  #[napi(getter, ts_return_type = "JsDependency[]")]
+  pub fn dependencies(&self) -> Vec<JsDependencyWrapper> {
+    self
+      .0
+      .dependencies
+      .iter()
+      .map(|dep| JsDependencyWrapper::new(dep.as_ref(), self.0.compilation_id, None))
+      .collect::<Vec<_>>()
   }
 }
 
@@ -245,55 +197,28 @@ impl FromNapiValue for JsContextModuleFactoryAfterResolveDataWrapper {
     env: napi::sys::napi_env,
     napi_val: napi::sys::napi_value,
   ) -> napi::Result<Self> {
-    let mut instance =
+    let instance =
       <ClassInstance<JsContextModuleFactoryAfterResolveData> as FromNapiValue>::from_napi_value(
         env, napi_val,
       )?;
-    let Some(mut data) = instance.data.take() else {
-      return Err(napi::Error::from_reason(
-        "Unable to take context module factory after resolve data now. The data has been taken on the Rust side."
-      ));
-    };
-    let Some(js_dependencies) = instance.js_dependencies.take() else {
-      return Err(napi::Error::from_reason(
-        "Unable to take dependencies in context module factory after resolve data now. The data has been taken on the Rust side."
-      ));
-    };
-
-    data.dependencies = js_dependencies
-      .into_iter()
-      .filter_map(|mut dep| dep.dependency.take())
-      .collect::<Vec<_>>();
-
-    Ok(Self(data))
+    Ok(Self(instance.0.clone()))
   }
 }
 
 impl ToNapiValue for JsContextModuleFactoryAfterResolveDataWrapper {
   unsafe fn to_napi_value(
     env: napi::sys::napi_env,
-    mut val: Self,
+    val: Self,
   ) -> napi::Result<napi::sys::napi_value> {
-    let dependencies = val.0.dependencies.take();
-    let compiler_id = val.0.compiler_id;
-    let js_data = JsContextModuleFactoryAfterResolveData {
-      data: Some(val.0),
-      js_dependencies: Some(
-        dependencies
-          .into_iter()
-          .map(|dep| JsDependencyWrapper::from_owned(dep, compiler_id).into_instance(env))
-          .collect::<napi::Result<Vec<_>>>()?,
-      ),
-    };
-    ToNapiValue::to_napi_value(env, js_data)
+    let js_val = JsContextModuleFactoryAfterResolveData(val.0);
+    ToNapiValue::to_napi_value(env, js_val)
   }
 }
 
 impl TypeName for JsContextModuleFactoryAfterResolveDataWrapper {
   fn type_name() -> &'static str {
     "JsContextModuleFactoryAfterResolveData"
   }
-
   fn value_type() -> napi::ValueType {
     napi::ValueType::Object
   }