use std::path::{Path, PathBuf};
use rustc_hash::FxHashSet;
use super::PluginResult;
const ALIAS_SOURCE_EXTENSIONS: &[&str] = &["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"];
pub(super) fn is_bare_package_specifier(spec: &str) -> bool {
crate::resolve::is_bare_specifier(spec)
&& crate::resolve::is_valid_package_name(spec)
&& !crate::resolve::is_path_alias(spec)
}
pub(super) fn alias_target_is_source_file(normalized: &str) -> bool {
Path::new(normalized)
.extension()
.and_then(|ext| ext.to_str())
.is_some_and(|ext| ALIAS_SOURCE_EXTENSIONS.contains(&ext))
}
fn is_path_specifier(find: &str) -> bool {
find.starts_with("./") || find.starts_with("../") || find.starts_with('/')
}
pub(super) fn credit_unrouted_replacement(
result: &mut PluginResult,
find: &str,
normalized: &str,
config_path: &Path,
root: &Path,
) -> bool {
if !alias_target_is_source_file(normalized) {
return false;
}
let unrouted = is_path_specifier(find)
|| (is_bare_package_specifier(find) && is_installed_package(find, config_path))
|| tsconfig_maps_elsewhere(find, &root.join(normalized), config_path);
if unrouted {
result.push_entry_export_credit(globset::escape(normalized), ["*"]);
}
unrouted
}
fn is_installed_package(specifier: &str, config_path: &Path) -> bool {
let Some(config_dir) = config_path.parent() else {
return false;
};
let pkg_name = crate::resolve::extract_package_name(specifier);
super::eslint::find_package_dir(config_dir, &pkg_name).is_some()
}
const MAX_TSCONFIG_WALK_DEPTH: usize = 12;
const MAX_TSCONFIG_CHAIN_LENGTH: usize = 8;
#[derive(Default)]
struct TsconfigModuleOptions {
paths: Option<(serde_json::Map<String, serde_json::Value>, PathBuf)>,
base_url: Option<PathBuf>,
}
fn tsconfig_maps_elsewhere(find: &str, replacement: &Path, config_path: &Path) -> bool {
let mut seen: FxHashSet<PathBuf> = FxHashSet::default();
[replacement.parent(), config_path.parent()]
.into_iter()
.flatten()
.filter_map(nearest_tsconfig)
.flat_map(|tsconfig| {
let references = referenced_tsconfigs(&tsconfig);
std::iter::once(tsconfig).chain(references)
})
.filter(|tsconfig| seen.insert(tsconfig.clone()))
.any(|tsconfig| {
let options = read_tsconfig_module_options(&tsconfig);
tsconfig_target(find, &options).is_some_and(|target| !same_file(&target, replacement))
})
}
fn nearest_tsconfig(dir: &Path) -> Option<PathBuf> {
dir.ancestors()
.take(MAX_TSCONFIG_WALK_DEPTH)
.map(|ancestor| ancestor.join("tsconfig.json"))
.find(|candidate| candidate.is_file())
}
fn referenced_tsconfigs(tsconfig: &Path) -> Vec<PathBuf> {
let Some(json) = read_jsonc(tsconfig) else {
return Vec::new();
};
let dir = tsconfig.parent().unwrap_or(tsconfig);
json.get("references")
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
.filter_map(|reference| reference.get("path")?.as_str())
.map(|path| {
let path = dir.join(path);
if path.is_dir() {
path.join("tsconfig.json")
} else {
path
}
})
.filter(|path| path.is_file())
.collect()
}
fn read_tsconfig_module_options(tsconfig: &Path) -> TsconfigModuleOptions {
let mut options = TsconfigModuleOptions::default();
let mut stack = vec![tsconfig.to_path_buf()];
for _ in 0..MAX_TSCONFIG_CHAIN_LENGTH {
let Some(path) = stack.pop() else {
break;
};
let Some(json) = read_jsonc(&path) else {
continue;
};
let dir = path.parent().map(Path::to_path_buf).unwrap_or_default();
let compiler_options = json.get("compilerOptions");
if options.paths.is_none()
&& let Some(paths) = compiler_options
.and_then(|opts| opts.get("paths"))
.and_then(serde_json::Value::as_object)
{
options.paths = Some((paths.clone(), dir.clone()));
}
if options.base_url.is_none()
&& let Some(base_url) = compiler_options
.and_then(|opts| opts.get("baseUrl"))
.and_then(serde_json::Value::as_str)
{
options.base_url = Some(dir.join(base_url));
}
stack.extend(
extends_values(&json)
.filter(|extends| extends.starts_with('.'))
.map(|extends| relative_extends_path(&dir, extends)),
);
}
options
}
fn extends_values(json: &serde_json::Value) -> impl Iterator<Item = &str> {
let extends = json.get("extends");
let single = extends.and_then(serde_json::Value::as_str);
let array = extends
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
.filter_map(serde_json::Value::as_str);
single.into_iter().chain(array)
}
fn read_jsonc(path: &Path) -> Option<serde_json::Value> {
let content = std::fs::read_to_string(path).ok()?;
fallow_config::jsonc::parse_to_value(content.trim_start_matches('\u{FEFF}')).ok()
}
fn relative_extends_path(dir: &Path, extends: &str) -> PathBuf {
let path = dir.join(extends);
if path.extension().is_some_and(|ext| ext == "json") {
path
} else {
let mut with_json = path.into_os_string();
with_json.push(".json");
PathBuf::from(with_json)
}
}
fn tsconfig_target(specifier: &str, options: &TsconfigModuleOptions) -> Option<PathBuf> {
let from_paths = options.paths.as_ref().and_then(|(paths, paths_dir)| {
let base = options.base_url.as_deref().unwrap_or(paths_dir);
let (targets, capture) = best_paths_match(paths, specifier)?;
targets
.iter()
.filter_map(serde_json::Value::as_str)
.find_map(|target| probe_source_file(&base.join(target.replacen('*', capture, 1))))
});
from_paths.or_else(|| {
options
.base_url
.as_ref()
.and_then(|base_url| probe_source_file(&base_url.join(specifier)))
})
}
fn best_paths_match<'a>(
paths: &'a serde_json::Map<String, serde_json::Value>,
specifier: &'a str,
) -> Option<(&'a [serde_json::Value], &'a str)> {
if let Some(targets) = paths.get(specifier).and_then(serde_json::Value::as_array) {
return Some((targets, ""));
}
paths
.iter()
.filter_map(|(pattern, targets)| {
let (prefix, suffix) = pattern.split_once('*')?;
let capture = specifier.strip_prefix(prefix)?.strip_suffix(suffix)?;
Some((prefix.len(), targets.as_array()?.as_slice(), capture))
})
.max_by_key(|(prefix_len, _, _)| *prefix_len)
.map(|(_, targets, capture)| (targets, capture))
}
fn probe_source_file(path: &Path) -> Option<PathBuf> {
if path.is_file() {
return Some(path.to_path_buf());
}
let with_extension = ALIAS_SOURCE_EXTENSIONS.iter().map(|ext| {
let mut file = path.as_os_str().to_owned();
file.push(".");
file.push(ext);
PathBuf::from(file)
});
let index = ALIAS_SOURCE_EXTENSIONS
.iter()
.map(|ext| path.join(format!("index.{ext}")));
with_extension.chain(index).find(|file| file.is_file())
}
fn same_file(left: &Path, right: &Path) -> bool {
match (std::fs::canonicalize(left), std::fs::canonicalize(right)) {
(Ok(left), Ok(right)) => left == right,
_ => false,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn write(path: &Path, contents: &str) {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).expect("create parent dir");
}
std::fs::write(path, contents).expect("write file");
}
fn credits(find: &str, root: &Path) -> Vec<crate::plugins::UsedExportRule> {
let mut result = PluginResult::default();
credit_unrouted_replacement(
&mut result,
find,
"test/stubs/clock.ts",
&root.join("vitest.config.ts"),
root,
);
result.entry_export_credits
}
fn project(tsconfig: &str) -> tempfile::TempDir {
let dir = tempfile::tempdir().expect("temp dir");
write(&dir.path().join("tsconfig.json"), tsconfig);
write(&dir.path().join("src/clock.ts"), "export const now = 1;\n");
write(
&dir.path().join("test/stubs/clock.ts"),
"export const now = 0;\n",
);
dir
}
#[test]
fn tsconfig_paths_key_credits_every_replacement_export() {
let dir = project(r#"{ "compilerOptions": { "paths": { "src/*": ["./src/*"] } } }"#);
assert_eq!(credits("src/clock", dir.path()).len(), 1);
}
#[test]
fn tsconfig_paths_from_relative_extends_credit_replacement_exports() {
let dir = project(r#"{ "extends": "./tsconfig.base" }"#);
write(
&dir.path().join("tsconfig.base.json"),
r#"{
// JSONC comment
"compilerOptions": { "paths": { "~/*": ["./src/*"] } },
}"#,
);
assert_eq!(credits("~/clock", dir.path()).len(), 1);
}
#[test]
fn tsconfig_paths_from_array_extends_credit_replacement_exports() {
let dir = project(r#"{ "extends": ["./tsconfig.other.json", "./tsconfig.base.json"] }"#);
write(
&dir.path().join("tsconfig.other.json"),
r#"{ "compilerOptions": {} }"#,
);
write(
&dir.path().join("tsconfig.base.json"),
r#"{ "compilerOptions": { "paths": { "src/*": ["./src/*"] } } }"#,
);
assert_eq!(credits("src/clock", dir.path()).len(), 1);
}
#[test]
fn later_array_extends_entry_overrides_earlier_entry() {
let dir = project(r#"{ "extends": ["./tsconfig.first.json", "./tsconfig.last.json"] }"#);
write(
&dir.path().join("tsconfig.first.json"),
r#"{ "compilerOptions": { "paths": { "~/*": ["./src/*"] } } }"#,
);
write(
&dir.path().join("tsconfig.last.json"),
r#"{ "compilerOptions": { "paths": { "~/*": ["./test/stubs/*"] } } }"#,
);
assert!(credits("~/clock", dir.path()).is_empty());
}
#[test]
fn tsconfig_base_url_key_credits_every_replacement_export() {
let dir = project(r#"{ "compilerOptions": { "baseUrl": "." } }"#);
assert_eq!(credits("src/clock", dir.path()).len(), 1);
}
#[test]
fn tsconfig_mapping_to_the_replacement_keeps_precise_tracking() {
let dir = project(
r#"{ "compilerOptions": { "paths": { "clock": ["./test/stubs/clock.ts"] } } }"#,
);
assert!(credits("clock", dir.path()).is_empty());
}
#[test]
fn tsconfig_mapping_to_a_missing_file_keeps_precise_tracking() {
let dir = project(r#"{ "compilerOptions": { "paths": { "src/*": ["./lib/*"] } } }"#);
assert!(credits("src/clock", dir.path()).is_empty());
}
#[test]
fn unmapped_key_keeps_precise_tracking() {
let dir = project(r#"{ "compilerOptions": { "paths": { "@/*": ["./src/*"] } } }"#);
assert!(credits("src/clock", dir.path()).is_empty());
}
#[test]
fn referenced_tsconfig_near_the_replacement_credits_replacement_exports() {
let dir = tempfile::tempdir().expect("temp dir");
let app = dir.path().join("app");
write(
&app.join("tsconfig.json"),
r#"{ "files": [], "references": [{ "path": "./tsconfig.app.json" }] }"#,
);
write(
&app.join("tsconfig.app.json"),
r#"{ "compilerOptions": { "paths": { "@/*": ["./src/*"] } } }"#,
);
write(&app.join("src/i18n/i18n.ts"), "export const t = 1;\n");
write(&app.join("src/test/stubs/i18n.ts"), "export const t = 0;\n");
let mut result = PluginResult::default();
credit_unrouted_replacement(
&mut result,
"@/i18n/i18n",
"app/src/test/stubs/i18n.ts",
&dir.path().join("vitest.config.ts"),
dir.path(),
);
assert_eq!(result.entry_export_credits.len(), 1);
}
#[test]
fn longest_prefix_paths_pattern_wins() {
let dir = project(
r#"{ "compilerOptions": { "paths": { "*": ["./src/*"], "src/*": ["./test/stubs/*"] } } }"#,
);
assert!(credits("src/clock", dir.path()).is_empty());
}
}