feat: add resolve_file API for tsconfig auto discovery to work (#860)

Add a new API to make tsconfig paths work with the auto-discovered tsconfig.

```rust
    /// Resolve `specifier` for an absolute path to a file.
    ///
    /// NOTE: [TsconfigDiscovery::Auto] only work for this API, use `ResolverGeneric::resolve_file` instead.
    ///
    /// # Errors
    ///
    /// * See [ResolveError]
    ///
    /// # Panics
    ///
    /// * If the provided path is not a file.
    pub fn resolve_file<P: AsRef<Path>>(
        &self,
        file: P,
        specifier: &str,
    ) -> Result<Resolution, ResolveError> {
```

---

New concept:

Given an input file:

* There is always a tsconfig associated with this file, we call it the resolved tsconfig, or tsconfig solution (in tsconfck)
* When resolving path aliases, always use the resolved tsconfig.

Author: Boshen

src/lib.rs

@@ -219,7 +219,7 @@ fn alias_is_full_path() {
     ];
 
     for specifier in specifiers {
-        let resolution = resolver.resolve_with_context(&f, &specifier, &mut ctx);
+        let resolution = resolver.resolve_with_context(&f, &specifier, None, &mut ctx);
         assert_eq!(resolution.map(|r| r.full_path()), Ok(dir.join("index.js")));
     }
 

src/tests/alias.rs

@@ -93,7 +93,7 @@ mod test {
             let mut ctx = ResolveContext::default();
             let path = PathBuf::from(context);
             let resolved_path =
-                resolver.resolve_with_context(path, request, &mut ctx).map(|r| r.full_path());
+                resolver.resolve_with_context(path, request, None, &mut ctx).map(|r| r.full_path());
             assert_eq!(resolved_path, Ok(PathBuf::from(result)));
             let file_dependencies = file_dependencies.iter().map(PathBuf::from).collect();
             let missing_dependencies = missing_dependencies.iter().map(PathBuf::from).collect();

src/tests/dependencies.rs

@@ -2554,6 +2554,7 @@ fn test_cases() {
                 &cached_path,
                 case.request,
                 &case.exports_field,
+                None,
                 &mut Ctx::default(),
             )
             .map(|p| p.map(|p| p.to_path_buf()));

src/tests/exports_field.rs

@@ -51,7 +51,7 @@ fn default_enforce_extension() {
         extensions: vec![".ts".into(), String::new(), ".js".into()],
         ..ResolveOptions::default()
     })
-    .resolve_with_context(&f, "./foo", &mut ctx);
+    .resolve_with_context(&f, "./foo", None, &mut ctx);
 
     assert_eq!(resolved.map(Resolution::into_path_buf), Ok(f.join("foo.ts")));
     assert_eq!(
@@ -72,7 +72,7 @@ fn respect_enforce_extension() {
         extensions: vec![".ts".into(), String::new(), ".js".into()],
         ..ResolveOptions::default()
     })
-    .resolve_with_context(&f, "./foo", &mut ctx);
+    .resolve_with_context(&f, "./foo", None, &mut ctx);
 
     assert_eq!(resolved.map(Resolution::into_path_buf), Ok(f.join("foo.ts")));
     assert_eq!(

src/tests/extensions.rs

@@ -1325,6 +1325,7 @@ fn test_cases() {
                 &cached_path,
                 true,
                 &case.condition_names.iter().map(ToString::to_string).collect::<Vec<_>>(),
+                None,
                 &mut Ctx::default(),
             )
             .map(|p| p.map(|p| p.to_path_buf()));

src/tests/imports_field.rs

@@ -10,7 +10,7 @@ fn incorrect_description_file_1() {
     let f = super::fixture().join("incorrect-package");
     let mut ctx = ResolveContext::default();
     let error =
-        Resolver::default().resolve_with_context(f.join("pack1"), ".", &mut ctx).unwrap_err();
+        Resolver::default().resolve_with_context(f.join("pack1"), ".", None, &mut ctx).unwrap_err();
     match error {
         ResolveError::Json(e) => {
             assert_eq!(e.path, f.join("pack1/package.json"));

src/tests/incorrect_description_file.rs

@@ -49,7 +49,7 @@ fn test() {
 
     for (specifier, missing_dependencies) in data {
         let mut ctx = ResolveContext::default();
-        let _ = resolver.resolve_with_context(&f, specifier, &mut ctx);
+        let _ = resolver.resolve_with_context(&f, specifier, None, &mut ctx);
 
         for path in ctx.file_dependencies {
             assert_eq!(path, path.normalize(), "{path:?}");
@@ -87,8 +87,8 @@ fn alias_and_extensions() {
     });
 
     let mut ctx = ResolveContext::default();
-    let _ = resolver.resolve_with_context(&f, "@scope-js/package-name/dir/router", &mut ctx);
-    let _ = resolver.resolve_with_context(&f, "react-dom/client", &mut ctx);
+    let _ = resolver.resolve_with_context(&f, "@scope-js/package-name/dir/router", None, &mut ctx);
+    let _ = resolver.resolve_with_context(&f, "react-dom/client", None, &mut ctx);
 
     for path in ctx.file_dependencies {
         assert_eq!(path, path.normalize(), "{path:?}");

src/tests/missing.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use walkdir::WalkDir;
 
-use crate::Resolver;
+use crate::{ResolveOptions, Resolver, TsconfigDiscovery};
 
 fn walk(dir: &PathBuf) -> Vec<PathBuf> {
     WalkDir::new(dir)
@@ -84,7 +84,10 @@ fn part_of_solution() {
         ("referenced-exclude", "src/bar.ts", "tsconfig.bar.json"),
     ];
 
-    let resolver = Resolver::default();
+    let resolver = Resolver::new(ResolveOptions {
+        tsconfig: Some(TsconfigDiscovery::Auto),
+        ..ResolveOptions::default()
+    });
     for (dir, specifier, expected) in pass {
         let dir = root.join(dir);
         let tsconfig = resolver.find_tsconfig(dir.join(specifier)).unwrap().unwrap();
@@ -96,7 +99,10 @@ fn part_of_solution() {
 #[test]
 fn find() {
     let dir = super::fixture_root().join("tsconfck").join("find").join("a");
-    let resolver = Resolver::default();
+    let resolver = Resolver::new(ResolveOptions {
+        tsconfig: Some(TsconfigDiscovery::Auto),
+        ..ResolveOptions::default()
+    });
 
     let result = resolver.find_tsconfig(dir.join("foo.ts"));
     let path = result.map(|tsconfig| tsconfig.unwrap().path().to_path_buf());

src/tests/tsconfck.rs

@@ -20,6 +20,6 @@ fn tsconfig_discovery_virtual_file_importer() {
     });
 
     let resolved_path =
-        resolver.resolve("\0virtual-module", "random-import").map(|f| f.full_path());
+        resolver.resolve_file("\0virtual-module/foo.js", "random-import").map(|f| f.full_path());
     assert_eq!(resolved_path, Err(ResolveError::NotFound("random-import".into())));
 }