Struct PackageJson 

pub struct PackageJson {
    pub name: Option<String>,
    pub version: Option<String>,
    pub dependencies: HashMap<String, String>,
    pub dev_dependencies: HashMap<String, String>,
    pub peer_dependencies: HashMap<String, String>,
    pub optional_dependencies: HashMap<String, String>,
    pub path: PathBuf,
}

Parsed package.json structure.

This focuses on dependency-related fields and omits other metadata like scripts, engines, etc. for simplicity.

Fields

name: Option<String>

Package name

version: Option<String>

Package version

dependencies: HashMap<String, String>

Production dependencies

dev_dependencies: HashMap<String, String>

Development dependencies

peer_dependencies: HashMap<String, String>

Peer dependencies

optional_dependencies: HashMap<String, String>

Optional dependencies

path: PathBuf

File path this was loaded from

Implementations

impl PackageJson

pub async fn from_path<R: Runtime>(runtime: &R, path: &Path) -> Result<Self>

Load package.json from a specific path using the provided runtime.

Security

• Validates the path is within allowed boundaries (prevents path traversal)
• Limits file size to 10MB to prevent DoS
• Uses safe JSON parsing

Example

let pkg = PackageJson::from_path(runtime, &PathBuf::from("./package.json")).await?;
println!("Package: {:?}", pkg.name);

pub async fn from_path_native(path: &Path) -> Result<Self>

👎Deprecated: Use from_path with explicit runtime parameter for better platform compatibility

Load package.json from a specific path (native builds only).

Deprecated

This method is provided for backward compatibility on native builds. For new code, use from_path with an explicit runtime parameter.

Example

let pkg = PackageJson::from_path_native(&PathBuf::from("./package.json")).await?;
println!("Package: {:?}", pkg.name);

pub async fn find_from_dir<R: Runtime>( runtime: &R, start_dir: &Path, ) -> Result<Self>

Find and load package.json starting from a directory using the provided runtime.

Searches upward through parent directories until package.json is found or the filesystem root is reached.

Example

let pkg = PackageJson::find_from_dir(runtime, &PathBuf::from("./src")).await?;
println!("Package: {:?}", pkg.name);

pub async fn find_from_dir_native(start_dir: &Path) -> Result<Self>

👎Deprecated: Use find_from_dir with explicit runtime parameter for better platform compatibility

Find and load package.json starting from a directory (native builds only).

Deprecated

This method is provided for backward compatibility on native builds. For new code, use find_from_dir with an explicit runtime parameter.

Example

let pkg = PackageJson::find_from_dir_native(&PathBuf::from("./src")).await?;
println!("Package: {:?}", pkg.name);

pub fn get_dependencies( &self, dep_type: DependencyType, ) -> &HashMap<String, String>

Get all dependencies of a specific type.

pub fn all_dependency_names( &self, include_dev: bool, include_peer: bool, ) -> Vec<String>

Get all dependency names across all types.

Trait Implementations

impl Clone for PackageJson

fn clone(&self) -> PackageJson

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PackageJson

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PackageJson

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PackageJson

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.