Skip to content

armgit / moli

Public Imported from GitHub
0

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

Model inline offset geometry from fragments

ldm0ce0a6157e29c
diff --git a/moli-layout/src/layout_tree/source_query.rs b/moli-layout/src/layout_tree/source_query.rs
index 0c34bad41..d9ade2474 100644
--- a/moli-layout/src/layout_tree/source_query.rs
+++ b/moli-layout/src/layout_tree/source_query.rs
@@ -13,6 +13,13 @@ use super::{
tree::FrozenLayoutTree,
};
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct InlineOffsetGeometry {
+ layout_origin_in_document: LayoutPoint,
+ border_origin_in_viewport_ignoring_css_transforms: LayoutPoint,
+ size: LayoutSize,
+}
+
impl<N> FrozenLayoutTree<N>
where
N: Copy + Debug + Eq + Hash,
@@ -109,44 +116,24 @@ where
}
})
.unwrap_or(LayoutPoint::ZERO);
- let fragment_origins = output.fragments.iter().find_map(|id| {
- let fragment = self.fragment(*id)?;
- let LayoutFragmentKind::InlineBox {
- box_id: fragment_box,
- ..
- } = fragment.kind
- else {
- return None;
- };
- if fragment_box != box_id {
- return None;
- }
- let border = fragment.box_model?.border;
- let fragment_space = self.coordinate_space(fragment.coordinate_space)?;
- let owner = fragment_space.owner?;
- let owner_origin = self.box_geometry(owner)?.layout_origin_in_document;
- let local_border_origin = LayoutPoint::new(border.x, border.y);
- Some((
- LayoutPoint::new(
- owner_origin.x + local_border_origin.x,
- owner_origin.y + local_border_origin.y,
- ),
- fragment_space
- .local_to_viewport_ignoring_css_transforms
- .map_point(local_border_origin),
- ))
- });
- let (layout_origin, border_origin_in_viewport_ignoring_css_transforms) = fragment_origins
+ let inline_offset_geometry = self.inline_offset_geometry(&output, box_id);
+ let layout_origin = inline_offset_geometry
+ .map(|geometry| geometry.layout_origin_in_document)
+ .unwrap_or(geometry.layout_origin_in_document);
+ let offset_size = inline_offset_geometry
+ .map(|geometry| geometry.size)
.unwrap_or_else(|| {
- (
- geometry.layout_origin_in_document,
- coordinate_space
- .local_to_viewport_ignoring_css_transforms
- .map_point(LayoutPoint::new(
- geometry.border_box.x,
- geometry.border_box.y,
- )),
- )
+ LayoutSize::new(geometry.border_box.width, geometry.border_box.height)
+ });
+ let border_origin_in_viewport_ignoring_css_transforms = inline_offset_geometry
+ .map(|geometry| geometry.border_origin_in_viewport_ignoring_css_transforms)
+ .unwrap_or_else(|| {
+ coordinate_space
+ .local_to_viewport_ignoring_css_transforms
+ .map_point(LayoutPoint::new(
+ geometry.border_box.x,
+ geometry.border_box.y,
+ ))
});
let client_size = if is_root {
// CSSOM defines root client dimensions from the viewport and only
@@ -176,7 +163,7 @@ where
layout_origin.y - offset_parent_origin.y,
),
border_origin_in_viewport_ignoring_css_transforms,
- offset_size: LayoutSize::new(geometry.border_box.width, geometry.border_box.height),
+ offset_size,
content_size: LayoutSize::new(geometry.content_box.width, geometry.content_box.height),
client_size,
client_border: LayoutPoint::new(
@@ -466,6 +453,86 @@ impl<N> FrozenLayoutTree<N>
where
N: Copy + Debug + Eq + Hash,
{
+ /// Returns the untransformed CSSOM offset geometry for a flattened inline.
+ ///
+ /// CSSOM View defines `offsetLeft`/`offsetTop` from the first fragment and
+ /// `offsetWidth`/`offsetHeight` from the bounding box of all non-empty
+ /// border-box fragments. Mapping each fragment through its IFC owner's
+ /// document-layout origin keeps that geometry in one physical coordinate
+ /// system while intentionally excluding transforms and scrolling.
+ fn inline_offset_geometry(
+ &self,
+ output: &LayoutNodeOutput,
+ box_id: LayoutOutputBoxId,
+ ) -> Option<InlineOffsetGeometry> {
+ let mut first_fragment = None;
+ let mut bounds = None::<LayoutRect>;
+
+ for id in &output.fragments {
+ let Some(fragment) = self.fragment(*id) else {
+ continue;
+ };
+ let LayoutFragmentKind::InlineBox {
+ box_id: fragment_box,
+ ..
+ } = fragment.kind
+ else {
+ continue;
+ };
+ if fragment_box != box_id {
+ continue;
+ }
+ let Some(box_model) = fragment.box_model else {
+ continue;
+ };
+ let Some(fragment_space) = self.coordinate_space(fragment.coordinate_space) else {
+ continue;
+ };
+ let Some(owner) = fragment_space.owner else {
+ continue;
+ };
+ let Some(owner_geometry) = self.box_geometry(owner) else {
+ continue;
+ };
+ let border = box_model.border;
+ let owner_origin = owner_geometry.layout_origin_in_document;
+ let local_origin = LayoutPoint::new(border.x, border.y);
+ let document_border = LayoutRect::new(
+ owner_origin.x + border.x,
+ owner_origin.y + border.y,
+ border.width,
+ border.height,
+ );
+ first_fragment.get_or_insert_with(|| {
+ (
+ LayoutPoint::new(document_border.x, document_border.y),
+ fragment_space
+ .local_to_viewport_ignoring_css_transforms
+ .map_point(local_origin),
+ )
+ });
+
+ // Blink's BoundingBoxRelativeToFirstFragment uses UniteIfNonZero:
+ // an empty fragment supplies the offset anchor but cannot stretch
+ // the size union across lines by its zero-area position alone.
+ if document_border.width <= 0.0 || document_border.height <= 0.0 {
+ continue;
+ }
+ bounds = Some(bounds.map_or(document_border, |current| current.union(document_border)));
+ }
+
+ let (layout_origin_in_document, border_origin_in_viewport_ignoring_css_transforms) =
+ first_fragment?;
+ let size = bounds.map_or(LayoutSize::ZERO, |rect| {
+ LayoutSize::new(rect.width, rect.height)
+ });
+ Some(InlineOffsetGeometry {
+ layout_origin_in_document,
+ border_origin_in_viewport_ignoring_css_transforms,
+ size,
+ })
+ }
+
fn project_fragment_box_models(
&self,
models: &[(LayoutCoordinateSpaceId, LayoutFragmentBoxModel)],
@@ -563,3 +630,128 @@ where
fn axis_aligned_union(left: LayoutQuad, right: LayoutQuad) -> LayoutQuad {
LayoutTransform2D::IDENTITY.map_rect(left.bounding_rect().union(right.bounding_rect()))
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::layout_tree::{
+ FrozenCoordinateSpace, FrozenLayoutBox, LayoutBoxGeometry, LayoutFragment,
+ LayoutFragmentId, LayoutScrollExtent, LayoutViewport,
+ };
+
+ fn identity_space(owner: Option<LayoutOutputBoxId>) -> FrozenCoordinateSpace {
+ FrozenCoordinateSpace {
+ owner,
+ local_to_viewport: LayoutTransform2D::IDENTITY,
+ local_to_viewport_ignoring_css_transforms: LayoutTransform2D::IDENTITY,
+ }
+ }
+
+ #[test]
+ fn inline_offset_geometry_skips_an_unprojectable_fragment_before_valid_geometry() {
+ let box_id = LayoutOutputBoxId::from_index(0);
+ let coordinate_space = LayoutCoordinateSpaceId::from_index(1);
+ let skipped_fragment = LayoutFragmentId::from_index(0);
+ let valid_fragment = LayoutFragmentId::from_index(1);
+ let fragment = |id, box_model| LayoutFragment {
+ id,
+ kind: LayoutFragmentKind::InlineBox {
+ box_id,
+ line_index: 0,
+ has_start_edge: true,
+ has_end_edge: true,
+ },
+ rect: LayoutRect::ZERO,
+ box_model,
+ coordinate_space,
+ clip_chain: None,
+ paint_order: None,
+ };
+ let valid_box_model = LayoutFragmentBoxModel {
+ content: LayoutRect::new(3.0, 4.0, 10.0, 5.0),
+ padding: LayoutRect::new(3.0, 4.0, 10.0, 5.0),
+ border: LayoutRect::new(3.0, 4.0, 10.0, 5.0),
+ margin: LayoutRect::new(3.0, 4.0, 10.0, 5.0),
+ };
+ let scroll_extent = LayoutScrollExtent {
+ scrollport: LayoutRect::ZERO,
+ scrollable_overflow: LayoutRect::ZERO,
+ scroll_size: LayoutSize::ZERO,
+ applied_offset: LayoutPoint::ZERO,
+ minimum_offset: LayoutPoint::ZERO,
+ maximum_offset: LayoutPoint::ZERO,
+ is_scroll_container: false,
+ allows_user_scroll_x: false,
+ allows_user_scroll_y: false,
+ clips_overflow: false,
+ horizontal_scrollbar: None,
+ vertical_scrollbar: None,
+ scrollbar_corner: None,
+ scrollbar_colors: None,
+ };
+ let tree = FrozenLayoutTree::new(
+ 0_u8,
+ LayoutViewport::new(100, 100, 1.0),
+ LayoutPoint::ZERO,
+ LayoutSize::new(100.0, 100.0),
+ box_id,
+ vec![FrozenLayoutBox {
+ geometry: LayoutBoxGeometry {
+ id: box_id,
+ structural_parent: None,
+ parent: None,
+ layout_parent: None,
+ position: LayoutPosition::Static,
+ coordinate_space,
+ clip_chain: None,
+ content_box: LayoutRect::ZERO,
+ padding_box: LayoutRect::ZERO,
+ border_box: LayoutRect::ZERO,
+ margin_box: LayoutRect::ZERO,
+ fragments: vec![skipped_fragment, valid_fragment],
+ layout_origin_in_document: LayoutPoint::new(100.0, 200.0),
+ is_body_element: false,
+ is_table_offset_parent: false,
+ establishes_positioned_containing_block: false,
+ establishes_fixed_containing_block: false,
+ visible: true,
+ pointer_events: true,
+ },
+ scroll_extent,
+ coordinate_space: identity_space(Some(box_id)),
+ geometry_source: Some(1),
+ principal_source: Some(1),
+ hit_source: Some(1),
+ control_paint_order: None,
+ }],
+ vec![
+ fragment(skipped_fragment, None),
+ fragment(valid_fragment, Some(valid_box_model)),
+ ],
+ Vec::new(),
+ identity_space(None),
+ Vec::new(),
+ Vec::new(),
+ true,
+ );
+ let output = LayoutNodeOutput {
+ principal_box: Some(box_id),
+ fragments: vec![skipped_fragment, valid_fragment],
+ scroll_proxy_boxes: Vec::new(),
+ };
+
+ let geometry = tree
+ .inline_offset_geometry(&output, box_id)
+ .expect("the valid fragment after the skipped entry must contribute geometry");
+
+ assert_eq!(
+ geometry.layout_origin_in_document,
+ LayoutPoint::new(103.0, 204.0)
+ );
+ assert_eq!(
+ geometry.border_origin_in_viewport_ignoring_css_transforms,
+ LayoutPoint::new(3.0, 4.0)
+ );
+ assert_eq!(geometry.size, LayoutSize::new(10.0, 5.0));
+ }
+}
diff --git a/moli-layout/tests/phase5_output_contract.rs b/moli-layout/tests/phase5_output_contract.rs
index 8c71751c6..ec241f85f 100644
--- a/moli-layout/tests/phase5_output_contract.rs
+++ b/moli-layout/tests/phase5_output_contract.rs
@@ -1278,6 +1278,87 @@ fn inline_output_preserves_line_text_and_utf16_source_fragments() {
assert_eq!(scroll_geometry.scroll_containers.len(), 1);
}
+#[test]
+fn inline_offset_metrics_use_fragment_bounds_and_keep_empty_sibling_anchors() {
+ let source = Source(vec![
+ Node::element("root", vec![1, 3]),
+ Node::element("reference", vec![2]),
+ Node::text("reference-text", "ref"),
+ Node::element("empty-target", vec![4]),
+ Node::text("collapsed-trailing-space", " "),
+ ]);
+ let mut styles = Styles::default();
+ styles.0.insert(
+ 0,
+ fixed_size(LayoutDisplay::Block, 80.0, 80.0).with_text_metrics(10.0, 10.0),
+ );
+ for node in 1..=4 {
+ styles.0.insert(
+ node,
+ resolved(LayoutDisplay::Inline, Style::default()).with_text_metrics(10.0, 10.0),
+ );
+ }
+
+ let output = build(&source, &mut styles);
+ let reference = output
+ .element_metrics_for_source(1)
+ .expect("reference inline metrics");
+ let target = output
+ .element_metrics_for_source(3)
+ .expect("empty target inline metrics");
+
+ assert!(reference.offset_size.width > 0.0);
+ assert_close(
+ target.offset_position.x,
+ reference.offset_position.x + reference.offset_size.width,
+ );
+ assert_close(target.offset_position.y, reference.offset_position.y);
+}
+
+#[test]
+fn multiline_inline_offset_size_is_the_nonempty_fragment_union() {
+ let source = Source(vec![
+ Node::element("root", vec![1]),
+ Node::element("multiline-inline", vec![2]),
+ Node::text("wrapped-text", "ref ref ref"),
+ ]);
+ let mut styles = Styles::default();
+ styles.0.insert(
+ 0,
+ fixed_size(LayoutDisplay::Block, 14.0, 100.0).with_text_metrics(10.0, 10.0),
+ );
+ for node in 1..=2 {
+ styles.0.insert(
+ node,
+ resolved(LayoutDisplay::Inline, Style::default()).with_text_metrics(10.0, 10.0),
+ );
+ }
+
+ let output = build(&source, &mut styles);
+ let fragments = output
+ .client_rects_for_source(1)
+ .into_iter()
+ .map(|quad| quad.bounding_rect())
+ .filter(|rect| rect.width > 0.0 && rect.height > 0.0)
+ .collect::<Vec<_>>();
+ assert!(
+ fragments.len() > 1,
+ "the fixture must generate multiple inline fragments: {fragments:?}"
+ );
+ let union = fragments[1..]
+ .iter()
+ .copied()
+ .fold(fragments[0], LayoutRect::union);
+ let metrics = output
+ .element_metrics_for_source(1)
+ .expect("multiline inline metrics");
+
+ assert_close(metrics.offset_position.x, fragments[0].x);
+ assert_close(metrics.offset_position.y, fragments[0].y);
+ assert_close(metrics.offset_size.width, union.width);
+ assert_close(metrics.offset_size.height, union.height);
+}
+
#[test]
fn inline_and_range_rects_use_font_bounds_instead_of_the_css_line_height() {
const CJK_TEXT: &str = "台风白海豚在浙江玉环沿海登陆";
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 5cf2de47b..25659380b 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
@@ -3168,6 +3168,61 @@ const y = rect.top + 1;
.expect("negative-margin elementsFromPoint fixture should run");
}
+#[tokio::test(flavor = "current_thread")]
+async fn inline_offset_metrics_keep_empty_trailing_space_anchor_after_bordered_inline() {
+ 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/inline-offset-fragments.html")?,
+ );
+ page_vm.vm_mut().eval(
+ r#"
+document.head.innerHTML = `<style>
+html,body { margin:0 }
+.container { position:relative; width:80px; height:70px; padding:10px; font:10px/10px sans-serif }
+.reference { border:1px solid transparent; padding:0 6px }
+</style>`;
+document.body.innerHTML = `
+<div class=container><br><span class=reference></span><span class=target> </span></div>`;
+'installed'
+"#,
+ )?;
+ page_vm
+ .vm_mut()
+ .prime_document_lifecycle_processing_and_record_stylesheet_network_results();
+ page_vm
+ .vm_mut()
+ .screenshot_layout_snapshot(moli_layout::PaintViewport::new(100, 90, 1.0))?
+ .expect("inline offset fixture must retain a layout root");
+
+ let geometry = page_vm.vm_mut().eval(
+ r#"(()=>{const target=document.querySelector('.target');const reference=target.previousSibling;return JSON.stringify({reference:[reference.offsetLeft,reference.offsetTop,reference.offsetWidth,reference.offsetHeight],target:[target.offsetLeft,target.offsetTop]})})()"#,
+ )?;
+ let geometry: serde_json::Value = serde_json::from_str(&geometry)?;
+ let reference = geometry["reference"]
+ .as_array()
+ .unwrap_or_else(|| panic!("missing reference metrics: {geometry}"));
+ let target = geometry["target"]
+ .as_array()
+ .unwrap_or_else(|| panic!("missing target metrics: {geometry}"));
+ let number = |values: &[serde_json::Value], axis: usize| {
+ values[axis].as_f64().expect("numeric offset geometry")
+ };
+ assert_eq!(number(reference, 2), 14.0, "reference width: {geometry}");
+ assert_eq!(
+ number(target, 0),
+ number(reference, 0) + number(reference, 2),
+ "the empty inline starts after the reference fragment: {geometry}"
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("inline offset fragment 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 {