Skip to main content

fallow_config/workspace/
package_json.rs

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/// Type alias for standard `HashMap` used in serde-deserialized structs.
11/// `rustc-hash` v2 does not have a `serde` feature, so fields deserialized
12/// from JSON must use `std::collections::HashMap`.
13#[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
70/// The `package.json` keys that hold the inline config of a built-in plugin
71/// ([`PackageJson::inline_tool_config`]).
72pub 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
89/// Keeps the value of each [`INLINE_TOOL_CONFIG_KEYS`] key raw. A repeated key
90/// keeps its last value, as `JSON.parse` does, and any value is accepted, so
91/// these keys never fail manifest parsing.
92fn 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/// The NAPI-RS `napi` block of a `package.json`, used to recognize the
136/// per-platform artifact packages a native addon generates so they are not
137/// reported as unused dependencies. All fields deserialize leniently: a
138/// wrong-typed value becomes `None`/empty instead of failing manifest parsing.
139#[derive(Debug, Clone, Default, Deserialize, Serialize)]
140pub struct NapiConfig {
141    /// The `binaryName` field: basename of the generated `.node` binary.
142    #[serde(
143        default,
144        rename = "binaryName",
145        deserialize_with = "deserialize_optional_string_lenient"
146    )]
147    pub binary_name: Option<String>,
148    /// The `packageName` field: base npm package name from which per-platform
149    /// artifact package names (`<name>-<triple>`) are derived.
150    #[serde(
151        default,
152        rename = "packageName",
153        deserialize_with = "deserialize_optional_string_lenient"
154    )]
155    pub package_name: Option<String>,
156    /// The `targets` field: platform triples the addon is built for.
157    #[serde(default, deserialize_with = "deserialize_string_array_lenient")]
158    pub targets: Vec<String>,
159}
160
161/// Parsed package.json with fields relevant to fallow.
162#[derive(Debug, Clone, Default, Deserialize, Serialize)]
163pub struct PackageJson {
164    /// The `name` field: the package's npm name, used to identify workspace
165    /// packages and match `public_packages` config entries.
166    #[serde(default)]
167    pub name: Option<String>,
168    /// The `private` field. Non-boolean values become `None` rather than
169    /// failing manifest parsing.
170    #[serde(default, deserialize_with = "deserialize_optional_bool_lenient")]
171    pub private: Option<bool>,
172    /// The `main` field: CommonJS entry-point path, seeded as an entry point.
173    #[serde(default)]
174    pub main: Option<String>,
175    /// The `module` field: ESM entry-point path, seeded as an entry point.
176    #[serde(default)]
177    pub module: Option<String>,
178    /// The `types` field: type-declaration entry-point path.
179    #[serde(default)]
180    pub types: Option<String>,
181    /// The `typings` field: legacy spelling of `types`.
182    #[serde(default)]
183    pub typings: Option<String>,
184    /// The `source` field: unbundled source entry point used by bundler-based
185    /// packages (Parcel convention).
186    #[serde(default)]
187    pub source: Option<String>,
188    /// The `files` field: publish allowlist patterns. Non-array values become
189    /// empty rather than failing manifest parsing.
190    #[serde(default, deserialize_with = "deserialize_string_array_lenient")]
191    pub files: Vec<String>,
192    /// The `browser` field, kept raw because it is either a string entry point
193    /// or a path-remap object.
194    #[serde(default)]
195    pub browser: Option<serde_json::Value>,
196    /// The `bin` field, kept raw because it is either a string path or a
197    /// name-to-path object; every referenced file is an entry point.
198    #[serde(default)]
199    pub bin: Option<serde_json::Value>,
200    /// The `typescript` field, kept raw. Its `contentMapper.exec` command
201    /// names a script that TypeScript runs.
202    #[serde(default)]
203    pub typescript: Option<serde_json::Value>,
204    /// The `exports` field, kept raw because of its many shapes (string,
205    /// conditions object, subpath map); referenced files are entry points and
206    /// the map drives subpath resolution.
207    #[serde(default)]
208    pub exports: Option<serde_json::Value>,
209    /// The `imports` field (`#`-prefixed internal subpath map), kept raw and
210    /// consumed by the module resolver.
211    #[serde(default)]
212    pub imports: Option<serde_json::Value>,
213    /// The `dependencies` map (package name to version range), the base set
214    /// for unused/unlisted-dependency accounting.
215    #[serde(default)]
216    pub dependencies: Option<StdHashMap<String, String>>,
217    /// The `devDependencies` map, checked by `unused-dev-dependencies` and
218    /// `dev-dependency-in-production`.
219    #[serde(default, rename = "devDependencies")]
220    pub dev_dependencies: Option<StdHashMap<String, String>>,
221    /// The `peerDependencies` map. Peers are provided by the consumer, so
222    /// they are exempt from unused-dependency reporting.
223    #[serde(default, rename = "peerDependencies")]
224    pub peer_dependencies: Option<StdHashMap<String, String>>,
225    /// The `peerDependenciesMeta` map, marking which peers are optional.
226    #[serde(default, rename = "peerDependenciesMeta")]
227    pub peer_dependencies_meta: Option<StdHashMap<String, PeerDependencyMeta>>,
228    /// The `optionalDependencies` map, checked by
229    /// `unused-optional-dependencies`.
230    #[serde(default, rename = "optionalDependencies")]
231    pub optional_dependencies: Option<StdHashMap<String, String>>,
232    /// The `scripts` map, scanned so packages invoked from scripts count as
233    /// used tooling dependencies.
234    #[serde(default)]
235    pub scripts: Option<StdHashMap<String, String>>,
236    /// The NAPI-RS `napi` block; see [`NapiConfig`]. Non-object values become
237    /// `None` rather than failing manifest parsing.
238    #[serde(default, deserialize_with = "deserialize_optional_napi_config")]
239    pub napi: Option<NapiConfig>,
240    /// The `workspaces` field, kept raw because it is either a pattern array
241    /// or an object with a `packages` array; drives workspace discovery.
242    #[serde(default)]
243    pub workspaces: Option<serde_json::Value>,
244    /// The `packageManager` field (e.g. `"pnpm@9.1.0"`), used to determine
245    /// the canonical package manager for the project.
246    #[serde(
247        default,
248        rename = "packageManager",
249        deserialize_with = "deserialize_optional_string_lenient"
250    )]
251    pub package_manager: Option<String>,
252    /// The Egg.js `egg` block (for example `framework` and `tscompiler`),
253    /// kept raw so that an unexpected shape does not fail manifest parsing.
254    #[serde(default)]
255    pub egg: Option<serde_json::Value>,
256    /// The Egg.js `eggPlugin` block of a plugin package, kept raw.
257    #[serde(default, rename = "eggPlugin")]
258    pub egg_plugin: Option<serde_json::Value>,
259    /// The tegg `eggModule` block of a module package, kept raw.
260    #[serde(default, rename = "eggModule")]
261    pub egg_module: Option<serde_json::Value>,
262    /// The `n8n` block of an n8n node package (`nodes` and `credentials`),
263    /// kept raw so that an unexpected shape does not fail manifest parsing.
264    #[serde(default)]
265    pub n8n: Option<serde_json::Value>,
266    /// The value of each [`INLINE_TOOL_CONFIG_KEYS`] key that the manifest
267    /// has, kept raw. See [`PackageJson::inline_tool_config`].
268    #[serde(default, flatten, deserialize_with = "deserialize_inline_tool_configs")]
269    pub inline_tool_configs: BTreeMap<&'static str, serde_json::Value>,
270}
271
272/// The package.json field that declares an entry point.
273#[derive(Debug, Clone, Copy, PartialEq, Eq)]
274pub enum PackageEntryField {
275    /// The `main` field.
276    Main,
277    /// The `module` field.
278    Module,
279    /// The `types` field.
280    Types,
281    /// The `typings` field.
282    Typings,
283    /// The `source` field.
284    Source,
285    /// The `browser` field, as a string or as a map of replacement paths.
286    Browser,
287    /// The `bin` field, as a string or as a map of command names.
288    Bin,
289    /// The `exports` field, at any depth of conditions and subpaths.
290    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
308/// Collects the paths of a field that holds one string or a map of strings.
309/// `keep_map_value` filters the map values: a `browser` map also holds bare
310/// package names, which are not files of the package.
311fn 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    /// The raw value of the tool config key `key`, such as `prettier` or
332    /// `nodemonConfig`. Returns `None` when the manifest has no such key, or
333    /// when `key` is not in [`INLINE_TOOL_CONFIG_KEYS`].
334    #[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    /// Load from a package.json file.
340    ///
341    /// # Errors
342    ///
343    /// Returns an error string when the file cannot be read or parsed as JSON.
344    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    /// Get all dependency names (production + dev + peer + optional).
353    #[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    /// Get production dependency names only.
372    #[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    /// Get dev dependency names only.
381    #[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    /// Get optional dependency names only.
390    #[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    /// Get every peer dependency name, required or optional.
399    #[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    /// Whether `peerDependenciesMeta` marks the peer `dep` as optional.
408    #[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    /// Extract entry points from package.json fields.
417    #[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    /// Extract entry points from package.json fields, each with the field
426    /// that declares it, in field order: `main`, `module`, `types`,
427    /// `typings`, `source`, `browser`, `bin`, `exports`.
428    #[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    /// Extract unique subdirectory names referenced by the `exports` field keys.
468    ///
469    /// For exports like `"./compat": { ... }`, `"./hooks/client": { ... }`,
470    /// this returns `["compat", "hooks"]`. Used to discover sub-packages in
471    /// projects that define their internal package structure via the exports map
472    /// (e.g., preact with `compat/`, `hooks/`, `debug/` sub-packages).
473    #[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    /// Extract workspace patterns from package.json.
481    #[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    /// Dependencies with a `link:` or `file:` spec in `dependencies`,
502    /// `devDependencies` or `optionalDependencies`, as `(name, target)` pairs
503    /// sorted by name.
504    ///
505    /// The target is the path as written, relative to this manifest's
506    /// directory. The caller decides which targets are real package
507    /// directories.
508    #[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    /// The workspace package that the dependency `name` is an alias of.
532    ///
533    /// pnpm installs `"vite": "workspace:@scope/core@*"` as the workspace
534    /// package `@scope/core` under the name `vite`. A `workspace:` spec with
535    /// only a range (`workspace:*`, `workspace:^1.0.0`) or a path
536    /// (`workspace:../core`) is not an alias.
537    #[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    /// Every dependency that the manifest installs under an npm alias, as
552    /// `(alias, aliased package)` pairs.
553    ///
554    /// `"@typescript/native": "npm:typescript@~7.0.2"` installs the package
555    /// `typescript` in `node_modules/@typescript/native`, so the alias
556    /// provides the binaries of `typescript`.
557    #[must_use]
558    pub fn npm_aliases(&self) -> Vec<(String, String)> {
559        self.npm_aliases_with_catalogs(None)
560    }
561
562    /// Every npm alias of the manifest, as [`Self::npm_aliases`] gives, plus
563    /// every alias that a `catalog:` reference gets from `catalogs`.
564    ///
565    /// `"@typescript/native": "catalog:"` with the catalog entry
566    /// `"@typescript/native": npm:typescript@~7.0.2` installs `typescript`
567    /// under the alias, the same as the inline spec.
568    #[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
596/// The package name in a `workspace:<name>@<range>` dependency spec.
597fn 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
607/// The package name in an `npm:<name>@<range>` or `npm:<name>` dependency
608/// spec.
609fn 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
619/// `name` when it has the shape of a package name: `name` or `@scope/name`.
620fn 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
655/// Recursively extract file paths from package.json exports field.
656fn 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}