typespec_client_core: New web_runtime to support wasm32-unknown-unknown

Cargo.toml

@@ -122,6 +122,7 @@ tracing = "0.1.40"
 tracing-subscriber = "0.3"
 url = "2.2"
 uuid = { version = "1.17", features = ["v4"] }
+wasm-bindgen-futures = "0.4"
 zerofrom = "0.1.5"
 zip = { version = "4.0.0", default-features = false, features = ["deflate"] }
 

sdk/typespec/typespec_client_core/Cargo.toml

@@ -37,6 +37,7 @@ tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
 getrandom.workspace = true
 tokio = { workspace = true, features = ["macros", "rt", "time"] }
 gloo-timers = { workspace = true, features = ["futures"] }
+wasm-bindgen-futures.workspace = true
 
 [dev-dependencies]
 tokio.workspace = true

sdk/typespec/typespec_client_core/src/async_runtime/mod.rs

@@ -41,6 +41,9 @@ mod standard_runtime;
 #[cfg(feature = "tokio")]
 mod tokio_runtime;
 
+#[cfg(target_arch = "wasm32")]
+mod web_runtime;
+
 #[cfg(test)]
 mod tests;
 
@@ -107,7 +110,7 @@ pub trait AsyncRuntime: Send + Sync {
     ///
     fn spawn(&self, f: TaskFuture) -> SpawnedTask;
 
-    fn sleep(&self, duration: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>>;
+    fn sleep(&self, duration: Duration) -> TaskFuture;
 }
 
 static ASYNC_RUNTIME_IMPLEMENTATION: OnceLock<Arc<dyn AsyncRuntime>> = OnceLock::new();
@@ -189,12 +192,16 @@ pub fn set_async_runtime(runtime: Arc<dyn AsyncRuntime>) -> crate::Result<()> {
 }
 
 fn create_async_runtime() -> Arc<dyn AsyncRuntime> {
-    #[cfg(not(feature = "tokio"))]
+    #[cfg(target_arch = "wasm32")]
     {
-        Arc::new(standard_runtime::StdRuntime)
+        Arc::new(web_runtime::WebRuntime) as Arc<dyn AsyncRuntime>
     }
     #[cfg(feature = "tokio")]
     {
         Arc::new(tokio_runtime::TokioRuntime) as Arc<dyn AsyncRuntime>
     }
+    #[cfg(not(any(feature = "tokio", target_arch = "wasm32")))]
+    {
+        Arc::new(standard_runtime::StdRuntime)
+    }
 }

sdk/typespec/typespec_client_core/src/async_runtime/standard_runtime.rs

@@ -150,7 +150,7 @@ impl AsyncRuntime for StdRuntime {
     /// Uses a simple thread based implementation for sleep. A more efficient
     /// implementation is available by using the `tokio` crate feature.
     #[cfg_attr(target_arch = "wasm32", allow(unused_variables))]
-    fn sleep(&self, duration: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>> {
+    fn sleep(&self, duration: Duration) -> TaskFuture {
         #[cfg(target_arch = "wasm32")]
         {
             panic!("sleep is not supported on wasm32")

sdk/typespec/typespec_client_core/src/async_runtime/web_runtime.rs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+use super::{AsyncRuntime, SpawnedTask, TaskFuture};
+use crate::time::Duration;
+use std::pin::Pin;
+
+/// An [`AsyncRuntime`] using `tokio` based APIs.
+pub(crate) struct WebRuntime;
+
+impl AsyncRuntime for WebRuntime {
+    fn spawn(&self, f: TaskFuture) -> SpawnedTask {
+        Box::pin(async {
+            wasm_bindgen_futures::spawn_local(f);
+            Ok(())
+        })
+    }
+
+    fn sleep(&self, duration: Duration) -> TaskFuture {
+        Box::pin(async move {
+            if let Ok(d) = duration.try_into() {
+                gloo_timers::future::sleep(d).await;
+            } else {
+                // This means the duration is negative, don't sleep at all.
+                return;
+            }
+        })
+    }
+}

sdk/typespec/typespec_client_core/src/sleep.rs

@@ -3,12 +3,8 @@
 
 //! Sleep functions.
 
-use crate::time::Duration;
+use crate::{async_runtime::get_async_runtime, time::Duration};
 
-#[cfg(not(target_family = "wasm"))]
-use crate::async_runtime::get_async_runtime;
-
-#[cfg(not(target_family = "wasm"))]
 /// Sleeps for the specified duration using the configured async runtime.
 ///
 /// # Arguments
@@ -31,13 +27,3 @@ use crate::async_runtime::get_async_runtime;
 pub async fn sleep(duration: Duration) {
     get_async_runtime().sleep(duration).await
 }
-
-#[cfg(target_family = "wasm")]
-pub async fn sleep(duration: Duration) {
-    if let Ok(d) = duration.try_into() {
-        gloo_timers::future::sleep(d).await;
-    } else {
-        // This means the duration is negative, don't sleep at all.
-        return;
-    }
-}