Vendoring gloo-workers into yew-agent, support module type web worker (#3859)

Author: LucaCappelletti94

Cargo.lock

@@ -13,11 +13,28 @@ rust-version = "1.76.0"
 
 [dependencies]
 yew = { version = "0.21.0", path = "../yew" }
-gloo-worker = { version = "0.5", features = ["futures"] }
 wasm-bindgen = "0.2"
+js-sys = "0.3"
+pinned = "0.1.0"
+thiserror = "1.0.37"
+bincode = { version = "1.3.3" }
+wasm-bindgen-futures = "0.4"
 serde = { version = "1", features = ["derive"] }
 futures = "0.3"
 yew-agent-macro = { version = "0.2", path = "../yew-agent-macro" }
 
+[dependencies.web-sys]
+version = "0.3"
+features = [
+    "Blob",
+    "BlobPropertyBag",
+    "DedicatedWorkerGlobalScope",
+    "MessageEvent",
+    "Url",
+    "Worker",
+    "WorkerOptions",
+	"WorkerType"
+]
+
 [dev-dependencies]
 serde = "1.0.218"

packages/yew-agent/Cargo.toml

@@ -0,0 +1,66 @@
+# Yew Agent
+
+This module contains Yew's web worker implementation.
+
+## Types
+
+There're a couple kinds of agents:
+
+### Oneshot
+
+A kind of agent that for each input, a single output is returned.
+
+#### Reactor
+
+A kind of agent that can send many inputs and receive many outputs over a single bridge.
+
+#### Worker
+
+The low-level implementation of agents that provides an actor model and communicates with
+multiple bridges.
+
+## Reachability
+
+When an agent is spawned, each agent is associated with a reachability.
+
+### Private
+
+Each time a bridge is created, a new instance
+of agent is spawned. This allows parallel computing between agents.
+
+#### Public
+
+Public agents are shared among all children of a provider.
+Only 1 instance will be spawned for each public agents provider.
+
+### Provider
+
+Each Agent requires a provider to provide communications and maintain bridges.
+All hooks must be called within a provider.
+
+## Communications with Agents
+
+Hooks provides means to communicate with agent instances.
+
+### Bridge
+
+See: [`use_worker_bridge`](worker::use_worker_bridge),
+[`use_reactor_bridge`](reactor::use_reactor_bridge)
+
+A bridge takes a callback to receive outputs from agents
+and provides a handle to send inputs to agents.
+
+#### Subscription
+
+See: [`use_worker_subscription`](worker::use_worker_subscription),
+[`use_reactor_subscription`](reactor::use_reactor_subscription)
+
+Similar to bridges, a subscription produces a handle to send inputs to agents. However, instead
+of notifying the receiver with a callback, it collect all outputs into a slice.
+
+#### Runner
+
+See: [`use_oneshot_runner`](oneshot::use_oneshot_runner)
+
+Unlike other agents, oneshot bridges provide a `use_oneshot_runner` hook to execute oneshot
+agents on demand.

packages/yew-agent/README.md

@@ -0,0 +1,40 @@
+//! Submodule providing the `Codec` trait and its default implementation using `bincode`.
+
+use js_sys::Uint8Array;
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::JsValue;
+
+/// Message Encoding and Decoding Format
+pub trait Codec {
+    /// Encode an input to JsValue
+    fn encode<I>(input: I) -> JsValue
+    where
+        I: Serialize;
+
+    /// Decode a message to a type
+    fn decode<O>(input: JsValue) -> O
+    where
+        O: for<'de> Deserialize<'de>;
+}
+
+/// Default message encoding with [bincode].
+#[derive(Debug)]
+pub struct Bincode;
+
+impl Codec for Bincode {
+    fn encode<I>(input: I) -> JsValue
+    where
+        I: Serialize,
+    {
+        let buf = bincode::serialize(&input).expect("can't serialize an worker message");
+        Uint8Array::from(buf.as_slice()).into()
+    }
+
+    fn decode<O>(input: JsValue) -> O
+    where
+        O: for<'de> Deserialize<'de>,
+    {
+        let data = Uint8Array::from(input).to_vec();
+        bincode::deserialize(&data).expect("can't deserialize an worker message")
+    }
+}

packages/yew-agent/src/codec.rs

@@ -1,68 +1,4 @@
-//! This module contains Yew's web worker implementation.
-//!
-//! ## Types
-//!
-//! There're a couple kinds of agents:
-//!
-//! #### Oneshot
-//!
-//! A kind of agent that for each input, a single output is returned.
-//!
-//! #### Reactor
-//!
-//! A kind of agent that can send many inputs and receive many outputs over a single bridge.
-//!
-//! #### Worker
-//!
-//! The low-level implementation of agents that provides an actor model and communicates with
-//! multiple bridges.
-//!
-//! ## Reachability
-//!
-//! When an agent is spawned, each agent is associated with a reachability.
-//!
-//! #### Private
-//!
-//! Each time a bridge is created, a new instance
-//! of agent is spawned. This allows parallel computing between agents.
-//!
-//! #### Public
-//!
-//! Public agents are shared among all children of a provider.
-//! Only 1 instance will be spawned for each public agents provider.
-//!
-//! ### Provider
-//!
-//! Each Agent requires a provider to provide communications and maintain bridges.
-//! All hooks must be called within a provider.
-//!
-//! ## Communications with Agents
-//!
-//! Hooks provides means to communicate with agent instances.
-//!
-//! #### Bridge
-//!
-//! See: [`use_worker_bridge`](worker::use_worker_bridge),
-//! [`use_reactor_bridge`](reactor::use_reactor_bridge)
-//!
-//! A bridge takes a callback to receive outputs from agents
-//! and provides a handle to send inputs to agents.
-//!
-//! #### Subscription
-//!
-//! See: [`use_worker_subscription`](worker::use_worker_subscription),
-//! [`use_reactor_subscription`](reactor::use_reactor_subscription)
-//!
-//! Similar to bridges, a subscription produces a handle to send inputs to agents. However, instead
-//! of notifying the receiver with a callback, it collect all outputs into a slice.
-//!
-//! #### Runner
-//!
-//! See: [`use_oneshot_runner`](oneshot::use_oneshot_runner)
-//!
-//! Unlike other agents, oneshot bridges provide a `use_oneshot_runner` hook to execute oneshot
-//! agents on demand.
-
+#![doc = include_str!("../README.md")]
 #![deny(
     clippy::all,
     missing_docs,
@@ -74,12 +10,13 @@
 
 extern crate self as yew_agent;
 
+pub mod codec;
 pub mod oneshot;
 pub mod reactor;
 pub mod worker;
-
-#[doc(inline)]
-pub use gloo_worker::{Bincode, Codec, Registrable, Spawnable};
+pub use codec::{Bincode, Codec};
+pub mod traits;
+pub use traits::{Registrable, Spawnable};
 
 mod reach;
 pub mod scope_ext;

packages/yew-agent/src/lib.rs

@@ -0,0 +1,73 @@
+use futures::stream::StreamExt;
+use pinned::mpsc;
+use pinned::mpsc::UnboundedReceiver;
+
+use super::traits::Oneshot;
+use super::worker::OneshotWorker;
+use crate::codec::Codec;
+use crate::worker::{WorkerBridge, WorkerSpawner};
+
+/// A connection manager for components interaction with oneshot workers.
+#[derive(Debug)]
+pub struct OneshotBridge<N>
+where
+    N: Oneshot + 'static,
+{
+    inner: WorkerBridge<OneshotWorker<N>>,
+    rx: UnboundedReceiver<N::Output>,
+}
+
+impl<N> OneshotBridge<N>
+where
+    N: Oneshot + 'static,
+{
+    #[inline(always)]
+    pub(crate) fn new(
+        inner: WorkerBridge<OneshotWorker<N>>,
+        rx: UnboundedReceiver<N::Output>,
+    ) -> Self {
+        Self { inner, rx }
+    }
+
+    #[inline(always)]
+    pub(crate) fn register_callback<CODEC>(
+        spawner: &mut WorkerSpawner<OneshotWorker<N>, CODEC>,
+    ) -> UnboundedReceiver<N::Output>
+    where
+        CODEC: Codec,
+    {
+        let (tx, rx) = mpsc::unbounded();
+        spawner.callback(move |output| {
+            let _ = tx.send_now(output);
+        });
+
+        rx
+    }
+
+    /// Forks the bridge.
+    ///
+    /// This method creates a new bridge that can be used to execute tasks on the same worker
+    /// instance.
+    pub fn fork(&self) -> Self {
+        let (tx, rx) = mpsc::unbounded();
+        let inner = self.inner.fork(Some(move |output| {
+            let _ = tx.send_now(output);
+        }));
+
+        Self { inner, rx }
+    }
+
+    /// Run the the current oneshot worker once in the current worker instance.
+    pub async fn run(&mut self, input: N::Input) -> N::Output {
+        // &mut self guarantees that the bridge will be
+        // exclusively borrowed during the time the oneshot worker is running.
+        self.inner.send(input);
+
+        // For each bridge, there can only be 1 active task running on the worker instance.
+        // The next output will be the output for the input that we just sent.
+        self.rx
+            .next()
+            .await
+            .expect("failed to receive result from worker")
+    }
+}

packages/yew-agent/src/oneshot/bridge.rs

@@ -1,12 +1,19 @@
 //! This module provides task agent implementation.
 
+mod bridge;
 mod hooks;
 mod provider;
+mod registrar;
+mod spawner;
+mod traits;
+mod worker;
 
-#[doc(inline)]
-pub use gloo_worker::oneshot::{Oneshot, OneshotBridge, OneshotRegistrar, OneshotSpawner};
+pub use bridge::OneshotBridge;
 pub use hooks::{use_oneshot_runner, UseOneshotRunnerHandle};
 pub use provider::OneshotProvider;
 pub(crate) use provider::OneshotProviderState;
+pub use registrar::OneshotRegistrar;
+pub use spawner::OneshotSpawner;
+pub use traits::Oneshot;
 /// A procedural macro to create oneshot agents.
 pub use yew_agent_macro::oneshot;

packages/yew-agent/src/oneshot/mod.rs

@@ -97,13 +97,19 @@ where
         children,
         path,
         lazy,
+        module,
         reach,
     } = props.clone();
 
     // Creates a spawning function so Codec is can be erased from contexts.
     let spawn_bridge_fn: Rc<dyn Fn() -> OneshotBridge<T>> = {
         let path = path.clone();
-        Rc::new(move || OneshotSpawner::<T>::new().encoding::<C>().spawn(&path))
+        Rc::new(move || {
+            OneshotSpawner::<T>::new()
+                .as_module(module)
+                .encoding::<C>()
+                .spawn(&path)
+        })
     };
 
     let state = {