1use std::collections::BTreeMap;
2
3use serde::{
4 Deserialize, Deserializer, Serialize,
5 de::{Error, IgnoredAny, MapAccess, Visitor},
6};
7
8use super::pnpm_catalog::PnpmCatalogData;
9
10#[expect(
14 clippy::disallowed_types,
15 reason = "rustc-hash v2 lacks serde feature — JSON deserialization needs std HashMap"
16)]
17type StdHashMap<K, V> = std::collections::HashMap<K, V>;
18
19fn deserialize_optional_bool_lenient<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
20where
21 D: Deserializer<'de>,
22{
23 let value = Option::<serde_json::Value>::deserialize(deserializer)?;
24 Ok(match value {
25 Some(serde_json::Value::Bool(value)) => Some(value),
26 _ => None,
27 })
28}
29
30fn deserialize_string_array_lenient<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
31where
32 D: Deserializer<'de>,
33{
34 let value = Option::<serde_json::Value>::deserialize(deserializer)?;
35 Ok(match value {
36 Some(serde_json::Value::Array(values)) => values
37 .into_iter()
38 .filter_map(|value| value.as_str().map(str::to_owned))
39 .collect(),
40 _ => Vec::new(),
41 })
42}
43
44fn deserialize_optional_string_lenient<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
45where
46 D: Deserializer<'de>,
47{
48 let value = Option::<serde_json::Value>::deserialize(deserializer)?;
49 Ok(match value {
50 Some(serde_json::Value::String(value)) if !value.trim().is_empty() => Some(value),
51 _ => None,
52 })
53}
54
55fn deserialize_optional_napi_config<'de, D>(deserializer: D) -> Result<Option<NapiConfig>, D::Error>
56where
57 D: Deserializer<'de>,
58{
59 let value = Option::<serde_json::Value>::deserialize(deserializer)?;
60 match value {
61 Some(serde_json::Value::Object(map)) => {
62 serde_json::from_value(serde_json::Value::Object(map))
63 .map(Some)
64 .map_err(D::Error::custom)
65 }
66 _ => Ok(None),
67 }
68}
69
70pub const INLINE_TOOL_CONFIG_KEYS: &[&str] = &[
73 "babel",
74 "commit-and-tag-version",
75 "eslintConfig",
76 "graphql",
77 "jest",
78 "mocha",
79 "nodemonConfig",
80 "prettier",
81 "release-it",
82 "stylelint",
83 "textlint",
84 "tsd",
85 "tsdown",
86 "tsup",
87];
88
89fn deserialize_inline_tool_configs<'de, D>(
93 deserializer: D,
94) -> Result<BTreeMap<&'static str, serde_json::Value>, D::Error>
95where
96 D: Deserializer<'de>,
97{
98 struct InlineToolConfigs;
99
100 impl<'de> Visitor<'de> for InlineToolConfigs {
101 type Value = BTreeMap<&'static str, serde_json::Value>;
102
103 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
104 formatter.write_str("a package.json object")
105 }
106
107 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
108 where
109 A: MapAccess<'de>,
110 {
111 let mut configs = BTreeMap::new();
112 while let Some(key) = map.next_key::<String>()? {
113 match INLINE_TOOL_CONFIG_KEYS.iter().find(|known| **known == key) {
114 Some(known) => {
115 configs.insert(*known, map.next_value()?);
116 }
117 None => {
118 map.next_value::<IgnoredAny>()?;
119 }
120 }
121 }
122 Ok(configs)
123 }
124 }
125
126 deserializer.deserialize_map(InlineToolConfigs)
127}
128
129#[derive(Debug, Clone, Default, Deserialize, Serialize)]
130pub struct PeerDependencyMeta {
131 #[serde(default)]
132 pub optional: bool,
133}
134
135#[derive(Debug, Clone, Default, Deserialize, Serialize)]
140pub struct NapiConfig {
141 #[serde(
143 default,
144 rename = "binaryName",
145 deserialize_with = "deserialize_optional_string_lenient"
146 )]
147 pub binary_name: Option<String>,
148 #[serde(
151 default,
152 rename = "packageName",
153 deserialize_with = "deserialize_optional_string_lenient"
154 )]
155 pub package_name: Option<String>,
156 #[serde(default, deserialize_with = "deserialize_string_array_lenient")]
158 pub targets: Vec<String>,
159}
160
161#[derive(Debug, Clone, Default, Deserialize, Serialize)]
163pub struct PackageJson {
164 #[serde(default)]
167 pub name: Option<String>,
168 #[serde(default, deserialize_with = "deserialize_optional_bool_lenient")]
171 pub private: Option<bool>,
172 #[serde(default)]
174 pub main: Option<String>,
175 #[serde(default)]
177 pub module: Option<String>,
178 #[serde(default)]
180 pub types: Option<String>,
181 #[serde(default)]
183 pub typings: Option<String>,
184 #[serde(default)]
187 pub source: Option<String>,
188 #[serde(default, deserialize_with = "deserialize_string_array_lenient")]
191 pub files: Vec<String>,
192 #[serde(default)]
195 pub browser: Option<serde_json::Value>,
196 #[serde(default)]
199 pub bin: Option<serde_json::Value>,
200 #[serde(default)]
203 pub typescript: Option<serde_json::Value>,
204 #[serde(default)]
208 pub exports: Option<serde_json::Value>,
209 #[serde(default)]
212 pub imports: Option<serde_json::Value>,
213 #[serde(default)]
216 pub dependencies: Option<StdHashMap<String, String>>,
217 #[serde(default, rename = "devDependencies")]
220 pub dev_dependencies: Option<StdHashMap<String, String>>,
221 #[serde(default, rename = "peerDependencies")]
224 pub peer_dependencies: Option<StdHashMap<String, String>>,
225 #[serde(default, rename = "peerDependenciesMeta")]
227 pub peer_dependencies_meta: Option<StdHashMap<String, PeerDependencyMeta>>,
228 #[serde(default, rename = "optionalDependencies")]
231 pub optional_dependencies: Option<StdHashMap<String, String>>,
232 #[serde(default)]
235 pub scripts: Option<StdHashMap<String, String>>,
236 #[serde(default, deserialize_with = "deserialize_optional_napi_config")]
239 pub napi: Option<NapiConfig>,
240 #[serde(default)]
243 pub workspaces: Option<serde_json::Value>,
244 #[serde(
247 default,
248 rename = "packageManager",
249 deserialize_with = "deserialize_optional_string_lenient"
250 )]
251 pub package_manager: Option<String>,
252 #[serde(default)]
255 pub egg: Option<serde_json::Value>,
256 #[serde(default, rename = "eggPlugin")]
258 pub egg_plugin: Option<serde_json::Value>,
259 #[serde(default, rename = "eggModule")]
261 pub egg_module: Option<serde_json::Value>,
262 #[serde(default)]
265 pub n8n: Option<serde_json::Value>,
266 #[serde(default, flatten, deserialize_with = "deserialize_inline_tool_configs")]
269 pub inline_tool_configs: BTreeMap<&'static str, serde_json::Value>,
270}
271
272#[derive(Debug, Clone, Copy, PartialEq, Eq)]
274pub enum PackageEntryField {
275 Main,
277 Module,
279 Types,
281 Typings,
283 Source,
285 Browser,
287 Bin,
289 Exports,
291}
292
293impl From<PackageEntryField> for fallow_types::discover::EntryPointSource {
294 fn from(field: PackageEntryField) -> Self {
295 match field {
296 PackageEntryField::Main => Self::PackageJsonMain,
297 PackageEntryField::Module => Self::PackageJsonModule,
298 PackageEntryField::Types => Self::PackageJsonTypes,
299 PackageEntryField::Typings => Self::PackageJsonTypings,
300 PackageEntryField::Source => Self::PackageJsonSource,
301 PackageEntryField::Browser => Self::PackageJsonBrowser,
302 PackageEntryField::Bin => Self::PackageJsonBin,
303 PackageEntryField::Exports => Self::PackageJsonExports,
304 }
305 }
306}
307
308fn push_string_values(
312 entries: &mut Vec<(PackageEntryField, String)>,
313 field: PackageEntryField,
314 value: &serde_json::Value,
315 keep_map_value: impl Fn(&str) -> bool,
316) {
317 match value {
318 serde_json::Value::String(path) => entries.push((field, path.clone())),
319 serde_json::Value::Object(map) => {
320 let paths = map
321 .values()
322 .filter_map(serde_json::Value::as_str)
323 .filter(|path| keep_map_value(path));
324 entries.extend(paths.map(|path| (field, path.to_owned())));
325 }
326 _ => {}
327 }
328}
329
330impl PackageJson {
331 #[must_use]
335 pub fn inline_tool_config(&self, key: &str) -> Option<&serde_json::Value> {
336 self.inline_tool_configs.get(key)
337 }
338
339 pub fn load(path: &std::path::Path) -> Result<Self, String> {
345 let content = std::fs::read_to_string(path)
346 .map_err(|e| format!("Failed to read {}: {}", path.display(), e))?;
347 let content = content.trim_start_matches('\u{FEFF}');
348 serde_json::from_str(content)
349 .map_err(|e| format!("Failed to parse {}: {}", path.display(), e))
350 }
351
352 #[must_use]
354 pub fn all_dependency_names(&self) -> Vec<String> {
355 let mut deps = Vec::new();
356 if let Some(d) = &self.dependencies {
357 deps.extend(d.keys().cloned());
358 }
359 if let Some(d) = &self.dev_dependencies {
360 deps.extend(d.keys().cloned());
361 }
362 if let Some(d) = &self.peer_dependencies {
363 deps.extend(d.keys().cloned());
364 }
365 if let Some(d) = &self.optional_dependencies {
366 deps.extend(d.keys().cloned());
367 }
368 deps
369 }
370
371 #[must_use]
373 pub fn production_dependency_names(&self) -> Vec<String> {
374 self.dependencies
375 .as_ref()
376 .map(|d| d.keys().cloned().collect())
377 .unwrap_or_default()
378 }
379
380 #[must_use]
382 pub fn dev_dependency_names(&self) -> Vec<String> {
383 self.dev_dependencies
384 .as_ref()
385 .map(|d| d.keys().cloned().collect())
386 .unwrap_or_default()
387 }
388
389 #[must_use]
391 pub fn optional_dependency_names(&self) -> Vec<String> {
392 self.optional_dependencies
393 .as_ref()
394 .map(|d| d.keys().cloned().collect())
395 .unwrap_or_default()
396 }
397
398 #[must_use]
400 pub fn peer_dependency_names(&self) -> Vec<String> {
401 self.peer_dependencies
402 .as_ref()
403 .map(|deps| deps.keys().cloned().collect())
404 .unwrap_or_default()
405 }
406
407 #[must_use]
409 pub fn peer_dependency_is_optional(&self, dep: &str) -> bool {
410 self.peer_dependencies_meta
411 .as_ref()
412 .and_then(|meta| meta.get(dep))
413 .is_some_and(|meta| meta.optional)
414 }
415
416 #[must_use]
418 pub fn entry_points(&self) -> Vec<String> {
419 self.entry_points_by_field()
420 .into_iter()
421 .map(|(_, entry)| entry)
422 .collect()
423 }
424
425 #[must_use]
429 pub fn entry_points_by_field(&self) -> Vec<(PackageEntryField, String)> {
430 let mut entries = Vec::new();
431
432 for (field, value) in [
433 (PackageEntryField::Main, &self.main),
434 (PackageEntryField::Module, &self.module),
435 (PackageEntryField::Types, &self.types),
436 (PackageEntryField::Typings, &self.typings),
437 (PackageEntryField::Source, &self.source),
438 ] {
439 if let Some(entry) = value {
440 entries.push((field, entry.clone()));
441 }
442 }
443
444 if let Some(browser) = &self.browser {
445 push_string_values(&mut entries, PackageEntryField::Browser, browser, |path| {
446 path.starts_with("./") || path.starts_with("../")
447 });
448 }
449
450 if let Some(bin) = &self.bin {
451 push_string_values(&mut entries, PackageEntryField::Bin, bin, |_| true);
452 }
453
454 if let Some(exports) = &self.exports {
455 let mut exported = Vec::new();
456 extract_exports_entries(exports, &mut exported);
457 entries.extend(
458 exported
459 .into_iter()
460 .map(|entry| (PackageEntryField::Exports, entry)),
461 );
462 }
463
464 entries
465 }
466
467 #[must_use]
474 pub fn exports_subdirectories(&self) -> Vec<String> {
475 self.exports
476 .as_ref()
477 .map_or_else(Vec::new, extract_exports_subdirectories)
478 }
479
480 #[must_use]
482 pub fn workspace_patterns(&self) -> Vec<String> {
483 match &self.workspaces {
484 Some(serde_json::Value::Array(arr)) => arr
485 .iter()
486 .filter_map(|v| v.as_str().map(String::from))
487 .collect(),
488 Some(serde_json::Value::Object(obj)) => obj
489 .get("packages")
490 .and_then(|v| v.as_array())
491 .map(|arr| {
492 arr.iter()
493 .filter_map(|v| v.as_str().map(String::from))
494 .collect()
495 })
496 .unwrap_or_default(),
497 _ => Vec::new(),
498 }
499 }
500
501 #[must_use]
509 pub fn local_link_dependencies(&self) -> Vec<(String, String)> {
510 let mut links: Vec<(String, String)> = [
511 &self.dependencies,
512 &self.dev_dependencies,
513 &self.optional_dependencies,
514 ]
515 .into_iter()
516 .flatten()
517 .flatten()
518 .filter_map(|(name, spec)| {
519 let target = spec
520 .strip_prefix("link:")
521 .or_else(|| spec.strip_prefix("file:"))?
522 .trim();
523 (!target.is_empty()).then(|| (name.clone(), target.to_string()))
524 })
525 .collect();
526 links.sort_unstable();
527 links.dedup();
528 links
529 }
530
531 #[must_use]
538 pub fn workspace_alias_target(&self, name: &str) -> Option<&str> {
539 [
540 &self.dependencies,
541 &self.dev_dependencies,
542 &self.optional_dependencies,
543 &self.peer_dependencies,
544 ]
545 .into_iter()
546 .flatten()
547 .find_map(|deps| deps.get(name))
548 .and_then(|spec| workspace_alias_name(spec))
549 }
550
551 #[must_use]
558 pub fn npm_aliases(&self) -> Vec<(String, String)> {
559 self.npm_aliases_with_catalogs(None)
560 }
561
562 #[must_use]
569 pub fn npm_aliases_with_catalogs(
570 &self,
571 catalogs: Option<&PnpmCatalogData>,
572 ) -> Vec<(String, String)> {
573 let mut aliases: Vec<(String, String)> = [
574 &self.dependencies,
575 &self.dev_dependencies,
576 &self.optional_dependencies,
577 &self.peer_dependencies,
578 ]
579 .into_iter()
580 .flatten()
581 .flat_map(|deps| deps.iter())
582 .filter_map(|(name, spec)| {
583 let spec = catalogs
584 .and_then(|data| data.resolve_reference(name, spec))
585 .unwrap_or(spec);
586 let target = npm_alias_name(spec)?;
587 (target != name).then(|| (name.clone(), target.to_string()))
588 })
589 .collect();
590 aliases.sort_unstable();
591 aliases.dedup();
592 aliases
593 }
594}
595
596fn workspace_alias_name(spec: &str) -> Option<&str> {
598 let rest = spec.trim().strip_prefix("workspace:")?;
599 let separator = if let Some(scoped) = rest.strip_prefix('@') {
600 scoped.find('@')? + 1
601 } else {
602 rest.find('@')?
603 };
604 valid_package_name(&rest[..separator])
605}
606
607fn npm_alias_name(spec: &str) -> Option<&str> {
610 let rest = spec.trim().strip_prefix("npm:")?;
611 let separator = if let Some(scoped) = rest.strip_prefix('@') {
612 scoped.find('@').map_or(rest.len(), |at| at + 1)
613 } else {
614 rest.find('@').unwrap_or(rest.len())
615 };
616 valid_package_name(&rest[..separator])
617}
618
619fn valid_package_name(name: &str) -> Option<&str> {
621 let is_package_name = !name.is_empty()
622 && !name.starts_with('.')
623 && match name.strip_prefix('@') {
624 Some(scoped) => scoped
625 .split_once('/')
626 .is_some_and(|(scope, base)| !scope.is_empty() && !base.is_empty()),
627 None => !name.contains('/'),
628 };
629 is_package_name.then_some(name)
630}
631
632fn extract_exports_subdirectories(exports: &serde_json::Value) -> Vec<String> {
633 let Some(map) = exports.as_object() else {
634 return Vec::new();
635 };
636
637 let skip_dirs = ["dist", "build", "out", "esm", "cjs", "lib", "node_modules"];
638 let mut dirs = rustc_hash::FxHashSet::default();
639
640 for key in map.keys() {
641 let stripped = key.strip_prefix("./").unwrap_or(key);
642 if let Some(first_segment) = stripped.split('/').next()
643 && !first_segment.is_empty()
644 && first_segment != "."
645 && first_segment != "package.json"
646 && !skip_dirs.contains(&first_segment)
647 {
648 dirs.insert(first_segment.to_owned());
649 }
650 }
651
652 dirs.into_iter().collect()
653}
654
655fn extract_exports_entries(value: &serde_json::Value, entries: &mut Vec<String>) {
657 match value {
658 serde_json::Value::String(s) if s.starts_with("./") || s.starts_with("../") => {
659 entries.push(s.clone());
660 }
661 serde_json::Value::Object(map) => {
662 for v in map.values() {
663 extract_exports_entries(v, entries);
664 }
665 }
666 serde_json::Value::Array(arr) => {
667 for v in arr {
668 extract_exports_entries(v, entries);
669 }
670 }
671 _ => {}
672 }
673}
674
675#[cfg(test)]
676mod tests {
677 use super::*;
678
679 #[test]
680 fn inline_tool_config_keeps_the_last_value_of_a_repeated_key() {
681 let pkg: PackageJson = serde_json::from_str(
682 r#"{"name": "app", "jest": {}, "devDependencies": {"jest": "1"}, "jest": {"x": 1}}"#,
683 )
684 .unwrap();
685 assert_eq!(
686 pkg.inline_tool_config("jest"),
687 Some(&serde_json::json!({ "x": 1 }))
688 );
689 assert_eq!(pkg.name.as_deref(), Some("app"));
690 assert_eq!(pkg.dev_dependency_names(), vec!["jest"]);
691 }
692
693 #[test]
694 fn repeated_unknown_key_parses() {
695 let pkg: PackageJson =
696 serde_json::from_str(r#"{"name": "app", "custom": 1, "custom": {"y": 2}}"#).unwrap();
697 assert_eq!(pkg.name.as_deref(), Some("app"));
698 assert!(pkg.inline_tool_configs.is_empty());
699 }
700
701 #[test]
702 fn inline_tool_config_keeps_any_value_shape() {
703 let pkg: PackageJson = serde_json::from_str(
704 r#"{"prettier": "@acme/prettier-config", "jest": 5, "mocha": null, "tsup": [1, "a"]}"#,
705 )
706 .unwrap();
707 assert_eq!(
708 pkg.inline_tool_config("prettier"),
709 Some(&serde_json::json!("@acme/prettier-config"))
710 );
711 assert_eq!(pkg.inline_tool_config("jest"), Some(&serde_json::json!(5)));
712 assert_eq!(
713 pkg.inline_tool_config("mocha"),
714 Some(&serde_json::Value::Null)
715 );
716 assert_eq!(
717 pkg.inline_tool_config("tsup"),
718 Some(&serde_json::json!([1, "a"]))
719 );
720 assert_eq!(pkg.inline_tool_config("custom"), None);
721 }
722
723 #[test]
724 fn package_json_workspace_patterns_array() {
725 let pkg: PackageJson =
726 serde_json::from_str(r#"{"workspaces": ["packages/*", "apps/*"]}"#).unwrap();
727 let patterns = pkg.workspace_patterns();
728 assert_eq!(patterns, vec!["packages/*", "apps/*"]);
729 }
730
731 #[test]
732 fn package_json_workspace_patterns_object() {
733 let pkg: PackageJson =
734 serde_json::from_str(r#"{"workspaces": {"packages": ["packages/*"]}}"#).unwrap();
735 let patterns = pkg.workspace_patterns();
736 assert_eq!(patterns, vec!["packages/*"]);
737 }
738
739 #[test]
740 fn package_json_workspace_patterns_none() {
741 let pkg: PackageJson = serde_json::from_str(r#"{"name": "test"}"#).unwrap();
742 let patterns = pkg.workspace_patterns();
743 assert!(patterns.is_empty());
744 }
745
746 #[test]
747 fn package_json_workspace_patterns_empty_array() {
748 let pkg: PackageJson = serde_json::from_str(r#"{"workspaces": []}"#).unwrap();
749 let patterns = pkg.workspace_patterns();
750 assert!(patterns.is_empty());
751 }
752
753 #[test]
754 fn package_json_load_valid() {
755 let temp_dir = std::env::temp_dir().join("fallow-test-pkg-json");
756 let _ = std::fs::create_dir_all(&temp_dir);
757 let pkg_path = temp_dir.join("package.json");
758 std::fs::write(&pkg_path, r#"{"name": "test", "main": "index.js"}"#).unwrap();
759
760 let pkg = PackageJson::load(&pkg_path).unwrap();
761 assert_eq!(pkg.name, Some("test".to_string()));
762 assert_eq!(pkg.main, Some("index.js".to_string()));
763
764 let _ = std::fs::remove_dir_all(&temp_dir);
765 }
766
767 #[test]
768 fn package_json_private_non_bool_values_are_ignored() {
769 for raw in [
770 r#"{"private": "true"}"#,
771 r#"{"private": 1}"#,
772 r#"{"private": null}"#,
773 ] {
774 let pkg: PackageJson = serde_json::from_str(raw).unwrap();
775 assert_eq!(pkg.private, None);
776 }
777
778 let pkg: PackageJson = serde_json::from_str(r#"{"private": true}"#).unwrap();
779 assert_eq!(pkg.private, Some(true));
780
781 let pkg: PackageJson = serde_json::from_str(r#"{"private": false}"#).unwrap();
782 assert_eq!(pkg.private, Some(false));
783 }
784
785 #[test]
786 fn package_json_files_preserves_string_array_values() {
787 let pkg: PackageJson =
788 serde_json::from_str(r#"{"files": ["index.js", "template-*", "dist"]}"#).unwrap();
789 assert_eq!(pkg.files, vec!["index.js", "template-*", "dist"]);
790 }
791
792 #[test]
793 fn package_json_files_missing_or_unexpected_shapes_are_ignored() {
794 let pkg: PackageJson = serde_json::from_str(r#"{"name": "pkg"}"#).unwrap();
795 assert!(pkg.files.is_empty());
796
797 let pkg: PackageJson = serde_json::from_str(r#"{"files": "dist"}"#).unwrap();
798 assert!(pkg.files.is_empty());
799
800 let pkg: PackageJson =
801 serde_json::from_str(r#"{"files": ["template-*", 42, false, null]}"#).unwrap();
802 assert_eq!(pkg.files, vec!["template-*"]);
803 }
804
805 #[test]
806 fn package_json_napi_config_preserves_current_string_fields() {
807 let pkg: PackageJson = serde_json::from_str(
808 r#"{
809 "napi": {
810 "binaryName": "srcmap-codec",
811 "packageName": "@srcmap/codec",
812 "targets": [
813 "aarch64-apple-darwin",
814 "x86_64-unknown-linux-gnu"
815 ]
816 }
817 }"#,
818 )
819 .unwrap();
820
821 let napi = pkg.napi.expect("napi config");
822 assert_eq!(napi.binary_name.as_deref(), Some("srcmap-codec"));
823 assert_eq!(napi.package_name.as_deref(), Some("@srcmap/codec"));
824 assert_eq!(
825 napi.targets,
826 vec![
827 "aarch64-apple-darwin".to_string(),
828 "x86_64-unknown-linux-gnu".to_string()
829 ]
830 );
831 }
832
833 #[test]
834 fn package_json_napi_config_ignores_unexpected_shapes() {
835 let pkg: PackageJson = serde_json::from_str(r#"{"napi": "enabled"}"#).unwrap();
836 assert!(pkg.napi.is_none());
837
838 let pkg: PackageJson = serde_json::from_str(
839 r#"{
840 "napi": {
841 "binaryName": 42,
842 "packageName": "",
843 "targets": ["x86_64-apple-darwin", false, null]
844 }
845 }"#,
846 )
847 .unwrap();
848
849 let napi = pkg.napi.expect("napi config");
850 assert!(napi.binary_name.is_none());
851 assert!(napi.package_name.is_none());
852 assert_eq!(napi.targets, vec!["x86_64-apple-darwin"]);
853 }
854
855 #[test]
856 fn package_json_load_missing_file() {
857 let result = PackageJson::load(std::path::Path::new("/nonexistent/package.json"));
858 assert!(result.is_err());
859 }
860
861 #[test]
862 fn package_json_entry_points_combined() {
863 let pkg: PackageJson = serde_json::from_str(
864 r#"{
865 "main": "dist/index.js",
866 "module": "dist/index.mjs",
867 "types": "dist/index.d.ts",
868 "typings": "dist/types.d.ts"
869 }"#,
870 )
871 .unwrap();
872 let entries = pkg.entry_points();
873 assert_eq!(entries.len(), 4);
874 assert!(entries.contains(&"dist/index.js".to_string()));
875 assert!(entries.contains(&"dist/index.mjs".to_string()));
876 assert!(entries.contains(&"dist/index.d.ts".to_string()));
877 assert!(entries.contains(&"dist/types.d.ts".to_string()));
878 }
879
880 #[test]
881 fn package_json_exports_nested() {
882 let pkg: PackageJson = serde_json::from_str(
883 r#"{
884 "exports": {
885 ".": {
886 "import": "./dist/index.mjs",
887 "require": "./dist/index.cjs"
888 },
889 "./utils": {
890 "import": "./dist/utils.mjs"
891 }
892 }
893 }"#,
894 )
895 .unwrap();
896 let entries = pkg.entry_points();
897 assert!(entries.contains(&"./dist/index.mjs".to_string()));
898 assert!(entries.contains(&"./dist/index.cjs".to_string()));
899 assert!(entries.contains(&"./dist/utils.mjs".to_string()));
900 }
901
902 #[test]
903 fn package_json_exports_array() {
904 let pkg: PackageJson = serde_json::from_str(
905 r#"{
906 "exports": {
907 ".": ["./dist/index.mjs", "./dist/index.cjs"]
908 }
909 }"#,
910 )
911 .unwrap();
912 let entries = pkg.entry_points();
913 assert!(entries.contains(&"./dist/index.mjs".to_string()));
914 assert!(entries.contains(&"./dist/index.cjs".to_string()));
915 }
916
917 #[test]
918 fn extract_exports_ignores_non_relative() {
919 let pkg: PackageJson = serde_json::from_str(
920 r#"{
921 "exports": {
922 ".": "not-a-relative-path"
923 }
924 }"#,
925 )
926 .unwrap();
927 let entries = pkg.entry_points();
928 assert!(entries.is_empty());
929 }
930
931 #[test]
932 fn package_json_source_field() {
933 let pkg: PackageJson = serde_json::from_str(
934 r#"{
935 "main": "dist/index.js",
936 "source": "src/index.ts"
937 }"#,
938 )
939 .unwrap();
940 let entries = pkg.entry_points();
941 assert!(entries.contains(&"src/index.ts".to_string()));
942 assert!(entries.contains(&"dist/index.js".to_string()));
943 }
944
945 #[test]
946 fn package_json_browser_field_string() {
947 let pkg: PackageJson = serde_json::from_str(
948 r#"{
949 "browser": "./dist/browser.js"
950 }"#,
951 )
952 .unwrap();
953 let entries = pkg.entry_points();
954 assert!(entries.contains(&"./dist/browser.js".to_string()));
955 }
956
957 #[test]
958 fn package_json_browser_field_object() {
959 let pkg: PackageJson = serde_json::from_str(
960 r#"{
961 "browser": {
962 "./server.js": "./browser.js",
963 "module-name": false
964 }
965 }"#,
966 )
967 .unwrap();
968 let entries = pkg.entry_points();
969 assert!(entries.contains(&"./browser.js".to_string()));
970 assert_eq!(entries.len(), 1);
971 }
972
973 #[test]
974 fn package_json_exports_string() {
975 let pkg: PackageJson = serde_json::from_str(r#"{"exports": "./dist/index.js"}"#).unwrap();
976 let entries = pkg.entry_points();
977 assert_eq!(entries, vec!["./dist/index.js"]);
978 }
979
980 #[test]
981 fn package_json_workspace_patterns_object_with_nohoist() {
982 let pkg: PackageJson = serde_json::from_str(
983 r#"{
984 "workspaces": {
985 "packages": ["packages/*", "apps/*"],
986 "nohoist": ["**/react-native"]
987 }
988 }"#,
989 )
990 .unwrap();
991 let patterns = pkg.workspace_patterns();
992 assert_eq!(patterns, vec!["packages/*", "apps/*"]);
993 }
994
995 #[test]
996 fn package_json_missing_optional_fields() {
997 let pkg: PackageJson = serde_json::from_str(r"{}").unwrap();
998 assert!(pkg.name.is_none());
999 assert!(pkg.main.is_none());
1000 assert!(pkg.module.is_none());
1001 assert!(pkg.types.is_none());
1002 assert!(pkg.typings.is_none());
1003 assert!(pkg.source.is_none());
1004 assert!(pkg.browser.is_none());
1005 assert!(pkg.bin.is_none());
1006 assert!(pkg.exports.is_none());
1007 assert!(pkg.dependencies.is_none());
1008 assert!(pkg.dev_dependencies.is_none());
1009 assert!(pkg.peer_dependencies.is_none());
1010 assert!(pkg.peer_dependencies_meta.is_none());
1011 assert!(pkg.optional_dependencies.is_none());
1012 assert!(pkg.scripts.is_none());
1013 assert!(pkg.workspaces.is_none());
1014 assert!(pkg.entry_points().is_empty());
1015 assert!(pkg.workspace_patterns().is_empty());
1016 assert!(pkg.all_dependency_names().is_empty());
1017 }
1018
1019 #[test]
1020 fn package_json_all_dependency_names() {
1021 let pkg: PackageJson = serde_json::from_str(
1022 r#"{
1023 "dependencies": {"react": "^18", "react-dom": "^18"},
1024 "devDependencies": {"typescript": "^5"},
1025 "peerDependencies": {"node": ">=18"},
1026 "optionalDependencies": {"fsevents": "^2"}
1027 }"#,
1028 )
1029 .unwrap();
1030 let deps = pkg.all_dependency_names();
1031 assert_eq!(deps.len(), 5);
1032 assert!(deps.contains(&"react".to_string()));
1033 assert!(deps.contains(&"react-dom".to_string()));
1034 assert!(deps.contains(&"typescript".to_string()));
1035 assert!(deps.contains(&"node".to_string()));
1036 assert!(deps.contains(&"fsevents".to_string()));
1037 }
1038
1039 #[test]
1040 fn package_json_production_dependency_names() {
1041 let pkg: PackageJson = serde_json::from_str(
1042 r#"{
1043 "dependencies": {"react": "^18"},
1044 "devDependencies": {"typescript": "^5"}
1045 }"#,
1046 )
1047 .unwrap();
1048 let prod = pkg.production_dependency_names();
1049 assert_eq!(prod, vec!["react"]);
1050 let dev = pkg.dev_dependency_names();
1051 assert_eq!(dev, vec!["typescript"]);
1052 }
1053
1054 #[test]
1055 fn package_json_bin_field_string() {
1056 let pkg: PackageJson = serde_json::from_str(r#"{"bin": "./cli.js"}"#).unwrap();
1057 let entries = pkg.entry_points();
1058 assert!(entries.contains(&"./cli.js".to_string()));
1059 }
1060
1061 #[test]
1062 fn package_json_bin_field_object() {
1063 let pkg: PackageJson = serde_json::from_str(
1064 r#"{"bin": {"my-cli": "./bin/cli.js", "my-tool": "./bin/tool.js"}}"#,
1065 )
1066 .unwrap();
1067 let entries = pkg.entry_points();
1068 assert!(entries.contains(&"./bin/cli.js".to_string()));
1069 assert!(entries.contains(&"./bin/tool.js".to_string()));
1070 }
1071
1072 #[test]
1073 fn package_json_exports_deeply_nested() {
1074 let pkg: PackageJson = serde_json::from_str(
1075 r#"{
1076 "exports": {
1077 ".": {
1078 "node": {
1079 "import": "./dist/node.mjs",
1080 "require": "./dist/node.cjs"
1081 },
1082 "browser": {
1083 "import": "./dist/browser.mjs"
1084 }
1085 }
1086 }
1087 }"#,
1088 )
1089 .unwrap();
1090 let entries = pkg.entry_points();
1091 assert_eq!(entries.len(), 3);
1092 assert!(entries.contains(&"./dist/node.mjs".to_string()));
1093 assert!(entries.contains(&"./dist/node.cjs".to_string()));
1094 assert!(entries.contains(&"./dist/browser.mjs".to_string()));
1095 }
1096
1097 #[test]
1098 fn package_json_peer_deps_only() {
1099 let pkg: PackageJson =
1100 serde_json::from_str(r#"{"peerDependencies": {"react": "^18", "react-dom": "^18"}}"#)
1101 .unwrap();
1102 let all = pkg.all_dependency_names();
1103 assert_eq!(all.len(), 2);
1104 assert!(all.contains(&"react".to_string()));
1105 assert!(all.contains(&"react-dom".to_string()));
1106
1107 assert!(pkg.production_dependency_names().is_empty());
1108 assert!(pkg.dev_dependency_names().is_empty());
1109 }
1110
1111 #[test]
1112 fn package_json_peer_dependency_names_include_optional_peers() {
1113 let pkg: PackageJson = serde_json::from_str(
1114 r#"{
1115 "peerDependencies": {"react": "^18", "typescript": "^5"},
1116 "peerDependenciesMeta": {"typescript": {"optional": true}}
1117 }"#,
1118 )
1119 .unwrap();
1120 let mut names = pkg.peer_dependency_names();
1121 names.sort_unstable();
1122 assert_eq!(names, vec!["react", "typescript"]);
1123 }
1124
1125 #[test]
1126 fn package_json_optional_deps_in_all_names() {
1127 let pkg: PackageJson =
1128 serde_json::from_str(r#"{"optionalDependencies": {"fsevents": "^2"}}"#).unwrap();
1129 let all = pkg.all_dependency_names();
1130 assert!(all.contains(&"fsevents".to_string()));
1131 }
1132
1133 #[test]
1134 fn package_json_browser_array_ignored() {
1135 let pkg: PackageJson =
1136 serde_json::from_str(r#"{"browser": ["./a.js", "./b.js"]}"#).unwrap();
1137 let entries = pkg.entry_points();
1138 assert!(
1139 entries.is_empty(),
1140 "array browser field should not produce entries"
1141 );
1142 }
1143
1144 #[test]
1145 fn package_json_browser_object_non_relative_skipped() {
1146 let pkg: PackageJson = serde_json::from_str(
1147 r#"{"browser": {"crypto": false, "./local.js": "./browser-local.js"}}"#,
1148 )
1149 .unwrap();
1150 let entries = pkg.entry_points();
1151 assert_eq!(entries.len(), 1);
1152 assert!(entries.contains(&"./browser-local.js".to_string()));
1153 }
1154
1155 #[test]
1156 fn package_json_exports_null_value() {
1157 let pkg: PackageJson =
1158 serde_json::from_str(r#"{"exports": {".": "./dist/index.js", "./internal": null}}"#)
1159 .unwrap();
1160 let entries = pkg.entry_points();
1161 assert_eq!(entries.len(), 1);
1162 assert!(entries.contains(&"./dist/index.js".to_string()));
1163 }
1164
1165 #[test]
1166 fn package_json_exports_empty_object() {
1167 let pkg: PackageJson = serde_json::from_str(r#"{"exports": {}}"#).unwrap();
1168 let entries = pkg.entry_points();
1169 assert!(entries.is_empty());
1170 }
1171
1172 #[test]
1173 fn package_json_workspace_patterns_string_value_ignored() {
1174 let pkg: PackageJson = serde_json::from_str(r#"{"workspaces": "packages/*"}"#).unwrap();
1175 let patterns = pkg.workspace_patterns();
1176 assert!(patterns.is_empty());
1177 }
1178
1179 #[test]
1180 fn package_json_workspace_patterns_object_missing_packages() {
1181 let pkg: PackageJson =
1182 serde_json::from_str(r#"{"workspaces": {"nohoist": ["**/react-native"]}}"#).unwrap();
1183 let patterns = pkg.workspace_patterns();
1184 assert!(patterns.is_empty());
1185 }
1186
1187 #[test]
1188 fn package_json_load_invalid_json() {
1189 let temp_dir = std::env::temp_dir().join("fallow-test-invalid-pkg-json");
1190 let _ = std::fs::create_dir_all(&temp_dir);
1191 let pkg_path = temp_dir.join("package.json");
1192 std::fs::write(&pkg_path, "{ not valid json }").unwrap();
1193
1194 let result = PackageJson::load(&pkg_path);
1195 assert!(result.is_err());
1196 let err = result.unwrap_err();
1197 assert!(err.contains("Failed to parse"), "got: {err}");
1198
1199 let _ = std::fs::remove_dir_all(&temp_dir);
1200 }
1201
1202 #[test]
1203 fn package_json_bin_object_non_string_values_skipped() {
1204 let pkg: PackageJson =
1205 serde_json::from_str(r#"{"bin": {"cli": "./bin/cli.js", "bad": 42}}"#).unwrap();
1206 let entries = pkg.entry_points();
1207 assert_eq!(entries.len(), 1);
1208 assert!(entries.contains(&"./bin/cli.js".to_string()));
1209 }
1210
1211 #[test]
1212 fn package_json_default() {
1213 let pkg = PackageJson::default();
1214 assert!(pkg.name.is_none());
1215 assert!(pkg.main.is_none());
1216 assert!(pkg.entry_points().is_empty());
1217 assert!(pkg.all_dependency_names().is_empty());
1218 assert!(pkg.workspace_patterns().is_empty());
1219 }
1220
1221 #[test]
1222 fn exports_subdirectories_preact_style() {
1223 let pkg: PackageJson = serde_json::from_str(
1224 r#"{
1225 "exports": {
1226 ".": "./dist/index.js",
1227 "./compat": { "import": "./compat/dist/compat.mjs" },
1228 "./hooks": { "import": "./hooks/dist/hooks.mjs" },
1229 "./debug": { "import": "./debug/dist/debug.mjs" },
1230 "./jsx-runtime": { "import": "./jsx-runtime/dist/jsx.mjs" },
1231 "./package.json": "./package.json"
1232 }
1233 }"#,
1234 )
1235 .unwrap();
1236 let mut dirs = pkg.exports_subdirectories();
1237 dirs.sort();
1238 assert_eq!(dirs, vec!["compat", "debug", "hooks", "jsx-runtime"]);
1239 }
1240
1241 #[test]
1242 fn exports_subdirectories_skips_dist_dirs() {
1243 let pkg: PackageJson = serde_json::from_str(
1244 r#"{
1245 "exports": {
1246 "./dist/index.js": "./dist/index.js",
1247 "./build/bundle.js": "./build/bundle.js",
1248 "./lib/utils": "./lib/utils.js",
1249 "./compat": "./compat/index.js"
1250 }
1251 }"#,
1252 )
1253 .unwrap();
1254 let dirs = pkg.exports_subdirectories();
1255 assert_eq!(dirs, vec!["compat"]);
1256 }
1257
1258 #[test]
1259 fn exports_subdirectories_no_exports() {
1260 let pkg: PackageJson = serde_json::from_str(r#"{"main": "index.js"}"#).unwrap();
1261 assert!(pkg.exports_subdirectories().is_empty());
1262 }
1263
1264 #[test]
1265 fn exports_subdirectories_dot_only() {
1266 let pkg: PackageJson =
1267 serde_json::from_str(r#"{"exports": {".": "./dist/index.js"}}"#).unwrap();
1268 assert!(pkg.exports_subdirectories().is_empty());
1269 }
1270
1271 #[test]
1272 fn npm_aliases_read_the_aliased_package_name() {
1273 let pkg: PackageJson = serde_json::from_str(
1274 r#"{
1275 "dependencies": {"plain": "npm:left-pad@^1.3.0", "range": "^1.0.0"},
1276 "devDependencies": {
1277 "@typescript/native": "npm:typescript@~7.0.2",
1278 "typescript": "npm:@typescript/typescript6@^6.0.2",
1279 "bare": "npm:eslint",
1280 "same": "npm:same@1.0.0",
1281 "path": "npm:./local",
1282 "bad-scope": "npm:@scope@1.0.0",
1283 "workspace": "workspace:@scope/core@*"
1284 }
1285 }"#,
1286 )
1287 .unwrap();
1288 assert_eq!(
1289 pkg.npm_aliases(),
1290 [
1291 ("@typescript/native", "typescript"),
1292 ("bare", "eslint"),
1293 ("plain", "left-pad"),
1294 ("typescript", "@typescript/typescript6"),
1295 ]
1296 .map(|(alias, target)| (alias.to_string(), target.to_string()))
1297 );
1298 }
1299
1300 #[test]
1301 fn npm_aliases_with_catalogs_resolves_catalog_references() {
1302 let catalogs = super::super::pnpm_catalog::parse_pnpm_catalog_data(
1303 "catalog:\n \"@typescript/native\": npm:typescript@~7.0.2\n react: ^18.2.0\ncatalogs:\n tools:\n vite-next: npm:vite@^7.0.0\n",
1304 )
1305 .unwrap();
1306 let pkg: PackageJson = serde_json::from_str(
1307 r#"{
1308 "devDependencies": {
1309 "@typescript/native": "catalog:",
1310 "react": "catalog:default",
1311 "vite-next": "catalog:tools",
1312 "missing": "catalog:tools",
1313 "inline": "npm:left-pad@1"
1314 }
1315 }"#,
1316 )
1317 .unwrap();
1318 assert_eq!(
1319 pkg.npm_aliases_with_catalogs(Some(&catalogs)),
1320 [
1321 ("@typescript/native", "typescript"),
1322 ("inline", "left-pad"),
1323 ("vite-next", "vite"),
1324 ]
1325 .map(|(alias, target)| (alias.to_string(), target.to_string()))
1326 );
1327 assert_eq!(
1328 pkg.npm_aliases(),
1329 [("inline".to_string(), "left-pad".to_string())]
1330 );
1331 }
1332
1333 #[test]
1334 fn workspace_alias_target_reads_the_aliased_package_name() {
1335 let pkg: PackageJson = serde_json::from_str(
1336 r#"{
1337 "dependencies": {
1338 "vite": "workspace:@scope/core@*",
1339 "plain": "workspace:other@^1.0.0",
1340 "range": "workspace:*",
1341 "caret": "workspace:^1.0.0",
1342 "path": "workspace:../core",
1343 "npm": "npm:@scope/core@1.0.0",
1344 "bad-scope": "workspace:@scope@1.0.0"
1345 },
1346 "devDependencies": {"tool": "workspace:@scope/tool@workspace:*"}
1347 }"#,
1348 )
1349 .unwrap();
1350 assert_eq!(pkg.workspace_alias_target("vite"), Some("@scope/core"));
1351 assert_eq!(pkg.workspace_alias_target("plain"), Some("other"));
1352 assert_eq!(pkg.workspace_alias_target("tool"), Some("@scope/tool"));
1353 for name in ["range", "caret", "path", "npm", "bad-scope", "missing"] {
1354 assert_eq!(pkg.workspace_alias_target(name), None, "{name}");
1355 }
1356 }
1357}