feat!: disallow manually passing a list of references to TsconfigOptions::references (#902)

Boshen · Boshen · commit 79b5660fc190 · 2025-12-04T07:58:51.000Z
Manually passing in a list of references is useless.
`tsconfig.json` should always be the source of truth.

Searching on github shows no one uses this option.
diff --git a/napi/index.d.ts b/napi/index.d.ts
@@ -279,7 +279,6 @@ export interface TsconfigOptions {
    * Support for Typescript Project References.
    *
    * * `'auto'`: use the `references` field from tsconfig of `config_file`.
-   * * `string[]`: manually provided relative or absolute path.
    */
-  references?: 'auto' | string[]
+  references?: 'auto'
 }
diff --git a/napi/src/options.rs b/napi/src/options.rs
@@ -210,9 +210,8 @@ pub struct TsconfigOptions {
     /// Support for Typescript Project References.
     ///
     /// * `'auto'`: use the `references` field from tsconfig of `config_file`.
-    /// * `string[]`: manually provided relative or absolute path.
-    #[napi(ts_type = "'auto' | string[]")]
-    pub references: Option<Either<String, Vec<String>>>,
+    #[napi(ts_type = "'auto'")]
+    pub references: Option<String>,
 }
 
 impl From<Restriction> for oxc_resolver::Restriction {
@@ -250,15 +249,10 @@ impl From<TsconfigOptions> for oxc_resolver::TsconfigOptions {
         oxc_resolver::TsconfigOptions {
             config_file: PathBuf::from(val.config_file),
             references: match val.references {
-                Some(Either::A(string)) if string.as_str() == "auto" => {
-                    oxc_resolver::TsconfigReferences::Auto
-                }
-                Some(Either::A(opt)) => {
+                Some(string) if string.as_str() == "auto" => oxc_resolver::TsconfigReferences::Auto,
+                Some(opt) => {
                     panic!("`{}` is not a valid option for  tsconfig references", opt)
                 }
-                Some(Either::B(paths)) => oxc_resolver::TsconfigReferences::Paths(
-                    paths.into_iter().map(PathBuf::from).collect::<Vec<_>>(),
-                ),
                 None => oxc_resolver::TsconfigReferences::Disabled,
             },
         }
diff --git a/src/options.rs b/src/options.rs
@@ -494,13 +494,11 @@ pub struct TsconfigOptions {
 }
 
 /// Configuration for [TsconfigOptions::references]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum TsconfigReferences {
     Disabled,
     /// Use the `references` field from tsconfig of `config_file`.
     Auto,
-    /// Manually provided relative or absolute path.
-    Paths(Vec<PathBuf>),
 }
 
 impl Default for ResolveOptions {
diff --git a/src/tests/tsconfig_project_references.rs b/src/tests/tsconfig_project_references.rs
@@ -134,97 +134,6 @@ fn disabled() {
     }
 }
 
-#[test]
-fn manual() {
-    let f = super::fixture_root().join("tsconfig/cases/project-references");
-
-    // The following resolver's `config_file` has defined it's own paths alias which has higher priority
-    // some cases will work without references
-    let resolver = Resolver::new(ResolveOptions {
-        tsconfig: Some(TsconfigDiscovery::Manual(TsconfigOptions {
-            config_file: f.join("app"),
-            references: TsconfigReferences::Paths(vec!["../project-a/conf.json".into()]),
-        })),
-        ..ResolveOptions::default()
-    });
-
-    #[rustfmt::skip]
-    let pass = [
-        // Test normal paths alias
-        (f.join("app"), "@/index.ts", Ok(f.join("app/aliased/index.ts"))),
-        (f.join("app"), "@/../index.ts", Ok(f.join("app/index.ts"))),
-        // Test project reference
-        (f.join("project-a"), "@/index.ts", Ok(f.join("project-a/aliased/index.ts"))),
-        (f.join("project-b/src"), "@/index.ts", Ok(f.join("app/aliased/index.ts"))),
-        // Does not have paths alias
-        (f.join("project-a"), "./index.ts", Ok(f.join("project-a/index.ts"))),
-        (f.join("project-c"), "./index.ts", Ok(f.join("project-c/index.ts"))),
-    ];
-
-    for (path, request, expected) in pass {
-        let resolved_path = resolver.resolve(&path, request).map(|f| f.full_path());
-        assert_eq!(resolved_path, expected, "{request} {path:?}");
-    }
-
-    // The following resolver's `config_file` has no `paths` alias with `references` enabled
-    let no_paths_resolver = Resolver::new(ResolveOptions {
-        tsconfig: Some(TsconfigDiscovery::Manual(TsconfigOptions {
-            config_file: f.join("app/tsconfig.nopaths.json"),
-            references: TsconfigReferences::Paths(vec!["../project-a/conf.json".into()]),
-        })),
-        ..ResolveOptions::default()
-    });
-
-    #[rustfmt::skip]
-    let pass = [
-        // Test normal paths alias
-        (f.join("app"), "@/index.ts", Err(ResolveError::NotFound("@/index.ts".into()))),
-        (f.join("app"), "@/../index.ts", Ok(f.join("app/index.ts"))),
-        // Test project reference
-        (f.join("project-a"), "@/index.ts", Ok(f.join("project-a/aliased/index.ts"))),
-        (f.join("project-b/src"), "@/index.ts", Err(ResolveError::NotFound("@/index.ts".into()))),
-        // Does not have paths alias
-        (f.join("project-a"), "./index.ts", Ok(f.join("project-a/index.ts"))),
-        (f.join("project-c"), "./index.ts", Ok(f.join("project-c/index.ts"))),
-    ];
-
-    for (path, request, expected) in pass {
-        let resolved_path = no_paths_resolver.resolve(&path, request).map(|f| f.full_path());
-        assert_eq!(resolved_path, expected, "{request} {path:?}");
-    }
-}
-
-#[test]
-fn self_reference() {
-    let f = super::fixture_root().join("tsconfig/cases/project-references");
-
-    #[rustfmt::skip]
-    let pass = [
-        (f.join("app"), vec!["./tsconfig.json".into()]),
-        (f.join("app/tsconfig.json"), vec!["./tsconfig.json".into()]),
-        (f.join("app"), vec![f.join("app")]),
-        (f.join("app/tsconfig.json"), vec![f.join("app")]),
-        (f.join("app/tsconfig.json"), vec![f.join("project-b"), f.join("app")]),
-    ];
-
-    for (config_file, reference_paths) in pass {
-        let resolver = Resolver::new(ResolveOptions {
-            tsconfig: Some(TsconfigDiscovery::Manual(TsconfigOptions {
-                config_file: config_file.clone(),
-                references: TsconfigReferences::Paths(reference_paths.clone()),
-            })),
-            ..ResolveOptions::default()
-        });
-        let path = f.join("app");
-        let resolved_path = resolver.resolve(&path, "@/index.ts").map(|f| f.full_path());
-        assert_eq!(
-            resolved_path,
-            Err(ResolveError::TsconfigSelfReference(f.join("app/tsconfig.json"))),
-            "{config_file:?} {reference_paths:?}"
-        );
-    }
-}
-
 #[test]
 fn references_with_extends() {
     let f = super::fixture_root().join("tsconfig/cases/project-references/extends");
diff --git a/src/tsconfig.rs b/src/tsconfig.rs
@@ -145,18 +145,13 @@ impl TsConfig {
     /// Loads the given references into this tsconfig.
     ///
     /// Returns whether any references are defined in the tsconfig.
-    pub(crate) fn load_references(&mut self, references: &TsconfigReferences) -> bool {
+    pub(crate) fn load_references(&mut self, references: TsconfigReferences) -> bool {
         match references {
             TsconfigReferences::Disabled => {
                 self.references.drain(..);
             }
             TsconfigReferences::Auto => {}
-            TsconfigReferences::Paths(paths) => {
-                self.references =
-                    paths.iter().map(|path| ProjectReference { path: path.clone() }).collect();
-            }
         }
-
         !self.references.is_empty()
     }
 
diff --git a/src/tsconfig_resolver.rs b/src/tsconfig_resolver.rs
@@ -138,7 +138,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
                 self.load_tsconfig(
                     true,
                     &tsconfig_options.config_file,
-                    &tsconfig_options.references,
+                    tsconfig_options.references,
                     &mut ctx,
                 )
                 .map(Some)
@@ -160,9 +160,9 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
     pub fn resolve_tsconfig<P: AsRef<Path>>(&self, path: P) -> Result<Arc<TsConfig>, ResolveError> {
         let path = path.as_ref();
         let references = match &self.options.tsconfig {
-            Some(TsconfigDiscovery::Manual(o)) => &o.references,
-            Some(TsconfigDiscovery::Auto) => &TsconfigReferences::Auto,
-            None => &TsconfigReferences::Disabled,
+            Some(TsconfigDiscovery::Manual(o)) => o.references,
+            Some(TsconfigDiscovery::Auto) => TsconfigReferences::Auto,
+            None => TsconfigReferences::Disabled,
         };
         self.load_tsconfig(true, path, references, &mut TsconfigResolveContext::default())
     }
@@ -171,7 +171,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
         &self,
         root: bool,
         path: &Path,
-        references: &TsconfigReferences,
+        references: TsconfigReferences,
         ctx: &mut TsconfigResolveContext,
     ) -> Result<Arc<TsConfig>, ResolveError> {
         self.cache.get_tsconfig(root, path, |tsconfig| {
@@ -195,7 +195,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
                         let extended_tsconfig = self.load_tsconfig(
                             /* root */ false,
                             &extended_tsconfig_path,
-                            &TsconfigReferences::Disabled,
+                            TsconfigReferences::Disabled,
                             ctx,
                         )?;
                         tsconfig.extend_tsconfig(&extended_tsconfig);
@@ -247,7 +247,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
             let extended_tsconfig = self.load_tsconfig(
                 /* root */ false,
                 &extended_tsconfig_path,
-                &TsconfigReferences::Disabled,
+                TsconfigReferences::Disabled,
                 ctx,
             )?;
             tsconfig.extend_tsconfig(&extended_tsconfig);
@@ -277,10 +277,7 @@ impl<Fs: FileSystem> ResolverGeneric<Fs> {
             }
             // Resolve against project references because project references are not discovered yet.
             Some(TsconfigDiscovery::Manual(o))
-                if matches!(
-                    o.references,
-                    TsconfigReferences::Auto | TsconfigReferences::Paths(_)
-                ) =>
+                if matches!(o.references, TsconfigReferences::Auto) =>
             {
                 tsconfig.resolve_references_then_self_paths(cached_path.path(), specifier)
             }

Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,6 @@ export interface TsconfigOptions {`
`279`	`279`	`* Support for Typescript Project References.`
`280`	`280`	`*`
`281`	`281`	* * `'auto'`: use the `references` field from tsconfig of `config_file`.
`282`		- * * `string[]`: manually provided relative or absolute path.
`283`	`282`	`*/`
`284`		`- references?: 'auto' \| string[]`
	`283`	`+ references?: 'auto'`
`285`	`284`	`}`
Original file line number	Diff line number	Diff line change
`@@ -494,13 +494,11 @@ pub struct TsconfigOptions {`
`494`	`494`	`}`
`495`	`495`
`496`	`496`	`/// Configuration for [TsconfigOptions::references]`
`497`		`-#[derive(Debug, Clone)]`
	`497`	`+#[derive(Debug, Clone, Copy)]`
`498`	`498`	`pub enum TsconfigReferences {`
`499`	`499`	`Disabled,`
`500`	`500`	/// Use the `references` field from tsconfig of `config_file`.
`501`	`501`	`Auto,`
`502`		`- /// Manually provided relative or absolute path.`
`503`		`- Paths(Vec<PathBuf>),`
`504`	`502`	`}`
`505`	`503`
`506`	`504`	`impl Default for ResolveOptions {`
Original file line number	Diff line number	Diff line change
`@@ -145,18 +145,13 @@ impl TsConfig {`
`145`	`145`	`/// Loads the given references into this tsconfig.`
`146`	`146`	`///`
`147`	`147`	`/// Returns whether any references are defined in the tsconfig.`
`148`		`- pub(crate) fn load_references(&mut self, references: &TsconfigReferences) -> bool {`
	`148`	`+ pub(crate) fn load_references(&mut self, references: TsconfigReferences) -> bool {`
`149`	`149`	`match references {`
`150`	`150`	`TsconfigReferences::Disabled => {`
`151`	`151`	`self.references.drain(..);`
`152`	`152`	`}`
`153`	`153`	`TsconfigReferences::Auto => {}`
`154`		`- TsconfigReferences::Paths(paths) => {`
`155`		`- self.references =`
`156`		`- paths.iter().map(\|path\| ProjectReference { path: path.clone() }).collect();`
`157`		`- }`
`158`	`154`	`}`
`159`		`-`
`160`	`155`	`!self.references.is_empty()`
`161`	`156`	`}`
`162`	`157`