Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

feat: implement default wheel scrolling

ldm0c09656bf3bfa
diff --git a/moli-layout/src/layout_tree/model.rs b/moli-layout/src/layout_tree/model.rs
index 0283617f2..a6aed75c2 100644
--- a/moli-layout/src/layout_tree/model.rs
+++ b/moli-layout/src/layout_tree/model.rs
@@ -301,6 +301,8 @@ pub struct LayoutScrollExtent {
pub minimum_offset: LayoutPoint,
pub maximum_offset: LayoutPoint,
pub is_scroll_container: bool,
+ pub allows_user_scroll_x: bool,
+ pub allows_user_scroll_y: bool,
pub clips_overflow: bool,
}
diff --git a/moli-layout/src/layout_tree/query.rs b/moli-layout/src/layout_tree/query.rs
index 3de2899cc..1bb30ccdc 100644
--- a/moli-layout/src/layout_tree/query.rs
+++ b/moli-layout/src/layout_tree/query.rs
@@ -52,6 +52,8 @@ pub struct LayoutElementMetrics<N> {
pub scrollport: LayoutQuad,
pub scrollable_overflow: LayoutQuad,
pub is_scroll_container: bool,
+ pub allows_user_scroll_x: bool,
+ pub allows_user_scroll_y: bool,
pub clips_overflow: bool,
pub visible: bool,
pub pointer_events: bool,
diff --git a/moli-layout/src/layout_tree/source_query.rs b/moli-layout/src/layout_tree/source_query.rs
index cdc654aeb..29651dd05 100644
--- a/moli-layout/src/layout_tree/source_query.rs
+++ b/moli-layout/src/layout_tree/source_query.rs
@@ -160,6 +160,8 @@ where
.local_to_viewport
.map_rect(extent.scrollable_overflow),
is_scroll_container: extent.is_scroll_container,
+ allows_user_scroll_x: extent.allows_user_scroll_x,
+ allows_user_scroll_y: extent.allows_user_scroll_y,
clips_overflow: extent.clips_overflow,
visible: geometry.visible,
pointer_events: geometry.pointer_events,
diff --git a/moli-layout/src/projection.rs b/moli-layout/src/projection.rs
index c3619577d..9ee9ab645 100644
--- a/moli-layout/src/projection.rs
+++ b/moli-layout/src/projection.rs
@@ -446,6 +446,10 @@ where
minimum_offset,
maximum_offset,
is_scroll_container,
+ allows_user_scroll_x: is_root
+ || self.world.boxes[index].style.allows_user_scroll_x(),
+ allows_user_scroll_y: is_root
+ || self.world.boxes[index].style.allows_user_scroll_y(),
clips_overflow: self.world.boxes[index].style.clips_overflow(),
});
}
diff --git a/moli-layout/src/style.rs b/moli-layout/src/style.rs
index 6d7e9d57c..45617cc32 100644
--- a/moli-layout/src/style.rs
+++ b/moli-layout/src/style.rs
@@ -1496,6 +1496,14 @@ impl ResolvedLayoutStyle {
.any(|overflow| matches!(overflow, taffy::Overflow::Hidden | taffy::Overflow::Scroll))
}
+ pub(crate) fn allows_user_scroll_x(&self) -> bool {
+ self.taffy.overflow.x == taffy::Overflow::Scroll
+ }
+
+ pub(crate) fn allows_user_scroll_y(&self) -> bool {
+ self.taffy.overflow.y == taffy::Overflow::Scroll
+ }
+
pub(crate) fn text_leaf_from(parent: &Self) -> Self {
Self {
computed: parent.computed.clone(),
diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
index 11676d518..639c38938 100644
--- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
@@ -98,6 +98,133 @@ async fn fetch_server_response(
(status, response[header_end + 4..].to_vec())
}
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn websocket_cdp_mouse_wheel_scrolls_page_and_honors_prevent_default() {
+ let (addr, server) = spawn_test_protocol_server().await;
+ let (mut browser, _) =
+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
+ .await
+ .expect("connect browser websocket");
+ let target_id = create_dynamic_target(&mut browser, 1).await;
+ let mut page = connect_dynamic_page(addr, &target_id).await;
+
+ let installed = send_cdp_command(
+ &mut page,
+ 1,
+ "Runtime.evaluate",
+ None,
+ json!({
+ "expression": r#"
+ (() => {
+ document.documentElement.style.margin = "0";
+ document.body.style.margin = "0";
+ document.body.innerHTML =
+ '<div style="height: 500px"></div>' +
+ '<div id="marker" style="height: 20px"></div>' +
+ '<div style="height: 2500px"></div>';
+ window.__wheelDeltas = [];
+ window.addEventListener("wheel", event => {
+ window.__wheelDeltas.push(event.deltaY);
+ }, { capture: true });
+ return document.getElementById("marker").getBoundingClientRect().top;
+ })()
+ "#,
+ "returnByValue": true
+ }),
+ )
+ .await;
+ let marker_before = response_by_id(&installed, 1)["result"]["result"]["value"]
+ .as_f64()
+ .expect("initial marker top");
+
+ let wheel = send_cdp_command(
+ &mut page,
+ 2,
+ "Input.dispatchMouseEvent",
+ None,
+ json!({
+ "type": "mouseWheel",
+ "x": 10,
+ "y": 10,
+ "deltaX": 0,
+ "deltaY": 120
+ }),
+ )
+ .await;
+ assert!(response_by_id(&wheel, 2).get("result").is_some());
+
+ let scrolled = send_cdp_command(
+ &mut page,
+ 3,
+ "Runtime.evaluate",
+ None,
+ json!({
+ "expression": r#"
+ ({
+ scrollY,
+ markerTop: document.getElementById("marker").getBoundingClientRect().top,
+ wheelDeltas: window.__wheelDeltas
+ })
+ "#,
+ "returnByValue": true
+ }),
+ )
+ .await;
+ let value = &response_by_id(&scrolled, 3)["result"]["result"]["value"];
+ assert_eq!(value["scrollY"], json!(120));
+ assert_eq!(
+ value["markerTop"].as_f64().expect("scrolled marker top"),
+ marker_before - 120.0
+ );
+ assert_eq!(value["wheelDeltas"], json!([120]));
+
+ let cancel = send_cdp_command(
+ &mut page,
+ 4,
+ "Runtime.evaluate",
+ None,
+ json!({
+ "expression": r#"
+ window.addEventListener("wheel", event => event.preventDefault(), {
+ capture: true,
+ passive: false
+ })
+ "#
+ }),
+ )
+ .await;
+ assert!(response_by_id(&cancel, 4).get("result").is_some());
+ let canceled_wheel = send_cdp_command(
+ &mut page,
+ 5,
+ "Input.dispatchMouseEvent",
+ None,
+ json!({
+ "type": "mouseWheel",
+ "x": 10,
+ "y": 10,
+ "deltaX": 0,
+ "deltaY": 80
+ }),
+ )
+ .await;
+ assert!(response_by_id(&canceled_wheel, 5).get("result").is_some());
+ let final_scroll = send_cdp_command(
+ &mut page,
+ 6,
+ "Runtime.evaluate",
+ None,
+ json!({ "expression": "scrollY", "returnByValue": true }),
+ )
+ .await;
+ assert_eq!(
+ response_by_id(&final_scroll, 6)["result"]["result"]["value"],
+ json!(120)
+ );
+
+ abort_test_cdp_server(server).await;
+}
+
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn websocket_cdp_dynamic_page_routes_to_existing_target_owner() {
let (addr, server) = spawn_test_protocol_server().await;
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index 24d5a2c07..e2924a526 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -401,7 +401,8 @@ pub(crate) use geometry::{
observable_bounding_client_rect, observable_caret_position, observable_deep_hit_test,
observable_event_offset, observable_geometry_batch, observable_hit_test_all,
observable_input_hit_test, observable_scroll_adjusted_client_rect,
- observable_sources_with_fragments, scroll_node_into_view_at_start,
+ observable_sources_with_fragments, perform_wheel_scroll_default_action,
+ queue_scroll_observable_effects, scroll_node_into_view_at_start,
};
pub(super) use global_attributes::{
anchor_target_getter_function, anchor_target_setter_function, area_no_href_setter_function,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rs
index 8e561350f..4eef52818 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs
@@ -19,7 +19,10 @@ pub(in crate::native_bridge) use metrics::{
node_scroll_top_getter_function, node_scroll_top_setter_function,
node_scroll_width_getter_function,
};
-pub(crate) use metrics::{scroll_node_into_view_at_start, scroll_node_into_view_if_needed};
+pub(crate) use metrics::{
+ perform_wheel_scroll_default_action, queue_scroll_observable_effects,
+ scroll_node_into_view_at_start, scroll_node_into_view_if_needed,
+};
pub(crate) use provider::{
observable_bounding_client_rect, observable_bounding_client_rects, observable_caret_position,
observable_client_rects, observable_deep_hit_test, observable_element_metrics,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs b/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs
index 44c2462e4..fec27494e 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs
@@ -85,6 +85,7 @@ fn node_scroll_position_setter_for_object<'s>(
};
let value = value.clamp(minimum, maximum);
let is_scrolling_element = runtime.dom_host().document_element_handle() == Some(handle);
+ let document = runtime.dom_host().owner_document_handle(handle);
let Some(element) = runtime
.dom_host_mut()
.node_mut(handle)
@@ -107,7 +108,7 @@ fn node_scroll_position_setter_for_object<'s>(
if horizontal { current.1 } else { value },
);
} else {
- crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);
+ queue_scroll_observable_effects(scope, runtime_ptr, document, false);
}
}
Ok(())
@@ -158,22 +159,44 @@ fn set_node_scroll_position(
top: f64,
queue_observable_effects: bool,
) {
- let runtime = unsafe { &mut *runtime_ptr };
- let Some(element) = runtime
- .dom_host_mut()
- .node_mut(handle)
- .and_then(|node| node.data_mut().as_element_mut())
- else {
- return;
+ let (changed, document) = {
+ let runtime = unsafe { &mut *runtime_ptr };
+ let document = runtime.dom_host().owner_document_handle(handle);
+ let Some(element) = runtime
+ .dom_host_mut()
+ .node_mut(handle)
+ .and_then(|node| node.data_mut().as_element_mut())
+ else {
+ return;
+ };
+ (
+ element.set_scroll_left(left) | element.set_scroll_top(top),
+ document,
+ )
};
- let changed = element.set_scroll_left(left) | element.set_scroll_top(top);
if changed && queue_observable_effects {
- crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);
- let document = runtime.dom_host().owner_document_handle(handle);
- if let Some(document) = document {
- queue_revealed_lazy_image_loads(scope, runtime_ptr, document);
- }
- queue_revealed_lazy_media_loads(scope, runtime_ptr);
+ queue_scroll_observable_effects(scope, runtime_ptr, document, false);
+ }
+}
+
+pub(crate) fn queue_scroll_observable_effects(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ document: Option<DomHandle>,
+ queue_document_events: bool,
+) {
+ // Native lazy loading deliberately combines the retained pre-scroll
+ // projection with live element offsets, so admit those requests before
+ // retiring the sampled projection. Observable geometry and author
+ // IntersectionObservers, on the other hand, must see a fresh projection.
+ if let Some(document) = document {
+ queue_revealed_lazy_image_loads(scope, runtime_ptr, document);
+ }
+ queue_revealed_lazy_media_loads(scope, runtime_ptr);
+ unsafe { &*runtime_ptr }.invalidate_layout_after_interaction_state_change();
+ crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);
+ if queue_document_events {
+ let _ = unsafe { &mut *runtime_ptr }.queue_document_scroll_events(scope);
}
}
@@ -259,6 +282,146 @@ fn apply_observable_window_scroll(
true
}
+fn consume_wheel_axis(
+ current: f64,
+ minimum: f64,
+ maximum: f64,
+ remaining: f64,
+ allows_user_scroll: bool,
+) -> (f64, f64) {
+ if !allows_user_scroll || remaining == 0.0 {
+ return (current, remaining);
+ }
+ let target = (current + remaining).clamp(minimum, maximum);
+ (target, remaining - (target - current))
+}
+
+/// Run the uncancelled default action for one pixel-mode WheelEvent.
+///
+/// Each axis starts at the innermost scroll container under the pointer. Any
+/// delta left at that container's boundary continues along the layout ancestor
+/// chain, matching the scroll chaining users expect from a trackpad or wheel.
+pub(crate) fn perform_wheel_scroll_default_action(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ delta_x: f64,
+ delta_y: f64,
+) -> Result<bool, moli_layout::LayoutError> {
+ let mut remaining_x = if delta_x.is_finite() { delta_x } else { 0.0 };
+ let mut remaining_y = if delta_y.is_finite() { delta_y } else { 0.0 };
+ if remaining_x == 0.0 && remaining_y == 0.0 {
+ return Ok(false);
+ }
+
+ let runtime = unsafe { &*runtime_ptr };
+ let target = if runtime
+ .dom_host()
+ .node(handle)
+ .is_some_and(Node::is_document)
+ {
+ let Some(root) = runtime.dom_host().document_element_handle() else {
+ return Ok(false);
+ };
+ root
+ } else if runtime.dom_host().is_connected(handle) {
+ handle
+ } else {
+ return Ok(false);
+ };
+ let Some(mut geometry) = observable_scroll_into_view_geometry(
+ runtime,
+ target,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )?
+ else {
+ return Ok(false);
+ };
+
+ // ScrollIntoView geometry begins at the target's parent. Include the
+ // target itself so an empty overflow scroller still responds when its own
+ // background is the hit-test result.
+ if let Some(metrics) = observable_element_metrics(
+ runtime,
+ target,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )? && metrics.is_scroll_container
+ && geometry
+ .scroll_containers
+ .iter()
+ .all(|container| container.source != target)
+ {
+ geometry.scroll_containers.insert(
+ 0,
+ moli_layout::LayoutScrollContainerMetrics {
+ source: target,
+ metrics,
+ },
+ );
+ }
+
+ let mut changed = false;
+ for container in geometry.scroll_containers {
+ if remaining_x == 0.0 && remaining_y == 0.0 {
+ break;
+ }
+ let (current_x, current_y) =
+ node_scroll_position(unsafe { &*runtime_ptr }, container.source);
+ let (target_x, next_remaining_x) = consume_wheel_axis(
+ current_x,
+ f64::from(container.metrics.minimum_scroll_offset.x),
+ f64::from(container.metrics.maximum_scroll_offset.x),
+ remaining_x,
+ container.metrics.allows_user_scroll_x,
+ );
+ let (target_y, next_remaining_y) = consume_wheel_axis(
+ current_y,
+ f64::from(container.metrics.minimum_scroll_offset.y),
+ f64::from(container.metrics.maximum_scroll_offset.y),
+ remaining_y,
+ container.metrics.allows_user_scroll_y,
+ );
+ remaining_x = next_remaining_x;
+ remaining_y = next_remaining_y;
+ if target_x == current_x && target_y == current_y {
+ continue;
+ }
+
+ let container_document = unsafe { &*runtime_ptr }
+ .dom_host()
+ .owner_document_handle(container.source);
+ let is_document_scroller = container_document.is_some_and(|document| {
+ unsafe { &*runtime_ptr }
+ .dom_host()
+ .dom()
+ .document_element_handle_for_document(document)
+ == Some(container.source)
+ });
+ if is_document_scroller {
+ changed |= apply_observable_window_scroll(
+ scope,
+ runtime_ptr,
+ container.source,
+ target_x,
+ target_y,
+ current_x,
+ current_y,
+ );
+ } else {
+ set_node_scroll_position(
+ scope,
+ runtime_ptr,
+ container.source,
+ target_x,
+ target_y,
+ true,
+ );
+ changed = true;
+ }
+ }
+ Ok(changed)
+}
+
pub(crate) fn scroll_node_into_view_if_needed(
scope: &mut v8::PinScope<'_, '_>,
runtime_ptr: *mut JsContextHost,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
index 493d16e4e..d9f67af89 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
@@ -628,6 +628,8 @@ fn mock_element_metrics(
scrollport: quad,
scrollable_overflow: quad,
is_scroll_container: false,
+ allows_user_scroll_x: false,
+ allows_user_scroll_y: false,
clips_overflow: false,
visible: rect.width > 0.0 && rect.height > 0.0,
pointer_events: true,
diff --git a/moli-renderer-v8/src/script_vm/input_dispatch.rs b/moli-renderer-v8/src/script_vm/input_dispatch.rs
index e18d3882b..a2a2fc732 100644
--- a/moli-renderer-v8/src/script_vm/input_dispatch.rs
+++ b/moli-renderer-v8/src/script_vm/input_dispatch.rs
@@ -23,8 +23,9 @@ use crate::native_bridge::element::{
construct_touch_event, construct_touch_event_with_points, construct_wheel_event,
contenteditable_editing_host, dispatch_public_event, observable_input_hit_test,
perform_drop_default_action, perform_mouse_focus_default_action,
- replace_contenteditable_selection, replace_text_control_selection,
- select_contenteditable_contents, text_control_set_selection_range_internal,
+ perform_wheel_scroll_default_action, replace_contenteditable_selection,
+ replace_text_control_selection, select_contenteditable_contents,
+ text_control_set_selection_range_internal,
text_control_set_selection_range_with_direction_internal, text_control_value, update_focus,
};
use crate::runtime::{
@@ -458,7 +459,15 @@ impl ScriptVm {
let mut context_host = self._context_host.borrow_mut();
context_host.set_hovered_element_for_input(hit_handle);
}
- let Some(handle) = capture_handle.or(hit_handle) else {
+ let wheel_fallback_handle = (event_name == "wheel")
+ .then(|| {
+ self._context_host
+ .borrow()
+ .dom_host()
+ .document_element_handle()
+ })
+ .flatten();
+ let Some(handle) = capture_handle.or(hit_handle).or(wheel_fallback_handle) else {
return Ok(input_dispatch_outcome(false));
};
let hover_transition = if tracks_mouse_hover_for_event(event_name) {
@@ -708,6 +717,15 @@ impl ScriptVm {
if let Some(event) = event {
let dispatched =
dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);
+ if event_name == "wheel" && dispatched.allows_default() {
+ let _ = perform_wheel_scroll_default_action(
+ scope,
+ runtime_ptr,
+ pointer_dispatch_handle,
+ delta_x,
+ delta_y,
+ )?;
+ }
if event_name == "mousedown" && dispatched.allows_default() {
// Chromium transfers mouse focus only after the
// pointer/mouse down events have run and only when
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs
index 8d543437a..40c1c910c 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs
@@ -242,6 +242,180 @@ fn element_scroll_into_view_if_needed_updates_observable_window_scroll() {
assert_eq!(result["scrollingElementScroll"], result["standardScroll"]);
}
+#[test]
+fn wheel_default_action_scrolls_and_refreshes_geometry_unless_canceled() {
+ let mut vm = new_storage_test_vm("https://wheel-default-scroll.test/");
+ vm.eval(
+ r#"
+ (() => {
+ if (!document.documentElement) {
+ document.appendChild(document.createElement("html"));
+ }
+ if (!document.body) {
+ document.documentElement.appendChild(document.createElement("body"));
+ }
+ document.documentElement.style.margin = "0";
+ document.body.style.margin = "0";
+ document.body.innerHTML =
+ '<div style="height: 500px"></div>' +
+ '<div id="marker" style="height: 20px"></div>' +
+ '<div style="height: 2500px"></div>';
+ window.__wheelDeltas = [];
+ window.addEventListener("wheel", event => {
+ window.__wheelDeltas.push(event.deltaY);
+ }, { capture: true });
+ })()
+ "#,
+ )
+ .expect("wheel fixture should initialize");
+ refresh_layout_for_test(&mut vm);
+
+ let before = vm
+ .eval("document.getElementById('marker').getBoundingClientRect().top")
+ .expect("initial marker geometry should evaluate")
+ .parse::<f64>()
+ .expect("initial marker top should be numeric");
+ let outcome = vm
+ .dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 120.0)
+ .expect("wheel input should dispatch");
+ assert!(outcome.handled);
+
+ let result = vm
+ .eval(
+ r#"
+ JSON.stringify({
+ scrollY,
+ scrollingElementScrollTop: document.scrollingElement.scrollTop,
+ markerTop: document.getElementById("marker").getBoundingClientRect().top,
+ wheelDeltas: window.__wheelDeltas
+ })
+ "#,
+ )
+ .expect("post-wheel geometry should evaluate");
+ let result: serde_json::Value =
+ serde_json::from_str(&result).expect("post-wheel result should be JSON");
+ assert_eq!(result["scrollY"], 120.0);
+ assert_eq!(result["scrollingElementScrollTop"], 120.0);
+ assert_eq!(result["markerTop"], before - 120.0);
+ assert_eq!(result["wheelDeltas"], serde_json::json!([120]));
+
+ vm.eval(
+ r#"
+ window.addEventListener("wheel", event => event.preventDefault(), {
+ capture: true,
+ passive: false
+ })
+ "#,
+ )
+ .expect("wheel cancellation listener should install");
+ vm.dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 80.0)
+ .expect("canceled wheel input should dispatch");
+ assert_eq!(
+ vm.eval("String(scrollY)")
+ .expect("canceled wheel scroll position should evaluate"),
+ "120"
+ );
+}
+
+#[test]
+fn window_scroll_refreshes_intersection_observer_geometry() {
+ let mut vm = new_storage_test_vm("https://scroll-intersection-observer.test/");
+ vm.eval(
+ r#"
+ (() => {
+ if (!document.documentElement) {
+ document.appendChild(document.createElement("html"));
+ }
+ if (!document.body) {
+ document.documentElement.appendChild(document.createElement("body"));
+ }
+ document.documentElement.style.margin = "0";
+ document.body.style.margin = "0";
+ document.body.innerHTML =
+ '<div style="height: 800px"></div>' +
+ '<div id="lazy-target" style="height: 20px"></div>' +
+ '<div style="height: 1000px"></div>';
+ })()
+ "#,
+ )
+ .expect("intersection scroll fixture should initialize");
+ refresh_layout_for_test(&mut vm);
+
+ vm.eval(
+ r#"
+ (() => {
+ window.__intersectionStates = [];
+ window.__intersectionObserver = new IntersectionObserver(entries => {
+ window.__intersectionStates.push(entries[0].isIntersecting);
+ });
+ window.__intersectionObserver.observe(
+ document.getElementById("lazy-target")
+ );
+ })()
+ "#,
+ )
+ .expect("intersection observer should register");
+ assert_eq!(
+ vm.eval("JSON.stringify(window.__intersectionStates)")
+ .expect("initial intersection state should flush"),
+ "[false]"
+ );
+
+ vm.eval("window.scrollTo(0, 400)")
+ .expect("window scroll should evaluate");
+ assert_eq!(
+ vm.eval("JSON.stringify(window.__intersectionStates)")
+ .expect("scrolled intersection state should flush"),
+ "[false,true]"
+ );
+}
+
+#[test]
+fn wheel_default_action_scrolls_the_innermost_container_then_chains_to_the_root() {
+ let mut vm = new_storage_test_vm("https://wheel-scroll-chain.test/");
+ vm.eval(
+ r#"
+ (() => {
+ if (!document.documentElement) {
+ document.appendChild(document.createElement("html"));
+ }
+ if (!document.body) {
+ document.documentElement.appendChild(document.createElement("body"));
+ }
+ document.documentElement.style.margin = "0";
+ document.body.style.margin = "0";
+ document.body.innerHTML =
+ '<div id="scroller" style="width: 200px; height: 100px; overflow: auto">' +
+ '<div style="height: 500px"></div>' +
+ '</div>' +
+ '<div style="height: 2000px"></div>';
+ })()
+ "#,
+ )
+ .expect("nested wheel fixture should initialize");
+ refresh_layout_for_test(&mut vm);
+
+ vm.dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 60.0)
+ .expect("nested wheel input should dispatch");
+ assert_eq!(
+ vm.eval("JSON.stringify([document.getElementById('scroller').scrollTop, window.scrollY])")
+ .expect("nested wheel positions should evaluate"),
+ "[60,0]"
+ );
+
+ vm.eval(
+ "document.getElementById('scroller').scrollTop = document.getElementById('scroller').scrollHeight"
+ )
+ .expect("nested scroller should move to its boundary");
+ vm.dispatch_mouse_event_at_point(10.0, 10.0, "wheel", -1, Some(0), 0.0, 40.0)
+ .expect("chained wheel input should dispatch");
+ assert_eq!(
+ vm.eval("String(window.scrollY)")
+ .expect("root chained scroll position should evaluate"),
+ "40"
+ );
+}
+
#[test]
fn dom_core_prototype_accessors_brand_check_live_and_detached_receivers() {
let mut vm = new_storage_test_vm("https://example.com/");
diff --git a/moli-renderer-v8/src/window_host.rs b/moli-renderer-v8/src/window_host.rs
index c27fa2f97..218201356 100644
--- a/moli-renderer-v8/src/window_host.rs
+++ b/moli-renderer-v8/src/window_host.rs
@@ -32,8 +32,7 @@ use super::{
iframe_handle_viewport, observable_event_offset,
perform_click_default_action_for_dispatched_event,
prepare_legacy_activation_for_dispatched_click,
- queue_animation_start_for_listener_target, queue_revealed_lazy_image_loads,
- queue_revealed_lazy_media_loads,
+ queue_animation_start_for_listener_target, queue_scroll_observable_effects,
},
enter_active_child_window_scope, enter_top_level_lightweight_popup_scope,
node_runtime_and_handle_from_object, throw_dom_exception,
@@ -1077,13 +1076,7 @@ pub(crate) fn scroll_window_to(
if !set_scroll_position(scope, global, x, y) && !scrolling_element_changed {
return;
}
- crate::observer_runtime::queue_intersection_checks(scope, host_ptr);
- if let Some(document) = document {
- queue_revealed_lazy_image_loads(scope, host_ptr, document);
- }
- queue_revealed_lazy_media_loads(scope, host_ptr);
- let runtime = unsafe { &mut *host_ptr };
- let _ = runtime.queue_document_scroll_events(scope);
+ queue_scroll_observable_effects(scope, host_ptr, document, true);
}
pub(crate) fn current_window_scroll_position(scope: &mut v8::PinScope<'_, '_>) -> (f64, f64) {