The design language that makes your AI harness better at design.
JavaScript
//! JS: lib/target-slug.mjs
use crate::jsp;
use crate::util::js_trim;
use sha2::{Digest, Sha256};
const SLUG_MAX: usize = 50;
const SLUG_HASH_LEN: usize = 8;
/// JS: slugFromTarget(resolved, { cwd })
pub fn slug_from_target(resolved: Option<&str>, cwd: &str) -> Option<String> {
slug_from_target_using(resolved, cwd, kebab)
}
/// Compatibility key used by releases that truncated normalized targets to
/// their last 50 characters without a hash suffix.
pub(crate) fn legacy_slug_from_target(resolved: Option<&str>, cwd: &str) -> Option<String> {
slug_from_target_using(resolved, cwd, legacy_kebab)
}
fn slug_from_target_using(
resolved: Option<&str>,
cwd: &str,
slugger: fn(&str) -> Option<String>,
) -> Option<String> {
let resolved = resolved?;
let trimmed = js_trim(resolved);
if trimmed.is_empty() {
return None;
}
let lower = trimmed.to_ascii_lowercase();
if lower.starts_with("http://") || lower.starts_with("https://") {
let (host, pathname) = parse_url_host_path(trimmed)?;
return slugger(&format!("{}{}", host, pathname));
}
let abs = if jsp::is_absolute(trimmed) { trimmed.to_string() } else { jsp::resolve(cwd, &[trimmed]) };
let mut rel = jsp::relative(cwd, cwd, &abs);
if rel.starts_with("..") || jsp::is_absolute(&rel) {
rel = jsp::basename(&abs);
}
if rel.is_empty() || rel == "." {
return None;
}
slugger(&rel)
}
/// Minimal WHATWG URL parse for http(s): returns (hostname lowercased, pathname).
/// Returns None when `new URL()` would throw.
pub fn parse_url_host_path(s: &str) -> Option<(String, String)> {
let u = crate::url::parse(s)?;
Some((u.hostname, u.pathname))
}
/// JS: kebab(value)
pub fn kebab(value: &str) -> Option<String> {
let u = normalized_kebab(value)?;
if u.len() <= SLUG_MAX {
Some(u)
} else {
let digest = Sha256::digest(u.as_bytes());
let hash = format!("{digest:x}");
let tail_len = SLUG_MAX - SLUG_HASH_LEN - 1;
let tail = &u[u.len() - tail_len..];
let tail = tail.strip_prefix('-').unwrap_or(tail);
Some(format!("{tail}-{}", &hash[..SLUG_HASH_LEN]))
}
}
fn legacy_kebab(value: &str) -> Option<String> {
let u = normalized_kebab(value)?;
if u.len() <= SLUG_MAX {
Some(u)
} else {
let tail = &u[u.len() - SLUG_MAX..];
Some(tail.strip_prefix('-').unwrap_or(tail).to_string())
}
}
fn normalized_kebab(value: &str) -> Option<String> {
let normalized = value
.to_lowercase()
.split(|c: char| !c.is_ascii_lowercase() && !c.is_ascii_digit())
.filter(|part| !part.is_empty())
.collect::<Vec<_>>()
.join("-");
(!normalized.is_empty()).then_some(normalized)
}
#[cfg(test)]
mod tests {
use super::{kebab, legacy_kebab, normalized_kebab, SLUG_MAX};
#[test]
fn normalization_preserves_ascii_runs_after_unicode_lowercasing() {
for (input, expected) in [
("", None),
(" /\\.--_!?\n🦀 ", None),
("--Button./\\ _Primary...99--", Some("button-primary-99")),
("A🦀B café", Some("a-b-caf")),
("İSTANBUL KELVIN", Some("i-stanbul-kelvin")),
] {
assert_eq!(normalized_kebab(input).as_deref(), expected, "{input:?}");
}
}
#[test]
fn truncated_slugs_keep_distinct_full_inputs_distinct() {
let suffix = "a".repeat(SLUG_MAX);
let alpha = kebab(&format!("alpha-prefix-{suffix}")).unwrap();
let beta = kebab(&format!("beta-prefix-{suffix}")).unwrap();
assert_ne!(alpha, beta);
assert!(alpha.len() <= SLUG_MAX);
assert!(beta.len() <= SLUG_MAX);
assert_eq!(alpha, kebab(&format!("alpha-prefix-{suffix}")).unwrap());
}
#[test]
fn non_truncated_slugs_are_unchanged() {
assert_eq!(kebab("Button.Primary"), Some("button-primary".to_string()));
assert_eq!(kebab(&"a".repeat(SLUG_MAX)), Some("a".repeat(SLUG_MAX)));
}
#[test]
fn legacy_kebab_preserves_the_previous_truncation_key() {
let value = "a-very-long-directory-structure-with-many-segments-component-name.tsx";
assert_eq!(
legacy_kebab(value),
Some("ry-structure-with-many-segments-component-name-tsx".to_string())
);
}
}