feat: deno vendor

cli/Cargo.toml

@@ -68,7 +68,7 @@ encoding_rs = "=0.8.29"
 env_logger = "=0.8.4"
 fancy-regex = "=0.7.1"
 http = "=0.2.4"
-import_map = "=0.8.0"
+import_map = "=0.9.0"
 jsonc-parser = { version = "=0.19.0", features = ["serde"] }
 libc = "=0.2.106"
 log = { version = "=0.4.14", features = ["serde"] }

cli/flags.rs

@@ -161,6 +161,13 @@ pub struct UpgradeFlags {
   pub ca_file: Option<String>,
 }
 
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+pub struct VendorFlags {
+  pub specifiers: Vec<String>,
+  pub output_path: Option<PathBuf>,
+  pub force: bool,
+}
+
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub enum DenoSubcommand {
   Bundle(BundleFlags),
@@ -181,6 +188,7 @@ pub enum DenoSubcommand {
   Test(TestFlags),
   Types,
   Upgrade(UpgradeFlags),
+  Vendor(VendorFlags),
 }
 
 impl Default for DenoSubcommand {
@@ -480,6 +488,7 @@ pub fn flags_from_vec(args: Vec<String>) -> clap::Result<Flags> {
     Some(("lint", m)) => lint_parse(&mut flags, m),
     Some(("compile", m)) => compile_parse(&mut flags, m),
     Some(("lsp", m)) => lsp_parse(&mut flags, m),
+    Some(("vendor", m)) => vendor_parse(&mut flags, m),
     _ => handle_repl_flags(&mut flags, ReplFlags { eval: None }),
   }
 
@@ -551,6 +560,7 @@ If the flag is set, restrict these messages to errors.",
     .subcommand(test_subcommand())
     .subcommand(types_subcommand())
     .subcommand(upgrade_subcommand())
+    .subcommand(vendor_subcommand())
     .long_about(DENO_HELP)
     .after_help(ENV_VARIABLES_HELP)
 }
@@ -1400,6 +1410,52 @@ update to a different location, use the --output flag
     .arg(ca_file_arg())
 }
 
+fn vendor_subcommand<'a>() -> App<'a> {
+  App::new("vendor")
+    .about("Vendor remote modules into a local directory")
+    .long_about(
+      "Vendor remote modules into a local directory.
+
+Analyzes the provided modules and their dependencies, downloads remote
+modules to the output directory, and produces an import map that maps
+remote specifiers to the downloaded files.
+
+  deno vendor main.ts
+  deno run --import-map vendor/import_map.json main.ts
+
+Remote modules and multiple modules may also be specified:
+
+  deno vendor main.ts test.deps.ts https://deno.land/std/path/mod.ts",
+    )
+    .arg(
+      Arg::new("specifiers")
+        .takes_value(true)
+        .multiple_values(true)
+        .multiple_occurrences(true)
+        .required(true),
+    )
+    .arg(
+      Arg::new("output")
+        .long("output")
+        .help("The directory to output the vendored modules to")
+        .takes_value(true),
+    )
+    .arg(
+      Arg::new("force")
+        .long("force")
+        .short('f')
+        .help(
+          "Forcefully overwrite conflicting files in existing output directory",
+        )
+        .takes_value(false),
+    )
+    .arg(config_arg())
+    .arg(import_map_arg())
+    .arg(lock_arg())
+    .arg(reload_arg())
+    .arg(ca_file_arg())
+}
+
 fn compile_args(app: App) -> App {
   app
     .arg(import_map_arg())
@@ -2222,6 +2278,23 @@ fn upgrade_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   });
 }
 
+fn vendor_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
+  ca_file_arg_parse(flags, matches);
+  config_arg_parse(flags, matches);
+  import_map_arg_parse(flags, matches);
+  lock_arg_parse(flags, matches);
+  reload_arg_parse(flags, matches);
+
+  flags.subcommand = DenoSubcommand::Vendor(VendorFlags {
+    specifiers: matches
+      .values_of("specifiers")
+      .map(|p| p.map(ToString::to_string).collect())
+      .unwrap_or_default(),
+    output_path: matches.value_of("output").map(PathBuf::from),
+    force: matches.is_present("force"),
+  });
+}
+
 fn compile_args_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   import_map_arg_parse(flags, matches);
   no_remote_arg_parse(flags, matches);
@@ -2428,13 +2501,17 @@ fn no_check_arg_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
 }
 
 fn lock_args_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
+  lock_arg_parse(flags, matches);
+  if matches.is_present("lock-write") {
+    flags.lock_write = true;
+  }
+}
+
+fn lock_arg_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   if matches.is_present("lock") {
     let lockfile = matches.value_of("lock").unwrap();
     flags.lock = Some(PathBuf::from(lockfile));
   }
-  if matches.is_present("lock-write") {
-    flags.lock_write = true;
-  }
 }
 
 fn config_arg_parse(flags: &mut Flags, matches: &ArgMatches) {
@@ -2497,8 +2574,8 @@ mod tests {
 
   /// Creates vector of strings, Vec<String>
   macro_rules! svec {
-    ($($x:expr),*) => (vec![$($x.to_string()),*]);
-}
+    ($($x:expr),* $(,)?) => (vec![$($x.to_string()),*]);
+  }
 
   #[test]
   fn global_flags() {
@@ -4855,4 +4932,55 @@ mod tests {
       .contains("error: The following required arguments were not provided:"));
     assert!(&error_message.contains("--watch=<FILES>..."));
   }
+
+  #[test]
+  fn vendor_minimal() {
+    let r = flags_from_vec(svec!["deno", "vendor", "mod.ts",]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Vendor(VendorFlags {
+          specifiers: svec!["mod.ts"],
+          force: false,
+          output_path: None,
+        }),
+        ..Flags::default()
+      }
+    );
+  }
+
+  #[test]
+  fn vendor_all() {
+    let r = flags_from_vec(svec![
+      "deno",
+      "vendor",
+      "--config",
+      "deno.json",
+      "--import-map",
+      "import_map.json",
+      "--lock",
+      "lock.json",
+      "--force",
+      "--output",
+      "out_dir",
+      "--reload",
+      "mod.ts",
+      "deps.test.ts",
+    ]);
+    assert_eq!(
+      r.unwrap(),
+      Flags {
+        subcommand: DenoSubcommand::Vendor(VendorFlags {
+          specifiers: svec!["mod.ts", "deps.test.ts"],
+          force: true,
+          output_path: Some(PathBuf::from("out_dir")),
+        }),
+        config_path: Some("deno.json".to_string()),
+        import_map_path: Some("import_map.json".to_string()),
+        lock: Some(PathBuf::from("lock.json")),
+        reload: true,
+        ..Flags::default()
+      }
+    );
+  }
 }

cli/fs_util.rs

@@ -362,6 +362,32 @@ pub fn path_has_trailing_slash(path: &Path) -> bool {
   }
 }
 
+/// Gets a path with the specified file stem suffix.
+pub fn path_with_stem_suffix(path: &Path, suffix: &str) -> PathBuf {
+  if let Some(file_name) = path.file_name().map(|f| f.to_string_lossy()) {
+    if let Some(file_stem) = path.file_stem().map(|f| f.to_string_lossy()) {
+      if let Some(ext) = path.extension().map(|f| f.to_string_lossy()) {
+        return if file_stem.to_lowercase().ends_with(".d") {
+          path.with_file_name(format!(
+            "{}_{}.{}.{}",
+            &file_stem[..file_stem.len() - ".d".len()],
+            suffix,
+            // maintain casing
+            &file_stem[file_stem.len() - "d".len()..],
+            ext
+          ))
+        } else {
+          path.with_file_name(format!("{}{}.{}", file_stem, suffix, ext))
+        };
+      }
+    }
+
+    path.with_file_name(format!("{}{}", file_name, suffix))
+  } else {
+    path.with_file_name(suffix)
+  }
+}
+
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -730,4 +756,44 @@ mod tests {
       assert_eq!(result, expected);
     }
   }
+
+  #[test]
+  fn test_path_with_stem_suffix() {
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/"), "_2"),
+      PathBuf::from("/_2")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test"), "_2"),
+      PathBuf::from("/test_2")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test.txt"), "_2"),
+      PathBuf::from("/test_2.txt")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test/subdir"), "_2"),
+      PathBuf::from("/test/subdir_2")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test/subdir.other.txt"), "_2"),
+      PathBuf::from("/test/subdir.other_2.txt")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test.d.ts"), "_2"),
+      PathBuf::from("/test_2.d.ts")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test.D.TS"), "_2"),
+      PathBuf::from("/test_2.D.TS")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test.d.mts"), "_2"),
+      PathBuf::from("/test_2.d.mts")
+    );
+    assert_eq!(
+      path_with_stem_suffix(&PathBuf::from("/test.d.cts"), "_2"),
+      PathBuf::from("/test_2.d.cts")
+    );
+  }
 }

cli/main.rs

@@ -58,6 +58,7 @@ use crate::flags::RunFlags;
 use crate::flags::TestFlags;
 use crate::flags::UninstallFlags;
 use crate::flags::UpgradeFlags;
+use crate::flags::VendorFlags;
 use crate::fmt_errors::PrettyJsError;
 use crate::graph_util::graph_lock_or_exit;
 use crate::graph_util::graph_valid;
@@ -1298,6 +1299,15 @@ async fn upgrade_command(
   Ok(0)
 }
 
+async fn vendor_command(
+  flags: Flags,
+  vendor_flags: VendorFlags,
+) -> Result<i32, AnyError> {
+  let ps = ProcState::build(Arc::new(flags)).await?;
+  tools::vendor::vendor(ps, vendor_flags).await?;
+  Ok(0)
+}
+
 fn init_v8_flags(v8_flags: &[String]) {
   let v8_flags_includes_help = v8_flags
     .iter()
@@ -1376,6 +1386,9 @@ fn get_subcommand(
     DenoSubcommand::Upgrade(upgrade_flags) => {
       upgrade_command(flags, upgrade_flags).boxed_local()
     }
+    DenoSubcommand::Vendor(vendor_flags) => {
+      vendor_command(flags, vendor_flags).boxed_local()
+    }
   }
 }
 

cli/tests/integration/mod.rs

@@ -84,6 +84,8 @@ mod run;
 mod test;
 #[path = "upgrade_tests.rs"]
 mod upgrade;
+#[path = "vendor_tests.rs"]
+mod vendor;
 #[path = "watcher_tests.rs"]
 mod watcher;
 #[path = "worker_tests.rs"]