blitz-pdf 0.1.6 → 0.1.8

package/vendor/blitz-dom/src/layout/construct.rs

@@ -3,10 +3,7 @@ use core::str;
 use std::sync::Arc;
 
 use markup5ever::{QualName, local_name};
-use parley::{
-    FontContext, InlineBox, InlineBoxKind, LayoutContext, StyleProperty, TreeBuilder,
-    WhiteSpaceCollapse,
-};
+use parley::StyleProperty;
 use style::{
     computed_values::position::T as PositionProperty,
     data::ElementData as StyloElementData,
@@ -23,20 +20,14 @@ use crate::{
     layout::damage::{
         CONSTRUCT_BOX, CONSTRUCT_DESCENDENT, CONSTRUCT_FC, sort_layout_children_by_order,
     },
-    node::{
-        ListItemLayout, ListItemLayoutPosition, Marker, NodeFlags, NodeKind, SpecialElementData,
-        TextBrush, TextInputData, TextLayout,
-    },
+    node::{NodeFlags, NodeKind, SpecialElementData, TextInputData, TextLayout},
     qual_name, stylo_to_parley,
     traversal::{iter_children, iter_children_and_pseudos},
 };
 
 use super::{
-    damage::ALL_DAMAGE,
-    list::{BULLET_FONT_FAMILY, collect_list_item_children},
-    replaced::is_inline_box_element,
+    damage::ALL_DAMAGE, list::collect_list_item_children, replaced::is_inline_box_element,
     table::build_table_context,
-    text_transform::{CaseTransform, TextTransformer},
 };
 
 const DUMMY_NAME: QualName = qual_name!("div", html);
@@ -733,6 +724,7 @@ fn flush_pseudo_elements(doc: &mut BaseDocument, node_id: NodeId) {
                 doc.nodes[new_node_id].children.push(text_node_id);
             }
 
+            doc.nodes[new_node_id].record_out_of_flow(pe_style);
             let mut element_data = StyloElementData::default();
             element_data.styles.primary = Some(pe_style.clone());
             element_data.set_restyled();
@@ -787,6 +779,7 @@ fn flush_pseudo_elements(doc: &mut BaseDocument, node_id: NodeId) {
                 (None, None) => {}
             }
 
+            doc.nodes[pe_node_id].record_out_of_flow(&pe_style);
             let mut node_styles = doc.nodes[pe_node_id]
                 .try_stylo_element_data_mut()
                 .and_then(|s| s.get_mut());
@@ -1038,291 +1031,3 @@ pub(crate) fn find_inline_layout_embedded_boxes(
         }
     }
 }
-
-pub(crate) fn build_inline_layout_into(
-    nodes: &crate::NodeTree,
-    layout_ctx: &mut LayoutContext<TextBrush>,
-    font_ctx: &mut FontContext,
-    text_layout: &mut TextLayout,
-    scale: f32,
-    inline_context_root_node_id: NodeId,
-) {
-    // Get the inline context's root node's text styles
-    let root_node = &nodes[inline_context_root_node_id];
-    let root_node_style = root_node.primary_styles().or_else(|| {
-        root_node
-            .parent
-            .and_then(|parent_id| nodes[parent_id].primary_styles())
-    });
-
-    let mut parley_style = root_node_style
-        .as_ref()
-        .map(|s| stylo_to_parley::style(inline_context_root_node_id, s))
-        .unwrap_or_else(|| parley::TextStyle {
-            white_space_collapse: WhiteSpaceCollapse::Collapse,
-            ..Default::default()
-        });
-
-    // The formatting-context root's vertical-align positions its box in its
-    // parent (for example a middle-aligned table cell), not its own text runs.
-    // Passing it to Parley shifts the root against its own strut and inflates
-    // every line. Descendant inline spans still use their own vertical-align.
-    parley_style.vertical_align = parley::VerticalAlign::BASELINE;
-
-    // Create a parley tree builder
-    let mut builder = layout_ctx.tree_builder(font_ctx, scale, true, &parley_style);
-    if let Some(style) = root_node_style.as_deref() {
-        builder.set_base_direction(stylo_to_parley::base_direction(
-            style.clone_direction(),
-            style.clone_unicode_bidi(),
-        ));
-    }
-
-    let text_transform = root_node_style
-        .as_deref()
-        .map(|s| CaseTransform::from_style(s))
-        .unwrap_or(CaseTransform::NONE);
-
-    // Render position-inside list items
-    if let Some(ListItemLayout {
-        marker,
-        position: ListItemLayoutPosition::Inside,
-    }) = root_node
-        .element_data()
-        .and_then(|el| el.list_item_data.as_deref())
-    {
-        match marker {
-            // Bullet glyphs live in the bundled bullet font. The position-outside
-            // path already asks for it; without the same span here a marker like
-            // disclosure-closed (U+25B8) falls back to the element's own font and
-            // renders as a missing glyph.
-            Marker::Char(char) => {
-                let mut marker_style = parley_style.clone();
-                marker_style.font_family = BULLET_FONT_FAMILY.into();
-                builder.push_style_span(marker_style);
-                builder.push_text(&format!("{char} "));
-                builder.pop_style_span();
-            }
-            Marker::String(str) => builder.push_text(str),
-        }
-    };
-    // The marker is a separate box, so words in the content don't continue from it.
-    let mut text_transformer = TextTransformer::default();
-    text_transformer.word_break(&builder);
-
-    if let Some(before_id) = root_node.before() {
-        build_inline_layout_recursive(
-            &mut builder,
-            &mut text_transformer,
-            nodes,
-            before_id,
-            &text_transform,
-        );
-    }
-    for child_id in root_node.children.iter().copied() {
-        build_inline_layout_recursive(
-            &mut builder,
-            &mut text_transformer,
-            nodes,
-            child_id,
-            &text_transform,
-        );
-    }
-    if let Some(after_id) = root_node.after() {
-        build_inline_layout_recursive(
-            &mut builder,
-            &mut text_transformer,
-            nodes,
-            after_id,
-            &text_transform,
-        );
-    }
-
-    text_layout.text = builder.build_into(&mut text_layout.layout);
-    return;
-
-    fn build_inline_layout_recursive(
-        builder: &mut TreeBuilder<TextBrush>,
-        text_transformer: &mut TextTransformer,
-        nodes: &crate::NodeTree,
-        node_id: NodeId,
-        parent_text_transform: &CaseTransform,
-    ) {
-        let node = &nodes[node_id];
-
-        let style = node.primary_styles();
-        let style = style.as_ref();
-
-        let text_transform = style
-            .map(|s| CaseTransform::from_style(s))
-            .unwrap_or(CaseTransform::NONE);
-
-        match &node.data {
-            NodeData::Element(element_data) | NodeData::AnonymousBlock(element_data) => {
-                // if the input type is hidden, hide it
-                if *element_data.name.local == *"input" {
-                    if let Some("hidden") = element_data.attr(local_name!("type")) {
-                        return;
-                    }
-                }
-
-                let display = node.display_style().unwrap_or(Display::inline());
-                let position = style
-                    .map(|s| s.clone_position())
-                    .unwrap_or(PositionProperty::Static);
-                let float = style.map(|s| s.clone_float()).unwrap_or(Float::None);
-                let box_kind = if position.is_absolutely_positioned() {
-                    InlineBoxKind::OutOfFlow
-                } else if float.is_floating() {
-                    InlineBoxKind::CustomOutOfFlow
-                } else {
-                    InlineBoxKind::InFlow
-                };
-
-                match (display.outside(), display.inside()) {
-                    (DisplayOutside::None, DisplayInside::None) => {
-                        // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
-                    }
-                    (DisplayOutside::None, DisplayInside::Contents) => {
-                        let whitespace = style.map(|s| {
-                            [
-                                parley::StyleProperty::WhiteSpaceCollapse(
-                                    stylo_to_parley::white_space_collapse(
-                                        s.clone_white_space_collapse(),
-                                    ),
-                                ),
-                                parley::StyleProperty::TextWrapMode(
-                                    stylo_to_parley::text_wrap_mode(s.clone_text_wrap_mode()),
-                                ),
-                            ]
-                        });
-                        builder.push_style_modification_span(
-                            whitespace
-                                .as_ref()
-                                .map_or(&[][..], |styles| styles.as_slice()),
-                        );
-                        for child_id in node.children.iter().copied() {
-                            // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
-                            build_inline_layout_recursive(
-                                builder,
-                                text_transformer,
-                                nodes,
-                                child_id,
-                                &text_transform,
-                            );
-                        }
-                        builder.pop_style_span();
-                    }
-                    (DisplayOutside::Inline, DisplayInside::Flow) => {
-                        let tag_name = &element_data.name.local;
-
-                        if is_inline_box_element(tag_name) {
-                            if box_kind == InlineBoxKind::InFlow {
-                                text_transformer.word_break(builder);
-                            }
-                            builder.push_inline_box(InlineBox {
-                                id: node_id.as_u64(),
-                                kind: box_kind,
-                                // Overridden by push_inline_box method
-                                index: 0,
-                                // Width and height are set during layout
-                                width: 0.0,
-                                height: 0.0,
-                                baseline: None,
-                                vertical_align: node
-                                    .primary_styles()
-                                    .map(|s| stylo_to_parley::vertical_align(&s))
-                                    .unwrap_or_default(),
-                            });
-                        } else if *tag_name == local_name!("br") {
-                            // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
-                            // TODO: update span id for br spans
-                            builder.push_style_modification_span(&[
-                                parley::StyleProperty::WhiteSpaceCollapse(
-                                    WhiteSpaceCollapse::Preserve,
-                                ),
-                            ]);
-                            builder.push_text("\n");
-                            builder.pop_style_span();
-                            text_transformer.word_break(builder);
-                        } else {
-                            // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
-                            let style = node
-                                .primary_styles()
-                                .map(|s| stylo_to_parley::style(node.id, &s))
-                                .unwrap_or_else(|| parley::TextStyle {
-                                    white_space_collapse: WhiteSpaceCollapse::Collapse,
-                                    ..Default::default()
-                                });
-
-                            builder.push_style_span(style);
-
-                            if let Some(before_id) = node.before() {
-                                build_inline_layout_recursive(
-                                    builder,
-                                    text_transformer,
-                                    nodes,
-                                    before_id,
-                                    &text_transform,
-                                );
-                            }
-
-                            for child_id in node.children.iter().copied() {
-                                build_inline_layout_recursive(
-                                    builder,
-                                    text_transformer,
-                                    nodes,
-                                    child_id,
-                                    &text_transform,
-                                );
-                            }
-                            if let Some(after_id) = node.after() {
-                                build_inline_layout_recursive(
-                                    builder,
-                                    text_transformer,
-                                    nodes,
-                                    after_id,
-                                    &text_transform,
-                                );
-                            }
-
-                            builder.pop_style_span();
-                        }
-                    }
-                    // Inline box
-                    (_, _) => {
-                        if box_kind == InlineBoxKind::InFlow {
-                            text_transformer.word_break(builder);
-                        }
-                        builder.push_inline_box(InlineBox {
-                            id: node_id.as_u64(),
-                            kind: box_kind,
-                            // Overridden by push_inline_box method
-                            index: 0,
-                            // Width and height are set during layout
-                            width: 0.0,
-                            height: 0.0,
-                            baseline: None,
-                            vertical_align: node
-                                .primary_styles()
-                                .map(|s| stylo_to_parley::vertical_align(&s))
-                                .unwrap_or_default(),
-                        });
-                    }
-                };
-            }
-            NodeData::Text(data) => {
-                // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
-                // dbg!(&data.content);
-
-                let text =
-                    text_transformer.transform(&data.content, parent_text_transform, builder);
-                builder.push_text(text);
-            }
-            NodeData::Comment { .. } => {
-                // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
-            }
-            NodeData::Document(_) => unreachable!(),
-        }
-    }
-}

package/vendor/blitz-dom/src/layout/inline/build.rs

@@ -0,0 +1,309 @@
+use blitz_traits::node_id::NodeId;
+use markup5ever::local_name;
+use parley::{
+    FontContext, InlineBox, InlineBoxKind, LayoutContext, TreeBuilder, WhiteSpaceCollapse,
+};
+use style::{
+    computed_values::position::T as PositionProperty,
+    values::{
+        computed::{Display, Float},
+        specified::box_::{DisplayInside, DisplayOutside},
+    },
+};
+
+use crate::{
+    NodeData,
+    layout::list::BULLET_FONT_FAMILY,
+    layout::replaced::is_inline_box_element,
+    layout::text_transform::{CaseTransform, TextTransformer},
+    node::{ListItemLayout, ListItemLayoutPosition, Marker, TextBrush, TextLayout},
+    stylo_to_parley,
+};
+
+pub(crate) fn build_inline_layout_into(
+    nodes: &crate::NodeTree,
+    layout_ctx: &mut LayoutContext<TextBrush>,
+    font_ctx: &mut FontContext,
+    text_layout: &mut TextLayout,
+    scale: f32,
+    inline_context_root_node_id: NodeId,
+) {
+    // Get the inline context's root node's text styles
+    let root_node = &nodes[inline_context_root_node_id];
+    let root_node_style = root_node.primary_styles().or_else(|| {
+        root_node
+            .parent
+            .and_then(|parent_id| nodes[parent_id].primary_styles())
+    });
+
+    let mut parley_style = root_node_style
+        .as_ref()
+        .map(|s| stylo_to_parley::style(inline_context_root_node_id, s))
+        .unwrap_or_else(|| parley::TextStyle {
+            white_space_collapse: WhiteSpaceCollapse::Collapse,
+            ..Default::default()
+        });
+
+    // The formatting-context root's vertical-align positions its box in its
+    // parent (for example a middle-aligned table cell), not its own text runs.
+    // Passing it to Parley shifts the root against its own strut and inflates
+    // every line. Descendant inline spans still use their own vertical-align.
+    parley_style.vertical_align = parley::VerticalAlign::BASELINE;
+
+    // Create a parley tree builder
+    let mut builder = layout_ctx.tree_builder(font_ctx, scale, true, &parley_style);
+    if let Some(style) = root_node_style.as_deref() {
+        builder.set_base_direction(stylo_to_parley::base_direction(
+            style.clone_direction(),
+            style.clone_unicode_bidi(),
+        ));
+    }
+
+    let text_transform = root_node_style
+        .as_deref()
+        .map(|s| CaseTransform::from_style(s))
+        .unwrap_or(CaseTransform::NONE);
+
+    // Render position-inside list items
+    if let Some(ListItemLayout {
+        marker,
+        position: ListItemLayoutPosition::Inside,
+    }) = root_node
+        .element_data()
+        .and_then(|el| el.list_item_data.as_deref())
+    {
+        match marker {
+            // Bullet glyphs live in the bundled bullet font. The position-outside
+            // path already asks for it; without the same span here a marker like
+            // disclosure-closed (U+25B8) falls back to the element's own font and
+            // renders as a missing glyph.
+            Marker::Char(char) => {
+                let mut marker_style = parley_style.clone();
+                marker_style.font_family = BULLET_FONT_FAMILY.into();
+                builder.push_style_span(marker_style);
+                builder.push_text(&format!("{char} "));
+                builder.pop_style_span();
+            }
+            Marker::String(str) => builder.push_text(str),
+        }
+    };
+    // The marker is a separate box, so words in the content don't continue from it.
+    let mut text_transformer = TextTransformer::default();
+    text_transformer.word_break(&builder);
+
+    if let Some(before_id) = root_node.before() {
+        build_inline_layout_recursive(
+            &mut builder,
+            &mut text_transformer,
+            nodes,
+            before_id,
+            &text_transform,
+        );
+    }
+    for child_id in root_node.children.iter().copied() {
+        build_inline_layout_recursive(
+            &mut builder,
+            &mut text_transformer,
+            nodes,
+            child_id,
+            &text_transform,
+        );
+    }
+    if let Some(after_id) = root_node.after() {
+        build_inline_layout_recursive(
+            &mut builder,
+            &mut text_transformer,
+            nodes,
+            after_id,
+            &text_transform,
+        );
+    }
+
+    text_layout.text = builder.build_into(&mut text_layout.layout);
+    return;
+
+    fn build_inline_layout_recursive(
+        builder: &mut TreeBuilder<TextBrush>,
+        text_transformer: &mut TextTransformer,
+        nodes: &crate::NodeTree,
+        node_id: NodeId,
+        parent_text_transform: &CaseTransform,
+    ) {
+        let node = &nodes[node_id];
+
+        let style = node.primary_styles();
+        let style = style.as_ref();
+
+        let text_transform = style
+            .map(|s| CaseTransform::from_style(s))
+            .unwrap_or(CaseTransform::NONE);
+
+        match &node.data {
+            NodeData::Element(element_data) | NodeData::AnonymousBlock(element_data) => {
+                // if the input type is hidden, hide it
+                if *element_data.name.local == *"input" {
+                    if let Some("hidden") = element_data.attr(local_name!("type")) {
+                        return;
+                    }
+                }
+
+                let display = node.display_style().unwrap_or(Display::inline());
+                let position = style
+                    .map(|s| s.clone_position())
+                    .unwrap_or(PositionProperty::Static);
+                let float = style.map(|s| s.clone_float()).unwrap_or(Float::None);
+                let box_kind = if position.is_absolutely_positioned() {
+                    InlineBoxKind::OutOfFlow
+                } else if float.is_floating() {
+                    InlineBoxKind::CustomOutOfFlow
+                } else {
+                    InlineBoxKind::InFlow
+                };
+
+                match (display.outside(), display.inside()) {
+                    (DisplayOutside::None, DisplayInside::None) => {
+                        // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
+                    }
+                    (DisplayOutside::None, DisplayInside::Contents) => {
+                        let whitespace = style.map(|s| {
+                            [
+                                parley::StyleProperty::WhiteSpaceCollapse(
+                                    stylo_to_parley::white_space_collapse(
+                                        s.clone_white_space_collapse(),
+                                    ),
+                                ),
+                                parley::StyleProperty::TextWrapMode(
+                                    stylo_to_parley::text_wrap_mode(s.clone_text_wrap_mode()),
+                                ),
+                            ]
+                        });
+                        builder.push_style_modification_span(
+                            whitespace
+                                .as_ref()
+                                .map_or(&[][..], |styles| styles.as_slice()),
+                        );
+                        for child_id in node.children.iter().copied() {
+                            // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
+                            build_inline_layout_recursive(
+                                builder,
+                                text_transformer,
+                                nodes,
+                                child_id,
+                                &text_transform,
+                            );
+                        }
+                        builder.pop_style_span();
+                    }
+                    (DisplayOutside::Inline, DisplayInside::Flow) => {
+                        let tag_name = &element_data.name.local;
+
+                        if is_inline_box_element(tag_name) {
+                            if box_kind == InlineBoxKind::InFlow {
+                                text_transformer.word_break(builder);
+                            }
+                            builder.push_inline_box(InlineBox {
+                                id: node_id.as_u64(),
+                                kind: box_kind,
+                                // Overridden by push_inline_box method
+                                index: 0,
+                                // Width and height are set during layout
+                                width: 0.0,
+                                height: 0.0,
+                                baseline: None,
+                                vertical_align: node
+                                    .primary_styles()
+                                    .map(|s| stylo_to_parley::vertical_align(&s))
+                                    .unwrap_or_default(),
+                            });
+                        } else if *tag_name == local_name!("br") {
+                            // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
+                            // TODO: update span id for br spans
+                            builder.push_style_modification_span(&[
+                                parley::StyleProperty::WhiteSpaceCollapse(
+                                    WhiteSpaceCollapse::Preserve,
+                                ),
+                            ]);
+                            builder.push_text("\n");
+                            builder.pop_style_span();
+                            text_transformer.word_break(builder);
+                        } else {
+                            // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
+                            let style = node
+                                .primary_styles()
+                                .map(|s| stylo_to_parley::style(node.id, &s))
+                                .unwrap_or_else(|| parley::TextStyle {
+                                    white_space_collapse: WhiteSpaceCollapse::Collapse,
+                                    ..Default::default()
+                                });
+
+                            builder.push_style_span(style);
+
+                            if let Some(before_id) = node.before() {
+                                build_inline_layout_recursive(
+                                    builder,
+                                    text_transformer,
+                                    nodes,
+                                    before_id,
+                                    &text_transform,
+                                );
+                            }
+
+                            for child_id in node.children.iter().copied() {
+                                build_inline_layout_recursive(
+                                    builder,
+                                    text_transformer,
+                                    nodes,
+                                    child_id,
+                                    &text_transform,
+                                );
+                            }
+                            if let Some(after_id) = node.after() {
+                                build_inline_layout_recursive(
+                                    builder,
+                                    text_transformer,
+                                    nodes,
+                                    after_id,
+                                    &text_transform,
+                                );
+                            }
+
+                            builder.pop_style_span();
+                        }
+                    }
+                    // Inline box
+                    (_, _) => {
+                        if box_kind == InlineBoxKind::InFlow {
+                            text_transformer.word_break(builder);
+                        }
+                        builder.push_inline_box(InlineBox {
+                            id: node_id.as_u64(),
+                            kind: box_kind,
+                            // Overridden by push_inline_box method
+                            index: 0,
+                            // Width and height are set during layout
+                            width: 0.0,
+                            height: 0.0,
+                            baseline: None,
+                            vertical_align: node
+                                .primary_styles()
+                                .map(|s| stylo_to_parley::vertical_align(&s))
+                                .unwrap_or_default(),
+                        });
+                    }
+                };
+            }
+            NodeData::Text(data) => {
+                // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
+                // dbg!(&data.content);
+
+                let text =
+                    text_transformer.transform(&data.content, parent_text_transform, builder);
+                builder.push_text(text);
+            }
+            NodeData::Comment { .. } => {
+                // node.remove_damage(CONSTRUCT_DESCENDENT | CONSTRUCT_FC | CONSTRUCT_BOX);
+            }
+            NodeData::Document(_) => unreachable!(),
+        }
+    }
+}

package/vendor/blitz-dom/src/layout/{inline.rs → inline/layout.rs}

@@ -20,8 +20,8 @@ use taffy::{BlockItemStyle as _, Clear, Float, prelude::TaffyMaxContent};
 
 use stylo_taffy::StyleFlags;
 
-use super::resolve_calc_value;
 use crate::layout::LayoutPassState;
+use crate::layout::resolve_calc_value;
 use crate::stylo_to_parley;
 
 /// Subtract a child's margins from the definite axes of the available space it is laid out in.

package/vendor/blitz-dom/src/layout/inline/mod.rs

@@ -0,0 +1,4 @@
+mod build;
+mod layout;
+
+pub(crate) use build::build_inline_layout_into;

package/vendor/blitz-dom/src/layout/mod.rs

@@ -853,7 +853,9 @@ impl RoundTree for LayoutPassState<'_> {
     }
 
     fn is_out_of_flow(&self, node_id: NodeId) -> bool {
-        self.node_from_id(node_id).is_out_of_flow()
+        self.node_from_id(node_id)
+            .out_of_flow
+            .load(core::sync::atomic::Ordering::Relaxed)
     }
 
     fn hoisted_child_count(&self, node_id: NodeId) -> usize {