fix: only yield when DOM is in a consistent state

Yield to the browser only when no DOM-mutating work (destroy, create,
render_first, render, render_priority) is pending, so event handlers
that fire during the yield never see a partially-rendered tree.

Also lower yield deadline from 50ms to 16ms (~60fps) and gate
start_now() to non-wasm/test targets where it is actually used.

Author: Madoshakalaka

packages/yew/src/scheduler.rs

@@ -211,6 +211,12 @@ mod feat_hydration {
 pub(crate) use feat_hydration::*;
 
 /// Execute any pending [Runnable]s
+#[cfg(any(
+    not(target_arch = "wasm32"),
+    target_os = "wasi",
+    feature = "not_browser_env",
+    test
+))]
 pub(crate) fn start_now() {
     #[tracing::instrument(level = tracing::Level::DEBUG)]
     fn scheduler_loop() {
@@ -270,7 +276,7 @@ mod arch {
         check_scheduled()
     }
 
-    const YIELD_DEADLINE_MS: f64 = 50.0;
+    const YIELD_DEADLINE_MS: f64 = 16.0;
 
     #[wasm_bindgen]
     extern "C" {
@@ -279,7 +285,7 @@ mod arch {
     }
 
     fn run_scheduler(mut queue: Vec<super::QueueEntry>) {
-        let mut deadline = js_sys::Date::now() + YIELD_DEADLINE_MS;
+        let deadline = js_sys::Date::now() + YIELD_DEADLINE_MS;
 
         loop {
             super::with(|s| s.fill_queue(&mut queue));
@@ -289,20 +295,27 @@ mod arch {
             for r in queue.drain(..) {
                 r.task.run();
             }
-            let now = js_sys::Date::now();
-            if now >= deadline {
-                let cb = Closure::once_into_js(move || run_scheduler(queue));
-                set_timeout(cb.unchecked_ref(), 0);
-                return;
+            if js_sys::Date::now() >= deadline {
+                // Only yield when no DOM-mutating work is pending, so event
+                // handlers that fire during the yield see a consistent DOM.
+                let can_yield = super::with(|s| s.can_yield());
+                if can_yield {
+                    let cb = Closure::once_into_js(move || run_scheduler(queue));
+                    set_timeout(cb.unchecked_ref(), 0);
+                    return;
+                }
             }
         }
 
         set_scheduled(false);
+        #[cfg(any(test, feature = "test"))]
+        super::flush_wakers::wake_all();
     }
 
     /// We delay the start of the scheduler to the end of the micro task queue.
     /// So any messages that needs to be queued can be queued.
-    /// Once running, we yield to the browser every ~50ms to avoid long tasks.
+    /// Once running, we yield to the browser every ~16ms, but only at points
+    /// where the DOM is in a consistent state (no pending renders/destroys).
     pub(crate) fn start() {
         if check_scheduled() {
             return;
@@ -378,6 +391,21 @@ pub async fn flush() {
 }
 
 impl Scheduler {
+    /// Returns true when no DOM-mutating work is pending, meaning it's safe to
+    /// yield to the browser without leaving the DOM in an inconsistent state.
+    #[cfg(all(
+        target_arch = "wasm32",
+        not(target_os = "wasi"),
+        not(feature = "not_browser_env")
+    ))]
+    fn can_yield(&self) -> bool {
+        self.destroy.inner.is_empty()
+            && self.create.inner.is_empty()
+            && self.render_first.inner.is_empty()
+            && self.render.inner.is_empty()
+            && self.render_priority.inner.is_empty()
+    }
+
     /// Fill vector with tasks to be executed according to Runnable type execution priority
     ///
     /// This method is optimized for typical usage, where possible, but does not break on