Implement time module for wasm-bindgen backend in iced_futures

core/Cargo.toml

@@ -14,6 +14,5 @@ bitflags = "1.2"
 version = "0.5"
 optional = true
 
-[target.'cfg(target_arch = "wasm32")'.dependencies.instant]
-version = "0.1"
-features = ["wasm-bindgen"]
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-timer = { version = "0.2" }

core/src/time.rs

@@ -1,7 +1,9 @@
 //! Keep track of time, both in native and web platforms!
 
 #[cfg(target_arch = "wasm32")]
-pub use instant::{Duration, Instant};
+pub use wasm_timer::Instant;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub use std::time::{Duration, Instant};
+pub use std::time::Instant;
+
+pub use std::time::Duration;

futures/Cargo.toml

@@ -36,6 +36,7 @@ optional = true
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen-futures = "0.4"
+wasm-timer = "0.2"
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--cfg", "docsrs"]

futures/src/backend/wasm/wasm_bindgen.rs

@@ -13,3 +13,47 @@ impl crate::Executor for Executor {
         wasm_bindgen_futures::spawn_local(future);
     }
 }
+
+pub mod time {
+    //! Listen and react to time.
+    use crate::subscription::{self, Subscription};
+    use crate::BoxStream;
+
+    /// Returns a [`Subscription`] that produces messages at a set interval.
+    ///
+    /// The first message is produced after a `duration`, and then continues to
+    /// produce more messages every `duration` after that.
+    pub fn every<H: std::hash::Hasher, E>(
+        duration: std::time::Duration,
+    ) -> Subscription<H, E, wasm_timer::Instant> {
+        Subscription::from_recipe(Every(duration))
+    }
+
+    #[derive(Debug)]
+    struct Every(std::time::Duration);
+
+    impl<H, E> subscription::Recipe<H, E> for Every
+    where
+        H: std::hash::Hasher,
+    {
+        type Output = wasm_timer::Instant;
+
+        fn hash(&self, state: &mut H) {
+            use std::hash::Hash;
+
+            std::any::TypeId::of::<Self>().hash(state);
+            self.0.hash(state);
+        }
+
+        fn stream(
+            self: Box<Self>,
+            _input: BoxStream<E>,
+        ) -> BoxStream<Self::Output> {
+            use futures::stream::StreamExt;
+
+            wasm_timer::Interval::new(self.0)
+                .map(|_| wasm_timer::Instant::now())
+                .boxed_local()
+        }
+    }
+}

native/src/mouse/click.rs

@@ -62,9 +62,14 @@ impl Click {
     }
 
     fn is_consecutive(&self, new_position: Point, time: Instant) -> bool {
+        let duration = if time > self.time {
+            Some(time - self.time)
+        } else {
+            None
+        };
+
         self.position == new_position
-            && time
-                .checked_duration_since(self.time)
+            && duration
                 .map(|duration| duration.as_millis() <= 300)
                 .unwrap_or(false)
     }

src/lib.rs

@@ -191,23 +191,10 @@ pub mod executor;
 pub mod keyboard;
 pub mod mouse;
 pub mod settings;
+pub mod time;
 pub mod widget;
 pub mod window;
 
-#[cfg(all(
-    any(feature = "tokio", feature = "async-std", feature = "smol"),
-    not(target_arch = "wasm32")
-))]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(
-        feature = "tokio",
-        feature = "async-std"
-        feature = "smol"
-    )))
-)]
-pub mod time;
-
 #[cfg(all(not(feature = "glow"), feature = "wgpu"))]
 use iced_winit as runtime;
 

src/time.rs

@@ -1,2 +1,4 @@
 //! Listen and react to time.
+pub use iced_core::time::{Duration, Instant};
+
 pub use iced_futures::backend::default::time::*;