feat: feature gate json, websocket and http; enable them by default (#16)

* feat: feature gate json support

* feat: feature gate weboscket api

* ci: check websocket and json features seperately in CI, check no default features

* feat: feature gate the http API

* refactor: use futures-core and futures-sink instead of depending on whole of futures

* ci: test http feature seperately in CI

* fix: only compile error conversion funcs if either APIs are enabled

* fix: add futures to dev-deps for tests, fix doc test

Author: yusdacra

.github/workflows/ci.yml

@@ -68,6 +68,30 @@ jobs:
         with:
           command: clippy
           args: --target wasm32-unknown-unknown -- -D warnings
+      
+      - name: Run clippy (no default features)
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --no-default-features --target wasm32-unknown-unknown -- -D warnings
+
+      - name: Run clippy (with json feature)
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --no-default-features --features json --target wasm32-unknown-unknown -- -D warnings
+
+      - name: Run clippy (with websocket feature)
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --no-default-features --features websocket --target wasm32-unknown-unknown -- -D warnings
+      
+      - name: Run clippy (with http feature)
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --no-default-features --features http --target wasm32-unknown-unknown -- -D warnings
 
   test:
     name: Test

Cargo.toml

@@ -13,47 +13,66 @@ exclude = [
     ".idea",
 ]
 
+[package.metadata.docs.rs]
+all-features = true
+
+[features]
+default = ["json", "websocket", "http"]
+
+# Enables `.json()` on `Response`
+json = ["wasm-bindgen/serde-serialize", "serde", "serde_json"]
+# Enables the WebSocket API
+websocket = [
+    'web-sys/WebSocket',
+    'web-sys/ErrorEvent',
+    'web-sys/FileReader',
+    'web-sys/MessageEvent',
+    'web-sys/ProgressEvent',
+    'web-sys/CloseEvent',
+    'web-sys/BinaryType',
+    'web-sys/Blob',
+    "async-broadcast",
+    "pin-project",
+    "futures-core",
+    "futures-sink",
+]
+# Enables the HTTP API
+http = [
+    'web-sys/Headers',
+    'web-sys/Request',
+    'web-sys/RequestInit',
+    'web-sys/RequestMode',
+    'web-sys/Response',
+    'web-sys/Window',
+    'web-sys/RequestCache',
+    'web-sys/RequestCredentials',
+    'web-sys/ObserverCallback',
+    'web-sys/RequestRedirect',
+    'web-sys/ReferrerPolicy',
+    'web-sys/AbortSignal',
+    'web-sys/ReadableStream',
+    'web-sys/Blob',
+    'web-sys/FormData',
+]
+
 [dependencies]
-wasm-bindgen = { version = "0.2", features = ["serde-serialize"] }
+wasm-bindgen = "0.2"
+web-sys = "0.3"
 js-sys = "0.3"
+gloo-utils = "0.1.0"
+
 wasm-bindgen-futures = "0.4"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+futures-core = { version = "0.3", optional = true }
+futures-sink = { version = "0.3", optional = true }
+
 thiserror = "1.0"
-futures = "0.3.14"
-gloo-utils = "0.1.0"
 
-async-broadcast = "0.3"
-pin-project = "1"
-
-[dependencies.web-sys]
-version = "0.3.4"
-features = [
-    'Headers',
-    'Request',
-    'RequestInit',
-    'RequestMode',
-    'Response',
-    'Window',
-    'RequestCache',
-    'RequestCredentials',
-    'ObserverCallback',
-    'RequestRedirect',
-    'ReferrerPolicy',
-    'AbortSignal',
-    'ReadableStream',
-    'Blob',
-    'FormData',
-    'FileReader',
-    'CloseEvent',
-
-    'WebSocket',
-    'ErrorEvent',
-    'FileReader',
-    'MessageEvent',
-    'ProgressEvent',
-    'BinaryType',
-]
+serde = { version = "1.0", features = ["derive"], optional = true }
+serde_json = { version = "1.0", optional = true }
+
+async-broadcast = { version = "0.3", optional = true }
+pin-project = { version = "1.0", optional = true }
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3"
+futures = "0.3"

src/error.rs

@@ -1,6 +1,5 @@
 use gloo_utils::errors::JsError;
 use thiserror::Error as ThisError;
-use wasm_bindgen::JsValue;
 
 /// All the errors returned by this crate.
 #[derive(Debug, ThisError)]
@@ -9,6 +8,7 @@ pub enum Error {
     #[error("{0}")]
     JsError(JsError),
     /// Error returned by `serde` during deserialization.
+    #[cfg(feature = "json")]
     #[error("{0}")]
     SerdeError(
         #[source]
@@ -17,13 +17,22 @@ pub enum Error {
     ),
 }
 
-pub(crate) fn js_to_error(js_value: JsValue) -> Error {
-    Error::JsError(js_to_js_error(js_value))
-}
+#[cfg(any(feature = "http", feature = "websocket"))]
+pub(crate) use conversion::*;
+#[cfg(any(feature = "http", feature = "websocket"))]
+mod conversion {
+    use gloo_utils::errors::JsError;
+    use wasm_bindgen::JsValue;
+
+    #[cfg(feature = "http")]
+    pub(crate) fn js_to_error(js_value: JsValue) -> super::Error {
+        super::Error::JsError(js_to_js_error(js_value))
+    }
 
-pub(crate) fn js_to_js_error(js_value: JsValue) -> JsError {
-    match JsError::try_from(js_value) {
-        Ok(error) => error,
-        Err(_) => unreachable!("JsValue passed is not an Error type -- this is a bug"),
+    pub(crate) fn js_to_js_error(js_value: JsValue) -> JsError {
+        match JsError::try_from(js_value) {
+            Ok(error) => error,
+            Err(_) => unreachable!("JsValue passed is not an Error type -- this is a bug"),
+        }
     }
 }

src/http.rs

@@ -15,12 +15,15 @@
 
 use crate::{js_to_error, Error};
 use js_sys::{ArrayBuffer, Uint8Array};
-use serde::de::DeserializeOwned;
 use std::fmt;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::window;
+
+#[cfg(feature = "json")]
+use serde::de::DeserializeOwned;
+
 pub use web_sys::{
     AbortSignal, FormData, Headers, ObserverCallback, ReadableStream, ReferrerPolicy, RequestCache,
     RequestCredentials, RequestMode, RequestRedirect,
@@ -259,6 +262,7 @@ impl Response {
     }
 
     /// Gets and parses the json.
+    #[cfg(feature = "json")]
     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)?;

src/lib.rs

@@ -10,7 +10,9 @@
 )]
 
 mod error;
+#[cfg(feature = "http")]
 pub mod http;
+#[cfg(feature = "websocket")]
 pub mod websocket;
 
 pub use error::*;

src/websocket/futures.rs

@@ -11,18 +11,16 @@
 //! #    ($($expr:expr),*) => {{}};
 //! # }
 //! # fn no_run() {
-//! let mut  ws = WebSocket::open("wss://echo.websocket.org").unwrap();
+//! let mut ws = WebSocket::open("wss://echo.websocket.org").unwrap();
+//! let (mut write, mut read) = ws.split();
 //!
-//! spawn_local({
-//!     let mut  ws = ws.clone();
-//!     async move {
-//!         ws.send(Message::Text(String::from("test"))).await.unwrap();
-//!         ws.send(Message::Text(String::from("test 2"))).await.unwrap();
-//!     }
+//! spawn_local(async move {
+//!     write.send(Message::Text(String::from("test"))).await.unwrap();
+//!     write.send(Message::Text(String::from("test 2"))).await.unwrap();
 //! });
 //!
 //! spawn_local(async move {
-//!     while let Some(msg) = ws.next().await {
+//!     while let Some(msg) = read.next().await {
 //!         console_log!(format!("1. {:?}", msg))
 //!     }
 //!     console_log!("WebSocket Closed")
@@ -35,8 +33,8 @@ use crate::websocket::{
     Message, State, WebSocketError,
 };
 use async_broadcast::Receiver;
-use futures::ready;
-use futures::{Sink, Stream};
+use futures_core::{ready, Stream};
+use futures_sink::Sink;
 use gloo_utils::errors::JsError;
 use pin_project::{pin_project, pinned_drop};
 use std::cell::RefCell;

tests/http.rs

@@ -1,7 +1,5 @@
-use js_sys::Uint8Array;
 use reqwasm::http::*;
 use serde::{Deserialize, Serialize};
-use wasm_bindgen::JsValue;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);