feat: Add support for import assertions and JSON modules

cli/config_file.rs

@@ -104,6 +104,7 @@ pub const IGNORED_COMPILER_OPTIONS: &[&str] = &[
   "paths",
   "preserveConstEnums",
   "reactNamespace",
+  "resolveJsonModule",
   "rootDir",
   "rootDirs",
   "skipLibCheck",

cli/emit.rs

@@ -153,6 +153,7 @@ pub(crate) fn get_ts_config(
         "isolatedModules": true,
         "lib": lib,
         "module": "esnext",
+        "resolveJsonModule": true,
         "strict": true,
         "target": "esnext",
         "tsBuildInfoFile": "deno:///.tsbuildinfo",
@@ -186,6 +187,7 @@ pub(crate) fn get_ts_config(
       "jsx": "react",
       "jsxFactory": "React.createElement",
       "jsxFragmentFactory": "React.Fragment",
+      "resolveJsonModule": true,
     })),
     ConfigType::RuntimeEmit { tsc_emit } => {
       let mut ts_config = TsConfig::new(json!({
@@ -403,14 +405,15 @@ pub(crate) fn check_and_maybe_emit(
           log::debug!("module missing, skipping emit for {}", specifier);
           continue;
         };
-        // Sometimes if `tsc` sees a CommonJS file it will _helpfully_ output it
-        // to ESM, which we don't really want to do unless someone has enabled
-        // check_js.
-        if !check_js
-          && matches!(
-            media_type,
-            MediaType::JavaScript | MediaType::Cjs | MediaType::Mjs
-          )
+        // Sometimes if `tsc` sees a CommonJS file or a JSON module, it will
+        // _helpfully_ output it, which we don't really want to do unless
+        // someone has enabled check_js.
+        if matches!(media_type, MediaType::Json)
+          || (!check_js
+            && matches!(
+              media_type,
+              MediaType::JavaScript | MediaType::Cjs | MediaType::Mjs
+            ))
         {
           log::debug!("skipping emit for {}", specifier);
           continue;
@@ -429,7 +432,10 @@ pub(crate) fn check_and_maybe_emit(
           MediaType::Dts | MediaType::Dcts | MediaType::Dmts => {
             cache.set(CacheType::Declaration, &specifier, emit.data)?;
           }
-          _ => unreachable!(),
+          _ => unreachable!(
+            "unexpected media_type {} {}",
+            emit.media_type, specifier
+          ),
         }
       }
     }

cli/lsp/language_server.rs

@@ -569,6 +569,7 @@ impl Inner {
       "lib": ["deno.ns", "deno.window"],
       "module": "esnext",
       "noEmit": true,
+      "resolveJsonModule": true,
       "strict": true,
       "target": "esnext",
       "useDefineForClassFields": true,

cli/proc_state.rs

@@ -31,6 +31,7 @@ use deno_core::url::Url;
 use deno_core::CompiledWasmModuleStore;
 use deno_core::ModuleSource;
 use deno_core::ModuleSpecifier;
+use deno_core::ModuleType;
 use deno_core::SharedArrayBufferStore;
 use deno_graph::create_graph;
 use deno_graph::Dependency;
@@ -68,6 +69,7 @@ pub struct ProcState(Arc<Inner>);
 enum ModuleEntry {
   Module {
     code: String,
+    media_type: MediaType,
     dependencies: BTreeMap<String, Dependency>,
   },
   Error(ModuleGraphError),
@@ -584,6 +586,7 @@ impl ProcState {
                 | MediaType::Unknown
                 | MediaType::Cjs
                 | MediaType::Mjs
+                | MediaType::Json
             ) {
               module.maybe_source().unwrap_or("").to_string()
             // The emit may also be missing when a declaration file is in the
@@ -602,7 +605,11 @@ impl ProcState {
               module.maybe_dependencies().cloned().unwrap_or_default();
             graph_data.modules.insert(
               specifier.clone(),
-              ModuleEntry::Module { code, dependencies },
+              ModuleEntry::Module {
+                code,
+                dependencies,
+                media_type: *media_type,
+              },
             );
             if let Some(dependencies) = module.maybe_dependencies() {
               for dep in dependencies.values() {
@@ -724,10 +731,16 @@ impl ProcState {
       _ => &specifier,
     };
     match graph_data.modules.get(found_specifier) {
-      Some(ModuleEntry::Module { code, .. }) => Ok(ModuleSource {
+      Some(ModuleEntry::Module {
+        code, media_type, ..
+      }) => Ok(ModuleSource {
         code: code.clone(),
         module_url_specified: specifier.to_string(),
         module_url_found: found_specifier.to_string(),
+        module_type: match media_type {
+          MediaType::Json => ModuleType::Json,
+          _ => ModuleType::JavaScript,
+        },
       }),
       _ => Err(anyhow!(
         "Loading unprepared module: {}",

cli/standalone.rs

@@ -164,6 +164,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
 
       Ok(deno_core::ModuleSource {
         code,
+        module_type: deno_core::ModuleType::JavaScript,
         module_url_specified: module_specifier.to_string(),
         module_url_found: module_specifier.to_string(),
       })

cli/tests/integration/run_tests.rs

@@ -2407,3 +2407,36 @@ fn issue12807() {
     .unwrap();
   assert!(status.success());
 }
+
+itest!(import_assertions_static_import {
+  args: "run --allow-read import_assertions/static_import.ts",
+  output: "import_assertions/static_import.out",
+});
+
+itest!(import_assertions_static_export {
+  args: "run --allow-read import_assertions/static_export.ts",
+  output: "import_assertions/static_export.out",
+});
+
+itest!(import_assertions_static_error {
+  args: "run --allow-read import_assertions/static_error.ts",
+  output: "import_assertions/static_error.out",
+  exit_code: 1,
+});
+
+itest!(import_assertions_dynamic_import {
+  args: "run --allow-read import_assertions/dynamic_import.ts",
+  output: "import_assertions/dynamic_import.out",
+});
+
+itest!(import_assertions_dynamic_error {
+  args: "run --allow-read import_assertions/dynamic_error.ts",
+  output: "import_assertions/dynamic_error.out",
+  exit_code: 1,
+});
+
+itest!(import_assertions_type_check {
+  args: "run --allow-read import_assertions/type_check.ts",
+  output: "import_assertions/type_check.out",
+  exit_code: 1,
+});

cli/tests/testdata/import_assertions/data.json

@@ -0,0 +1,6 @@
+{
+  "a": "b",
+  "c": {
+    "d": 10
+  }
+}

cli/tests/testdata/import_assertions/dynamic_error.out

@@ -0,0 +1,5 @@
+[WILDCARD]
+error: Uncaught (in promise) TypeError: Expected a "JavaScript" module but loaded a "JSON" module.
+const data = await import("./data.json");
+             ^
+    at async [WILDCARD]dynamic_error.ts:1:14

cli/tests/testdata/import_assertions/dynamic_error.ts

@@ -0,0 +1,3 @@
+const data = await import("./data.json");
+
+console.log(data);

cli/tests/testdata/import_assertions/dynamic_import.out

@@ -0,0 +1,2 @@
+[WILDCARD]
+Module { default: { a: "b", c: { d: 10 } } }

cli/tests/testdata/import_assertions/dynamic_import.ts

@@ -0,0 +1,3 @@
+const data = await import("./data.json", { assert: { type: "json" } });
+
+console.log(data);

cli/tests/testdata/import_assertions/static_error.out

@@ -0,0 +1,5 @@
+[WILDCARD]
+error: An unsupported media type was attempted to be imported as a module.
+  Specifier: [WILDCARD]data.json
+  MediaType: Json
+    at [WILDCARD]static_error.ts:1:18

cli/tests/testdata/import_assertions/static_error.ts

@@ -0,0 +1,3 @@
+import data from "./data.json";
+
+console.log(data);

cli/tests/testdata/import_assertions/static_export.out

@@ -0,0 +1,2 @@
+[WILDCARD]
+{ a: "b", c: { d: 10 } }

cli/tests/testdata/import_assertions/static_export.ts

@@ -0,0 +1,3 @@
+import data from "./static_reexport.ts";
+
+console.log(data);

cli/tests/testdata/import_assertions/static_import.out

@@ -0,0 +1,2 @@
+[WILDCARD]
+{ a: "b", c: { d: 10 } }

cli/tests/testdata/import_assertions/static_import.ts

@@ -0,0 +1,3 @@
+import data from "./data.json" assert { type: "json" };
+
+console.log(data);

cli/tests/testdata/import_assertions/static_reexport.ts

@@ -0,0 +1 @@
+export { default } from "./data.json" assert { type: "json" };

cli/tests/testdata/import_assertions/type_check.out

@@ -0,0 +1,5 @@
+[WILDCARD]
+error: TS2339 [ERROR]: Property 'foo' does not exist on type '{ a: string; c: { d: number; }; }'.
+console.log(data.foo);
+                 ~~~
+    at [WILDCARD]type_check.ts:3:18

cli/tests/testdata/import_assertions/type_check.ts

@@ -0,0 +1,3 @@
+import data from "./data.json" assert { type: "json" };
+
+console.log(data.foo);

cli/tsc.rs

@@ -352,6 +352,24 @@ struct LoadArgs {
   specifier: String,
 }
 
+fn as_ts_script_kind(media_type: &MediaType) -> i32 {
+  match media_type {
+    MediaType::JavaScript => 1,
+    MediaType::Jsx => 2,
+    MediaType::Mjs => 1,
+    MediaType::Cjs => 1,
+    MediaType::TypeScript => 3,
+    MediaType::Mts => 3,
+    MediaType::Cts => 3,
+    MediaType::Dts => 3,
+    MediaType::Dmts => 3,
+    MediaType::Dcts => 3,
+    MediaType::Tsx => 4,
+    MediaType::Json => 6,
+    _ => 0,
+  }
+}
+
 fn op_load(state: &mut State, args: Value) -> Result<Value, AnyError> {
   let v: LoadArgs = serde_json::from_value(args)
     .context("Invalid request from JavaScript for \"op_load\".")?;
@@ -395,7 +413,7 @@ fn op_load(state: &mut State, args: Value) -> Result<Value, AnyError> {
   };
 
   Ok(
-    json!({ "data": data, "hash": hash, "scriptKind": media_type.as_ts_script_kind() }),
+    json!({ "data": data, "hash": hash, "scriptKind": as_ts_script_kind(&media_type) }),
   )
 }
 

core/bindings.rs

@@ -1,6 +1,10 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
 use crate::error::is_instance_of_error;
+use crate::modules::get_module_type_from_assertions;
+use crate::modules::parse_import_assertions;
+use crate::modules::validate_import_assertions;
+use crate::modules::ImportAssertionsKind;
 use crate::modules::ModuleMap;
 use crate::resolve_url_or_path;
 use crate::JsRuntime;
@@ -243,7 +247,7 @@ pub extern "C" fn host_import_module_dynamically_callback(
   context: v8::Local<v8::Context>,
   referrer: v8::Local<v8::ScriptOrModule>,
   specifier: v8::Local<v8::String>,
-  _import_assertions: v8::Local<v8::FixedArray>,
+  import_assertions: v8::Local<v8::FixedArray>,
 ) -> *mut v8::Promise {
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
 
@@ -267,6 +271,22 @@ pub extern "C" fn host_import_module_dynamically_callback(
   let resolver = v8::PromiseResolver::new(scope).unwrap();
   let promise = resolver.get_promise(scope);
 
+  let assertions = parse_import_assertions(
+    scope,
+    import_assertions,
+    ImportAssertionsKind::DynamicImport,
+  );
+
+  {
+    let tc_scope = &mut v8::TryCatch::new(scope);
+    validate_import_assertions(tc_scope, &assertions);
+    if tc_scope.has_caught() {
+      let e = tc_scope.exception().unwrap();
+      resolver.reject(tc_scope, e);
+    }
+  }
+  let module_type = get_module_type_from_assertions(&assertions);
+
   let resolver_handle = v8::Global::new(scope, resolver);
   {
     let state_rc = JsRuntime::state(scope);
@@ -280,6 +300,7 @@ pub extern "C" fn host_import_module_dynamically_callback(
       module_map_rc,
       &specifier_str,
       &referrer_name_str,
+      module_type,
       resolver_handle,
     );
     state_rc.borrow_mut().notify_new_dynamic_import();
@@ -294,13 +315,29 @@ pub extern "C" fn host_import_module_dynamically_callback(
                  _rv: v8::ReturnValue| {
     let arg = args.get(0);
     if is_instance_of_error(scope, arg) {
+      let e: crate::error::NativeJsError =
+        serde_v8::from_v8(scope, arg).unwrap();
+      let name = e.name.unwrap_or_else(|| "Error".to_string());
       let message = v8::Exception::create_message(scope, arg);
       if message.get_stack_trace(scope).unwrap().get_frame_count() == 0 {
         let arg: v8::Local<v8::Object> = arg.try_into().unwrap();
         let message_key = v8::String::new(scope, "message").unwrap();
         let message = arg.get(scope, message_key.into()).unwrap();
-        let exception =
-          v8::Exception::type_error(scope, message.try_into().unwrap());
+        let exception = match name.as_str() {
+          "RangeError" => {
+            v8::Exception::range_error(scope, message.try_into().unwrap())
+          }
+          "TypeError" => {
+            v8::Exception::type_error(scope, message.try_into().unwrap())
+          }
+          "SyntaxError" => {
+            v8::Exception::syntax_error(scope, message.try_into().unwrap())
+          }
+          "ReferenceError" => {
+            v8::Exception::reference_error(scope, message.try_into().unwrap())
+          }
+          _ => v8::Exception::error(scope, message.try_into().unwrap()),
+        };
         let code_key = v8::String::new(scope, "code").unwrap();
         let code_value =
           v8::String::new(scope, "ERR_MODULE_NOT_FOUND").unwrap();
@@ -1311,7 +1348,7 @@ fn create_host_object(
 pub fn module_resolve_callback<'s>(
   context: v8::Local<'s, v8::Context>,
   specifier: v8::Local<'s, v8::String>,
-  _import_assertions: v8::Local<'s, v8::FixedArray>,
+  import_assertions: v8::Local<'s, v8::FixedArray>,
   referrer: v8::Local<'s, v8::Module>,
 ) -> Option<v8::Local<'s, v8::Module>> {
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
@@ -1328,8 +1365,17 @@ pub fn module_resolve_callback<'s>(
 
   let specifier_str = specifier.to_rust_string_lossy(scope);
 
-  let maybe_module =
-    module_map.resolve_callback(scope, &specifier_str, &referrer_name);
+  let assertions = parse_import_assertions(
+    scope,
+    import_assertions,
+    ImportAssertionsKind::StaticImport,
+  );
+  let maybe_module = module_map.resolve_callback(
+    scope,
+    &specifier_str,
+    &referrer_name,
+    assertions,
+  );
   if let Some(module) = maybe_module {
     return Some(module);
   }

core/error.rs

@@ -158,9 +158,9 @@ fn get_property<'a>(
 }
 
 #[derive(serde::Deserialize)]
-struct NativeJsError {
-  name: Option<String>,
-  message: Option<String>,
+pub(crate) struct NativeJsError {
+  pub name: Option<String>,
+  pub message: Option<String>,
   // Warning! .stack is special so handled by itself
   // stack: Option<String>,
 }