summaryrefslogtreecommitdiff
path: root/cli/npm
diff options
context:
space:
mode:
Diffstat (limited to 'cli/npm')
-rw-r--r--cli/npm/cache.rs2
-rw-r--r--cli/npm/mod.rs416
-rw-r--r--cli/npm/registry.rs15
-rw-r--r--cli/npm/resolution.rs2
-rw-r--r--cli/npm/resolvers/common.rs89
-rw-r--r--cli/npm/resolvers/global.rs138
-rw-r--r--cli/npm/resolvers/mod.rs158
7 files changed, 392 insertions, 428 deletions
diff --git a/cli/npm/cache.rs b/cli/npm/cache.rs
index a0082fb29..71a82fd51 100644
--- a/cli/npm/cache.rs
+++ b/cli/npm/cache.rs
@@ -18,10 +18,10 @@ use crate::file_fetcher::CacheSetting;
use crate::fs_util;
use crate::progress_bar::ProgressBar;
+use super::registry::NpmPackageVersionDistInfo;
use super::semver::NpmVersion;
use super::tarball::verify_and_extract_tarball;
use super::NpmPackageId;
-use super::NpmPackageVersionDistInfo;
pub const NPM_PACKAGE_SYNC_LOCK_FILENAME: &str = ".deno_sync_lock";
diff --git a/cli/npm/mod.rs b/cli/npm/mod.rs
index 2dd871cff..d60c06f14 100644
--- a/cli/npm/mod.rs
+++ b/cli/npm/mod.rs
@@ -3,422 +3,14 @@
mod cache;
mod registry;
mod resolution;
+mod resolvers;
mod semver;
mod tarball;
-use std::io::ErrorKind;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use deno_ast::ModuleSpecifier;
-use deno_core::anyhow::bail;
-use deno_core::anyhow::Context;
-use deno_core::error::custom_error;
-use deno_core::error::AnyError;
-use deno_core::futures;
-use deno_core::url::Url;
-use deno_runtime::deno_node::DenoDirNpmResolver;
+pub use cache::NpmCache;
+pub use registry::NpmRegistryApi;
pub use resolution::NpmPackageId;
pub use resolution::NpmPackageReference;
pub use resolution::NpmPackageReq;
pub use resolution::NpmResolutionPackage;
-
-use cache::NpmCache;
-use registry::NpmPackageVersionDistInfo;
-use registry::NpmRegistryApi;
-use resolution::NpmResolution;
-
-use crate::deno_dir::DenoDir;
-use crate::file_fetcher::CacheSetting;
-use crate::progress_bar::ProgressBar;
-
-use self::cache::ReadonlyNpmCache;
-use self::resolution::NpmResolutionSnapshot;
-
-/// Information about the local npm package.
-pub struct LocalNpmPackageInfo {
- /// Unique identifier.
- pub id: NpmPackageId,
- /// Local folder path of the npm package.
- pub folder_path: PathBuf,
-}
-
-pub trait NpmPackageResolver {
- /// Resolves an npm package from a Deno module.
- fn resolve_package_from_deno_module(
- &self,
- pkg_req: &NpmPackageReq,
- ) -> Result<LocalNpmPackageInfo, AnyError>;
-
- /// Resolves an npm package from an npm package referrer.
- fn resolve_package_from_package(
- &self,
- name: &str,
- referrer: &ModuleSpecifier,
- ) -> Result<LocalNpmPackageInfo, AnyError>;
-
- /// Resolve the root folder of the package the provided specifier is in.
- ///
- /// This will error when the provided specifier is not in an npm package.
- fn resolve_package_from_specifier(
- &self,
- specifier: &ModuleSpecifier,
- ) -> Result<LocalNpmPackageInfo, AnyError>;
-
- /// Gets if the provided specifier is in an npm package.
- fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
- self.resolve_package_from_specifier(specifier).is_ok()
- }
-}
-
-#[derive(Debug, Clone)]
-pub struct GlobalNpmPackageResolver {
- cache: NpmCache,
- resolution: Arc<NpmResolution>,
- registry_url: Url,
- unstable: bool,
- no_npm: bool,
-}
-
-impl GlobalNpmPackageResolver {
- pub fn from_deno_dir(
- dir: &DenoDir,
- reload: bool,
- cache_setting: CacheSetting,
- unstable: bool,
- no_npm: bool,
- progress_bar: ProgressBar,
- ) -> Self {
- Self::from_cache(
- NpmCache::from_deno_dir(dir, cache_setting.clone(), progress_bar.clone()),
- reload,
- cache_setting,
- unstable,
- no_npm,
- progress_bar,
- )
- }
-
- fn from_cache(
- cache: NpmCache,
- reload: bool,
- cache_setting: CacheSetting,
- unstable: bool,
- no_npm: bool,
- progress_bar: ProgressBar,
- ) -> Self {
- let api =
- NpmRegistryApi::new(cache.clone(), reload, cache_setting, progress_bar);
- let registry_url = api.base_url().to_owned();
- let resolution = Arc::new(NpmResolution::new(api));
-
- Self {
- cache,
- resolution,
- registry_url,
- unstable,
- no_npm,
- }
- }
-
- /// If the resolver has resolved any npm packages.
- pub fn has_packages(&self) -> bool {
- self.resolution.has_packages()
- }
-
- /// Adds a package requirement to the resolver.
- pub async fn add_package_reqs(
- &self,
- packages: Vec<NpmPackageReq>,
- ) -> Result<(), AnyError> {
- assert!(!packages.is_empty());
-
- if !self.unstable {
- bail!(
- "Unstable use of npm specifiers. The --unstable flag must be provided."
- )
- }
-
- if self.no_npm {
- let fmt_reqs = packages
- .iter()
- .map(|p| format!("\"{}\"", p))
- .collect::<Vec<_>>()
- .join(", ");
- return Err(custom_error(
- "NoNpm",
- format!(
- "Following npm specifiers were requested: {}; but --no-npm is specified.",
- fmt_reqs
- ),
- ));
- }
- self.resolution.add_package_reqs(packages).await
- }
-
- /// Caches all the packages in parallel.
- pub async fn cache_packages(&self) -> Result<(), AnyError> {
- if std::env::var("DENO_UNSTABLE_NPM_SYNC_DOWNLOAD") == Ok("1".to_string()) {
- // for some of the tests, we want downloading of packages
- // to be deterministic so that the output is always the same
- let mut packages = self.resolution.all_packages();
- packages.sort_by(|a, b| a.id.cmp(&b.id));
- for package in packages {
- self
- .cache
- .ensure_package(&package.id, &package.dist, &self.registry_url)
- .await
- .with_context(|| {
- format!("Failed caching npm package '{}'.", package.id)
- })?;
- }
- } else {
- let handles = self.resolution.all_packages().into_iter().map(|package| {
- let cache = self.cache.clone();
- let registry_url = self.registry_url.clone();
- tokio::task::spawn(async move {
- cache
- .ensure_package(&package.id, &package.dist, &registry_url)
- .await
- .with_context(|| {
- format!("Failed caching npm package '{}'.", package.id)
- })
- })
- });
- let results = futures::future::join_all(handles).await;
- for result in results {
- // surface the first error
- result??;
- }
- }
- Ok(())
- }
-
- fn local_package_info(&self, id: &NpmPackageId) -> LocalNpmPackageInfo {
- LocalNpmPackageInfo {
- folder_path: self.cache.package_folder(id, &self.registry_url),
- id: id.clone(),
- }
- }
-
- /// Creates an inner clone.
- #[allow(unused)]
- pub fn snapshot(&self) -> NpmPackageResolverSnapshot {
- NpmPackageResolverSnapshot {
- cache: self.cache.as_readonly(),
- snapshot: self.resolution.snapshot(),
- registry_url: self.registry_url.clone(),
- }
- }
-
- pub fn get_cache_location(&self) -> PathBuf {
- self.cache.as_readonly().get_cache_location()
- }
-}
-
-impl NpmPackageResolver for GlobalNpmPackageResolver {
- fn resolve_package_from_deno_module(
- &self,
- pkg_req: &NpmPackageReq,
- ) -> Result<LocalNpmPackageInfo, AnyError> {
- let pkg = self.resolution.resolve_package_from_deno_module(pkg_req)?;
- Ok(self.local_package_info(&pkg.id))
- }
-
- fn resolve_package_from_package(
- &self,
- name: &str,
- referrer: &ModuleSpecifier,
- ) -> Result<LocalNpmPackageInfo, AnyError> {
- let referrer_pkg_id = self
- .cache
- .resolve_package_id_from_specifier(referrer, &self.registry_url)?;
- let pkg = self
- .resolution
- .resolve_package_from_package(name, &referrer_pkg_id)?;
- Ok(self.local_package_info(&pkg.id))
- }
-
- fn resolve_package_from_specifier(
- &self,
- specifier: &ModuleSpecifier,
- ) -> Result<LocalNpmPackageInfo, AnyError> {
- let pkg_id = self
- .cache
- .resolve_package_id_from_specifier(specifier, &self.registry_url)?;
- Ok(self.local_package_info(&pkg_id))
- }
-}
-
-#[derive(Clone, Debug)]
-pub struct NpmPackageResolverSnapshot {
- cache: ReadonlyNpmCache,
- snapshot: NpmResolutionSnapshot,
- registry_url: Url,
-}
-
-// todo(dsherret): implementing Default for this is error prone, but
-// necessary for the LSP. We should remove this Default implementation.
-// See comment on `ReadonlyNpmCache` for more details.
-impl Default for NpmPackageResolverSnapshot {
- fn default() -> Self {
- Self {
- cache: Default::default(),
- snapshot: Default::default(),
- registry_url: NpmRegistryApi::default_url(),
- }
- }
-}
-
-impl NpmPackageResolverSnapshot {
- fn local_package_info(&self, id: &NpmPackageId) -> LocalNpmPackageInfo {
- LocalNpmPackageInfo {
- folder_path: self.cache.package_folder(id, &self.registry_url),
- id: id.clone(),
- }
- }
-}
-
-impl NpmPackageResolver for NpmPackageResolverSnapshot {
- fn resolve_package_from_deno_module(
- &self,
- pkg_req: &NpmPackageReq,
- ) -> Result<LocalNpmPackageInfo, AnyError> {
- let pkg = self.snapshot.resolve_package_from_deno_module(pkg_req)?;
- Ok(self.local_package_info(&pkg.id))
- }
-
- fn resolve_package_from_package(
- &self,
- name: &str,
- referrer: &ModuleSpecifier,
- ) -> Result<LocalNpmPackageInfo, AnyError> {
- let referrer_pkg_id = self
- .cache
- .resolve_package_id_from_specifier(referrer, &self.registry_url)?;
- let pkg = self
- .snapshot
- .resolve_package_from_package(name, &referrer_pkg_id)?;
- Ok(self.local_package_info(&pkg.id))
- }
-
- fn resolve_package_from_specifier(
- &self,
- specifier: &ModuleSpecifier,
- ) -> Result<LocalNpmPackageInfo, AnyError> {
- let pkg_id = self
- .cache
- .resolve_package_id_from_specifier(specifier, &self.registry_url)?;
- Ok(self.local_package_info(&pkg_id))
- }
-}
-
-impl DenoDirNpmResolver for GlobalNpmPackageResolver {
- fn resolve_package_folder_from_package(
- &self,
- specifier: &str,
- referrer: &std::path::Path,
- ) -> Result<PathBuf, AnyError> {
- let referrer = specifier_to_path(referrer)?;
- self
- .resolve_package_from_package(specifier, &referrer)
- .map(|p| p.folder_path)
- }
-
- fn resolve_package_folder_from_path(
- &self,
- path: &Path,
- ) -> Result<PathBuf, AnyError> {
- let specifier = specifier_to_path(path)?;
- self
- .resolve_package_from_specifier(&specifier)
- .map(|p| p.folder_path)
- }
-
- fn in_npm_package(&self, path: &Path) -> bool {
- let specifier = match ModuleSpecifier::from_file_path(path) {
- Ok(p) => p,
- Err(_) => return false,
- };
- self.resolve_package_from_specifier(&specifier).is_ok()
- }
-
- fn ensure_read_permission(&self, path: &Path) -> Result<(), AnyError> {
- let registry_path = self.cache.registry_folder(&self.registry_url);
- ensure_read_permission(&registry_path, path)
- }
-}
-
-impl DenoDirNpmResolver for NpmPackageResolverSnapshot {
- fn resolve_package_folder_from_package(
- &self,
- specifier: &str,
- referrer: &std::path::Path,
- ) -> Result<PathBuf, AnyError> {
- let referrer = specifier_to_path(referrer)?;
- self
- .resolve_package_from_package(specifier, &referrer)
- .map(|p| p.folder_path)
- }
-
- fn resolve_package_folder_from_path(
- &self,
- path: &Path,
- ) -> Result<PathBuf, AnyError> {
- let specifier = specifier_to_path(path)?;
- self
- .resolve_package_from_specifier(&specifier)
- .map(|p| p.folder_path)
- }
-
- fn in_npm_package(&self, path: &Path) -> bool {
- let specifier = match ModuleSpecifier::from_file_path(path) {
- Ok(p) => p,
- Err(_) => return false,
- };
- self.resolve_package_from_specifier(&specifier).is_ok()
- }
-
- fn ensure_read_permission(&self, path: &Path) -> Result<(), AnyError> {
- let registry_path = self.cache.registry_folder(&self.registry_url);
- ensure_read_permission(&registry_path, path)
- }
-}
-
-fn specifier_to_path(path: &Path) -> Result<ModuleSpecifier, AnyError> {
- match ModuleSpecifier::from_file_path(&path) {
- Ok(specifier) => Ok(specifier),
- Err(()) => bail!("Could not convert '{}' to url.", path.display()),
- }
-}
-
-fn ensure_read_permission(
- registry_path: &Path,
- path: &Path,
-) -> Result<(), AnyError> {
- // allow reading if it's in the deno_dir node modules
- if path.starts_with(&registry_path)
- && path
- .components()
- .all(|c| !matches!(c, std::path::Component::ParentDir))
- {
- // todo(dsherret): cache this?
- if let Ok(registry_path) = std::fs::canonicalize(registry_path) {
- match std::fs::canonicalize(path) {
- Ok(path) if path.starts_with(registry_path) => {
- return Ok(());
- }
- Err(e) if e.kind() == ErrorKind::NotFound => {
- return Ok(());
- }
- _ => {} // ignore
- }
- }
- }
-
- Err(deno_core::error::custom_error(
- "PermissionDenied",
- format!("Reading {} is not allowed", path.display()),
- ))
-}
+pub use resolvers::NpmPackageResolver;
diff --git a/cli/npm/registry.rs b/cli/npm/registry.rs
index f5b8b9fc8..4fb926287 100644
--- a/cli/npm/registry.rs
+++ b/cli/npm/registry.rs
@@ -131,21 +131,6 @@ impl NpmRegistryApi {
}
pub fn new(
- cache: NpmCache,
- reload: bool,
- cache_setting: CacheSetting,
- progress_bar: ProgressBar,
- ) -> Self {
- Self::from_base(
- Self::default_url(),
- cache,
- reload,
- cache_setting,
- progress_bar,
- )
- }
-
- pub fn from_base(
base_url: Url,
cache: NpmCache,
reload: bool,
diff --git a/cli/npm/resolution.rs b/cli/npm/resolution.rs
index 8fac92716..4bde3b340 100644
--- a/cli/npm/resolution.rs
+++ b/cli/npm/resolution.rs
@@ -471,6 +471,8 @@ impl NpmResolution {
!self.snapshot.read().packages.is_empty()
}
+ // todo(dsherret): for use in the lsp
+ #[allow(dead_code)]
pub fn snapshot(&self) -> NpmResolutionSnapshot {
self.snapshot.read().clone()
}
diff --git a/cli/npm/resolvers/common.rs b/cli/npm/resolvers/common.rs
new file mode 100644
index 000000000..f0231859a
--- /dev/null
+++ b/cli/npm/resolvers/common.rs
@@ -0,0 +1,89 @@
+use std::path::Path;
+use std::path::PathBuf;
+
+use deno_ast::ModuleSpecifier;
+use deno_core::anyhow::Context;
+use deno_core::error::AnyError;
+use deno_core::futures;
+use deno_core::futures::future::BoxFuture;
+use deno_core::url::Url;
+
+use crate::npm::NpmCache;
+use crate::npm::NpmPackageId;
+use crate::npm::NpmPackageReq;
+use crate::npm::NpmResolutionPackage;
+
+/// Information about the local npm package.
+pub struct LocalNpmPackageInfo {
+ /// Unique identifier.
+ pub id: NpmPackageId,
+ /// Local folder path of the npm package.
+ pub folder_path: PathBuf,
+}
+
+pub trait InnerNpmPackageResolver: Send + Sync {
+ fn resolve_package_from_deno_module(
+ &self,
+ pkg_req: &NpmPackageReq,
+ ) -> Result<LocalNpmPackageInfo, AnyError>;
+
+ fn resolve_package_from_package(
+ &self,
+ name: &str,
+ referrer: &ModuleSpecifier,
+ ) -> Result<LocalNpmPackageInfo, AnyError>;
+
+ fn resolve_package_from_specifier(
+ &self,
+ specifier: &ModuleSpecifier,
+ ) -> Result<LocalNpmPackageInfo, AnyError>;
+
+ fn has_packages(&self) -> bool;
+
+ fn add_package_reqs(
+ &self,
+ packages: Vec<NpmPackageReq>,
+ ) -> BoxFuture<'static, Result<(), AnyError>>;
+
+ fn ensure_read_permission(&self, path: &Path) -> Result<(), AnyError>;
+}
+
+/// Caches all the packages in parallel.
+pub async fn cache_packages(
+ mut packages: Vec<NpmResolutionPackage>,
+ cache: &NpmCache,
+ registry_url: &Url,
+) -> Result<(), AnyError> {
+ if std::env::var("DENO_UNSTABLE_NPM_SYNC_DOWNLOAD") == Ok("1".to_string()) {
+ // for some of the tests, we want downloading of packages
+ // to be deterministic so that the output is always the same
+ packages.sort_by(|a, b| a.id.cmp(&b.id));
+ for package in packages {
+ cache
+ .ensure_package(&package.id, &package.dist, registry_url)
+ .await
+ .with_context(|| {
+ format!("Failed caching npm package '{}'.", package.id)
+ })?;
+ }
+ } else {
+ let handles = packages.into_iter().map(|package| {
+ let cache = cache.clone();
+ let registry_url = registry_url.clone();
+ tokio::task::spawn(async move {
+ cache
+ .ensure_package(&package.id, &package.dist, &registry_url)
+ .await
+ .with_context(|| {
+ format!("Failed caching npm package '{}'.", package.id)
+ })
+ })
+ });
+ let results = futures::future::join_all(handles).await;
+ for result in results {
+ // surface the first error
+ result??;
+ }
+ }
+ Ok(())
+}
diff --git a/cli/npm/resolvers/global.rs b/cli/npm/resolvers/global.rs
new file mode 100644
index 000000000..259d9b9a0
--- /dev/null
+++ b/cli/npm/resolvers/global.rs
@@ -0,0 +1,138 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+use std::io::ErrorKind;
+use std::path::Path;
+use std::sync::Arc;
+
+use deno_ast::ModuleSpecifier;
+use deno_core::error::AnyError;
+use deno_core::futures::future::BoxFuture;
+use deno_core::futures::FutureExt;
+use deno_core::url::Url;
+
+use crate::npm::resolution::NpmResolution;
+use crate::npm::resolvers::common::cache_packages;
+use crate::npm::NpmCache;
+use crate::npm::NpmPackageId;
+use crate::npm::NpmPackageReq;
+use crate::npm::NpmRegistryApi;
+
+use super::common::InnerNpmPackageResolver;
+use super::common::LocalNpmPackageInfo;
+
+#[derive(Debug, Clone)]
+pub struct GlobalNpmPackageResolver {
+ cache: NpmCache,
+ resolution: Arc<NpmResolution>,
+ registry_url: Url,
+}
+
+impl GlobalNpmPackageResolver {
+ pub fn new(cache: NpmCache, api: NpmRegistryApi) -> Self {
+ let registry_url = api.base_url().to_owned();
+ let resolution = Arc::new(NpmResolution::new(api));
+
+ Self {
+ cache,
+ resolution,
+ registry_url,
+ }
+ }
+
+ fn local_package_info(&self, id: &NpmPackageId) -> LocalNpmPackageInfo {
+ LocalNpmPackageInfo {
+ folder_path: self.cache.package_folder(id, &self.registry_url),
+ id: id.clone(),
+ }
+ }
+}
+
+impl InnerNpmPackageResolver for GlobalNpmPackageResolver {
+ fn resolve_package_from_deno_module(
+ &self,
+ pkg_req: &NpmPackageReq,
+ ) -> Result<LocalNpmPackageInfo, AnyError> {
+ let pkg = self.resolution.resolve_package_from_deno_module(pkg_req)?;
+ Ok(self.local_package_info(&pkg.id))
+ }
+
+ fn resolve_package_from_package(
+ &self,
+ name: &str,
+ referrer: &ModuleSpecifier,
+ ) -> Result<LocalNpmPackageInfo, AnyError> {
+ let referrer_pkg_id = self
+ .cache
+ .resolve_package_id_from_specifier(referrer, &self.registry_url)?;
+ let pkg = self
+ .resolution
+ .resolve_package_from_package(name, &referrer_pkg_id)?;
+ Ok(self.local_package_info(&pkg.id))
+ }
+
+ fn resolve_package_from_specifier(
+ &self,
+ specifier: &ModuleSpecifier,
+ ) -> Result<LocalNpmPackageInfo, AnyError> {
+ let pkg_id = self
+ .cache
+ .resolve_package_id_from_specifier(specifier, &self.registry_url)?;
+ Ok(self.local_package_info(&pkg_id))
+ }
+
+ fn has_packages(&self) -> bool {
+ self.resolution.has_packages()
+ }
+
+ fn add_package_reqs(
+ &self,
+ packages: Vec<NpmPackageReq>,
+ ) -> BoxFuture<'static, Result<(), AnyError>> {
+ let resolver = self.clone();
+ async move {
+ resolver.resolution.add_package_reqs(packages).await?;
+ cache_packages(
+ resolver.resolution.all_packages(),
+ &resolver.cache,
+ &resolver.registry_url,
+ )
+ .await
+ }
+ .boxed()
+ }
+
+ fn ensure_read_permission(&self, path: &Path) -> Result<(), AnyError> {
+ let registry_path = self.cache.registry_folder(&self.registry_url);
+ ensure_read_permission(&registry_path, path)
+ }
+}
+
+fn ensure_read_permission(
+ registry_path: &Path,
+ path: &Path,
+) -> Result<(), AnyError> {
+ // allow reading if it's in the deno_dir node modules
+ if path.starts_with(&registry_path)
+ && path
+ .components()
+ .all(|c| !matches!(c, std::path::Component::ParentDir))
+ {
+ // todo(dsherret): cache this?
+ if let Ok(registry_path) = std::fs::canonicalize(registry_path) {
+ match std::fs::canonicalize(path) {
+ Ok(path) if path.starts_with(registry_path) => {
+ return Ok(());
+ }
+ Err(e) if e.kind() == ErrorKind::NotFound => {
+ return Ok(());
+ }
+ _ => {} // ignore
+ }
+ }
+ }
+
+ Err(deno_core::error::custom_error(
+ "PermissionDenied",
+ format!("Reading {} is not allowed", path.display()),
+ ))
+}
diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
new file mode 100644
index 000000000..02e5be983
--- /dev/null
+++ b/cli/npm/resolvers/mod.rs
@@ -0,0 +1,158 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+mod common;
+mod global;
+
+use deno_core::anyhow::bail;
+use deno_core::error::custom_error;
+use deno_runtime::deno_node::RequireNpmResolver;
+use global::GlobalNpmPackageResolver;
+
+use std::path::Path;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use deno_ast::ModuleSpecifier;
+use deno_core::error::AnyError;
+
+use self::common::InnerNpmPackageResolver;
+use super::NpmCache;
+use super::NpmPackageReq;
+use super::NpmRegistryApi;
+
+pub use self::common::LocalNpmPackageInfo;
+
+#[derive(Clone)]
+pub struct NpmPackageResolver {
+ unstable: bool,
+ no_npm: bool,
+ inner: Arc<dyn InnerNpmPackageResolver>,
+}
+
+impl NpmPackageResolver {
+ pub fn new(
+ cache: NpmCache,
+ api: NpmRegistryApi,
+ unstable: bool,
+ no_npm: bool,
+ ) -> Self {
+ // For now, always create a GlobalNpmPackageResolver, but in the future
+ // this might be a local node_modules folder
+ let inner = Arc::new(GlobalNpmPackageResolver::new(cache, api));
+ Self {
+ unstable,
+ no_npm,
+ inner,
+ }
+ }
+
+ /// Resolves an npm package from a Deno module.
+ pub fn resolve_package_from_deno_module(
+ &self,
+ pkg_req: &NpmPackageReq,
+ ) -> Result<LocalNpmPackageInfo, AnyError> {
+ self.inner.resolve_package_from_deno_module(pkg_req)
+ }
+
+ /// Resolves an npm package from an npm package referrer.
+ pub fn resolve_package_from_package(
+ &self,
+ name: &str,
+ referrer: &ModuleSpecifier,
+ ) -> Result<LocalNpmPackageInfo, AnyError> {
+ self.inner.resolve_package_from_package(name, referrer)
+ }
+
+ /// Resolve the root folder of the package the provided specifier is in.
+ ///
+ /// This will error when the provided specifier is not in an npm package.
+ pub fn resolve_package_from_specifier(
+ &self,
+ specifier: &ModuleSpecifier,
+ ) -> Result<LocalNpmPackageInfo, AnyError> {
+ self.inner.resolve_package_from_specifier(specifier)
+ }
+
+ /// Gets if the provided specifier is in an npm package.
+ pub fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
+ self.resolve_package_from_specifier(specifier).is_ok()
+ }
+
+ /// If the resolver has resolved any npm packages.
+ pub fn has_packages(&self) -> bool {
+ self.inner.has_packages()
+ }
+
+ /// Adds a package requirement to the resolver and ensures everything is setup.
+ pub async fn add_package_reqs(
+ &self,
+ packages: Vec<NpmPackageReq>,
+ ) -> Result<(), AnyError> {
+ assert!(!packages.is_empty());
+
+ if !self.unstable {
+ bail!(
+ "Unstable use of npm specifiers. The --unstable flag must be provided."
+ )
+ }
+
+ if self.no_npm {
+ let fmt_reqs = packages
+ .iter()
+ .map(|p| format!("\"{}\"", p))
+ .collect::<Vec<_>>()
+ .join(", ");
+ return Err(custom_error(
+ "NoNpm",
+ format!(
+ "Following npm specifiers were requested: {}; but --no-npm is specified.",
+ fmt_reqs
+ ),
+ ));
+ }
+
+ self.inner.add_package_reqs(packages).await
+ }
+}
+
+impl RequireNpmResolver for NpmPackageResolver {
+ fn resolve_package_folder_from_package(
+ &self,
+ specifier: &str,
+ referrer: &std::path::Path,
+ ) -> Result<PathBuf, AnyError> {
+ let referrer = specifier_to_path(referrer)?;
+ self
+ .resolve_package_from_package(specifier, &referrer)
+ .map(|p| p.folder_path)
+ }
+
+ fn resolve_package_folder_from_path(
+ &self,
+ path: &Path,
+ ) -> Result<PathBuf, AnyError> {
+ let specifier = specifier_to_path(path)?;
+ self
+ .resolve_package_from_specifier(&specifier)
+ .map(|p| p.folder_path)
+ }
+
+ fn in_npm_package(&self, path: &Path) -> bool {
+ let specifier = match ModuleSpecifier::from_file_path(path) {
+ Ok(p) => p,
+ Err(_) => return false,
+ };
+ self.resolve_package_from_specifier(&specifier).is_ok()
+ }
+
+ fn ensure_read_permission(&self, path: &Path) -> Result<(), AnyError> {
+ self.inner.ensure_read_permission(path)
+ }
+}
+
+fn specifier_to_path(path: &Path) -> Result<ModuleSpecifier, AnyError> {
+ match ModuleSpecifier::from_file_path(&path) {
+ Ok(specifier) => Ok(specifier),
+ Err(()) => bail!("Could not convert '{}' to url.", path.display()),
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 10:25:35 +0000