use oxc_ast::ast::{Expression, ObjectExpression, RegExpFlags, RegExpLiteral, TemplateLiteral};
use super::{
PathScope, alias_replacement_kinded, expression_to_string, find_property, path_string_in,
};
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)),
}
}
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}");
}
}
}