fix(vendor): do not panic vendoring with jsxImportSource and no jsx files (#19837)

Closes #19833

1 files changed, 60 insertions, 37 deletions

diff --git a/cli/tools/vendor/test.rs b/cli/tools/vendor/test.rs
index 4bc6941e2..0bf6f84f3 100644
--- a/cli/tools/vendor/test.rs
+++ b/cli/tools/vendor/test.rs
@@ -12,6 +12,7 @@ use deno_core::anyhow::anyhow;
 use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
 use deno_core::futures;
+use deno_core::futures::FutureExt;
 use deno_core::serde_json;
 use deno_graph::source::LoadFuture;
 use deno_graph::source::LoadResponse;
@@ -195,8 +196,12 @@ impl VendorTestBuilder {
     builder
   }
 
+  pub fn resolve_to_url(&self, path: &str) -> ModuleSpecifier {
+    ModuleSpecifier::from_file_path(make_path(path)).unwrap()
+  }
+
   pub fn new_import_map(&self, base_path: &str) -> ImportMap {
-    let base = ModuleSpecifier::from_file_path(make_path(base_path)).unwrap();
+    let base = self.resolve_to_url(base_path);
     ImportMap::new(base)
   }
 
@@ -226,27 +231,42 @@ impl VendorTestBuilder {
 
   pub async fn build(&mut self) -> Result<VendorOutput, AnyError> {
     let output_dir = make_path("/vendor");
-    let roots = self.entry_points.clone();
+    let entry_points = self.entry_points.clone();
     let loader = self.loader.clone();
     let parsed_source_cache = ParsedSourceCache::new_in_memory();
     let analyzer = parsed_source_cache.as_analyzer();
-    let graph = build_test_graph(
-      roots,
+    let resolver = Arc::new(build_resolver(
       self.jsx_import_source_config.clone(),
       self.original_import_map.clone(),
-      loader,
-      &*analyzer,
-    )
-    .await;
-    super::build::build(
-      graph,
-      &parsed_source_cache,
-      &output_dir,
-      self.original_import_map.as_ref(),
-      None,
-      self.jsx_import_source_config.as_ref(),
-      &self.environment,
-    )?;
+    ));
+    super::build::build(super::build::BuildInput {
+      entry_points,
+      build_graph: {
+        let resolver = resolver.clone();
+        move |entry_points| {
+          async move {
+            Ok(
+              build_test_graph(
+                entry_points,
+                loader,
+                resolver.as_graph_resolver(),
+                &*analyzer,
+              )
+              .await,
+            )
+          }
+          .boxed_local()
+        }
+      },
+      parsed_source_cache: &parsed_source_cache,
+      output_dir: &output_dir,
+      maybe_original_import_map: self.original_import_map.as_ref(),
+      maybe_lockfile: None,
+      maybe_jsx_import_source: self.jsx_import_source_config.as_ref(),
+      resolver: resolver.as_graph_resolver(),
+      environment: &self.environment,
+    })
+    .await?;
 
     let mut files = self.environment.files.borrow_mut();
     let import_map = files.remove(&output_dir.join("import_map.json"));
@@ -269,37 +289,40 @@ impl VendorTestBuilder {
   }
 }
 
-async fn build_test_graph(
-  roots: Vec<ModuleSpecifier>,
+fn build_resolver(
   jsx_import_source_config: Option<JsxImportSourceConfig>,
   original_import_map: Option<ImportMap>,
+) -> CliGraphResolver {
+  let npm_registry_api = Arc::new(CliNpmRegistryApi::new_uninitialized());
+  let npm_resolution = Arc::new(NpmResolution::from_serialized(
+    npm_registry_api.clone(),
+    None,
+    None,
+  ));
+  CliGraphResolver::new(
+    jsx_import_source_config,
+    original_import_map.map(Arc::new),
+    false,
+    npm_registry_api,
+    npm_resolution,
+    Default::default(),
+    Default::default(),
+  )
+}
+
+async fn build_test_graph(
+  roots: Vec<ModuleSpecifier>,
   mut loader: TestLoader,
+  resolver: &dyn deno_graph::source::Resolver,
   analyzer: &dyn deno_graph::ModuleAnalyzer,
 ) -> ModuleGraph {
-  let resolver = original_import_map.map(|original_import_map| {
-    let npm_registry_api = Arc::new(CliNpmRegistryApi::new_uninitialized());
-    let npm_resolution = Arc::new(NpmResolution::from_serialized(
-      npm_registry_api.clone(),
-      None,
-      None,
-    ));
-    CliGraphResolver::new(
-      jsx_import_source_config,
-      Some(Arc::new(original_import_map)),
-      false,
-      npm_registry_api,
-      npm_resolution,
-      Default::default(),
-      Default::default(),
-    )
-  });
   let mut graph = ModuleGraph::new(GraphKind::All);
   graph
     .build(
       roots,
       &mut loader,
       deno_graph::BuildOptions {
-        resolver: resolver.as_ref().map(|r| r.as_graph_resolver()),
+        resolver: Some(resolver),
         module_analyzer: Some(analyzer),
         ..Default::default()
       },