use std::path::Path;
use oxc_ast::ast::{
ArrayExpressionElement, Expression, ObjectExpression, Program, RegExpFlags, RegExpLiteral,
TemplateLiteral,
};
use super::{
MAX_ALIAS_RESOLVE_DEPTH, PathScope, alias_replacement_kinded, expression_to_string,
extract_from_source, find_property, find_variable_init_expression, get_nested_expression,
is_package_specifier, path_string_in, read_each_config,
};
const REST_CAPTURES: &[&str] = &["(.*)", "(.+)"];
const CAPTURE_SUFFIX: &str = "/$1";
#[derive(Debug, PartialEq, Eq)]
enum RegexAliasKey {
Exact(String),
Prefix(String),
SlashPrefix(String),
}
pub(super) fn object_alias_pair(
obj: &ObjectExpression<'_>,
scope: PathScope<'_>,
) -> Option<(String, String, bool)> {
let find = &find_property(obj, "find")?.value;
let (replacement, is_bare) = find_property(obj, "replacement")
.and_then(|prop| alias_replacement_kinded(&prop.value, scope))?;
match find.without_parentheses() {
Expression::RegExpLiteral(regex) => regex_alias_pair(regex, &replacement)
.map(|(key, replacement)| (key, replacement, is_bare)),
other => expression_to_string(other).map(|key| (key, replacement, is_bare)),
}
}
#[must_use]
pub fn extract_config_regex_alias_packages(
source: &str,
path: &Path,
prop_path: &[&str],
) -> Vec<String> {
extract_from_source(source, path, |program| {
read_each_config(program, |obj| {
let expr = get_nested_expression(obj, prop_path)?;
let mut packages = Vec::new();
regex_alias_packages(program, expr, 0, &mut packages);
(!packages.is_empty()).then_some(packages)
})
})
.unwrap_or_default()
}
fn regex_alias_packages(
program: &Program<'_>,
expr: &Expression<'_>,
depth: usize,
packages: &mut Vec<String>,
) {
if depth >= MAX_ALIAS_RESOLVE_DEPTH {
return;
}
match expr.get_inner_expression() {
Expression::ArrayExpression(arr) => {
for element in &arr.elements {
match element {
ArrayExpressionElement::SpreadElement(spread) => {
regex_alias_packages(program, &spread.argument, depth + 1, packages);
}
_ => {
if let Some(Expression::ObjectExpression(obj)) = element.as_expression()
&& let Some(package) =
regex_find_package(obj, PathScope::Program(program))
{
packages.push(package);
}
}
}
}
}
Expression::Identifier(id) => {
if let Some(init) = find_variable_init_expression(program, id.name.as_str()) {
regex_alias_packages(program, init, depth + 1, packages);
}
}
_ => {}
}
}
fn regex_find_package(obj: &ObjectExpression<'_>, scope: PathScope<'_>) -> Option<String> {
let find = &find_property(obj, "find")?.value;
if !matches!(find.without_parentheses(), Expression::RegExpLiteral(_)) {
return None;
}
let (replacement, is_bare) = find_property(obj, "replacement")
.and_then(|prop| alias_replacement_kinded(&prop.value, scope))?;
if !is_bare || !is_package_specifier(&replacement) {
return None;
}
let package = crate::resolve::extract_package_name(&replacement);
(!package.contains('$')).then_some(package)
}
pub(super) fn path_value(expr: &Expression<'_>, scope: PathScope<'_>) -> Option<String> {
match expr {
Expression::TemplateLiteral(template) if !template.expressions.is_empty() => {
path_template_string(template, scope)
}
_ => path_string_in(expr, scope),
}
}
fn path_template_string(template: &TemplateLiteral<'_>, scope: PathScope<'_>) -> Option<String> {
let starts_with_path_call = template.quasis.first()?.value.raw.is_empty()
&& matches!(
template.expressions.first()?.without_parentheses(),
Expression::CallExpression(_) | Expression::NewExpression(_)
);
if !starts_with_path_call {
return None;
}
let mut value = String::new();
for (index, quasi) in template.quasis.iter().enumerate() {
value.push_str(quasi.value.raw.as_str());
if let Some(expr) = template.expressions.get(index) {
value.push_str(&path_string_in(expr, scope)?);
}
}
Some(value)
}
fn regex_alias_pair(regex: &RegExpLiteral<'_>, replacement: &str) -> Option<(String, String)> {
if !regex
.regex
.flags
.difference(RegExpFlags::U | RegExpFlags::V)
.is_empty()
{
return None;
}
let key = parse_regex_alias_key(regex.regex.pattern.text.as_str())?;
alias_pair_for_key(key, replacement)
}
fn alias_pair_for_key(key: RegexAliasKey, replacement: &str) -> Option<(String, String)> {
let (key, replacement) = match key {
RegexAliasKey::Exact(key) => (key, replacement),
RegexAliasKey::Prefix(key) => (key, replacement.strip_suffix(CAPTURE_SUFFIX)?),
RegexAliasKey::SlashPrefix(key) => {
replacement.strip_suffix('/')?;
(key, replacement)
}
};
if replacement.contains('$') {
return None;
}
Some((key, replacement.to_owned()))
}
fn parse_regex_alias_key(pattern: &str) -> Option<RegexAliasKey> {
let body = pattern.strip_prefix('^')?;
for capture in REST_CAPTURES {
let Some(head) = body.strip_suffix('$').unwrap_or(body).strip_suffix(capture) else {
continue;
};
let prefix = unescape_literal(head)?;
let prefix = prefix.strip_suffix('/')?;
return (!prefix.is_empty()).then(|| RegexAliasKey::Prefix(prefix.to_owned()));
}
if let Some(exact) = body.strip_suffix('$') {
let literal = unescape_literal(exact)?;
return (!literal.is_empty()).then_some(RegexAliasKey::Exact(literal));
}
let literal = unescape_literal(body)?;
let has_name = literal
.strip_suffix('/')
.is_some_and(|name| !name.is_empty());
has_name.then_some(RegexAliasKey::SlashPrefix(literal))
}
fn unescape_literal(fragment: &str) -> Option<String> {
let mut literal = String::with_capacity(fragment.len());
let mut chars = fragment.chars();
while let Some(ch) = chars.next() {
match ch {
'\\' => {
let escaped = chars.next()?;
if escaped.is_ascii_alphanumeric() {
return None;
}
literal.push(escaped);
}
'.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '^' | '$' => {
return None;
}
_ => literal.push(ch),
}
}
Some(literal)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn anchored_literal_maps_to_an_exact_key() {
assert_eq!(
parse_regex_alias_key("^node:module$"),
Some(RegexAliasKey::Exact("node:module".to_owned()))
);
assert_eq!(
parse_regex_alias_key(r"^@scope\/pkg$"),
Some(RegexAliasKey::Exact("@scope/pkg".to_owned()))
);
assert_eq!(
parse_regex_alias_key(r"^lodash\.debounce$"),
Some(RegexAliasKey::Exact("lodash.debounce".to_owned()))
);
}
#[test]
fn anchored_capture_maps_to_a_prefix_key() {
for pattern in [r"^@\/(.*)$", "^@/(.*)$", r"^@\/(.+)$", r"^@\/(.*)"] {
assert_eq!(
parse_regex_alias_key(pattern),
Some(RegexAliasKey::Prefix("@".to_owned())),
"{pattern}"
);
}
assert_eq!(
parse_regex_alias_key(r"^~lib\/(.*)$"),
Some(RegexAliasKey::Prefix("~lib".to_owned()))
);
}
#[test]
fn anchored_slash_prefix_maps_to_a_slash_prefix_key() {
for (pattern, key) in [(r"^@\/", "@/"), (r"^#\/", "#/"), ("^~lib/", "~lib/")] {
assert_eq!(
parse_regex_alias_key(pattern),
Some(RegexAliasKey::SlashPrefix(key.to_owned())),
"{pattern}"
);
}
}
#[test]
fn slash_prefix_needs_a_replacement_that_ends_with_a_slash() {
let pair = |pattern: &str, replacement: &str| {
let key = parse_regex_alias_key(pattern)?;
alias_pair_for_key(key, replacement)
};
assert_eq!(
pair(r"^#\/", "/src/lib/"),
Some(("#/".to_owned(), "/src/lib/".to_owned()))
);
assert_eq!(pair(r"^#\/", "/src/lib"), None);
}
#[test]
fn other_regex_shapes_give_no_key() {
for pattern in [
"node:module",
"^lodash",
r"\.svg$",
"^lodash.debounce$",
r"^(foo|bar)$",
r"^@(.*)$",
r"^\/(.*)$",
r"^@\/(.*)\.js$",
r"^\d+$",
"^$",
r"^\/",
r"^@\/.*",
] {
assert_eq!(parse_regex_alias_key(pattern), None, "{pattern}");
}
}
}