Dev/listener multiplexer

ci/run_tests.sh

@@ -22,6 +22,9 @@ set -x
 
 (cd yew &&
   wasm-pack test "${test_flags[@]}" -- --features "${test_features}" &&
+  # Event listener tests have to be run in their own `wasm-pack test` invocation or they won't work.
+  RUSTFLAGS="--cfg  listener_tests" wasm-pack test "${test_flags[@]}" -- \
+    --features "${test_features}" yew::html::listener::registry &&
   cargo test --doc --features doc_test,wasm_test,yaml,msgpack,cbor,toml &&
   cargo test --doc --features doc_test,wasm_test,yaml,msgpack,cbor,toml \
     --features std_web,agent,services --no-default-features)

yew/Cargo.toml

@@ -59,6 +59,7 @@ features = [
   "Element",
   "ErrorEvent",
   "Event",
+  "EventInit",
   "EventTarget",
   "File",
   "FileList",
@@ -71,6 +72,7 @@ features = [
   "HtmlSelectElement",
   "HtmlTextAreaElement",
   "InputEvent",
+  "InputEventInit",
   "KeyboardEvent",
   "Location",
   "MessageEvent",

yew/src/callback.rs

@@ -4,6 +4,61 @@ use std::cell::RefCell;
 use std::fmt;
 use std::rc::Rc;
 
+/// Flags that modify default callback behaviour
+#[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)]
+pub struct Flags(u8);
+
+impl std::ops::BitAnd for Flags {
+    type Output = Self;
+
+    fn bitand(self, rhs: Self) -> Self {
+        Self(self.0 & rhs.0)
+    }
+}
+
+impl std::ops::BitAndAssign for Flags {
+    fn bitand_assign(&mut self, rhs: Self) {
+        self.0 &= rhs.0;
+    }
+}
+
+impl std::ops::BitOr for Flags {
+    type Output = Self;
+
+    fn bitor(self, rhs: Self) -> Self {
+        Self(self.0 | rhs.0)
+    }
+}
+
+impl std::ops::BitOrAssign for Flags {
+    fn bitor_assign(&mut self, rhs: Self) {
+        self.0 |= rhs.0;
+    }
+}
+
+impl Flags {
+    /// Return, if self hash f set inside of it
+    pub fn has_set(&self, f: Flags) -> bool {
+        *self & f != NO_FLAGS
+    }
+}
+
+/// Apply no Flags to callback. This is different from constructing a callback with None flags as it
+/// overrides the defaults for the callback type.
+pub const NO_FLAGS: Flags = Flags(0);
+/// Defines the event listener as passive.
+/// Yew sets sane defaults depending on the type of the listener.
+/// See [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEvent).
+pub const PASSIVE: Flags = Flags(1);
+/// Causes the event handler to not fire until the next animation frame
+/// Implies `PASSIVE`.
+// TODO: this flag can apply to Agents and Components as well
+pub const DEFER: Flags = Flags(1 << 1 | PASSIVE.0);
+/// Defines event listener to also listen to events in the child tree that bubbled up to the target
+/// element
+#[cfg(feature = "web_sys")]
+pub const HANDLE_BUBBLED: Flags = Flags(1 << 2);
+
 /// Universal callback wrapper.
 /// <aside class="warning">
 /// Use callbacks carefully, because if you call one from the `update` loop
@@ -12,8 +67,18 @@ use std::rc::Rc;
 /// </aside>
 /// An `Rc` wrapper is used to make it cloneable.
 pub enum Callback<IN> {
-    /// A callback which can be called multiple times
-    Callback(Rc<dyn Fn(IN)>),
+    /// A callback which can be called multiple times with optional modifier flags
+    Callback {
+        /// A callback which can be called multiple times
+        cb: Rc<dyn Fn(IN)>,
+
+        /// Sets flags for event listening. A combination of any Flags.
+        /// If None, the default flags for the callback event source are used.
+        ///
+        /// Currently only used with `feature = "web_sys"`.
+        flags: Option<Flags>,
+    },
+
     /// A callback which can only be called once. The callback will panic if it is
     /// called more than once.
     CallbackOnce(Rc<CallbackOnce<IN>>),
@@ -23,14 +88,20 @@ type CallbackOnce<IN> = RefCell<Option<Box<dyn FnOnce(IN)>>>;
 
 impl<IN, F: Fn(IN) + 'static> From<F> for Callback<IN> {
     fn from(func: F) -> Self {
-        Callback::Callback(Rc::new(func))
+        Callback::Callback {
+            cb: Rc::new(func),
+            flags: None,
+        }
     }
 }
 
 impl<IN> Clone for Callback<IN> {
     fn clone(&self) -> Self {
         match self {
-            Callback::Callback(cb) => Callback::Callback(cb.clone()),
+            Callback::Callback { cb, flags } => Callback::Callback {
+                cb: cb.clone(),
+                flags: *flags,
+            },
             Callback::CallbackOnce(cb) => Callback::CallbackOnce(cb.clone()),
         }
     }
@@ -40,10 +111,16 @@ impl<IN> Clone for Callback<IN> {
 impl<IN> PartialEq for Callback<IN> {
     fn eq(&self, other: &Callback<IN>) -> bool {
         match (&self, &other) {
-            (Callback::Callback(cb), Callback::Callback(other_cb)) => Rc::ptr_eq(cb, other_cb),
             (Callback::CallbackOnce(cb), Callback::CallbackOnce(other_cb)) => {
                 Rc::ptr_eq(cb, other_cb)
             }
+            (
+                Callback::Callback { cb, flags },
+                Callback::Callback {
+                    cb: rhs_cb,
+                    flags: rhs_flags,
+                },
+            ) => Rc::ptr_eq(cb, rhs_cb) && flags == rhs_flags,
             _ => false,
         }
     }
@@ -52,7 +129,7 @@ impl<IN> PartialEq for Callback<IN> {
 impl<IN> fmt::Debug for Callback<IN> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let data = match self {
-            Callback::Callback(_) => "Callback<_>",
+            Callback::Callback { .. } => "Callback<_>",
             Callback::CallbackOnce(_) => "CallbackOnce<_>",
         };
 
@@ -64,10 +141,10 @@ impl<IN> Callback<IN> {
     /// This method calls the callback's function.
     pub fn emit(&self, value: IN) {
         match self {
-            Callback::Callback(cb) => cb(value),
+            Callback::Callback { cb, .. } => cb(value),
             Callback::CallbackOnce(rc) => {
                 let cb = rc.replace(None);
-                let f = cb.expect("callback in CallbackOnce has already been used");
+                let f = cb.expect("callback contains `FnOnce` which has already been used");
                 f(value)
             }
         };