Initial Release

crates/obscura-js/src/module_loader.rs

@@ -0,0 +1,93 @@
+use std::pin::Pin;
+
+use deno_core::error::ModuleLoaderError;
+use deno_core::ModuleLoadResponse;
+use deno_core::ModuleLoader;
+use deno_core::ModuleSource;
+use deno_core::ModuleSourceCode;
+use deno_core::ModuleSpecifier;
+use deno_core::RequestedModuleType;
+
+pub struct ObscuraModuleLoader {
+    pub base_url: String,
+}
+
+impl ObscuraModuleLoader {
+    pub fn new(base_url: &str) -> Self {
+        ObscuraModuleLoader {
+            base_url: base_url.to_string(),
+        }
+    }
+}
+
+fn io_err(msg: String) -> ModuleLoaderError {
+    std::io::Error::new(std::io::ErrorKind::Other, msg).into()
+}
+
+impl ModuleLoader for ObscuraModuleLoader {
+    fn resolve(
+        &self,
+        specifier: &str,
+        referrer: &str,
+        _kind: deno_core::ResolutionKind,
+    ) -> Result<ModuleSpecifier, ModuleLoaderError> {
+        let base = if referrer.is_empty()
+            || referrer.starts_with('<')
+            || referrer == "."
+            || referrer == "about:blank"
+        {
+            &self.base_url
+        } else {
+            referrer
+        };
+
+        deno_core::resolve_import(specifier, base).map_err(|e| e.into())
+    }
+
+    fn load(
+        &self,
+        module_specifier: &ModuleSpecifier,
+        _maybe_referrer: Option<&ModuleSpecifier>,
+        _is_dyn_import: bool,
+        _requested_module_type: RequestedModuleType,
+    ) -> ModuleLoadResponse {
+        let url = module_specifier.to_string();
+
+        ModuleLoadResponse::Async(Pin::from(Box::new(async move {
+            let client = reqwest::Client::builder()
+                .build()
+                .map_err(|e| io_err(format!("HTTP client error: {}", e)))?;
+
+            tracing::debug!("Loading ES module: {}", url);
+
+            let resp = client
+                .get(&url)
+                .header("Accept", "application/javascript, text/javascript, */*")
+                .send()
+                .await
+                .map_err(|e| io_err(format!("Failed to fetch module {}: {}", url, e)))?;
+
+            if !resp.status().is_success() {
+                return Err(io_err(format!(
+                    "Module {} returned HTTP {}",
+                    url,
+                    resp.status()
+                )));
+            }
+
+            let code = resp.text().await.map_err(|e| {
+                io_err(format!("Failed to read module body {}: {}", url, e))
+            })?;
+
+            let specifier = ModuleSpecifier::parse(&url)
+                .map_err(|e| io_err(format!("Invalid module URL {}: {}", url, e)))?;
+
+            Ok(ModuleSource::new(
+                deno_core::ModuleType::JavaScript,
+                ModuleSourceCode::String(code.into()),
+                &specifier,
+                None,
+            ))
+        })))
+    }
+}