1mod pnpm;
16
17pub use pnpm::{parse_pnpm_lock, PNPM_LOCK_READER};
18
19use std::path::Path;
20
21#[derive(Debug, Clone, PartialEq, Eq)]
23pub struct LockfileHit {
24 pub version: String,
26 pub source: String,
28 pub exact: bool,
30}
31
32pub struct LockfileReader {
35 pub file: &'static str,
37 pub exact: bool,
39 pub read: fn(&str, &Path) -> Option<LockfileHit>,
41}
42
43pub fn strip_peer_suffix(v: &str) -> &str {
50 match v.find('(') {
51 Some(i) => v[..i].trim_end(),
52 None => v.trim_end(),
53 }
54}
55
56pub fn strip_inline_comment(s: &str) -> &str {
59 match s.find(" #") {
60 Some(i) => s[..i].trim_end(),
61 None => s,
62 }
63}
64
65pub fn trim_quotes(s: &str) -> &str {
67 s.trim_matches(['\'', '"'])
68}
69
70pub fn clean_value(s: &str) -> &str {
73 trim_quotes(strip_inline_comment(s.trim()))
74}
75
76pub fn split_pkg_spec(spec: &str) -> Option<(&str, &str)> {
79 let at_pos = match spec.strip_prefix('@') {
80 Some(rest) => rest.find('@').map(|i| i + 1)?,
83 None => spec.find('@')?,
84 };
85 Some((&spec[..at_pos], &spec[at_pos + 1..]))
86}
87
88pub fn is_registry_version(v: &str) -> bool {
93 !v.is_empty() && v != "0.0.0-use.local" && !v.contains(':')
94}
95
96fn parse_bun(content: &str, name: &str) -> Option<String> {
106 let needle = format!("\"{name}@");
107 let mut base = 0;
108 while let Some(rel) = content[base..].find(&needle) {
109 let start = base + rel + needle.len();
110 let rest = &content[start..];
111 match rest.chars().next() {
114 Some(c) if c != '@' && c != '"' => {
115 if let Some(qpos) = rest.find('"') {
116 return Some(rest[..qpos].to_string());
117 }
118 }
119 _ => {}
120 }
121 base = base + rel + 1; }
123 None
124}
125
126fn read_file(project_dir: &Path, file: &str) -> Option<String> {
127 std::fs::read_to_string(project_dir.join(file)).ok()
128}
129
130fn bun_read(name: &str, project_dir: &Path) -> Option<LockfileHit> {
131 let content = read_file(project_dir, "bun.lock")?;
132 parse_bun(&content, name).map(|version| LockfileHit {
133 version,
134 source: "bun.lock".to_string(),
135 exact: true,
136 })
137}
138
139fn parse_npm(content: &str, name: &str) -> Option<String> {
143 let json: serde_json::Value = serde_json::from_str(content).ok()?;
144 let pkg_key = format!("node_modules/{name}");
145 if let Some(v) = json
146 .get("packages")
147 .and_then(|p| p.get(&pkg_key))
148 .and_then(|e| e.get("version"))
149 .and_then(|v| v.as_str())
150 {
151 return Some(v.to_string());
152 }
153 json.get("dependencies")
154 .and_then(|d| d.get(name))
155 .and_then(|e| e.get("version"))
156 .and_then(|v| v.as_str())
157 .map(str::to_string)
158}
159
160fn npm_read(name: &str, project_dir: &Path) -> Option<LockfileHit> {
161 let content = read_file(project_dir, "package-lock.json")?;
162 parse_npm(&content, name).map(|version| LockfileHit {
163 version,
164 source: "package-lock.json".to_string(),
165 exact: true,
166 })
167}
168
169fn parse_package_json(content: &str, name: &str) -> Option<String> {
172 let json: serde_json::Value = serde_json::from_str(content).ok()?;
173 let lookup = |field: &str| {
174 json.get(field)
175 .and_then(|m| m.get(name))
176 .and_then(|v| v.as_str())
177 .map(str::to_string)
178 };
179 let value = lookup("dependencies")
180 .or_else(|| lookup("devDependencies"))
181 .or_else(|| lookup("peerDependencies"))
182 .or_else(|| lookup("optionalDependencies"))?;
183 is_registry_version(&value).then_some(value)
184}
185
186fn package_json_read(name: &str, project_dir: &Path) -> Option<LockfileHit> {
187 let content = read_file(project_dir, "package.json")?;
188 parse_package_json(&content, name).map(|version| LockfileHit {
189 version,
190 source: "package.json".to_string(),
191 exact: false,
192 })
193}
194
195pub fn parse_yarn_lock(text: &str, pkg: &str) -> Option<String> {
203 let mut blocks: Vec<Vec<&str>> = Vec::new();
205 let mut current: Vec<&str> = Vec::new();
206 for raw in text.split('\n') {
207 let line = raw.strip_suffix('\r').unwrap_or(raw);
208 if line.trim().is_empty() {
209 if !current.is_empty() {
210 blocks.push(std::mem::take(&mut current));
211 }
212 } else {
213 current.push(line);
214 }
215 }
216 if !current.is_empty() {
217 blocks.push(current);
218 }
219
220 for block in blocks {
221 let mut header: Option<&str> = None;
222 let mut body: Vec<&str> = Vec::new();
223
224 for line in block {
225 if line.trim_start().starts_with('#') {
226 continue;
227 }
228 let first_is_ws = line.chars().next().is_some_and(char::is_whitespace);
229 if header.is_none() && !first_is_ws {
230 header = Some(line);
231 } else {
232 body.push(line);
233 }
234 }
235
236 let Some(header) = header else { continue };
237 if header.starts_with("__metadata:") || !header.ends_with(':') {
238 continue;
239 }
240 let header_body = &header[..header.len() - 1];
241
242 let matched = header_body.split(", ").any(|s| {
245 let spec = trim_quotes(s.trim());
246 split_pkg_spec(spec).is_some_and(|(name, _)| name == pkg)
247 });
248 if !matched {
249 continue;
250 }
251
252 for line in body {
253 let trimmed = line.trim_start();
254 let Some(rest) = trimmed.strip_prefix("version") else {
255 continue;
256 };
257 match rest.chars().next() {
259 Some(':') | Some(' ') | Some('\t') => {}
260 _ => continue,
261 }
262 let rest = rest.trim_start();
263 let rest = rest.strip_prefix(':').unwrap_or(rest);
264 let stripped = strip_peer_suffix(clean_value(rest));
265 if is_registry_version(stripped) {
266 return Some(stripped.to_string());
267 }
268 }
269 }
270
271 None
272}
273
274fn yarn_read(name: &str, project_dir: &Path) -> Option<LockfileHit> {
275 let content = read_file(project_dir, "yarn.lock")?;
276 parse_yarn_lock(&content, name).map(|version| LockfileHit {
277 version,
278 source: "yarn.lock".to_string(),
279 exact: true,
280 })
281}
282
283pub const BUN_LOCK_READER: LockfileReader = LockfileReader {
284 file: "bun.lock",
285 exact: true,
286 read: bun_read,
287};
288pub const NPM_LOCK_READER: LockfileReader = LockfileReader {
289 file: "package-lock.json",
290 exact: true,
291 read: npm_read,
292};
293pub const PACKAGE_JSON_READER: LockfileReader = LockfileReader {
294 file: "package.json",
295 exact: false,
296 read: package_json_read,
297};
298pub const YARN_LOCK_READER: LockfileReader = LockfileReader {
299 file: "yarn.lock",
300 exact: true,
301 read: yarn_read,
302};
303
304pub const NPM_ECOSYSTEM_CHAIN: &[LockfileReader] = &[
307 BUN_LOCK_READER,
308 NPM_LOCK_READER,
309 PNPM_LOCK_READER,
310 YARN_LOCK_READER,
311 PACKAGE_JSON_READER,
312];
313
314pub fn npm_ecosystem_read(name: &str, project_dir: &Path) -> Option<LockfileHit> {
316 for reader in NPM_ECOSYSTEM_CHAIN {
317 if let Some(hit) = (reader.read)(name, project_dir) {
318 return Some(hit);
319 }
320 }
321 None
322}
323
324#[cfg(test)]
325mod tests {
326 use super::*;
327
328 #[test]
331 fn strip_peer_suffix_cases() {
332 assert_eq!(strip_peer_suffix("18.2.0(react@17.0.0)"), "18.2.0");
333 assert_eq!(strip_peer_suffix("18.2.0(a@1)(b@2(c@3))"), "18.2.0");
334 assert_eq!(strip_peer_suffix("1.0.0 "), "1.0.0");
335 }
336
337 #[test]
338 fn strip_inline_comment_keeps_url_fragments() {
339 assert_eq!(strip_inline_comment("1.0.0 # a comment"), "1.0.0");
340 assert_eq!(
341 strip_inline_comment("github:foo/bar#branch"),
342 "github:foo/bar#branch"
343 );
344 }
345
346 #[test]
347 fn trim_and_clean() {
348 assert_eq!(trim_quotes("\"'x'\""), "x");
349 assert_eq!(clean_value(" \"1.0.0\" # c "), "1.0.0");
350 }
351
352 #[test]
353 fn split_pkg_spec_scoped_and_plain() {
354 assert_eq!(split_pkg_spec("next@15.0.0"), Some(("next", "15.0.0")));
355 assert_eq!(
356 split_pkg_spec("@scope/pkg@1.2.3"),
357 Some(("@scope/pkg", "1.2.3"))
358 );
359 assert_eq!(split_pkg_spec("noatsign"), None);
360 }
361
362 #[test]
363 fn is_registry_version_rejects_protocols() {
364 assert!(is_registry_version("1.2.3"));
365 assert!(!is_registry_version("workspace:*"));
366 assert!(!is_registry_version("link:../pkg"));
367 assert!(!is_registry_version("0.0.0-use.local"));
368 assert!(!is_registry_version(""));
369 }
370
371 #[test]
374 fn bun_finds_scoped_and_plain() {
375 let content = r#"{
376 "packages": {
377 "next": ["next@15.0.3", {}],
378 "@scope/pkg": ["@scope/pkg@1.2.3", {}]
379 }
380 }"#;
381 assert_eq!(parse_bun(content, "next").as_deref(), Some("15.0.3"));
382 assert_eq!(parse_bun(content, "@scope/pkg").as_deref(), Some("1.2.3"));
383 assert_eq!(parse_bun(content, "absent"), None);
384 }
385
386 #[test]
387 fn bun_skips_empty_or_double_at_token() {
388 let content = "\"next@\": x\n\"next@1.0.0\": y\n";
391 assert_eq!(parse_bun(content, "next").as_deref(), Some("1.0.0"));
392 }
393
394 #[test]
397 fn npm_prefers_packages_then_dependencies() {
398 let v3 = r#"{"packages":{"node_modules/next":{"version":"15.0.3"}}}"#;
399 assert_eq!(parse_npm(v3, "next").as_deref(), Some("15.0.3"));
400 let v1 = r#"{"dependencies":{"next":{"version":"14.0.0"}}}"#;
401 assert_eq!(parse_npm(v1, "next").as_deref(), Some("14.0.0"));
402 assert_eq!(parse_npm("{}", "next"), None);
403 assert_eq!(parse_npm("not json", "next"), None);
404 }
405
406 #[test]
409 fn package_json_ranges_and_protocol_skip() {
410 let json = r#"{
411 "dependencies": { "next": "^15.0.0", "linked": "link:../x" },
412 "devDependencies": { "vitest": "1.2.3" }
413 }"#;
414 assert_eq!(parse_package_json(json, "next").as_deref(), Some("^15.0.0"));
415 assert_eq!(parse_package_json(json, "vitest").as_deref(), Some("1.2.3"));
416 assert_eq!(parse_package_json(json, "linked"), None); assert_eq!(parse_package_json(json, "absent"), None);
418 }
419
420 #[test]
423 fn yarn_v1_multi_specifier_header() {
424 let text = "\
425# yarn lockfile v1
426
427
428\"next@^15.0.0\", \"next@~15.0.3\":
429 version \"15.0.3\"
430 resolved \"https://...\"
431";
432 assert_eq!(parse_yarn_lock(text, "next").as_deref(), Some("15.0.3"));
433 }
434
435 #[test]
436 fn yarn_berry_and_peer_suffix_and_protocol_skip() {
437 let text = "\
440__metadata:
441 version: 8
442
443\"root@workspace:.\":
444 version: 0.0.0-use.local
445
446\"react@npm:^18.0.0, react@npm:^18.2.0\":
447 version: 18.2.0(loose)
448";
449 assert_eq!(parse_yarn_lock(text, "react").as_deref(), Some("18.2.0"));
450 assert_eq!(parse_yarn_lock(text, "root"), None);
452 }
453
454 #[test]
455 fn yarn_versions_key_is_not_the_version_key() {
456 let text = "\
458\"pkg@^1.0.0\":
459 versions:
460 - 1.0.0
461 version \"1.0.0\"
462";
463 assert_eq!(parse_yarn_lock(text, "pkg").as_deref(), Some("1.0.0"));
464 }
465
466 #[test]
469 fn chain_priority_bun_beats_package_json() {
470 let dir = tempfile::tempdir().unwrap();
471 std::fs::write(dir.path().join("bun.lock"), "\"next@15.0.3\": {}").unwrap();
472 std::fs::write(
473 dir.path().join("package.json"),
474 r#"{"dependencies":{"next":"^14.0.0"}}"#,
475 )
476 .unwrap();
477 let hit = npm_ecosystem_read("next", dir.path()).unwrap();
478 assert_eq!(hit.version, "15.0.3");
479 assert_eq!(hit.source, "bun.lock");
480 assert!(hit.exact);
481 }
482
483 #[test]
484 fn chain_falls_back_to_package_json_range() {
485 let dir = tempfile::tempdir().unwrap();
486 std::fs::write(
487 dir.path().join("package.json"),
488 r#"{"dependencies":{"next":"^14.0.0"}}"#,
489 )
490 .unwrap();
491 let hit = npm_ecosystem_read("next", dir.path()).unwrap();
492 assert_eq!(hit.version, "^14.0.0");
493 assert_eq!(hit.source, "package.json");
494 assert!(!hit.exact);
495 assert!(npm_ecosystem_read("absent", dir.path()).is_none());
496 }
497}