fallow_config/workspace/

package_json.rs

use serde::{Deserialize, Deserializer, Serialize, de::Error};

/// Type alias for standard `HashMap` used in serde-deserialized structs.
/// `rustc-hash` v2 does not have a `serde` feature, so fields deserialized
/// from JSON must use `std::collections::HashMap`.
#[expect(
    clippy::disallowed_types,
    reason = "rustc-hash v2 lacks serde feature — JSON deserialization needs std HashMap"
)]
type StdHashMap<K, V> = std::collections::HashMap<K, V>;

fn deserialize_optional_bool_lenient<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
where
    D: Deserializer<'de>,
{
    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
    Ok(match value {
        Some(serde_json::Value::Bool(value)) => Some(value),
        _ => None,
    })
}

fn deserialize_string_array_lenient<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
where
    D: Deserializer<'de>,
{
    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
    Ok(match value {
        Some(serde_json::Value::Array(values)) => values
            .into_iter()
            .filter_map(|value| value.as_str().map(str::to_owned))
            .collect(),
        _ => Vec::new(),
    })
}

fn deserialize_optional_string_lenient<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
    D: Deserializer<'de>,
{
    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
    Ok(match value {
        Some(serde_json::Value::String(value)) if !value.trim().is_empty() => Some(value),
        _ => None,
    })
}

fn deserialize_optional_napi_config<'de, D>(deserializer: D) -> Result<Option<NapiConfig>, D::Error>
where
    D: Deserializer<'de>,
{
    let value = Option::<serde_json::Value>::deserialize(deserializer)?;
    match value {
        Some(serde_json::Value::Object(map)) => {
            serde_json::from_value(serde_json::Value::Object(map))
                .map(Some)
                .map_err(D::Error::custom)
        }
        _ => Ok(None),
    }
}

#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct PeerDependencyMeta {
    #[serde(default)]
    pub optional: bool,
}

/// The NAPI-RS `napi` block of a `package.json`, used to recognize the
/// per-platform artifact packages a native addon generates so they are not
/// reported as unused dependencies. All fields deserialize leniently: a
/// wrong-typed value becomes `None`/empty instead of failing manifest parsing.
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct NapiConfig {
    /// The `binaryName` field: basename of the generated `.node` binary.
    #[serde(
        default,
        rename = "binaryName",
        deserialize_with = "deserialize_optional_string_lenient"
    )]
    pub binary_name: Option<String>,
    /// The `packageName` field: base npm package name from which per-platform
    /// artifact package names (`<name>-<triple>`) are derived.
    #[serde(
        default,
        rename = "packageName",
        deserialize_with = "deserialize_optional_string_lenient"
    )]
    pub package_name: Option<String>,
    /// The `targets` field: platform triples the addon is built for.
    #[serde(default, deserialize_with = "deserialize_string_array_lenient")]
    pub targets: Vec<String>,
}

/// Parsed package.json with fields relevant to fallow.
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct PackageJson {
    /// The `name` field: the package's npm name, used to identify workspace
    /// packages and match `public_packages` config entries.
    #[serde(default)]
    pub name: Option<String>,
    /// The `private` field. Non-boolean values become `None` rather than
    /// failing manifest parsing.
    #[serde(default, deserialize_with = "deserialize_optional_bool_lenient")]
    pub private: Option<bool>,
    /// The `main` field: CommonJS entry-point path, seeded as an entry point.
    #[serde(default)]
    pub main: Option<String>,
    /// The `module` field: ESM entry-point path, seeded as an entry point.
    #[serde(default)]
    pub module: Option<String>,
    /// The `types` field: type-declaration entry-point path.
    #[serde(default)]
    pub types: Option<String>,
    /// The `typings` field: legacy spelling of `types`.
    #[serde(default)]
    pub typings: Option<String>,
    /// The `source` field: unbundled source entry point used by bundler-based
    /// packages (Parcel convention).
    #[serde(default)]
    pub source: Option<String>,
    /// The `files` field: publish allowlist patterns. Non-array values become
    /// empty rather than failing manifest parsing.
    #[serde(default, deserialize_with = "deserialize_string_array_lenient")]
    pub files: Vec<String>,
    /// The `browser` field, kept raw because it is either a string entry point
    /// or a path-remap object.
    #[serde(default)]
    pub browser: Option<serde_json::Value>,
    /// The `bin` field, kept raw because it is either a string path or a
    /// name-to-path object; every referenced file is an entry point.
    #[serde(default)]
    pub bin: Option<serde_json::Value>,
    /// The `exports` field, kept raw because of its many shapes (string,
    /// conditions object, subpath map); referenced files are entry points and
    /// the map drives subpath resolution.
    #[serde(default)]
    pub exports: Option<serde_json::Value>,
    /// The `imports` field (`#`-prefixed internal subpath map), kept raw and
    /// consumed by the module resolver.
    #[serde(default)]
    pub imports: Option<serde_json::Value>,
    /// The `dependencies` map (package name to version range), the base set
    /// for unused/unlisted-dependency accounting.
    #[serde(default)]
    pub dependencies: Option<StdHashMap<String, String>>,
    /// The `devDependencies` map, checked by `unused-dev-dependencies` and
    /// `dev-dependency-in-production`.
    #[serde(default, rename = "devDependencies")]
    pub dev_dependencies: Option<StdHashMap<String, String>>,
    /// The `peerDependencies` map. Peers are provided by the consumer, so
    /// they are exempt from unused-dependency reporting.
    #[serde(default, rename = "peerDependencies")]
    pub peer_dependencies: Option<StdHashMap<String, String>>,
    /// The `peerDependenciesMeta` map, marking which peers are optional.
    #[serde(default, rename = "peerDependenciesMeta")]
    pub peer_dependencies_meta: Option<StdHashMap<String, PeerDependencyMeta>>,
    /// The `optionalDependencies` map, checked by
    /// `unused-optional-dependencies`.
    #[serde(default, rename = "optionalDependencies")]
    pub optional_dependencies: Option<StdHashMap<String, String>>,
    /// The `scripts` map, scanned so packages invoked from scripts count as
    /// used tooling dependencies.
    #[serde(default)]
    pub scripts: Option<StdHashMap<String, String>>,
    /// The NAPI-RS `napi` block; see [`NapiConfig`]. Non-object values become
    /// `None` rather than failing manifest parsing.
    #[serde(default, deserialize_with = "deserialize_optional_napi_config")]
    pub napi: Option<NapiConfig>,
    /// The `workspaces` field, kept raw because it is either a pattern array
    /// or an object with a `packages` array; drives workspace discovery.
    #[serde(default)]
    pub workspaces: Option<serde_json::Value>,
    /// The `packageManager` field (e.g. `"pnpm@9.1.0"`), used to determine
    /// the canonical package manager for the project.
    #[serde(
        default,
        rename = "packageManager",
        deserialize_with = "deserialize_optional_string_lenient"
    )]
    pub package_manager: Option<String>,
}

impl PackageJson {
    /// Load from a package.json file.
    ///
    /// # Errors
    ///
    /// Returns an error string when the file cannot be read or parsed as JSON.
    pub fn load(path: &std::path::Path) -> Result<Self, String> {
        let content = std::fs::read_to_string(path)
            .map_err(|e| format!("Failed to read {}: {}", path.display(), e))?;
        let content = content.trim_start_matches('\u{FEFF}');
        serde_json::from_str(content)
            .map_err(|e| format!("Failed to parse {}: {}", path.display(), e))
    }

    /// Get all dependency names (production + dev + peer + optional).
    #[must_use]
    pub fn all_dependency_names(&self) -> Vec<String> {
        let mut deps = Vec::new();
        if let Some(d) = &self.dependencies {
            deps.extend(d.keys().cloned());
        }
        if let Some(d) = &self.dev_dependencies {
            deps.extend(d.keys().cloned());
        }
        if let Some(d) = &self.peer_dependencies {
            deps.extend(d.keys().cloned());
        }
        if let Some(d) = &self.optional_dependencies {
            deps.extend(d.keys().cloned());
        }
        deps
    }

    /// Get production dependency names only.
    #[must_use]
    pub fn production_dependency_names(&self) -> Vec<String> {
        self.dependencies
            .as_ref()
            .map(|d| d.keys().cloned().collect())
            .unwrap_or_default()
    }

    /// Get dev dependency names only.
    #[must_use]
    pub fn dev_dependency_names(&self) -> Vec<String> {
        self.dev_dependencies
            .as_ref()
            .map(|d| d.keys().cloned().collect())
            .unwrap_or_default()
    }

    /// Get optional dependency names only.
    #[must_use]
    pub fn optional_dependency_names(&self) -> Vec<String> {
        self.optional_dependencies
            .as_ref()
            .map(|d| d.keys().cloned().collect())
            .unwrap_or_default()
    }

    /// Get required peer dependency names only.
    #[must_use]
    pub fn required_peer_dependency_names(&self) -> Vec<String> {
        self.peer_dependencies
            .as_ref()
            .map(|deps| {
                deps.keys()
                    .filter(|dep| !self.peer_dependency_is_optional(dep))
                    .cloned()
                    .collect()
            })
            .unwrap_or_default()
    }

    fn peer_dependency_is_optional(&self, dep: &str) -> bool {
        self.peer_dependencies_meta
            .as_ref()
            .and_then(|meta| meta.get(dep))
            .is_some_and(|meta| meta.optional)
    }

    /// Extract entry points from package.json fields.
    #[must_use]
    pub fn entry_points(&self) -> Vec<String> {
        let mut entries = Vec::new();

        if let Some(main) = &self.main {
            entries.push(main.clone());
        }
        if let Some(module) = &self.module {
            entries.push(module.clone());
        }
        if let Some(types) = &self.types {
            entries.push(types.clone());
        }
        if let Some(typings) = &self.typings {
            entries.push(typings.clone());
        }
        if let Some(source) = &self.source {
            entries.push(source.clone());
        }

        if let Some(browser) = &self.browser {
            match browser {
                serde_json::Value::String(s) => entries.push(s.clone()),
                serde_json::Value::Object(map) => {
                    for v in map.values() {
                        if let serde_json::Value::String(s) = v
                            && (s.starts_with("./") || s.starts_with("../"))
                        {
                            entries.push(s.clone());
                        }
                    }
                }
                _ => {}
            }
        }

        if let Some(bin) = &self.bin {
            match bin {
                serde_json::Value::String(s) => entries.push(s.clone()),
                serde_json::Value::Object(map) => {
                    for v in map.values() {
                        if let serde_json::Value::String(s) = v {
                            entries.push(s.clone());
                        }
                    }
                }
                _ => {}
            }
        }

        if let Some(exports) = &self.exports {
            extract_exports_entries(exports, &mut entries);
        }

        entries
    }

    /// Extract unique subdirectory names referenced by the `exports` field keys.
    ///
    /// For exports like `"./compat": { ... }`, `"./hooks/client": { ... }`,
    /// this returns `["compat", "hooks"]`. Used to discover sub-packages in
    /// projects that define their internal package structure via the exports map
    /// (e.g., preact with `compat/`, `hooks/`, `debug/` sub-packages).
    #[must_use]
    pub fn exports_subdirectories(&self) -> Vec<String> {
        self.exports
            .as_ref()
            .map_or_else(Vec::new, extract_exports_subdirectories)
    }

    /// Extract workspace patterns from package.json.
    #[must_use]
    pub fn workspace_patterns(&self) -> Vec<String> {
        match &self.workspaces {
            Some(serde_json::Value::Array(arr)) => arr
                .iter()
                .filter_map(|v| v.as_str().map(String::from))
                .collect(),
            Some(serde_json::Value::Object(obj)) => obj
                .get("packages")
                .and_then(|v| v.as_array())
                .map(|arr| {
                    arr.iter()
                        .filter_map(|v| v.as_str().map(String::from))
                        .collect()
                })
                .unwrap_or_default(),
            _ => Vec::new(),
        }
    }
}

/// Extract unique subdirectory names referenced by the `exports` field keys.
///
/// For exports like `"./compat": { ... }`, `"./hooks/client": { ... }`,
/// this returns `["compat", "hooks"]`. Used to discover sub-packages in
/// projects that use the exports map to define their internal package structure
/// (e.g., preact with `compat/`, `hooks/`, `debug/` sub-packages).
fn extract_exports_subdirectories(exports: &serde_json::Value) -> Vec<String> {
    let Some(map) = exports.as_object() else {
        return Vec::new();
    };

    let skip_dirs = ["dist", "build", "out", "esm", "cjs", "lib", "node_modules"];
    let mut dirs = rustc_hash::FxHashSet::default();

    for key in map.keys() {
        let stripped = key.strip_prefix("./").unwrap_or(key);
        if let Some(first_segment) = stripped.split('/').next()
            && !first_segment.is_empty()
            && first_segment != "."
            && first_segment != "package.json"
            && !skip_dirs.contains(&first_segment)
        {
            dirs.insert(first_segment.to_owned());
        }
    }

    dirs.into_iter().collect()
}

/// Recursively extract file paths from package.json exports field.
fn extract_exports_entries(value: &serde_json::Value, entries: &mut Vec<String>) {
    match value {
        serde_json::Value::String(s) if s.starts_with("./") || s.starts_with("../") => {
            entries.push(s.clone());
        }
        serde_json::Value::Object(map) => {
            for v in map.values() {
                extract_exports_entries(v, entries);
            }
        }
        serde_json::Value::Array(arr) => {
            for v in arr {
                extract_exports_entries(v, entries);
            }
        }
        _ => {}
    }
}

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

    #[test]
    fn package_json_workspace_patterns_array() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"workspaces": ["packages/*", "apps/*"]}"#).unwrap();
        let patterns = pkg.workspace_patterns();
        assert_eq!(patterns, vec!["packages/*", "apps/*"]);
    }

    #[test]
    fn package_json_workspace_patterns_object() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"workspaces": {"packages": ["packages/*"]}}"#).unwrap();
        let patterns = pkg.workspace_patterns();
        assert_eq!(patterns, vec!["packages/*"]);
    }

    #[test]
    fn package_json_workspace_patterns_none() {
        let pkg: PackageJson = serde_json::from_str(r#"{"name": "test"}"#).unwrap();
        let patterns = pkg.workspace_patterns();
        assert!(patterns.is_empty());
    }

    #[test]
    fn package_json_workspace_patterns_empty_array() {
        let pkg: PackageJson = serde_json::from_str(r#"{"workspaces": []}"#).unwrap();
        let patterns = pkg.workspace_patterns();
        assert!(patterns.is_empty());
    }

    #[test]
    fn package_json_load_valid() {
        let temp_dir = std::env::temp_dir().join("fallow-test-pkg-json");
        let _ = std::fs::create_dir_all(&temp_dir);
        let pkg_path = temp_dir.join("package.json");
        std::fs::write(&pkg_path, r#"{"name": "test", "main": "index.js"}"#).unwrap();

        let pkg = PackageJson::load(&pkg_path).unwrap();
        assert_eq!(pkg.name, Some("test".to_string()));
        assert_eq!(pkg.main, Some("index.js".to_string()));

        let _ = std::fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn package_json_private_non_bool_values_are_ignored() {
        for raw in [
            r#"{"private": "true"}"#,
            r#"{"private": 1}"#,
            r#"{"private": null}"#,
        ] {
            let pkg: PackageJson = serde_json::from_str(raw).unwrap();
            assert_eq!(pkg.private, None);
        }

        let pkg: PackageJson = serde_json::from_str(r#"{"private": true}"#).unwrap();
        assert_eq!(pkg.private, Some(true));

        let pkg: PackageJson = serde_json::from_str(r#"{"private": false}"#).unwrap();
        assert_eq!(pkg.private, Some(false));
    }

    #[test]
    fn package_json_files_preserves_string_array_values() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"files": ["index.js", "template-*", "dist"]}"#).unwrap();
        assert_eq!(pkg.files, vec!["index.js", "template-*", "dist"]);
    }

    #[test]
    fn package_json_files_missing_or_unexpected_shapes_are_ignored() {
        let pkg: PackageJson = serde_json::from_str(r#"{"name": "pkg"}"#).unwrap();
        assert!(pkg.files.is_empty());

        let pkg: PackageJson = serde_json::from_str(r#"{"files": "dist"}"#).unwrap();
        assert!(pkg.files.is_empty());

        let pkg: PackageJson =
            serde_json::from_str(r#"{"files": ["template-*", 42, false, null]}"#).unwrap();
        assert_eq!(pkg.files, vec!["template-*"]);
    }

    #[test]
    fn package_json_napi_config_preserves_current_string_fields() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
                "napi": {
                    "binaryName": "srcmap-codec",
                    "packageName": "@srcmap/codec",
                    "targets": [
                        "aarch64-apple-darwin",
                        "x86_64-unknown-linux-gnu"
                    ]
                }
            }"#,
        )
        .unwrap();

        let napi = pkg.napi.expect("napi config");
        assert_eq!(napi.binary_name.as_deref(), Some("srcmap-codec"));
        assert_eq!(napi.package_name.as_deref(), Some("@srcmap/codec"));
        assert_eq!(
            napi.targets,
            vec![
                "aarch64-apple-darwin".to_string(),
                "x86_64-unknown-linux-gnu".to_string()
            ]
        );
    }

    #[test]
    fn package_json_napi_config_ignores_unexpected_shapes() {
        let pkg: PackageJson = serde_json::from_str(r#"{"napi": "enabled"}"#).unwrap();
        assert!(pkg.napi.is_none());

        let pkg: PackageJson = serde_json::from_str(
            r#"{
                "napi": {
                    "binaryName": 42,
                    "packageName": "",
                    "targets": ["x86_64-apple-darwin", false, null]
                }
            }"#,
        )
        .unwrap();

        let napi = pkg.napi.expect("napi config");
        assert!(napi.binary_name.is_none());
        assert!(napi.package_name.is_none());
        assert_eq!(napi.targets, vec!["x86_64-apple-darwin"]);
    }

    #[test]
    fn package_json_load_missing_file() {
        let result = PackageJson::load(std::path::Path::new("/nonexistent/package.json"));
        assert!(result.is_err());
    }

    #[test]
    fn package_json_entry_points_combined() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "main": "dist/index.js",
            "module": "dist/index.mjs",
            "types": "dist/index.d.ts",
            "typings": "dist/types.d.ts"
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert_eq!(entries.len(), 4);
        assert!(entries.contains(&"dist/index.js".to_string()));
        assert!(entries.contains(&"dist/index.mjs".to_string()));
        assert!(entries.contains(&"dist/index.d.ts".to_string()));
        assert!(entries.contains(&"dist/types.d.ts".to_string()));
    }

    #[test]
    fn package_json_exports_nested() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "exports": {
                ".": {
                    "import": "./dist/index.mjs",
                    "require": "./dist/index.cjs"
                },
                "./utils": {
                    "import": "./dist/utils.mjs"
                }
            }
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"./dist/index.mjs".to_string()));
        assert!(entries.contains(&"./dist/index.cjs".to_string()));
        assert!(entries.contains(&"./dist/utils.mjs".to_string()));
    }

    #[test]
    fn package_json_exports_array() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "exports": {
                ".": ["./dist/index.mjs", "./dist/index.cjs"]
            }
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"./dist/index.mjs".to_string()));
        assert!(entries.contains(&"./dist/index.cjs".to_string()));
    }

    #[test]
    fn extract_exports_ignores_non_relative() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "exports": {
                ".": "not-a-relative-path"
            }
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.is_empty());
    }

    #[test]
    fn package_json_source_field() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "main": "dist/index.js",
            "source": "src/index.ts"
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"src/index.ts".to_string()));
        assert!(entries.contains(&"dist/index.js".to_string()));
    }

    #[test]
    fn package_json_browser_field_string() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "browser": "./dist/browser.js"
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"./dist/browser.js".to_string()));
    }

    #[test]
    fn package_json_browser_field_object() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "browser": {
                "./server.js": "./browser.js",
                "module-name": false
            }
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"./browser.js".to_string()));
        assert_eq!(entries.len(), 1);
    }

    #[test]
    fn package_json_exports_string() {
        let pkg: PackageJson = serde_json::from_str(r#"{"exports": "./dist/index.js"}"#).unwrap();
        let entries = pkg.entry_points();
        assert_eq!(entries, vec!["./dist/index.js"]);
    }

    #[test]
    fn package_json_workspace_patterns_object_with_nohoist() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "workspaces": {
                "packages": ["packages/*", "apps/*"],
                "nohoist": ["**/react-native"]
            }
        }"#,
        )
        .unwrap();
        let patterns = pkg.workspace_patterns();
        assert_eq!(patterns, vec!["packages/*", "apps/*"]);
    }

    #[test]
    fn package_json_missing_optional_fields() {
        let pkg: PackageJson = serde_json::from_str(r"{}").unwrap();
        assert!(pkg.name.is_none());
        assert!(pkg.main.is_none());
        assert!(pkg.module.is_none());
        assert!(pkg.types.is_none());
        assert!(pkg.typings.is_none());
        assert!(pkg.source.is_none());
        assert!(pkg.browser.is_none());
        assert!(pkg.bin.is_none());
        assert!(pkg.exports.is_none());
        assert!(pkg.dependencies.is_none());
        assert!(pkg.dev_dependencies.is_none());
        assert!(pkg.peer_dependencies.is_none());
        assert!(pkg.peer_dependencies_meta.is_none());
        assert!(pkg.optional_dependencies.is_none());
        assert!(pkg.scripts.is_none());
        assert!(pkg.workspaces.is_none());
        assert!(pkg.entry_points().is_empty());
        assert!(pkg.workspace_patterns().is_empty());
        assert!(pkg.all_dependency_names().is_empty());
    }

    #[test]
    fn package_json_all_dependency_names() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "dependencies": {"react": "^18", "react-dom": "^18"},
            "devDependencies": {"typescript": "^5"},
            "peerDependencies": {"node": ">=18"},
            "optionalDependencies": {"fsevents": "^2"}
        }"#,
        )
        .unwrap();
        let deps = pkg.all_dependency_names();
        assert_eq!(deps.len(), 5);
        assert!(deps.contains(&"react".to_string()));
        assert!(deps.contains(&"react-dom".to_string()));
        assert!(deps.contains(&"typescript".to_string()));
        assert!(deps.contains(&"node".to_string()));
        assert!(deps.contains(&"fsevents".to_string()));
    }

    #[test]
    fn package_json_production_dependency_names() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "dependencies": {"react": "^18"},
            "devDependencies": {"typescript": "^5"}
        }"#,
        )
        .unwrap();
        let prod = pkg.production_dependency_names();
        assert_eq!(prod, vec!["react"]);
        let dev = pkg.dev_dependency_names();
        assert_eq!(dev, vec!["typescript"]);
    }

    #[test]
    fn package_json_bin_field_string() {
        let pkg: PackageJson = serde_json::from_str(r#"{"bin": "./cli.js"}"#).unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"./cli.js".to_string()));
    }

    #[test]
    fn package_json_bin_field_object() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{"bin": {"my-cli": "./bin/cli.js", "my-tool": "./bin/tool.js"}}"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert!(entries.contains(&"./bin/cli.js".to_string()));
        assert!(entries.contains(&"./bin/tool.js".to_string()));
    }

    #[test]
    fn package_json_exports_deeply_nested() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "exports": {
                ".": {
                    "node": {
                        "import": "./dist/node.mjs",
                        "require": "./dist/node.cjs"
                    },
                    "browser": {
                        "import": "./dist/browser.mjs"
                    }
                }
            }
        }"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert_eq!(entries.len(), 3);
        assert!(entries.contains(&"./dist/node.mjs".to_string()));
        assert!(entries.contains(&"./dist/node.cjs".to_string()));
        assert!(entries.contains(&"./dist/browser.mjs".to_string()));
    }

    #[test]
    fn package_json_peer_deps_only() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"peerDependencies": {"react": "^18", "react-dom": "^18"}}"#)
                .unwrap();
        let all = pkg.all_dependency_names();
        assert_eq!(all.len(), 2);
        assert!(all.contains(&"react".to_string()));
        assert!(all.contains(&"react-dom".to_string()));

        assert!(pkg.production_dependency_names().is_empty());
        assert!(pkg.dev_dependency_names().is_empty());
    }

    #[test]
    fn package_json_required_peer_dependency_names_excludes_optional_peers() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "peerDependencies": {"react": "^18", "typescript": "^5"},
            "peerDependenciesMeta": {"typescript": {"optional": true}}
        }"#,
        )
        .unwrap();
        assert_eq!(pkg.required_peer_dependency_names(), vec!["react"]);
    }

    #[test]
    fn package_json_optional_deps_in_all_names() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"optionalDependencies": {"fsevents": "^2"}}"#).unwrap();
        let all = pkg.all_dependency_names();
        assert!(all.contains(&"fsevents".to_string()));
    }

    #[test]
    fn package_json_browser_array_ignored() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"browser": ["./a.js", "./b.js"]}"#).unwrap();
        let entries = pkg.entry_points();
        assert!(
            entries.is_empty(),
            "array browser field should not produce entries"
        );
    }

    #[test]
    fn package_json_browser_object_non_relative_skipped() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{"browser": {"crypto": false, "./local.js": "./browser-local.js"}}"#,
        )
        .unwrap();
        let entries = pkg.entry_points();
        assert_eq!(entries.len(), 1);
        assert!(entries.contains(&"./browser-local.js".to_string()));
    }

    #[test]
    fn package_json_exports_null_value() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"exports": {".": "./dist/index.js", "./internal": null}}"#)
                .unwrap();
        let entries = pkg.entry_points();
        assert_eq!(entries.len(), 1);
        assert!(entries.contains(&"./dist/index.js".to_string()));
    }

    #[test]
    fn package_json_exports_empty_object() {
        let pkg: PackageJson = serde_json::from_str(r#"{"exports": {}}"#).unwrap();
        let entries = pkg.entry_points();
        assert!(entries.is_empty());
    }

    #[test]
    fn package_json_workspace_patterns_string_value_ignored() {
        let pkg: PackageJson = serde_json::from_str(r#"{"workspaces": "packages/*"}"#).unwrap();
        let patterns = pkg.workspace_patterns();
        assert!(patterns.is_empty());
    }

    #[test]
    fn package_json_workspace_patterns_object_missing_packages() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"workspaces": {"nohoist": ["**/react-native"]}}"#).unwrap();
        let patterns = pkg.workspace_patterns();
        assert!(patterns.is_empty());
    }

    #[test]
    fn package_json_load_invalid_json() {
        let temp_dir = std::env::temp_dir().join("fallow-test-invalid-pkg-json");
        let _ = std::fs::create_dir_all(&temp_dir);
        let pkg_path = temp_dir.join("package.json");
        std::fs::write(&pkg_path, "{ not valid json }").unwrap();

        let result = PackageJson::load(&pkg_path);
        assert!(result.is_err());
        let err = result.unwrap_err();
        assert!(err.contains("Failed to parse"), "got: {err}");

        let _ = std::fs::remove_dir_all(&temp_dir);
    }

    #[test]
    fn package_json_bin_object_non_string_values_skipped() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"bin": {"cli": "./bin/cli.js", "bad": 42}}"#).unwrap();
        let entries = pkg.entry_points();
        assert_eq!(entries.len(), 1);
        assert!(entries.contains(&"./bin/cli.js".to_string()));
    }

    #[test]
    fn package_json_default() {
        let pkg = PackageJson::default();
        assert!(pkg.name.is_none());
        assert!(pkg.main.is_none());
        assert!(pkg.entry_points().is_empty());
        assert!(pkg.all_dependency_names().is_empty());
        assert!(pkg.workspace_patterns().is_empty());
    }

    #[test]
    fn exports_subdirectories_preact_style() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "exports": {
                ".": "./dist/index.js",
                "./compat": { "import": "./compat/dist/compat.mjs" },
                "./hooks": { "import": "./hooks/dist/hooks.mjs" },
                "./debug": { "import": "./debug/dist/debug.mjs" },
                "./jsx-runtime": { "import": "./jsx-runtime/dist/jsx.mjs" },
                "./package.json": "./package.json"
            }
        }"#,
        )
        .unwrap();
        let mut dirs = pkg.exports_subdirectories();
        dirs.sort();
        assert_eq!(dirs, vec!["compat", "debug", "hooks", "jsx-runtime"]);
    }

    #[test]
    fn exports_subdirectories_skips_dist_dirs() {
        let pkg: PackageJson = serde_json::from_str(
            r#"{
            "exports": {
                "./dist/index.js": "./dist/index.js",
                "./build/bundle.js": "./build/bundle.js",
                "./lib/utils": "./lib/utils.js",
                "./compat": "./compat/index.js"
            }
        }"#,
        )
        .unwrap();
        let dirs = pkg.exports_subdirectories();
        assert_eq!(dirs, vec!["compat"]);
    }

    #[test]
    fn exports_subdirectories_no_exports() {
        let pkg: PackageJson = serde_json::from_str(r#"{"main": "index.js"}"#).unwrap();
        assert!(pkg.exports_subdirectories().is_empty());
    }

    #[test]
    fn exports_subdirectories_dot_only() {
        let pkg: PackageJson =
            serde_json::from_str(r#"{"exports": {".": "./dist/index.js"}}"#).unwrap();
        assert!(pkg.exports_subdirectories().is_empty());
    }
}