blitz-pdf 0.1.2 → 0.1.4

package/vendor/blitz-dom/src/node/scrollbar.rs

@@ -0,0 +1,237 @@
+//! Overlay scrollbar geometry and css-scrollbars-1 style accessors for
+//! [`Node`]. Geometry is shared between painting (blitz-paint) and thumb
+//! hit-testing so the two cannot drift.
+
+use blitz_traits::node_id::NodeId;
+use kurbo::Rect as KurboRect;
+use taffy::AbsoluteAxis;
+use web_time::Duration;
+
+use super::Node;
+
+/// How long overlay scrollbars stay fully opaque after their last activity
+/// (a scroll, or the pointer leaving the thumb), and how long the fade-out
+/// takes. Chromium's overlay values.
+pub(crate) const FADE_DELAY: Duration = Duration::from_millis(500);
+pub(crate) const FADE_DURATION: Duration = Duration::from_millis(200);
+
+/// Overlay scrollbar opacity as a function of time since the scroll
+/// container's last scrollbar activity: fully opaque through the fade
+/// delay, then fading linearly to hidden.
+pub(crate) fn opacity_at(elapsed: Duration) -> f32 {
+    match elapsed.checked_sub(FADE_DELAY) {
+        None => 1.0,
+        Some(fading) => 1.0 - (fading.as_secs_f32() / FADE_DURATION.as_secs_f32()).min(1.0),
+    }
+}
+
+/// A specific scrollbar: one axis of one scroll container.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ScrollbarRef {
+    pub node_id: NodeId,
+    pub axis: AbsoluteAxis,
+}
+
+/// The computed value of `scrollbar-width` (css-scrollbars-1).
+pub use style::properties::generated::longhands::scrollbar_width::computed_value::T as ScrollbarWidth;
+
+/// The computed value of `scrollbar-color` (css-scrollbars-1), with colors
+/// fully resolved (no `currentColor`).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub enum ScrollbarColor {
+    #[default]
+    Auto,
+    Colors {
+        thumb: style::color::AbsoluteColor,
+        track: style::color::AbsoluteColor,
+    },
+}
+
+impl Node {
+    /// The node's computed `scrollbar-width`.
+    pub fn scrollbar_width(&self) -> ScrollbarWidth {
+        self.primary_styles()
+            .map(|style| style.clone_scrollbar_width())
+            .unwrap_or(ScrollbarWidth::Auto)
+    }
+
+    /// The node's computed `scrollbar-color`, with colors resolved against
+    /// the element's computed `color`.
+    pub fn scrollbar_color(&self) -> ScrollbarColor {
+        let Some(style) = self.primary_styles() else {
+            return ScrollbarColor::Auto;
+        };
+        let current_color = style.clone_color();
+        match style.clone_scrollbar_color() {
+            style::values::computed::ScrollbarColor::Auto => ScrollbarColor::Auto,
+            style::values::computed::ScrollbarColor::Colors { thumb, track } => {
+                ScrollbarColor::Colors {
+                    thumb: thumb.resolve_to_absolute(&current_color),
+                    track: track.resolve_to_absolute(&current_color),
+                }
+            }
+        }
+    }
+
+    /// Whether the node shows an overlay scrollbar in the given axis:
+    /// always for `overflow: scroll`, only when the content overflows for
+    /// `overflow: auto`, never otherwise — and never when
+    /// `scrollbar-width: none`.
+    pub fn wants_scrollbar(&self, axis: AbsoluteAxis) -> bool {
+        use style::values::computed::Overflow;
+        let Some(style) = self.primary_styles() else {
+            return false;
+        };
+        if self.scrollbar_width() == ScrollbarWidth::None {
+            return false;
+        }
+        let (overflow, scroll_extent) = match axis {
+            AbsoluteAxis::Horizontal => (
+                style.clone_overflow_x(),
+                self.final_layout().scroll_width() as f64,
+            ),
+            AbsoluteAxis::Vertical => (
+                style.clone_overflow_y(),
+                self.final_layout().scroll_height() as f64,
+            ),
+        };
+        match overflow {
+            Overflow::Scroll => true,
+            Overflow::Auto => scroll_extent > 0.5,
+            _ => false,
+        }
+    }
+
+    /// The scrollport (padding box) in (unscaled) CSS px relative to the
+    /// node's border-box origin. Taffy has content-box helpers but none for
+    /// the padding box.
+    fn scrollport(&self) -> KurboRect {
+        let layout = self.final_layout();
+        KurboRect::new(
+            layout.border.left as f64,
+            layout.border.top as f64,
+            layout.size.width as f64 - layout.border.right as f64,
+            layout.size.height as f64 - layout.border.bottom as f64,
+        )
+    }
+
+    /// Geometry of the overlay scrollbar thumb for the given axis, in
+    /// (unscaled) CSS px relative to the node's border-box origin. `None`
+    /// if there is no scrollable overflow in that axis.
+    pub fn scrollbar_thumb(&self, axis: AbsoluteAxis) -> Option<KurboRect> {
+        // Matches Chromium's overlay thumb in its interactive state.
+        const THUMB_THICKNESS: f64 = 10.0;
+        const THIN_THUMB_THICKNESS: f64 = 6.0;
+        const THUMB_MARGIN: f64 = 2.0;
+        const MIN_THUMB_LENGTH: f64 = 32.0;
+
+        let layout = self.final_layout();
+        let scroll_extent = match axis {
+            AbsoluteAxis::Horizontal => layout.scroll_width() as f64,
+            AbsoluteAxis::Vertical => layout.scroll_height() as f64,
+        };
+        if scroll_extent <= 0.5 {
+            return None;
+        }
+
+        let thickness = match self.scrollbar_width() {
+            ScrollbarWidth::Thin => THIN_THUMB_THICKNESS,
+            _ => THUMB_THICKNESS,
+        };
+
+        let port = self.scrollport();
+        let (viewport_len, scroll_offset) = match axis {
+            AbsoluteAxis::Horizontal => (port.width(), self.scroll_offset().x),
+            AbsoluteAxis::Vertical => (port.height(), self.scroll_offset().y),
+        };
+        let thumb_len = (viewport_len * viewport_len / (viewport_len + scroll_extent))
+            .max(MIN_THUMB_LENGTH)
+            .min(viewport_len);
+        let progress = (scroll_offset / scroll_extent).clamp(0.0, 1.0);
+        // Round a sub-pixel displacement up to a whole pixel so any nonzero
+        // scroll visibly moves the thumb off the origin.
+        let thumb_start = match progress * (viewport_len - thumb_len) {
+            start if start > 0.0 && start < 1.0 => 1.0,
+            start => start,
+        };
+
+        Some(match axis {
+            AbsoluteAxis::Horizontal => KurboRect::new(
+                port.x0 + thumb_start,
+                port.y1 - THUMB_MARGIN - thickness,
+                port.x0 + thumb_start + thumb_len,
+                port.y1 - THUMB_MARGIN,
+            ),
+            AbsoluteAxis::Vertical => KurboRect::new(
+                port.x1 - THUMB_MARGIN - thickness,
+                port.y0 + thumb_start,
+                port.x1 - THUMB_MARGIN,
+                port.y0 + thumb_start + thumb_len,
+            ),
+        })
+    }
+
+    /// Content px scrolled per thumb px dragged, for the given axis.
+    pub fn scrollbar_drag_ratio(&self, axis: AbsoluteAxis) -> f64 {
+        let Some(thumb) = self.scrollbar_thumb(axis) else {
+            return 0.0;
+        };
+        let port = self.scrollport();
+        let (scroll_extent, viewport_len, thumb_len) = match axis {
+            AbsoluteAxis::Horizontal => (
+                self.final_layout().scroll_width() as f64,
+                port.width(),
+                thumb.width(),
+            ),
+            AbsoluteAxis::Vertical => (
+                self.final_layout().scroll_height() as f64,
+                port.height(),
+                thumb.height(),
+            ),
+        };
+        let track_play = viewport_len - thumb_len;
+        if track_play <= 0.0 {
+            return 0.0;
+        }
+        scroll_extent / track_play
+    }
+
+    /// The scrollbar thumb containing the given point (in this node's
+    /// border-box coordinates), if any. The `scrollbars` feature's single
+    /// behavioral gate: returning `None` keeps unpainted thumbs from ever
+    /// claiming pointer events.
+    pub(crate) fn scrollbar_at_local(&self, x: f64, y: f64) -> Option<ScrollbarRef> {
+        if !cfg!(feature = "scrollbars") {
+            return None;
+        }
+        for axis in [AbsoluteAxis::Vertical, AbsoluteAxis::Horizontal] {
+            if !self.wants_scrollbar(axis) {
+                continue;
+            }
+            if let Some(thumb) = self.scrollbar_thumb(axis)
+                && thumb.contains(kurbo::Point::new(x, y))
+            {
+                return Some(ScrollbarRef {
+                    node_id: self.id,
+                    axis,
+                });
+            }
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn opacity_holds_through_the_fade_delay_then_fades_out() {
+        assert_eq!(opacity_at(Duration::ZERO), 1.0);
+        assert_eq!(opacity_at(FADE_DELAY), 1.0);
+        let mid_fade = opacity_at(FADE_DELAY + FADE_DURATION / 2);
+        assert!((mid_fade - 0.5).abs() < 0.01, "got {mid_fade}");
+        assert_eq!(opacity_at(FADE_DELAY + FADE_DURATION), 0.0);
+        assert_eq!(opacity_at(Duration::from_secs(3600)), 0.0);
+    }
+}

package/vendor/blitz-dom/src/node/serialize.rs

@@ -0,0 +1,225 @@
+//! Serialization of nodes to HTML, and of inline `<svg>` subtrees to SVG source for usvg.
+
+use html_escape::{encode_quoted_attribute_to_string, encode_text_to_string};
+use markup5ever::{QualName, ns};
+use style_traits::values::ToCss;
+
+use super::{Node, NodeData};
+
+#[derive(Clone, Copy)]
+enum OutputStyle {
+    Normal,
+    Pretty,
+}
+
+#[derive(Clone, Copy)]
+struct SerializeOpts {
+    style: OutputStyle,
+    /// Replace `currentColor` in attribute values with the element's computed `color`
+    resolve_current_color: bool,
+    /// Declare the `xlink` prefix on the root element so that the output is well-formed XML
+    declare_xlink_ns: bool,
+}
+
+impl SerializeOpts {
+    const fn html(style: OutputStyle) -> Self {
+        Self {
+            style,
+            resolve_current_color: false,
+            declare_xlink_ns: false,
+        }
+    }
+}
+
+const XLINK_NS: &str = "http://www.w3.org/1999/xlink";
+
+/// Writes an attribute's serialized name, per the HTML fragment serialization algorithm
+fn write_attr_name(name: &QualName, writer: &mut String) {
+    match name.ns {
+        ns!() | ns!(html) => {}
+        ns!(xml) => writer.push_str("xml:"),
+        ns!(xmlns) if name.local.as_str() == "xmlns" => {}
+        ns!(xmlns) => writer.push_str("xmlns:"),
+        ns!(xlink) => writer.push_str("xlink:"),
+        _ => {
+            if let Some(prefix) = &name.prefix {
+                writer.push_str(prefix);
+                writer.push(':');
+            }
+        }
+    }
+    writer.push_str(&name.local);
+}
+
+fn is_xlink_ns_decl(name: &QualName) -> bool {
+    (name.ns == ns!(xmlns) && name.local.as_str() == "xlink")
+        || name.local.as_str() == "xmlns:xlink"
+}
+
+impl Node {
+    /// Renders the HTML of this node and all its children as a `String` without extra whitespace.
+    ///
+    /// Example output:
+    ///
+    /// ```text
+    /// <html><head /><body><main id="main"><div class="arbitrary-class" /></main></body></html>
+    /// ```
+    pub fn outer_html(&self) -> String {
+        let mut output = String::new();
+        self.write_outer_html(&mut output);
+        output
+    }
+
+    /// Renders the HTML of this node and all its children as a `String` with whitespace for human
+    /// readability.
+    ///
+    /// Example output:
+    ///
+    /// ```text
+    /// <html>
+    ///   <head />
+    ///   <body>
+    ///     <main id="main">
+    ///       <div class="arbitrary-class" />
+    ///     </main>
+    ///   </body>
+    /// </html>
+    /// ```
+    pub fn outer_html_pretty(&self) -> String {
+        let mut output = String::new();
+        self.write_outer_html_pretty(&mut output);
+        output
+    }
+
+    pub fn write_outer_html(&self, writer: &mut String) {
+        self.write_outer_html_in_style(writer, SerializeOpts::html(OutputStyle::Normal), 0);
+    }
+
+    pub fn write_outer_html_pretty(&self, writer: &mut String) {
+        self.write_outer_html_in_style(writer, SerializeOpts::html(OutputStyle::Pretty), 0);
+    }
+
+    /// Serializes this `<svg>` subtree as a standalone SVG document for usvg, with
+    /// `currentColor` resolved against each element's computed `color`.
+    #[cfg(feature = "svg")]
+    pub(crate) fn svg_source(&self) -> String {
+        let mut output = String::new();
+        let opts = SerializeOpts {
+            style: OutputStyle::Normal,
+            resolve_current_color: true,
+            declare_xlink_ns: true,
+        };
+        self.write_outer_html_in_style(&mut output, opts, 0);
+        output
+    }
+
+    fn write_outer_html_in_style(&self, writer: &mut String, opts: SerializeOpts, nesting: usize) {
+        const INDENT: &str = "  ";
+        let style = opts.style;
+        let has_children = !self.children.is_empty();
+        let current_color = opts
+            .resolve_current_color
+            .then(|| self.primary_styles())
+            .flatten()
+            .map(|style| style.clone_color())
+            .map(|color| color.to_css_string());
+
+        match &self.data {
+            NodeData::Document(_) => {}
+            NodeData::Comment { .. } => {}
+            NodeData::AnonymousBlock(_) => {}
+            // NodeData::Doctype { name, .. } => write!(s, "DOCTYPE {name}"),
+            NodeData::Text(data) => {
+                if matches!(style, OutputStyle::Pretty) {
+                    for _ in 0..nesting {
+                        writer.push_str(INDENT);
+                    }
+                }
+                let in_raw_text_element = self
+                    .parent
+                    .and_then(|id| self.tree()[id].data.downcast_element())
+                    .is_some_and(|el| {
+                        // Documents are parsed with scripting disabled, so `<noscript>` is not raw text
+                        el.name.ns == ns!(html)
+                            && matches!(
+                                el.name.local.as_ref(),
+                                "style"
+                                    | "script"
+                                    | "xmp"
+                                    | "iframe"
+                                    | "noembed"
+                                    | "noframes"
+                                    | "plaintext"
+                            )
+                    });
+                if in_raw_text_element {
+                    writer.push_str(data.content.as_str());
+                } else {
+                    encode_text_to_string(data.content.as_str(), writer);
+                }
+                if matches!(style, OutputStyle::Pretty) {
+                    writer.push('\n');
+                }
+            }
+            NodeData::Element(data) => {
+                if matches!(style, OutputStyle::Pretty) {
+                    for _ in 0..nesting {
+                        writer.push_str(INDENT);
+                    }
+                }
+                writer.push('<');
+                writer.push_str(&data.name.local);
+
+                if opts.declare_xlink_ns
+                    && nesting == 0
+                    && !data.attrs().iter().any(|attr| is_xlink_ns_decl(&attr.name))
+                {
+                    writer.push_str(" xmlns:xlink=\"");
+                    writer.push_str(XLINK_NS);
+                    writer.push('"');
+                }
+
+                for attr in data.attrs() {
+                    writer.push(' ');
+                    write_attr_name(&attr.name, writer);
+                    writer.push_str("=\"");
+                    #[allow(clippy::unnecessary_unwrap)] // Convert to if-let chain once stabilised
+                    if current_color.is_some() && attr.value.contains("currentColor") {
+                        let value = attr
+                            .value
+                            .replace("currentColor", current_color.as_ref().unwrap());
+                        encode_quoted_attribute_to_string(&value, writer);
+                    } else {
+                        encode_quoted_attribute_to_string(&attr.value, writer);
+                    }
+                    writer.push('"');
+                }
+                if !has_children {
+                    writer.push_str(" /");
+                }
+                writer.push('>');
+                if matches!(style, OutputStyle::Pretty) {
+                    writer.push('\n');
+                }
+
+                if has_children {
+                    for &child_id in &self.children {
+                        self.tree()[child_id].write_outer_html_in_style(writer, opts, nesting + 1);
+                    }
+
+                    if matches!(style, OutputStyle::Pretty) {
+                        for _ in 0..nesting {
+                            writer.push_str(INDENT);
+                        }
+                    }
+                    writer.push_str("</");
+                    writer.push_str(&data.name.local);
+                    writer.push('>');
+                    if matches!(style, OutputStyle::Pretty) {
+                        writer.push('\n');
+                    }
+                }
+            }
+        }
+    }
+}

package/vendor/blitz-dom/src/node/stylo_data.rs

@@ -0,0 +1,142 @@
+use std::fmt;
+use std::ops::Deref;
+use std::{cell::UnsafeCell, ops::DerefMut};
+use style::data::{ElementDataMut, ElementDataRef, ElementDataWrapper};
+use style::servo_arc::Arc;
+
+use crate::layout::damage::ALL_DAMAGE;
+
+/// Interior-mutable wrapper around `Option<ElementDataWrapper>`.
+///
+/// Encapsulates the `UnsafeCell` so that access sites don't need raw `unsafe` blocks.
+///
+/// Safety relies on:
+///   - Regular static-borrow checking for regular access, and on:
+///   - Stylo having exclusive access to nodes during style traversals
+///   - Stylo's thread-safe traversal model: `init`/`clear` only happen during exclusive-access phases
+pub struct StyloData {
+    inner: UnsafeCell<Option<ElementDataWrapper>>,
+}
+
+impl Default for StyloData {
+    fn default() -> Self {
+        Self {
+            inner: UnsafeCell::new(None),
+        }
+    }
+}
+
+impl fmt::Debug for StyloData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StyloData").finish_non_exhaustive()
+    }
+}
+
+impl Deref for StyloData {
+    type Target = Option<ElementDataWrapper>;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.inner.get() }
+    }
+}
+
+impl DerefMut for StyloData {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.get_mut()
+    }
+}
+
+impl StyloData {
+    /// Whether element data has been initialized.
+    pub fn has_data(&self) -> bool {
+        unsafe { &*self.inner.get() }.is_some()
+    }
+
+    /// Borrow the element data immutably, if present.
+    pub fn get(&self) -> Option<ElementDataRef<'_>> {
+        self.as_ref().map(|w| w.borrow())
+    }
+
+    /// Borrow the element data mutably, if present.
+    pub fn get_mut(&mut self) -> Option<ElementDataMut<'_>> {
+        self.as_mut().map(|w| w.borrow_mut())
+    }
+
+    /// Initialize the element data ready for use (if it is not already initialized)
+    pub fn ensure_init_mut(&mut self) -> ElementDataMut<'_> {
+        // SAFETY:
+        // If we have exclusive access to self (implied by &mut self) then it safe to mutate self.
+        unsafe { self.ensure_init() }
+    }
+
+    pub fn primary_styles(&self) -> Option<StyleDataRef<'_>> {
+        let stylo_element_data = self.get();
+        if stylo_element_data
+            .as_ref()
+            .and_then(|d| d.styles.get_primary())
+            .is_some()
+        {
+            Some(StyleDataRef(self.get().unwrap()))
+        } else {
+            None
+        }
+    }
+
+    /// Borrow the primary computed style directly (rather than the `Arc` containing it).
+    pub fn computed_styles(&self) -> Option<ComputedStyleRef<'_>> {
+        self.primary_styles().map(ComputedStyleRef)
+    }
+
+    /// Get a mutable reference to the data
+    pub unsafe fn unsafe_stylo_only_mut(&self) -> Option<ElementDataMut<'_>> {
+        let opt = unsafe { &mut *self.inner.get() };
+        opt.as_mut().map(|w| w.borrow_mut())
+    }
+
+    /// Initialize the element data ready for use (if it is not already initialized)
+    ///
+    /// SAFETY:
+    /// There must be no outstanding borrows to this container or anything contained within it
+    /// when this method is called
+    pub unsafe fn ensure_init(&self) -> ElementDataMut<'_> {
+        if !self.has_data() {
+            unsafe { *self.inner.get() = Some(ElementDataWrapper::default()) };
+            let mut data_mut = unsafe { self.unsafe_stylo_only_mut() }.unwrap();
+            data_mut.damage = ALL_DAMAGE;
+            data_mut
+        } else {
+            unsafe { self.unsafe_stylo_only_mut() }.unwrap()
+        }
+    }
+
+    /// Clear the element data, returning to the uninitialized state.
+    ///
+    /// SAFETY:
+    /// There must be no outstanding borrows to this container or anything contained within it
+    /// when this method is called
+    pub unsafe fn clear(&self) {
+        unsafe { *self.inner.get() = None };
+    }
+}
+
+pub struct StyleDataRef<'a>(ElementDataRef<'a>);
+
+impl Deref for StyleDataRef<'_> {
+    type Target = Arc<style::properties::ComputedValues>;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.styles.get_primary().unwrap()
+    }
+}
+
+/// Borrow of a node's stylo element data that `Deref`s directly to the primary
+/// [`ComputedValues`](style::properties::ComputedValues), suitable for wrapping
+/// in [`stylo_taffy::TaffyStyloStyle`].
+pub struct ComputedStyleRef<'a>(StyleDataRef<'a>);
+
+impl Deref for ComputedStyleRef<'_> {
+    type Target = style::properties::ComputedValues;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.0.styles.get_primary().unwrap()
+    }
+}