Switch to bundler target for wasm-pack for manifest v3

.github/workflows/release-plz.yml

@@ -113,8 +113,8 @@ jobs:
           fi
 
           # publish lumina-node-wasm
-          wasm-pack build --target web node-wasm
-          wasm-pack publish --target web --access public node-wasm
+          wasm-pack build node-wasm
+          wasm-pack publish --access public node-wasm
 
           # publish lumina-node
           cd node-wasm/js

README.md

@@ -66,7 +66,7 @@ you need to compile wasm node manually. Follow these additional steps:
 cargo install wasm-pack
 
 # compile lumina to wasm
-wasm-pack build --target web node-wasm
+wasm-pack build node-wasm
 
 # install lumina-cli
 cargo install --path cli --features browser-node

node-wasm/Cargo.toml

@@ -60,6 +60,8 @@ web-sys = { version = "0.3.70", features = [
   "RequestInit",
   "RequestMode",
   "Response",
+  "ServiceWorker",
+  "ServiceWorkerGlobalScope",
   "SharedWorker",
   "SharedWorkerGlobalScope",
   "StorageManager",
@@ -79,5 +81,5 @@ targets = ["wasm32-unknown-unknown"]
 
 # Uncomment this if you need debug symbols in release.
 # Also check workspace's `Cargo.toml`.
-#[package.metadata.wasm-pack.profile.release]
-#wasm-opt = ['-O4', '-g']
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = ['-O4', '-g']

node-wasm/js/index.d.ts

@@ -3,4 +3,3 @@
 */
 export function spawnNode(): Promise<NodeClient>;
 export * from "lumina-node-wasm";
-export default function init(): Promise<void>;

node-wasm/js/index.js

@@ -1,14 +1,12 @@
-import init, { NodeClient } from "lumina-node-wasm"
+import { NodeClient } from "lumina-node-wasm"
 
 /**
 * Spawn a worker running lumina node and get the `NodeClient` connected to it.
 */
 export async function spawnNode() {
-  await init();
-  let worker = new Worker(new URL("worker.js", import.meta.url), { type: "module" });
+  let worker = new Worker(new URL("worker.js", import.meta.url));
   let client = await new NodeClient(worker);
   return client;
 }
 
 export * from "lumina-node-wasm";
-export default init;

node-wasm/js/worker.js

@@ -1,10 +1,8 @@
-import init, { NodeWorker } from "lumina-node-wasm"
+import { NodeWorker, NodeClient } from "lumina-node-wasm"
 
 Error.stackTraceLimit = 99;
 
-init().then(async () => {
-  let worker = new NodeWorker(self);
-  console.log("Starting NodeWorker");
+let worker = new NodeWorker(self);
+console.log("starting worker: ", worker);
 
-  await worker.run();
-});
+worker.run();

node-wasm/src/utils.rs

@@ -5,7 +5,7 @@ use std::future::Future;
 use std::net::{IpAddr, Ipv4Addr};
 
 use gloo_timers::future::TimeoutFuture;
-use js_sys::Math;
+use js_sys::{Math, Promise};
 use libp2p::multiaddr::Protocol;
 use libp2p::{Multiaddr, PeerId};
 use lumina_node::network;
@@ -21,7 +21,7 @@ use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
     DedicatedWorkerGlobalScope, MessageEvent, Request, RequestInit, RequestMode, Response,
-    SharedWorker, SharedWorkerGlobalScope, Worker,
+    ServiceWorker, ServiceWorkerGlobalScope, SharedWorker, SharedWorkerGlobalScope, Worker,
 };
 
 use crate::error::{Context, Error, Result};
@@ -81,7 +81,7 @@ pub(crate) fn js_value_from_display<D: fmt::Display>(value: D) -> JsValue {
     JsValue::from(value.to_string())
 }
 
-pub(crate) trait WorkerSelf {
+trait WorkerSelf {
     type GlobalScope;
 
     fn worker_self() -> Self::GlobalScope;
@@ -112,6 +112,18 @@ impl WorkerSelf for Worker {
     }
 }
 
+impl WorkerSelf for ServiceWorker {
+    type GlobalScope = ServiceWorkerGlobalScope;
+
+    fn worker_self() -> Self::GlobalScope {
+        JsValue::from(js_sys::global()).into()
+    }
+
+    fn is_worker_type() -> bool {
+        js_sys::global().has_type::<Self::GlobalScope>()
+    }
+}
+
 /// This type is useful in cases where we want to deal with de/serialising `Result<T, E>`, with
 /// [`serde_wasm_bindgen::preserve`] where `T` is a JavaScript object (which are not serializable by
 /// Rust standards, but can be passed through unchanged via cast as they implement [`JsCast`]).
@@ -182,6 +194,9 @@ pub(crate) async fn request_storage_persistence() -> Result<(), Error> {
         Worker::worker_self().navigator().storage()
     } else if SharedWorker::is_worker_type() {
         SharedWorker::worker_self().navigator().storage()
+    } else if ServiceWorker::is_worker_type() {
+        warn!("ServiceWorker doesn't have access to StorageManager");
+        return Ok(());
     } else {
         return Err(Error::new("`navigator.storage` not found in global scope"));
     };
@@ -218,6 +233,8 @@ pub(crate) fn get_user_agent() -> Result<String, Error> {
         Ok(Worker::worker_self().navigator().user_agent()?)
     } else if SharedWorker::is_worker_type() {
         Ok(SharedWorker::worker_self().navigator().user_agent()?)
+    } else if ServiceWorker::is_worker_type() {
+        Ok(ServiceWorker::worker_self().navigator().user_agent()?)
     } else {
         Err(Error::new(
             "`navigator.user_agent` not found in global scope",
@@ -256,6 +273,12 @@ pub(crate) fn random_id() -> u32 {
     (Math::random() * f64::from(u32::MAX)).floor() as u32
 }
 
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = fetch)]
+    fn fetch_with_request(input: &Request) -> Promise;
+}
+
 async fn fetch(url: &str, opts: &RequestInit, headers: &[(&str, &str)]) -> Result<Response, Error> {
     let request = Request::new_with_str_and_init(url, opts)
         .with_context(|| format!("failed to create a request to {url}"))?;
@@ -267,15 +290,7 @@ async fn fetch(url: &str, opts: &RequestInit, headers: &[(&str, &str)]) -> Resul
             .with_context(|| format!("failed setting header: '{name}: {value}'"))?;
     }
 
-    let fetch_promise = if let Some(window) = web_sys::window() {
-        window.fetch_with_request(&request)
-    } else if Worker::is_worker_type() {
-        Worker::worker_self().fetch_with_request(&request)
-    } else if SharedWorker::is_worker_type() {
-        SharedWorker::worker_self().fetch_with_request(&request)
-    } else {
-        return Err(Error::new("`fetch` not found in global scope"));
-    };
+    let fetch_promise = fetch_with_request(&request);
 
     JsFuture::from(fetch_promise)
         .await

node/src/p2p.rs

@@ -1014,6 +1014,7 @@ where
 
     #[instrument(level = "trace", skip(self))]
     async fn on_kademlia_event(&mut self, ev: kad::Event) -> Result<()> {
+        info!("KAD: {ev:?}");
         match ev {
             kad::Event::RoutingUpdated {
                 peer, addresses, ..