Skip to content

armgit / moli

Public Imported from GitHub
0

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

perf(layout): stream point hit candidates before ordering results

ldm029b5a36d5fe1
diff --git a/moli-layout/src/layout_tree/hit_test.rs b/moli-layout/src/layout_tree/hit_test.rs
index 4918612b9..4aa9a256d 100644
--- a/moli-layout/src/layout_tree/hit_test.rs
+++ b/moli-layout/src/layout_tree/hit_test.rs
@@ -1,4 +1,4 @@
-//! Temporary hit-test candidates and caret projections derived per query.
+//! Streaming hit-test candidates and caret projections derived per query.
use std::{collections::HashSet, fmt::Debug, hash::Hash};
@@ -27,7 +27,7 @@ impl<N: Copy> LayoutPaintedSurfaceHit<N> {
}
}
-/// One front-to-back hit-test candidate.
+/// One hit-test candidate in fragment storage order.
#[derive(Clone, Debug, PartialEq)]
struct LayoutHitTestEntry<N> {
source: N,
@@ -91,9 +91,18 @@ where
viewport_point: LayoutPoint,
ignore_pointer_events_none: bool,
) -> Option<LayoutHit<N>> {
- self.hit_test_entries().into_iter().find_map(|entry| {
- self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)
- })
+ let mut foremost: Option<LayoutHit<N>> = None;
+ for entry in self.hit_test_entries() {
+ if foremost.is_some_and(|hit| hit.paint_order >= Some(entry.paint_order)) {
+ continue;
+ }
+ if let Some(hit) =
+ self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)
+ {
+ foremost = Some(hit);
+ }
+ }
+ foremost
}
pub fn hit_test_all(
@@ -101,17 +110,15 @@ where
viewport_point: LayoutPoint,
ignore_pointer_events_none: bool,
) -> Vec<LayoutHit<N>> {
+ let mut hits = self
+ .hit_test_entries()
+ .filter_map(|entry| {
+ self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)
+ })
+ .collect::<Vec<_>>();
+ hits.sort_by_key(|hit| std::cmp::Reverse(hit.paint_order));
let mut seen = HashSet::new();
- let mut hits = Vec::new();
- for entry in self.hit_test_entries() {
- let Some(hit) = self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)
- else {
- continue;
- };
- if seen.insert(hit.source) {
- hits.push(hit);
- }
- }
+ hits.retain(|hit| seen.insert(hit.source));
hits
}
@@ -126,7 +133,6 @@ where
) -> Vec<LayoutPaintedSurfaceHit<N>> {
let mut hits = self
.hit_test_entries()
- .into_iter()
.filter_map(|entry| {
self.hit_for_entry(&entry, viewport_point, ignore_pointer_events_none)
.map(LayoutPaintedSurfaceHit::Dom)
@@ -240,7 +246,10 @@ where
}
pub fn caret_position(&self, viewport_point: LayoutPoint) -> Option<LayoutCaretPosition<N>> {
- let entries = self.hit_test_entries();
+ // Caret distance ties follow front-to-back order. Keep that ordering
+ // local to the caret query rather than sorting every point query.
+ let mut entries = self.hit_test_entries().collect::<Vec<_>>();
+ entries.sort_by_key(|entry| std::cmp::Reverse(entry.paint_order));
let top_entry = entries
.iter()
.find(|entry| self.hit_for_entry(entry, viewport_point, true).is_some())?;
@@ -285,40 +294,35 @@ where
})
}
- /// Builds the front-to-back hit candidates for one query.
+ /// Streams candidates directly from canonical geometry, without retaining
+ /// an index or duplicating the fragment set into a query-local vector.
///
- /// Paint order, source provenance, transforms, and clips are canonical
- /// tree data. The duplicated candidate vector is deliberately temporary.
- fn hit_test_entries(&self) -> Vec<LayoutHitTestEntry<N>> {
- let mut entries = self
- .fragments
- .iter()
- .filter_map(|fragment| {
- let paint_order = fragment.paint_order?;
- let (box_id, is_text) = match fragment.kind {
- LayoutFragmentKind::Box { box_id }
- | LayoutFragmentKind::InlineBox { box_id, .. } => (box_id, false),
- LayoutFragmentKind::Text { box_id, .. } => (box_id, true),
- LayoutFragmentKind::Line { .. } => return None,
- };
- let layout_box = self.boxes.get(box_id.index())?;
- if !layout_box.visible {
- return None;
- }
- Some(LayoutHitTestEntry {
- source: layout_box.hit_source?,
- fragment: fragment.id,
- coordinate_space: fragment.coordinate_space,
- clip_chain: fragment.clip_chain,
- local_rect: fragment.rect,
- paint_order,
- is_text,
- pointer_events: layout_box.pointer_events,
- })
+ /// Fragment storage order is not paint order; callers select or sort by
+ /// the explicit paint ordinal only after resolving geometric hits.
+ fn hit_test_entries(&self) -> impl Iterator<Item = LayoutHitTestEntry<N>> + '_ {
+ self.fragments.iter().filter_map(|fragment| {
+ let paint_order = fragment.paint_order?;
+ let (box_id, is_text) = match fragment.kind {
+ LayoutFragmentKind::Box { box_id }
+ | LayoutFragmentKind::InlineBox { box_id, .. } => (box_id, false),
+ LayoutFragmentKind::Text { box_id, .. } => (box_id, true),
+ LayoutFragmentKind::Line { .. } => return None,
+ };
+ let layout_box = self.boxes.get(box_id.index())?;
+ if !layout_box.visible {
+ return None;
+ }
+ Some(LayoutHitTestEntry {
+ source: layout_box.hit_source?,
+ fragment: fragment.id,
+ coordinate_space: fragment.coordinate_space,
+ clip_chain: fragment.clip_chain,
+ local_rect: fragment.rect,
+ paint_order,
+ is_text,
+ pointer_events: layout_box.pointer_events,
})
- .collect::<Vec<_>>();
- entries.sort_by_key(|entry| std::cmp::Reverse(entry.paint_order));
- entries
+ })
}
fn caret_position_for_text_entry(
diff --git a/moli-layout/tests/phase5_output_contract.rs b/moli-layout/tests/phase5_output_contract.rs
index 1fcc438b0..300a1c654 100644
--- a/moli-layout/tests/phase5_output_contract.rs
+++ b/moli-layout/tests/phase5_output_contract.rs
@@ -2874,6 +2874,92 @@ fn transforms_and_semantic_paint_order_share_the_hit_test_projection() {
);
}
+#[test]
+fn point_hits_select_paint_order_before_deduplicating_sources() {
+ let source = Source(vec![
+ Node::element("root", vec![2, 1, 3]),
+ Node::element("foremost", Vec::new()),
+ Node::element("back", Vec::new()),
+ Node::element("middle", Vec::new()),
+ ]);
+ let mut styles = Styles::default();
+ styles
+ .0
+ .insert(0, fixed_size(LayoutDisplay::Block, 200.0, 150.0));
+ for (source, z_index) in [(1, 3), (2, 1), (3, 2)] {
+ styles.0.insert(
+ source,
+ resolved(
+ LayoutDisplay::Block,
+ Style {
+ position: Position::Absolute,
+ inset: Rect {
+ left: length(20.0),
+ top: length(20.0),
+ right: LengthPercentageAuto::auto(),
+ bottom: LengthPercentageAuto::auto(),
+ },
+ size: Size {
+ width: length(80.0),
+ height: length(80.0),
+ },
+ ..Style::default()
+ },
+ )
+ .with_position(LayoutPosition::Absolute)
+ .with_z_index(z_index),
+ );
+ }
+ let mut output = build(&source, &mut styles);
+ let point = LayoutPoint::new(30.0, 30.0);
+ let hit = output.hit_test(point, false).unwrap();
+ assert_eq!(hit.source, 1, "the last stored box is not foremost");
+
+ // Generated boxes can retarget to the same DOM source. The lower box is
+ // stored first, but deduplication must retain the foremost fragment.
+ output
+ .tree
+ .boxes
+ .iter_mut()
+ .find(|layout_box| layout_box.hit_source == Some(2))
+ .unwrap()
+ .hit_source = Some(1);
+ let hits = output.hit_test_all(point, false);
+ assert_eq!(
+ hits.iter().map(|hit| hit.source).collect::<Vec<_>>(),
+ [1, 3, 0]
+ );
+ assert_eq!(hits[0].fragment, hit.fragment);
+ assert_eq!(output.hit_test(point, false), Some(hits[0]));
+ let surfaces = output.painted_surface_hits(point, false);
+ assert!(
+ surfaces
+ .windows(2)
+ .all(|pair| pair[0].paint_order() >= pair[1].paint_order())
+ );
+
+ for layout_box in &mut output.tree.boxes {
+ if layout_box.hit_source == Some(1) {
+ layout_box.geometry.pointer_events = false;
+ }
+ }
+ assert_eq!(output.hit_test(point, false).unwrap().source, 3);
+ assert_eq!(output.hit_test(point, true).unwrap().source, 1);
+ assert_eq!(
+ output
+ .hit_test_all(point, false)
+ .iter()
+ .map(|hit| hit.source)
+ .collect::<Vec<_>>(),
+ [3, 0]
+ );
+ assert!(
+ output
+ .hit_test(LayoutPoint::new(-1.0, -1.0), false)
+ .is_none()
+ );
+}
+
#[test]
fn transformed_hit_retains_exact_local_content_box_and_inverse_mapping() {
let source = Source(vec![