Address the feedback

Author: andoriyu

crates/console/Cargo.toml

@@ -15,7 +15,7 @@ categories = ["api-bindings", "development-tools::profiling", "wasm"]
 wasm-bindgen = "0.2"
 js-sys = "0.3"
 serde = { version = "1", features = ["derive"] }
-gloo-utils = { version = "0.1", path = "../utils", features = ["serde-serialize"] }
+gloo-utils = { version = "0.1", path = "../utils", features = ["serde"] }
 [dependencies.web-sys]
 version = "0.3"
 features = [

crates/console/src/lib.rs

@@ -30,6 +30,7 @@ pub use timer::Timer;
 
 #[doc(hidden)]
 pub mod __macro {
+    use gloo_utils::format::JsValueSerdeExt;
     pub use js_sys::Array;
     pub use wasm_bindgen::JsValue;
     use wasm_bindgen::UnwrapThrowExt;
@@ -38,7 +39,7 @@ pub mod __macro {
         data: impl serde::Serialize,
         columns: impl IntoIterator<Item = &'a str>,
     ) {
-        let data = gloo_utils::json::from_serde(&data).unwrap_throw();
+        let data = <JsValue as JsValueSerdeExt>::from_serde(&data).unwrap_throw();
         let columns = columns.into_iter().map(JsValue::from_str).collect();
 
         crate::externs::table_with_data_and_columns(data, columns);

crates/net/Cargo.toml

@@ -18,7 +18,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 wasm-bindgen = "0.2"
 web-sys = "0.3"
 js-sys = "0.3"
-gloo-utils = { version = "0.1", path = "../utils", features = ["serde-serialize"] }
+gloo-utils = { version = "0.1", path = "../utils", features = ["serde"] }
 
 wasm-bindgen-futures = "0.4"
 futures-core = { version = "0.3", optional = true }

crates/net/src/http/mod.rs

@@ -27,6 +27,10 @@ use wasm_bindgen_futures::JsFuture;
 #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
 use serde::de::DeserializeOwned;
 
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+use gloo_utils::format::JsValueSerdeExt;
+
 pub use headers::Headers;
 pub use query::QueryParams;
 pub use web_sys::{
@@ -392,7 +396,7 @@ impl Response {
     pub async fn json<T: DeserializeOwned>(&self) -> Result<T, Error> {
         let promise = self.response.json().map_err(js_to_error)?;
         let json = JsFuture::from(promise).await.map_err(js_to_error)?;
-        Ok(gloo_utils::json::into_serde(&json)?)
+        Ok(JsValueSerdeExt::into_serde(&json)?)
     }
 
     /// Reads the response as a String.

crates/net/src/websocket/futures.rs

@@ -33,6 +33,7 @@ use futures_channel::mpsc;
 use futures_core::{ready, Stream};
 use futures_sink::Sink;
 use gloo_utils::errors::JsError;
+use gloo_utils::format::JsValueSerdeExt;
 use pin_project::{pin_project, pinned_drop};
 use std::cell::RefCell;
 use std::pin::Pin;
@@ -106,7 +107,7 @@ impl WebSocket {
         url: &str,
         protocols: &[S],
     ) -> Result<Self, JsError> {
-        let json = gloo_utils::json::from_serde(protocols).map_err(|err| {
+        let json = <JsValue as JsValueSerdeExt>::from_serde(protocols).map_err(|err| {
             js_sys::Error::new(&format!(
                 "Failed to convert protocols to Javascript value: {}",
                 err

crates/utils/Cargo.toml

@@ -30,9 +30,13 @@ features = [
 ]
 
 [features]
-default = ["serde-serialize"]
-serde-serialize = ["dep:serde", "dep:serde_json"]
+default = ["serde"]
+serde = ["dep:serde", "dep:serde_json"]
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3"
 serde_derive = "1.0"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]

crates/utils/src/format/json.rs

@@ -0,0 +1,86 @@
+#![cfg(feature = "serde")]
+
+use wasm_bindgen::{JsValue, UnwrapThrowExt};
+mod private {
+    pub trait Sealed {}
+    impl Sealed for wasm_bindgen::JsValue {}
+}
+
+/// Extenstion trait to provide conversion between [`JsValue`](wasm_bindgen::JsValue) and [`serde`].
+///
+/// Usage of this API requires activating the `serde` feature of the `gloo-utils` crate.
+#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+pub trait JsValueSerdeExt: private::Sealed {
+    /// Creates a new `JsValue` from the JSON serialization of the object `t`
+    /// provided.
+    ///
+    /// This function will serialize the provided value `t` to a JSON string,
+    /// send the JSON string to JS, parse it into a JS object, and then return
+    /// a handle to the JS object. This is unlikely to be super speedy so it's
+    /// not recommended for large payloads, but it's a nice to have in some
+    /// situations!
+    ///
+    /// Usage of this API requires activating the `serde` feature of
+    /// the `gloo-utils` crate.
+    ///
+    /// # Errors
+    ///
+    /// Returns any error encountered when serializing `T` into JSON.
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`serde_json`](serde_json::to_string) generated JSON that couldn't be parsed by [`js_sys`].
+    /// Uses [`unwrap_throw`](UnwrapThrowExt::unwrap_throw) from [`wasm_bindgen::UnwrapThrowExt`].
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+    fn from_serde<T>(t: &T) -> serde_json::Result<JsValue>
+    where
+        T: serde::ser::Serialize + ?Sized;
+
+    /// Invokes `JSON.stringify` on this value and then parses the resulting
+    /// JSON into an arbitrary Rust value.
+    ///
+    /// This function will first call `JSON.stringify` on the `JsValue` itself.
+    /// The resulting string is then passed into Rust which then parses it as
+    /// JSON into the resulting value.
+    ///
+    /// Usage of this API requires activating the `serde` feature of
+    /// the `gloo-utils` crate.
+    ///
+    /// # Errors
+    ///
+    /// Returns any error encountered when parsing the JSON into a `T`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`js_sys`] couldn't stringify the JsValue. Uses [`unwrap_throw`](UnwrapThrowExt::unwrap_throw)
+    /// from [`wasm_bindgen::UnwrapThrowExt`].
+    #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+    #[allow(clippy::wrong_self_convention)]
+    fn into_serde<T>(&self) -> serde_json::Result<T>
+    where
+        T: for<'a> serde::de::Deserialize<'a>;
+}
+
+impl JsValueSerdeExt for JsValue {
+    fn from_serde<T>(t: &T) -> serde_json::Result<JsValue>
+    where
+        T: serde::ser::Serialize + ?Sized,
+    {
+        let s = serde_json::to_string(t)?;
+        Ok(js_sys::JSON::parse(&s).unwrap_throw())
+    }
+
+    fn into_serde<T>(&self) -> serde_json::Result<T>
+    where
+        T: for<'a> serde::de::Deserialize<'a>,
+    {
+        let s = if self.is_undefined() {
+            String::new()
+        } else {
+            js_sys::JSON::stringify(self)
+                .map(String::from)
+                .unwrap_throw()
+        };
+        serde_json::from_str(&s)
+    }
+}

crates/utils/src/json.rs

@@ -1,6 +1,11 @@
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
 pub mod errors;
 pub mod iter;
-pub mod json;
+pub mod format {
+    mod json;
+    pub use json::JsValueSerdeExt;
+}
 use wasm_bindgen::UnwrapThrowExt;
 
 /// Convenience function to avoid repeating expect logic.

crates/utils/src/lib.rs

@@ -8,7 +8,9 @@ exports.verify_serde = function(a) {
     c: null,
     d: { a: 1 }
   });
+};
 
+exports.make_js_value = function() {
   return {
     a: 2,
     b: 'bar',

crates/utils/tests/serde.js

@@ -1,12 +1,13 @@
 #![cfg(target_arch = "wasm32")]
-
+#![cfg(feature = "serde")]
 extern crate wasm_bindgen;
 extern crate wasm_bindgen_test;
 
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_test::*;
 
-use gloo_utils::json::{from_serde, into_serde};
+use gloo_utils::format::JsValueSerdeExt;
+
 use serde_derive::{Deserialize, Serialize};
 
 #[wasm_bindgen(start)]
@@ -16,44 +17,50 @@ pub fn start() {
 
 #[wasm_bindgen(module = "/tests/serde.js")]
 extern "C" {
-    fn verify_serde(val: JsValue) -> JsValue;
+    fn verify_serde(val: JsValue);
+    fn make_js_value() -> JsValue;
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SerdeFoo {
+    a: u32,
+    b: String,
+    c: Option<SerdeBar>,
+    d: SerdeBar,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct SerdeBar {
+    a: u32,
 }
 
-#[cfg(feature = "serde-serialize")]
 #[wasm_bindgen_test]
-fn it_works() {
-    #[derive(Deserialize, Serialize, Debug)]
-    pub struct SerdeFoo {
-        a: u32,
-        b: String,
-        c: Option<SerdeBar>,
-        d: SerdeBar,
-    }
-
-    #[derive(Deserialize, Serialize, Debug)]
-    pub struct SerdeBar {
-        a: u32,
-    }
-
-    let js = from_serde("foo").unwrap();
+fn from_serde() {
+    let js = JsValue::from_serde("foo").unwrap();
     assert_eq!(js.as_string(), Some("foo".to_string()));
 
-    let ret = verify_serde(
-        from_serde(&SerdeFoo {
+    verify_serde(
+        JsValue::from_serde(&SerdeFoo {
             a: 0,
             b: "foo".to_string(),
             c: None,
             d: SerdeBar { a: 1 },
         })
         .unwrap(),
     );
-    let foo = into_serde::<SerdeFoo>(&ret).unwrap();
+}
+
+#[wasm_bindgen_test]
+fn into_serde() {
+    let js_value = make_js_value();
+    let foo = js_value.into_serde::<SerdeFoo>().unwrap();
     assert_eq!(foo.a, 2);
     assert_eq!(foo.b, "bar");
     assert!(foo.c.is_some());
     assert_eq!(foo.c.as_ref().unwrap().a, 3);
     assert_eq!(foo.d.a, 4);
-    assert_eq!(into_serde::<String>(&JsValue::from("bar")).unwrap(), "bar");
-    assert_eq!(into_serde::<i32>(&JsValue::undefined()).ok(), None);
-    assert_eq!(into_serde::<i32>(&JsValue::null()).ok(), None);
+
+    assert_eq!(JsValue::from("bar").into_serde::<String>().unwrap(), "bar");
+    assert_eq!(JsValue::undefined().into_serde::<i32>().ok(), None);
+    assert_eq!(JsValue::null().into_serde::<i32>().ok(), None);
 }