refactor: check assertions per import statement

lib/deno_graph_wasm.generated.js

@@ -226,7 +226,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 }
 function __wbg_adapter_48(arg0, arg1, arg2) {
   wasm
-    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf0940dd4fdf51f25(
+    ._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hec49a88a8b459e09(
       arg0,
       arg1,
       addHeapObject(arg2),
@@ -383,7 +383,7 @@ function handleError(f, args) {
   }
 }
 function __wbg_adapter_95(arg0, arg1, arg2, arg3) {
-  wasm.wasm_bindgen__convert__closures__invoke2_mut__h9adfd02b55150fae(
+  wasm.wasm_bindgen__convert__closures__invoke2_mut__h5fc0ee5e5d0575ff(
     arg0,
     arg1,
     addHeapObject(arg2),
@@ -393,6 +393,9 @@ function __wbg_adapter_95(arg0, arg1, arg2, arg3) {
 
 const imports = {
   __wbindgen_placeholder__: {
+    __wbindgen_object_drop_ref: function (arg0) {
+      takeObject(arg0);
+    },
     __wbindgen_cb_drop: function (arg0) {
       const obj = takeObject(arg0).original;
       if (obj.cnt-- == 1) {
@@ -428,9 +431,6 @@ const imports = {
         state0.a = state0.b = 0;
       }
     },
-    __wbindgen_object_drop_ref: function (arg0) {
-      takeObject(arg0);
-    },
     __wbg_length_6e3bbe7c8bd4dbd8: function (arg0) {
       const ret = getObject(arg0).length;
       return ret;

lib/types.d.ts

@@ -105,6 +105,16 @@ export type ModuleKind =
   | "external"
   | "script";
 
+export type ImportAssertions = "unknown" | Record<string, string>;
+
+export interface ImportJson {
+  specifier: string;
+  range: RangeJson;
+  isDynamic?: true;
+  assertions?: ImportAssertions;
+  errors?: string[];
+}
+
 export interface DependencyJson {
   /** The string specifier that was used for the dependency. */
   specifier: string;
@@ -117,7 +127,7 @@ export interface DependencyJson {
   /** A flag indicating if the dependency was dynamic. (e.g.
    * `await import("mod.ts")`) */
   isDynamic?: true;
-  assertionType?: string;
+  imports?: ImportJson[];
 }
 
 export interface ModuleJson extends CacheInfo {

src/analyzer.rs

@@ -128,6 +128,7 @@ impl DependencyKind {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum ImportAssertion {
   /// The value of this assertion could not be statically analyzed.
   Unknown,
@@ -147,6 +148,7 @@ impl ImportAssertion {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum ImportAssertions {
   /// There was no import assertions object literal.
   None,
@@ -182,6 +184,47 @@ impl ImportAssertions {
       _ => None,
     }
   }
+
+  /// Check if a assertion key is known to be absent (not set to a value and not
+  /// undeterminable). This is significant because it is the precise case where
+  /// `type: "javascript"` is asserted.
+  pub fn is_known_none(&self, key: &str) -> bool {
+    match self {
+      ImportAssertions::None => true,
+      ImportAssertions::Known(map) => !map.contains_key(key),
+      ImportAssertions::Unknown => false,
+    }
+  }
+
+  pub fn is_empty(&self) -> bool {
+    matches!(self, ImportAssertions::None)
+  }
+
+  /// Try to get a flat dictionary, successful if there are no unknowns.
+  pub fn maybe_static(&self) -> Option<HashMap<String, String>> {
+    let mut assertions = HashMap::new();
+    match self {
+      ImportAssertions::None => {}
+      ImportAssertions::Known(map) => {
+        for (key, assertion) in map {
+          match assertion {
+            ImportAssertion::Known(value) => {
+              assertions.insert(key.clone(), value.clone());
+            }
+            ImportAssertion::Unknown => return None,
+          }
+        }
+      }
+      _ => return None,
+    }
+    Some(assertions)
+  }
+}
+
+impl Default for ImportAssertions {
+  fn default() -> Self {
+    Self::None
+  }
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]