refactor: check assertions per import statement

Cargo.toml

@@ -20,6 +20,7 @@ anyhow = "1.0.43"
 data-url = "0.2.0"
 deno_ast = { version = "0.24.0", features = ["dep_graph", "module_specifier"] }
 futures = "0.3.17"
+lazy_static = "1.4.0"
 monch = "0.4.0"
 once_cell = "1.16.0"
 parking_lot = "0.12.0"

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),

lib/types.d.ts

@@ -105,6 +105,20 @@ export type ModuleKind =
   | "external"
   | "script";
 
+export type ImportAssertion = "Unknown" | { "Known": string };
+
+export type ImportAssertions = "Unknown" | {
+  "Known": Record<string, ImportAssertion>;
+};
+
+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 +131,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

@@ -182,6 +182,44 @@ impl ImportAssertions {
       _ => None,
     }
   }
+
+  pub fn is_known_none(&self, key: &str) -> bool {
+    match self {
+      ImportAssertions::None => true,
+      ImportAssertions::Known(map) => !map.contains_key(key),
+      _ => 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)]