feat: expose package_json_path (#376)

---------

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

Author: sxzz

napi/__test__/resolver.spec.mjs

@@ -238,25 +238,28 @@ test('resolve pnpm package', (t) => {
   const resolver = new ResolverFactory({
     aliasFields: ['browser'],
   });
-  t.deepEqual(resolver.sync(pnpmProjectPath, 'styled-components'), {
-    path: join(
+
+  const styledComponents = resolver.sync(pnpmProjectPath, 'styled-components');
+  t.deepEqual(
+    styledComponents.path,
+    join(
       rootDir,
       'node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/styled-components/dist/styled-components.browser.cjs.js',
     ),
-  });
+  );
+
+  const react = resolver.sync(
+    join(
+      rootDir,
+      'node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/styled-components',
+    ),
+    'react',
+  );
   t.deepEqual(
-    resolver.sync(
-      join(
-        rootDir,
-        'node_modules/.pnpm/[email protected][email protected][email protected][email protected]/node_modules/styled-components',
-      ),
-      'react',
+    react.path,
+    join(
+      rootDir,
+      'node_modules/.pnpm/[email protected]/node_modules/react/index.js',
     ),
-    {
-      path: join(
-        rootDir,
-        'node_modules/.pnpm/[email protected]/node_modules/react/index.js',
-      ),
-    },
   );
 });

napi/index.d.ts

@@ -190,6 +190,7 @@ export interface ResolveResult {
   error?: string;
   /** "type" field in the package.json file */
   moduleType?: string;
+  packageJsonPath?: string;
 }
 
 /**

napi/src/lib.rs

@@ -25,6 +25,7 @@ pub struct ResolveResult {
     pub error: Option<String>,
     /// "type" field in the package.json file
     pub module_type: Option<String>,
+    pub package_json_path: Option<String>,
 }
 
 fn resolve(resolver: &Resolver, path: &Path, request: &str) -> ResolveResult {
@@ -33,8 +34,17 @@ fn resolve(resolver: &Resolver, path: &Path, request: &str) -> ResolveResult {
             path: Some(resolution.full_path().to_string_lossy().to_string()),
             error: None,
             module_type: resolution.package_json().and_then(|p| p.r#type()).map(|t| t.to_string()),
+            package_json_path: resolution
+                .package_json()
+                .and_then(|p| p.path().to_str())
+                .map(|p| p.to_string()),
+        },
+        Err(err) => ResolveResult {
+            path: None,
+            module_type: None,
+            error: Some(err.to_string()),
+            package_json_path: None,
         },
-        Err(err) => ResolveResult { path: None, module_type: None, error: Some(err.to_string()) },
     }
 }
 
@@ -76,11 +86,12 @@ impl ResolverFactory {
     #[napi(constructor)]
     pub fn new(options: Option<NapiResolveOptions>) -> Self {
         init_tracing();
-        let options = options.map_or_else(|| ResolveOptions::default(), Self::normalize_options);
+        let options = options.map_or_else(ResolveOptions::default, Self::normalize_options);
         Self { resolver: Arc::new(Resolver::new(options)) }
     }
 
     #[napi]
+    #[allow(clippy::should_implement_trait)]
     pub fn default() -> Self {
         let default_options = ResolveOptions::default();
         Self { resolver: Arc::new(Resolver::new(default_options)) }

napi/src/options.rs

@@ -202,9 +202,9 @@ pub struct TsconfigOptions {
     pub references: Option<Either<String, Vec<String>>>,
 }
 
-impl Into<oxc_resolver::Restriction> for Restriction {
-    fn into(self) -> oxc_resolver::Restriction {
-        match (self.path, self.regex) {
+impl From<Restriction> for oxc_resolver::Restriction {
+    fn from(val: Restriction) -> Self {
+        match (val.path, val.regex) {
             (None, None) => {
                 panic!("Should specify path or regex")
             }
@@ -217,21 +217,21 @@ impl Into<oxc_resolver::Restriction> for Restriction {
     }
 }
 
-impl Into<oxc_resolver::EnforceExtension> for EnforceExtension {
-    fn into(self) -> oxc_resolver::EnforceExtension {
-        match self {
+impl From<EnforceExtension> for oxc_resolver::EnforceExtension {
+    fn from(val: EnforceExtension) -> Self {
+        match val {
             EnforceExtension::Auto => oxc_resolver::EnforceExtension::Auto,
             EnforceExtension::Enabled => oxc_resolver::EnforceExtension::Enabled,
             EnforceExtension::Disabled => oxc_resolver::EnforceExtension::Disabled,
         }
     }
 }
 
-impl Into<oxc_resolver::TsconfigOptions> for TsconfigOptions {
-    fn into(self) -> oxc_resolver::TsconfigOptions {
+impl From<TsconfigOptions> for oxc_resolver::TsconfigOptions {
+    fn from(val: TsconfigOptions) -> Self {
         oxc_resolver::TsconfigOptions {
-            config_file: PathBuf::from(self.config_file),
-            references: match self.references {
+            config_file: PathBuf::from(val.config_file),
+            references: match val.references {
                 Some(Either::A(string)) if string.as_str() == "auto" => {
                     oxc_resolver::TsconfigReferences::Auto
                 }
@@ -250,9 +250,9 @@ impl Into<oxc_resolver::TsconfigOptions> for TsconfigOptions {
 type StrOrStrListType = Either<String, Vec<String>>;
 pub struct StrOrStrList(pub StrOrStrListType);
 
-impl Into<Vec<String>> for StrOrStrList {
-    fn into(self) -> Vec<String> {
-        match self {
+impl From<StrOrStrList> for Vec<String> {
+    fn from(val: StrOrStrList) -> Self {
+        match val {
             StrOrStrList(Either::A(s)) => Vec::from([s]),
             StrOrStrList(Either::B(a)) => a,
         }