Deduplicate reactive scope updates/Reset subscriptions on reruns/fix use memo double update (#2506)

* deduplicate effect updates

* only subscribe to signals read in the current run of reactive scopes

* subscribe to memo reads after recomputing the value

packages/hooks/tests/memo.rs

@@ -50,21 +50,73 @@ async fn memo_updates() {
         }
     }
 
-    let mut dom = VirtualDom::new(app);
+    let race = async move {
+        let mut dom = VirtualDom::new(app);
 
-    dom.rebuild_in_place();
-    let mut signal = VEC_SIGNAL.with(|cell| (*cell.borrow()).unwrap());
-    // Wait for the signal to update
-    for _ in 0..2 {
-        dom.wait_for_work().await;
-        dom.render_immediate(&mut dioxus::dioxus_core::NoOpMutations);
+        dom.rebuild_in_place();
+        let mut signal = VEC_SIGNAL.with(|cell| (*cell.borrow()).unwrap());
+        // Wait for the signal to update
+        for _ in 0..2 {
+            dom.wait_for_work().await;
+            dom.render_immediate(&mut dioxus::dioxus_core::NoOpMutations);
+        }
+        assert_eq!(signal(), vec![0, 1, 2, 3, 4, 5]);
+        // Remove each element from the vec
+        for _ in 0..6 {
+            signal.pop();
+            dom.wait_for_work().await;
+            dom.render_immediate(&mut dioxus::dioxus_core::NoOpMutations);
+            println!("Signal: {signal:?}");
+        }
+    };
+
+    tokio::select! {
+        _ = race => {},
+        _ = tokio::time::sleep(std::time::Duration::from_millis(1000)) => panic!("timed out")
+    };
+}
+
+#[tokio::test]
+async fn use_memo_only_triggers_one_update() {
+    use dioxus::prelude::*;
+    use std::cell::RefCell;
+
+    thread_local! {
+        static VEC_SIGNAL: RefCell<Vec<usize>> = const { RefCell::new(Vec::new()) };
     }
-    assert_eq!(signal(), vec![0, 1, 2, 3, 4, 5]);
-    // Remove each element from the vec
-    for _ in 0..6 {
-        signal.pop();
-        dom.wait_for_work().await;
-        dom.render_immediate(&mut dioxus::dioxus_core::NoOpMutations);
-        println!("Signal: {signal:?}");
+
+    fn app() -> Element {
+        let mut count = use_signal(|| 0);
+
+        let memorized = use_memo(move || dbg!(count() * 2));
+
+        use_memo(move || {
+            println!("reading doubled");
+            let doubled = memorized();
+            VEC_SIGNAL.with_borrow_mut(|v| v.push(doubled))
+        });
+
+        // Writing to count many times in a row should not cause the memo to update other subscribers multiple times
+        use_hook(move || {
+            for _ in 0..10 {
+                count += 1;
+                // Reading the memo each time will trigger the memo to rerun immediately, but the VEC_SIGNAL should still only rerun once
+                println!("doubled {memorized}");
+            }
+        });
+
+        rsx! {}
     }
+
+    let mut dom = VirtualDom::new(app);
+    dom.rebuild_in_place();
+
+    tokio::select! {
+        _ = dom.wait_for_work() => {},
+        _ = tokio::time::sleep(std::time::Duration::from_millis(100)) => {}
+    };
+
+    dom.render_immediate(&mut dioxus::dioxus_core::NoOpMutations);
+
+    assert_eq!(VEC_SIGNAL.with(|v| v.borrow().clone()), vec![0, 20]);
 }