1 files changed, 58 insertions, 31 deletions

diff --git a/cli/compat/esm_resolver.rs b/cli/compat/esm_resolver.rs
index 77dbc3e05..300b76f31 100644
--- a/cli/compat/esm_resolver.rs
+++ b/cli/compat/esm_resolver.rs
@@ -9,6 +9,7 @@ use deno_core::serde_json::Map;
 use deno_core::serde_json::Value;
 use deno_core::url::Url;
 use deno_core::ModuleSpecifier;
+use deno_graph::source::ResolveResponse;
 use deno_graph::source::Resolver;
 use regex::Regex;
 use std::path::PathBuf;
@@ -31,24 +32,28 @@ impl Resolver for NodeEsmResolver {
     &self,
     specifier: &str,
     referrer: &ModuleSpecifier,
-  ) -> Result<ModuleSpecifier, AnyError> {
+  ) -> ResolveResponse {
     // First try to resolve using import map, ignoring any errors
     if !specifier.starts_with("node:") {
       if let Some(import_map_resolver) = &self.maybe_import_map_resolver {
-        if let Ok(specifier) = import_map_resolver.resolve(specifier, referrer)
-        {
-          return Ok(specifier);
+        let response = import_map_resolver.resolve(specifier, referrer);
+        if !matches!(response, ResolveResponse::Err(_)) {
+          return response;
         }
       }
     }
 
+    let current_dir = match std::env::current_dir() {
+      Ok(path) => path,
+      Err(err) => return ResolveResponse::Err(err.into()),
+    };
     let node_resolution =
-      node_resolve(specifier, referrer.as_str(), &std::env::current_dir()?);
+      node_resolve(specifier, referrer.as_str(), &current_dir);
 
     match node_resolution {
-      Ok(specifier) => {
+      Ok(resolve_response) => {
         // If node resolution succeeded, return the specifier
-        Ok(specifier)
+        resolve_response
       }
       Err(err) => {
         // If node resolution failed, check if it's because of unsupported
@@ -57,11 +62,13 @@ impl Resolver for NodeEsmResolver {
           .to_string()
           .starts_with("[ERR_UNSUPPORTED_ESM_URL_SCHEME]")
         {
-          return deno_core::resolve_import(specifier, referrer.as_str())
-            .map_err(|err| err.into());
+          return match deno_core::resolve_import(specifier, referrer.as_str()) {
+            Ok(specifier) => ResolveResponse::Esm(specifier),
+            Err(err) => ResolveResponse::Err(err.into()),
+          };
         }
 
-        Err(err)
+        ResolveResponse::Err(err)
       }
     }
   }
@@ -75,16 +82,16 @@ fn node_resolve(
   specifier: &str,
   referrer: &str,
   cwd: &std::path::Path,
-) -> Result<ModuleSpecifier, AnyError> {
+) -> Result<ResolveResponse, AnyError> {
   // TODO(bartlomieju): skipped "policy" part as we don't plan to support it
 
   if let Some(resolved) = crate::compat::try_resolve_builtin_module(specifier) {
-    return Ok(resolved);
+    return Ok(ResolveResponse::Esm(resolved));
   }
 
   if let Ok(url) = Url::parse(specifier) {
     if url.scheme() == "data" {
-      return Ok(url);
+      return Ok(ResolveResponse::Specifier(url));
     }
 
     let protocol = url.scheme();
@@ -95,7 +102,7 @@ fn node_resolve(
       if let Some(resolved) =
         crate::compat::try_resolve_builtin_module(&specifier)
       {
-        return Ok(resolved);
+        return Ok(ResolveResponse::Esm(resolved));
       } else {
         return Err(generic_error(format!("Unknown module {}", specifier)));
       }
@@ -107,7 +114,8 @@ fn node_resolve(
 
     if referrer.starts_with("data:") {
       let referrer_url = Url::parse(referrer)?;
-      return referrer_url.join(specifier).map_err(AnyError::from);
+      let url = referrer_url.join(specifier).map_err(AnyError::from)?;
+      return Ok(ResolveResponse::Specifier(url));
     }
   }
 
@@ -121,9 +129,23 @@ fn node_resolve(
   let conditions = DEFAULT_CONDITIONS;
   let url = module_resolve(specifier, &parent_url, conditions)?;
 
+  let resolve_response = if url.as_str().starts_with("http") {
+    ResolveResponse::Esm(url)
+  } else if url.as_str().ends_with(".js") {
+    let package_config = get_package_scope_config(&url)?;
+    if package_config.typ == "module" {
+      ResolveResponse::Esm(url)
+    } else {
+      ResolveResponse::CommonJs(url)
+    }
+  } else if url.as_str().ends_with(".cjs") {
+    ResolveResponse::CommonJs(url)
+  } else {
+    ResolveResponse::Esm(url)
+  };
   // TODO(bartlomieju): skipped checking errors for commonJS resolution and
   // "preserveSymlinksMain"/"preserveSymlinks" options.
-  Ok(url)
+  Ok(resolve_response)
 }
 
 fn to_file_path(url: &ModuleSpecifier) -> PathBuf {
@@ -1146,7 +1168,8 @@ mod tests {
     let actual = node_resolve("foo", main.as_str(), &cwd).unwrap();
     let expected =
       Url::from_file_path(cwd.join("node_modules/foo/index.js")).unwrap();
-    assert_eq!(actual, expected);
+    assert!(matches!(actual, ResolveResponse::Esm(_)));
+    assert_eq!(actual.to_result().unwrap(), expected);
 
     let actual = node_resolve(
       "data:application/javascript,console.log(\"Hello%20Deno\");",
@@ -1154,12 +1177,11 @@ mod tests {
       &cwd,
     )
     .unwrap();
-    eprintln!("actual {}", actual);
-    assert_eq!(
-      actual,
+    let expected =
       Url::parse("data:application/javascript,console.log(\"Hello%20Deno\");")
-        .unwrap()
-    );
+        .unwrap();
+    assert!(matches!(actual, ResolveResponse::Specifier(_)));
+    assert_eq!(actual.to_result().unwrap(), expected);
   }
 
   #[test]
@@ -1169,7 +1191,8 @@ mod tests {
     let actual = node_resolve("foo", main.as_str(), &cwd).unwrap();
     let expected =
       Url::from_file_path(cwd.join("node_modules/foo/index.js")).unwrap();
-    assert_eq!(actual, expected);
+    matches!(actual, ResolveResponse::Esm(_));
+    assert_eq!(actual.to_result().unwrap(), expected);
   }
 
   #[test]
@@ -1179,13 +1202,15 @@ mod tests {
     let actual = node_resolve("foo", main.as_str(), &cwd).unwrap();
     let foo_js =
       Url::from_file_path(cwd.join("node_modules/foo/foo.js")).unwrap();
-    assert_eq!(actual, foo_js);
+    assert!(matches!(actual, ResolveResponse::Esm(_)));
+    assert_eq!(actual.to_result().unwrap(), foo_js);
 
     let actual = node_resolve("bar", foo_js.as_str(), &cwd).unwrap();
 
     let bar_js =
       Url::from_file_path(cwd.join("node_modules/bar/bar.js")).unwrap();
-    assert_eq!(actual, bar_js);
+    assert!(matches!(actual, ResolveResponse::Esm(_)));
+    assert_eq!(actual.to_result().unwrap(), bar_js);
   }
 
   #[test]
@@ -1196,12 +1221,12 @@ mod tests {
       Url::parse("https://deno.land/std@0.123.0/node/http.ts").unwrap();
 
     let actual = node_resolve("http", main.as_str(), &cwd).unwrap();
-    println!("actual {}", actual);
-    assert_eq!(actual, expected);
+    assert!(matches!(actual, ResolveResponse::Esm(_)));
+    assert_eq!(actual.to_result().unwrap(), expected);
 
     let actual = node_resolve("node:http", main.as_str(), &cwd).unwrap();
-    println!("actual {}", actual);
-    assert_eq!(actual, expected);
+    assert!(matches!(actual, ResolveResponse::Esm(_)));
+    assert_eq!(actual.to_result().unwrap(), expected);
   }
 
   #[test]
@@ -1214,14 +1239,16 @@ mod tests {
       cwd.join("node_modules/imports_exports/import_export.js"),
     )
     .unwrap();
-    assert_eq!(actual, expected);
+    assert!(matches!(actual, ResolveResponse::CommonJs(_)));
+    assert_eq!(actual.to_result().unwrap(), expected);
 
     // check that `imports` mapping works correctly
     let cwd = testdir("conditions/node_modules/imports_exports");
     let main = Url::from_file_path(cwd.join("import_export.js")).unwrap();
     let actual = node_resolve("#dep", main.as_str(), &cwd).unwrap();
     let expected = Url::from_file_path(cwd.join("import_polyfill.js")).unwrap();
-    assert_eq!(actual, expected);
+    assert!(matches!(actual, ResolveResponse::CommonJs(_)));
+    assert_eq!(actual.to_result().unwrap(), expected);
   }
 
   #[test]