feat(compile): unstable npm and node specifier support (#19005)

This is the initial support for npm and node specifiers in `deno
compile`. The npm packages are included in the binary and read from it via
a virtual file system. This also supports the `--node-modules-dir` flag,
dependencies specified in a package.json, and npm binary commands (ex.
`deno compile --unstable npm:cowsay`)

Closes #16632

cli/factory.rs

@@ -1,9 +1,11 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use crate::args::npm_pkg_req_ref_to_binary_command;
 use crate::args::CliOptions;
 use crate::args::DenoSubcommand;
 use crate::args::Flags;
 use crate::args::Lockfile;
+use crate::args::PackageJsonDepsProvider;
 use crate::args::StorageKeyResolver;
 use crate::args::TsConfigType;
 use crate::cache::Caches;
@@ -30,6 +32,7 @@ use crate::npm::NpmCache;
 use crate::npm::NpmResolution;
 use crate::npm::PackageJsonDepsInstaller;
 use crate::resolver::CliGraphResolver;
+use crate::standalone::DenoCompileBinaryWriter;
 use crate::tools::check::TypeChecker;
 use crate::util::progress_bar::ProgressBar;
 use crate::util::progress_bar::ProgressBarStyle;
@@ -151,6 +154,7 @@ struct CliFactoryServices {
   npm_cache: Deferred<Arc<NpmCache>>,
   npm_resolver: Deferred<Arc<CliNpmResolver>>,
   npm_resolution: Deferred<Arc<NpmResolution>>,
+  package_json_deps_provider: Deferred<Arc<PackageJsonDepsProvider>>,
   package_json_deps_installer: Deferred<Arc<PackageJsonDepsInstaller>>,
   text_only_progress_bar: Deferred<ProgressBar>,
   type_checker: Deferred<Arc<TypeChecker>>,
@@ -301,8 +305,9 @@ impl CliFactory {
       .npm_resolver
       .get_or_try_init_async(async {
         let npm_resolution = self.npm_resolution().await?;
+        let fs = self.fs().clone();
         let npm_fs_resolver = create_npm_fs_resolver(
-          self.fs().clone(),
+          fs.clone(),
           self.npm_cache()?.clone(),
           self.text_only_progress_bar(),
           CliNpmRegistryApi::default_url().to_owned(),
@@ -310,6 +315,7 @@ impl CliFactory {
           self.options.node_modules_dir_path(),
         );
         Ok(Arc::new(CliNpmResolver::new(
+          fs.clone(),
           npm_resolution.clone(),
           npm_fs_resolver,
           self.maybe_lockfile().as_ref().cloned(),
@@ -318,6 +324,14 @@ impl CliFactory {
       .await
   }
 
+  pub fn package_json_deps_provider(&self) -> &Arc<PackageJsonDepsProvider> {
+    self.services.package_json_deps_provider.get_or_init(|| {
+      Arc::new(PackageJsonDepsProvider::new(
+        self.options.maybe_package_json_deps(),
+      ))
+    })
+  }
+
   pub async fn package_json_deps_installer(
     &self,
   ) -> Result<&Arc<PackageJsonDepsInstaller>, AnyError> {
@@ -325,12 +339,10 @@ impl CliFactory {
       .services
       .package_json_deps_installer
       .get_or_try_init_async(async {
-        let npm_api = self.npm_api()?;
-        let npm_resolution = self.npm_resolution().await?;
         Ok(Arc::new(PackageJsonDepsInstaller::new(
-          npm_api.clone(),
-          npm_resolution.clone(),
-          self.options.maybe_package_json_deps(),
+          self.package_json_deps_provider().clone(),
+          self.npm_api()?.clone(),
+          self.npm_resolution().await?.clone(),
         )))
       })
       .await
@@ -365,6 +377,7 @@ impl CliFactory {
           self.options.no_npm(),
           self.npm_api()?.clone(),
           self.npm_resolution().await?.clone(),
+          self.package_json_deps_provider().clone(),
           self.package_json_deps_installer().await?.clone(),
         )))
       })
@@ -535,6 +548,21 @@ impl CliFactory {
     self.services.cjs_resolutions.get_or_init(Default::default)
   }
 
+  pub async fn create_compile_binary_writer(
+    &self,
+  ) -> Result<DenoCompileBinaryWriter, AnyError> {
+    Ok(DenoCompileBinaryWriter::new(
+      self.file_fetcher()?,
+      self.http_client(),
+      self.deno_dir()?,
+      self.npm_api()?,
+      self.npm_cache()?,
+      self.npm_resolver().await?,
+      self.npm_resolution().await?,
+      self.package_json_deps_provider(),
+    ))
+  }
+
   /// Gets a function that can be used to create a CliMainWorkerFactory
   /// for a file watcher.
   pub async fn create_cli_main_worker_factory_func(
@@ -572,6 +600,7 @@ impl CliFactory {
           NpmModuleLoader::new(
             cjs_resolutions.clone(),
             node_code_translator.clone(),
+            fs.clone(),
             node_resolver.clone(),
           ),
         )),
@@ -587,6 +616,7 @@ impl CliFactory {
     &self,
   ) -> Result<CliMainWorkerFactory, AnyError> {
     let node_resolver = self.node_resolver().await?;
+    let fs = self.fs();
     Ok(CliMainWorkerFactory::new(
       StorageKeyResolver::from_options(&self.options),
       self.npm_resolver().await?.clone(),
@@ -603,6 +633,7 @@ impl CliFactory {
         NpmModuleLoader::new(
           self.cjs_resolutions().clone(),
           self.node_code_translator().await?.clone(),
+          fs.clone(),
           node_resolver.clone(),
         ),
       )),
@@ -637,11 +668,8 @@ impl CliFactory {
           if let Ok(pkg_ref) = NpmPackageReqReference::from_str(&flags.script) {
             // if the user ran a binary command, we'll need to set process.argv[0]
             // to be the name of the binary command instead of deno
-            let binary_name = pkg_ref
-              .sub_path
-              .as_deref()
-              .unwrap_or(pkg_ref.req.name.as_str());
-            maybe_binary_command_name = Some(binary_name.to_string());
+            maybe_binary_command_name =
+              Some(npm_pkg_req_ref_to_binary_command(&pkg_ref));
           }
         }
         maybe_binary_command_name