ud 0.1.0

UpDate! — A fast, universal dependency updater.
Documentation
use crate::core::model::RegistryId;
use deno_semver::jsr::JsrPackageReqReference;
use deno_semver::npm::NpmPackageReqReference;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParsedSpecifier {
    pub registry: RegistryId,
    pub coordinate: String,
    pub constraint: String,
    pub sub_path: Option<String>,
}

pub fn parse_specifier(specifier: &str) -> Option<ParsedSpecifier> {
    if specifier.starts_with("npm:") {
        let npm_ref = NpmPackageReqReference::from_str(specifier).ok()?;
        let req = npm_ref.req();

        // Version-less check: check if '@' exists in the package part
        let has_at = if req.name.starts_with('@') {
            specifier[4..].get(1..).map_or(false, |s| s.contains('@'))
        } else {
            specifier[4..].contains('@')
        };
        if !has_at {
            return None;
        }

        let mut name = req.name.to_string();
        let mut registry = RegistryId::from("npm");

        // Alias translation rule
        if name.starts_with("@jsr/") {
            registry = RegistryId::from("jsr");
            let trimmed = name.strip_prefix("@jsr/").unwrap();
            if let Some(idx) = trimmed.find("__") {
                let scope = &trimmed[..idx];
                let pkg = &trimmed[idx + 2..];
                name = format!("@{}/{}", scope, pkg);
            }
        }

        let constraint = req.version_req.version_text().to_string();

        Some(ParsedSpecifier {
            registry,
            coordinate: name,
            constraint,
            sub_path: npm_ref.sub_path().map(|s| s.to_string()),
        })
    } else if specifier.starts_with("jsr:") {
        let jsr_ref = JsrPackageReqReference::from_str(specifier).ok()?;
        let req = jsr_ref.req();

        let has_at = if req.name.starts_with('@') {
            specifier[4..].get(1..).map_or(false, |s| s.contains('@'))
        } else {
            specifier[4..].contains('@')
        };
        if !has_at {
            return None;
        }

        Some(ParsedSpecifier {
            registry: RegistryId::from("jsr"),
            coordinate: req.name.to_string(),
            constraint: req.version_req.version_text().to_string(),
            sub_path: jsr_ref.sub_path().map(|s| s.to_string()),
        })
    } else {
        None
    }
}

pub fn is_checkable_constraint(constraint: &str) -> bool {
    if let Ok(req) = deno_semver::npm::parse_npm_version_req(constraint) {
        req.range().is_some()
    } else {
        false
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_specifier() {
        assert_eq!(
            parse_specifier("jsr:@std/fs@^1.0.0/exists"),
            Some(ParsedSpecifier {
                registry: RegistryId::from("jsr"),
                coordinate: "@std/fs".to_string(),
                constraint: "^1.0.0".to_string(),
                sub_path: Some("exists".to_string()),
            })
        );

        assert_eq!(
            parse_specifier("npm:react@^18.2.0"),
            Some(ParsedSpecifier {
                registry: RegistryId::from("npm"),
                coordinate: "react".to_string(),
                constraint: "^18.2.0".to_string(),
                sub_path: None,
            })
        );

        assert_eq!(
            parse_specifier("npm:@jsr/luca__flag@^1.0.0"),
            Some(ParsedSpecifier {
                registry: RegistryId::from("jsr"),
                coordinate: "@luca/flag".to_string(),
                constraint: "^1.0.0".to_string(),
                sub_path: None,
            })
        );

        assert_eq!(parse_specifier("npm:react"), None);
    }
}