Skip to content

armgit / moli

Public Imported from GitHub
0

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

Separate single and penetrating hit tests

ldm0eb829a980b9e
diff --git a/moli-dom/src/native/element/mod.rs b/moli-dom/src/native/element/mod.rs
index b8d2e67fc..d1f760b3e 100644
--- a/moli-dom/src/native/element/mod.rs
+++ b/moli-dom/src/native/element/mod.rs
@@ -248,6 +248,15 @@ impl Element {
self.is_html_element("img") || self.is_svg_element("image")
}
+ /// Whether this element implements the SVG text-content-element role.
+ ///
+ /// This inheritance fact is needed even for SVG element interfaces that
+ /// currently share the generic wrapper prototype.
+ pub fn is_svg_text_content_element(&self) -> bool {
+ self.namespace() == "http://www.w3.org/2000/svg"
+ && matches!(self.local_name(), "text" | "tspan" | "textPath")
+ }
+
pub fn is_inline_style_element(&self) -> bool {
self.local_name() == "style"
&& matches!(
diff --git a/moli-dom/src/native/element/tests.rs b/moli-dom/src/native/element/tests.rs
index 170eeedc5..c88abf318 100644
--- a/moli-dom/src/native/element/tests.rs
+++ b/moli-dom/src/native/element/tests.rs
@@ -215,6 +215,35 @@ fn svg_element_interface_name_specializes_standard_elements() {
assert_eq!(svg_element_interface_name("custom"), "SVGElement");
}
+#[test]
+fn svg_text_content_role_covers_text_tspan_and_text_path() {
+ for local_name in ["text", "tspan", "textPath"] {
+ let element = Element::new(
+ local_name.to_owned(),
+ "http://www.w3.org/2000/svg".to_owned(),
+ None,
+ Vec::new(),
+ );
+ assert!(element.is_svg_text_content_element(), "{local_name}");
+ }
+
+ for (namespace, local_name) in [
+ ("http://www.w3.org/2000/svg", "textpath"),
+ ("http://www.w3.org/1999/xhtml", "text"),
+ ] {
+ let element = Element::new(
+ local_name.to_owned(),
+ namespace.to_owned(),
+ None,
+ Vec::new(),
+ );
+ assert!(
+ !element.is_svg_text_content_element(),
+ "{namespace} {local_name}"
+ );
+ }
+}
+
#[test]
fn mathml_element_interface_name_uses_mathml_element() {
assert_eq!(mathml_element_interface_name("math"), "MathMLElement");
diff --git a/moli-renderer-v8/src/native_bridge/document/hit_test.rs b/moli-renderer-v8/src/native_bridge/document/hit_test.rs
index 2747f1fe0..b93b7acde 100644
--- a/moli-renderer-v8/src/native_bridge/document/hit_test.rs
+++ b/moli-renderer-v8/src/native_bridge/document/hit_test.rs
@@ -1,6 +1,8 @@
use std::collections::HashSet;
-use super::super::element::{ClientRect, observable_caret_position, observable_hit_test_all};
+use super::super::element::{
+ ClientRect, observable_caret_position, observable_hit_test, observable_hit_test_all,
+};
use super::super::node::{node_is_document, node_runtime_and_handle_from_args};
use crate::document_runtime::DomHandle;
use crate::native_bridge::JsContextHost;
@@ -461,6 +463,37 @@ fn element_for_hit_source(runtime: &JsContextHost, mut handle: DomHandle) -> Opt
}
}
+fn list_hit_accepts_non_element_source(runtime: &JsContextHost, source: DomHandle) -> bool {
+ let Some(parent) = runtime
+ .dom_host()
+ .node(source)
+ .and_then(|node| node.parent_node())
+ else {
+ return false;
+ };
+ let Some(parent) = runtime
+ .dom_host()
+ .node(parent)
+ .and_then(|node| node.as_element())
+ else {
+ return false;
+ };
+
+ // Blink's TreeScope::ElementsFromHitTestResult drops ordinary text-node
+ // hits from a penetrating list. Slot and SVG text-content children are
+ // retained because those parent elements may not contribute their own
+ // hit-test background entry.
+ parent.is_html_element("slot") || parent.is_svg_text_content_element()
+}
+
+fn element_for_list_hit_source(runtime: &JsContextHost, source: DomHandle) -> Option<DomHandle> {
+ let node = runtime.dom_host().node(source)?;
+ if !node.is_element() && !list_hit_accepts_non_element_source(runtime, source) {
+ return None;
+ }
+ element_for_hit_source(runtime, source)
+}
+
fn retarget_element_to_tree_scope(
runtime: &JsContextHost,
mut element: DomHandle,
@@ -484,6 +517,31 @@ fn point_is_inside_viewport(metrics: moli_layout::LayoutDocumentMetrics, x: f64,
&& y < f64::from(metrics.viewport.css_height)
}
+fn element_at_point(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ tree_scope: DomHandle,
+ x: f64,
+ y: f64,
+) -> Result<Option<DomHandle>, moli_layout::LayoutError> {
+ // A single-point query intentionally keeps a foremost text hit and maps
+ // it to its web-exposed parent element. This is observably different from
+ // the penetrating-list filtering performed by `elements_at_point`.
+ let (metrics, hit) = observable_hit_test(
+ runtime,
+ document,
+ moli_layout::LayoutPoint::new(x as f32, y as f32),
+ false,
+ moli_layout::LayoutFlushReason::HitTest,
+ )?;
+ if !point_is_inside_viewport(metrics, x, y) {
+ return Ok(None);
+ }
+ Ok(hit
+ .and_then(|hit| element_for_hit_source(runtime, hit.source))
+ .and_then(|element| retarget_element_to_tree_scope(runtime, element, tree_scope)))
+}
+
fn elements_at_point(
runtime: &JsContextHost,
document: DomHandle,
@@ -505,7 +563,7 @@ fn elements_at_point(
let mut seen = HashSet::new();
let mut elements = Vec::new();
for hit in hits {
- let Some(element) = element_for_hit_source(runtime, hit.source)
+ let Some(element) = element_for_list_hit_source(runtime, hit.source)
.and_then(|element| retarget_element_to_tree_scope(runtime, element, tree_scope))
else {
continue;
@@ -562,12 +620,10 @@ pub(in crate::native_bridge) fn node_document_element_from_point_callback<'s>(
return;
};
let runtime = unsafe { &*runtime_ptr };
- match elements_at_point(runtime, handle, handle, parsed.x, parsed.y) {
- Ok(elements) => {
- if let Some(element) = elements
- .into_iter()
- .next()
- .and_then(|element| node_wrapper_from_handle(scope, element))
+ match element_at_point(runtime, handle, handle, parsed.x, parsed.y) {
+ Ok(element) => {
+ if let Some(element) =
+ element.and_then(|element| node_wrapper_from_handle(scope, element))
{
rv.set(element.into());
} else {
@@ -683,12 +739,10 @@ pub(in crate::native_bridge) fn node_shadow_root_element_from_point_callback<'s>
rv.set_null();
return;
};
- match elements_at_point(runtime, document, handle, parsed.x, parsed.y) {
- Ok(elements) => {
- if let Some(element) = elements
- .into_iter()
- .next()
- .and_then(|element| node_wrapper_from_handle(scope, element))
+ match element_at_point(runtime, document, handle, parsed.x, parsed.y) {
+ Ok(element) => {
+ if let Some(element) =
+ element.and_then(|element| node_wrapper_from_handle(scope, element))
{
rv.set(element.into());
} else {
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index c15381178..5cf3704ee 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -390,10 +390,11 @@ pub(crate) use geometry::observable_scrollbar_hit_test;
pub(crate) use geometry::{
apply_scroll_observable_effects, 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_input_surface_hit_test,
- observable_scroll_adjusted_client_rect, observable_sources_with_fragments,
- perform_scrollbar_scroll_default_action, perform_wheel_scroll_default_action,
- queue_scroll_observable_effects, scroll_node_into_view_at_start,
+ observable_hit_test, observable_hit_test_all, observable_input_hit_test,
+ observable_input_surface_hit_test, observable_scroll_adjusted_client_rect,
+ observable_sources_with_fragments, perform_scrollbar_scroll_default_action,
+ perform_wheel_scroll_default_action, queue_scroll_observable_effects,
+ scroll_node_into_view_at_start,
};
pub(super) use geometry::{
node_client_height_getter_function, node_client_left_getter_function,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rs
index c327828f7..1fd9be50a 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs
@@ -11,7 +11,8 @@ pub use client_rect::ClientRect;
#[cfg(test)]
pub(crate) use hit_test::observable_scrollbar_hit_test;
pub(crate) use hit_test::{
- observable_deep_hit_test, observable_input_hit_test, observable_input_surface_hit_test,
+ observable_deep_hit_test, observable_hit_test, observable_input_hit_test,
+ observable_input_surface_hit_test,
};
pub(in crate::native_bridge) use metrics::{
node_client_height_getter_function, node_client_left_getter_function,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs b/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs
index b6b230f5d..67a89e31c 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs
@@ -370,7 +370,14 @@ fn observable_hit_test_in_viewport(
ignore_pointer_events_none: bool,
) -> Result<Option<LayoutHit<DomHandle>>, LayoutError> {
if !runtime.layout_policy().uses_real_layout() {
- return observable_hit_test(runtime, document, point, ignore_pointer_events_none);
+ return observable_hit_test(
+ runtime,
+ document,
+ point,
+ ignore_pointer_events_none,
+ LayoutFlushReason::HitTest,
+ )
+ .map(|(_, hit)| hit);
}
let answers = runtime.answer_layout_at_viewport(
document,
@@ -387,23 +394,40 @@ fn observable_hit_test_in_viewport(
}
}
-fn observable_hit_test(
+/// Resolve the foremost painted hit and the viewport sampled by the same
+/// frozen layout pass. Single-point DOM APIs consume this query while
+/// penetrating-list APIs use `observable_hit_test_all`.
+pub(crate) fn observable_hit_test(
runtime: &JsContextHost,
document: DomHandle,
point: LayoutPoint,
ignore_pointer_events_none: bool,
-) -> Result<Option<LayoutHit<DomHandle>>, LayoutError> {
+ reason: LayoutFlushReason,
+) -> Result<
+ (
+ moli_layout::LayoutDocumentMetrics,
+ Option<LayoutHit<DomHandle>>,
+ ),
+ LayoutError,
+> {
let answers = observable_geometry_batch(
runtime,
document,
- LayoutFlushReason::HitTest,
- &LayoutQueryBatch::new(vec![LayoutQuery::HitTest {
- point,
- ignore_pointer_events_none,
- }]),
+ reason,
+ &LayoutQueryBatch::new(vec![
+ LayoutQuery::DocumentMetrics,
+ LayoutQuery::HitTest {
+ point,
+ ignore_pointer_events_none,
+ },
+ ]),
)?;
- match answers.answers.into_iter().next() {
- Some(LayoutQueryAnswer::HitTest(hit)) => Ok(hit),
+ let mut answers = answers.answers.into_iter();
+ match (answers.next(), answers.next()) {
+ (
+ Some(LayoutQueryAnswer::DocumentMetrics(metrics)),
+ Some(LayoutQueryAnswer::HitTest(hit)),
+ ) => Ok((metrics, hit)),
_ => Err(provider_contract_error("hit test")),
}
}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
index 325ffa385..be817db51 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
@@ -3073,6 +3073,51 @@ document.getElementById('absolute').offsetParent === document.getElementById('pa
.expect("block-in-inline CSSOM ancestry fixture should run");
}
+#[tokio::test(flavor = "current_thread")]
+async fn elements_from_point_filters_html_text_hits_from_the_penetrating_list() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/elements-from-point-negative-margin.html")?,
+ );
+ page_vm.vm_mut().eval(
+ r#"
+document.head.innerHTML = '<style>html,body{margin:0}</style>';
+document.body.innerHTML = `<div id=outer style="background:yellow">
+ <div id=inner style="width:100px;height:100px;margin-bottom:-100px;background:lime"></div>
+ Hello
+</div>`;
+'installed'
+"#,
+ )?;
+ page_vm.vm_mut().sync_live_document_style_sources();
+ page_vm
+ .vm_mut()
+ .screenshot_layout_snapshot(moli_layout::PaintViewport::new(200, 120, 1.0))?
+ .expect("negative-margin hit-test fixture must retain a layout root");
+
+ assert_eq!(
+ page_vm.vm_mut().eval(
+ r#"const rect = document.getElementById('outer').getBoundingClientRect();
+const x = rect.left + 1;
+const y = rect.top + 1;
+[
+ document.elementFromPoint(x, y)?.id,
+ document.elementsFromPoint(x, y).map(element => element.id || element.localName).join(',')
+].join('|')"#,
+ )?,
+ "outer|inner,outer,body,html",
+ "single and penetrating hit tests must apply their distinct text-node policies",
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("negative-margin elementsFromPoint fixture should run");
+}
+
#[tokio::test(flavor = "current_thread")]
async fn stylesheet_lifecycle_registers_only_the_current_documents_data_web_fonts() {
run_page_vm_async_test(async move {