feat: async module loading

Author: piscisaureus

rs_lib/Cargo.toml

@@ -14,6 +14,7 @@ default = ["file_fetcher"]
 file_fetcher = ["async-trait", "base64", "cache_control", "chrono", "data-url", "http"]
 wasm = ["console_error_panic_hook", "js-sys", "serde-wasm-bindgen", "wasm-bindgen", "sys_traits/wasm"]
 sync = []
+async-module-loading = ["tokio"]
 
 [dependencies]
 async-trait = { version = "0.1.73", optional = true }
@@ -44,6 +45,11 @@ js-sys = { version = "=0.3.68", optional = true }
 wasm-bindgen = { version = "=0.2.91", optional = true }
 serde-wasm-bindgen = { version = "0.6.5", optional = true }
 
+[dependencies.tokio]
+version = "1"
+features = ["rt", "sync", "macros", "rt-multi-thread", "blocking"]
+optional = true
+
 [dev-dependencies]
 pretty_assertions = "1.4.0"
 sys_traits = { workspace = true, features = ["memory", "real", "getrandom", "libc", "winapi"] }

rs_lib/src/file_fetcher/async/mod.rs

@@ -0,0 +1,112 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+use std::borrow::Cow;
+
+use url::Url;
+
+use super::FetchCachedError;
+use super::FetchCachedErrorKind;
+use super::FetchCachedNoFollowError;
+use super::FetchCachedNoFollowErrorKind;
+use super::FileOrRedirect;
+use super::File;
+use super::TooManyRedirectsError;
+use crate::Checksum;
+
+pub trait AsyncFileFetcherExt {
+    /// Fetch cached remote file asynchronously.
+    ///
+    /// This is a recursive operation if source file has redirections.
+    async fn fetch_cached_async(
+        &self,
+        url: &Url,
+        redirect_limit: i64,
+    ) -> Result<Option<File>, FetchCachedError>;
+
+    /// Fetches from cache without following redirects asynchronously.
+    async fn fetch_cached_no_follow_async(
+        &self,
+        url: &Url,
+        maybe_checksum: Option<Checksum<'_>>,
+    ) -> Result<Option<FileOrRedirect>, FetchCachedNoFollowError>;
+}
+
+#[cfg(feature = "async-module-loading")]
+impl<TBlobStore, TSys, THttpClient> AsyncFileFetcherExt for super::FileFetcher<TBlobStore, TSys, THttpClient>
+where
+    TBlobStore: super::BlobStore + Clone,
+    TSys: crate::sync::MaybeSend + crate::sync::MaybeSync + sys_traits::FsRead + sys_traits::SystemTimeNow + Clone,
+    THttpClient: super::HttpClient + Clone,
+{
+    async fn fetch_cached_async(
+        &self,
+        url: &Url,
+        redirect_limit: i64,
+    ) -> Result<Option<File>, FetchCachedError> {
+        if !matches!(url.scheme(), "http" | "https") {
+            return Ok(None);
+        }
+
+        let mut url = Cow::Borrowed(url);
+        for _ in 0..=redirect_limit {
+            match self.fetch_cached_no_follow_async(&url, None).await? {
+                Some(FileOrRedirect::File(file)) => {
+                    return Ok(Some(file));
+                }
+                Some(FileOrRedirect::Redirect(redirect_url)) => {
+                    url = Cow::Owned(redirect_url);
+                }
+                None => {
+                    return Ok(None);
+                }
+            }
+        }
+        Err(
+            FetchCachedErrorKind::TooManyRedirects(TooManyRedirectsError(
+                url.into_owned(),
+            ))
+            .into_box(),
+        )
+    }
+
+    async fn fetch_cached_no_follow_async(
+        &self,
+        url: &Url,
+        maybe_checksum: Option<Checksum<'_>>,
+    ) -> Result<Option<FileOrRedirect>, FetchCachedNoFollowError> {
+        let url = url.clone();
+        let maybe_checksum_owned = maybe_checksum.map(|checksum| Checksum::new(checksum.as_str()));
+        let this = self.clone();
+        
+        // Run in a blocking task to avoid holding the JS thread
+        tokio::task::spawn_blocking(move || {
+            this.fetch_cached_no_follow(&url, maybe_checksum_owned)
+        })
+        .await
+        .unwrap()
+    }
+}
+
+#[cfg(not(feature = "async-module-loading"))]
+impl<TBlobStore, TSys, THttpClient> AsyncFileFetcherExt for super::FileFetcher<TBlobStore, TSys, THttpClient>
+where
+    TBlobStore: super::BlobStore + Clone,
+    TSys: crate::sync::MaybeSend + crate::sync::MaybeSync + sys_traits::FsRead + sys_traits::SystemTimeNow + Clone,
+    THttpClient: super::HttpClient + Clone,
+{
+    async fn fetch_cached_async(
+        &self,
+        url: &Url,
+        redirect_limit: i64,
+    ) -> Result<Option<File>, FetchCachedError> {
+        self.fetch_cached(url, redirect_limit)
+    }
+
+    async fn fetch_cached_no_follow_async(
+        &self,
+        url: &Url,
+        maybe_checksum: Option<Checksum<'_>>,
+    ) -> Result<Option<FileOrRedirect>, FetchCachedNoFollowError> {
+        self.fetch_cached_no_follow(url, maybe_checksum)
+    }
+}

rs_lib/src/file_fetcher/mod.rs

@@ -34,6 +34,9 @@ use crate::ChecksumIntegrityError;
 mod auth_tokens;
 mod http_util;
 
+#[cfg(feature = "async-module-loading")]
+pub mod r#async;
+
 pub use auth_tokens::AuthDomain;
 pub use auth_tokens::AuthToken;
 pub use auth_tokens::AuthTokenData;
@@ -442,7 +445,7 @@ pub struct FileFetcherOptions {
 }
 
 /// A structure for resolving, fetching and caching source files.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FileFetcher<
   TBlobStore: BlobStore,
   TSys: FsRead + SystemTimeNow,

rs_lib/src/lib.rs

@@ -33,6 +33,9 @@ pub use local::LocalHttpCache;
 pub use local::LocalHttpCacheRc;
 pub use local::LocalLspHttpCache;
 
+#[cfg(all(feature = "file_fetcher", feature = "async-module-loading"))]
+pub use file_fetcher::r#async::AsyncFileFetcherExt;
+
 #[cfg(feature = "wasm")]
 pub mod wasm {
   use std::collections::HashMap;