blitz-pdf 0.1.3 → 0.1.4

package/vendor/blitz-dom/src/tree.rs

@@ -0,0 +1,136 @@
+//! Versioned storage for the nodes of the DOM tree.
+
+use std::ops::{Index, IndexMut};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use blitz_traits::node_id::NodeId;
+use slotmap::{Key as _, KeyData, SlotMap};
+
+use crate::Node;
+
+slotmap::new_key_type! {
+    /// The internal [`slotmap`] key for node storage. Only used at the
+    /// storage boundary: all public APIs use [`NodeId`].
+    struct NodeKey;
+}
+
+#[inline(always)]
+fn to_key(id: NodeId) -> NodeKey {
+    NodeKey::from(KeyData::from_ffi(id.as_u64()))
+}
+
+#[inline(always)]
+fn to_id(key: NodeKey) -> NodeId {
+    NodeId::from_u64(key.data().as_ffi())
+}
+
+/// The versioned map in which the nodes of the DOM tree are stored, backed by
+/// a [`slotmap::SlotMap`].
+///
+/// Nodes are addressed by [`NodeId`], which carries the slot's version in
+/// addition to its index: when a node is dropped and its slot reused, ids
+/// referring to the dropped node no longer resolve ([`NodeTree::get`] returns
+/// `None`, and indexing panics) instead of aliasing the new occupant.
+pub struct NodeTree {
+    map: SlotMap<NodeKey, Node>,
+    /// Bumped whenever box geometry may have moved (layout ran or a scroll
+    /// offset changed). Values derived from `final_layout()` (e.g. hoisted
+    /// paint child offsets) are memoised against it. Starts at 1 so that a
+    /// stamp of 0 is never current.
+    geometry_generation: AtomicU64,
+    /// Scroll offset of the viewport (the root element scrolls the viewport,
+    /// so its offset lives here rather than on the node).
+    viewport_scroll: crate::Point<f64>,
+}
+
+impl NodeTree {
+    pub(crate) fn new() -> Self {
+        Self {
+            map: SlotMap::with_key(),
+            geometry_generation: AtomicU64::new(1),
+            viewport_scroll: crate::Point::ZERO,
+        }
+    }
+
+    pub fn viewport_scroll(&self) -> crate::Point<f64> {
+        self.viewport_scroll
+    }
+
+    /// Memoised paint geometry may depend on the viewport scroll, so this
+    /// bumps the geometry generation like any other scroll write.
+    pub(crate) fn set_viewport_scroll(&mut self, scroll: crate::Point<f64>) {
+        self.viewport_scroll = scroll;
+        self.bump_geometry_generation();
+    }
+
+    /// See the `geometry_generation` field.
+    pub fn geometry_generation(&self) -> u64 {
+        self.geometry_generation.load(Ordering::Relaxed)
+    }
+
+    pub(crate) fn bump_geometry_generation(&self) {
+        self.geometry_generation.fetch_add(1, Ordering::Relaxed);
+    }
+
+    /// The number of live nodes in the map.
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+
+    /// Whether `id` resolves to a live node.
+    pub fn contains_key(&self, id: NodeId) -> bool {
+        self.map.contains_key(to_key(id))
+    }
+
+    /// Get a reference to the node with the given id, if it is still live.
+    pub fn get(&self, id: NodeId) -> Option<&Node> {
+        self.map.get(to_key(id))
+    }
+
+    /// Get a mutable reference to the node with the given id, if it is still live.
+    pub fn get_mut(&mut self, id: NodeId) -> Option<&mut Node> {
+        self.map.get_mut(to_key(id))
+    }
+
+    /// Insert a node constructed with knowledge of its own id.
+    pub(crate) fn insert_with_key(&mut self, f: impl FnOnce(NodeId) -> Node) -> NodeId {
+        to_id(self.map.insert_with_key(|key| f(to_id(key))))
+    }
+
+    /// Remove the node with the given id, returning it if it was still live.
+    pub(crate) fn remove(&mut self, id: NodeId) -> Option<Node> {
+        self.map.remove(to_key(id))
+    }
+
+    /// Iterate over all live `(NodeId, &Node)` pairs.
+    pub fn iter(&self) -> impl Iterator<Item = (NodeId, &Node)> {
+        self.map.iter().map(|(key, node)| (to_id(key), node))
+    }
+
+    /// Iterate over all live `(NodeId, &mut Node)` pairs.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (NodeId, &mut Node)> {
+        self.map.iter_mut().map(|(key, node)| (to_id(key), node))
+    }
+}
+
+impl Index<NodeId> for NodeTree {
+    type Output = Node;
+
+    #[track_caller]
+    #[inline]
+    fn index(&self, id: NodeId) -> &Node {
+        &self.map[to_key(id)]
+    }
+}
+
+impl IndexMut<NodeId> for NodeTree {
+    #[track_caller]
+    #[inline]
+    fn index_mut(&mut self, id: NodeId) -> &mut Node {
+        &mut self.map[to_key(id)]
+    }
+}

package/vendor/blitz-dom/src/url.rs

@@ -0,0 +1,63 @@
+use std::ops::Deref;
+use std::str::FromStr;
+
+use style::servo_arc::Arc as ServoArc;
+use style::stylesheets::UrlExtraData;
+use url::{Position, Url};
+
+#[derive(Clone)]
+pub(crate) struct DocumentUrl {
+    base_url: ServoArc<Url>,
+}
+
+impl DocumentUrl {
+    /// Create a stylo `UrlExtraData` from the URL
+    pub(crate) fn url_extra_data(&self) -> UrlExtraData {
+        UrlExtraData(ServoArc::clone(&self.base_url))
+    }
+
+    pub(crate) fn resolve_relative(&self, raw: &str) -> Option<url::Url> {
+        self.base_url.join(raw).ok()
+    }
+
+    /// Returns `true` if `other` refers to the same document as this URL, i.e. it is
+    /// identical to this URL except (possibly) for the fragment (`#...`) component.
+    ///
+    /// This is used to decide whether following a link should perform in-page fragment
+    /// navigation (scrolling) rather than a full navigation.
+    pub(crate) fn is_same_document(&self, other: &Url) -> bool {
+        let this: &Url = &self.base_url;
+        this[..Position::AfterQuery] == other[..Position::AfterQuery]
+    }
+}
+
+impl Default for DocumentUrl {
+    fn default() -> Self {
+        Self::from_str("data:text/css;charset=utf-8;base64,").unwrap()
+    }
+}
+impl FromStr for DocumentUrl {
+    type Err = <Url as FromStr>::Err;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let base_url = ServoArc::new(Url::parse(s)?);
+        Ok(Self { base_url })
+    }
+}
+impl From<Url> for DocumentUrl {
+    fn from(base_url: Url) -> Self {
+        Self {
+            base_url: ServoArc::new(base_url),
+        }
+    }
+}
+impl From<ServoArc<Url>> for DocumentUrl {
+    fn from(base_url: ServoArc<Url>) -> Self {
+        Self { base_url }
+    }
+}
+impl Deref for DocumentUrl {
+    type Target = Url;
+    fn deref(&self) -> &Self::Target {
+        &self.base_url
+    }
+}

package/vendor/blitz-dom/src/util.rs

@@ -0,0 +1,256 @@
+use crate::node::{Node, NodeData};
+use color::{AlphaColor, Srgb};
+use keyboard_types::Modifiers;
+use std::borrow::Cow;
+use style::color::AbsoluteColor;
+
+#[cfg(target_os = "macos")]
+pub(crate) const ACTION_MOD: Modifiers = Modifiers::SUPER;
+#[cfg(not(target_os = "macos"))]
+pub(crate) const ACTION_MOD: Modifiers = Modifiers::CONTROL;
+
+pub type Color = AlphaColor<Srgb>;
+
+/// Decode raw font bytes, decompressing WOFF/WOFF2 if the `woff` feature is enabled.
+/// Returns the original slice unchanged for TTF/OTF input, and also on decompression
+/// failure. With the `woff` feature disabled, all input passes through unchanged.
+pub fn decode_font_bytes(bytes: &[u8]) -> Cow<'_, [u8]> {
+    if bytes.len() < 4 {
+        return Cow::Borrowed(bytes);
+    }
+    match &bytes[0..4] {
+        #[cfg(feature = "woff")]
+        b"wOFF" => wuff::decompress_woff1(bytes)
+            .map(Cow::Owned)
+            .unwrap_or_else(|_| {
+                #[cfg(feature = "tracing")]
+                tracing::warn!("Failed to decompress woff1 font");
+                Cow::Borrowed(bytes)
+            }),
+        #[cfg(feature = "woff")]
+        b"wOF2" => wuff::decompress_woff2(bytes)
+            .map(Cow::Owned)
+            .unwrap_or_else(|_| {
+                #[cfg(feature = "tracing")]
+                tracing::warn!("Failed to decompress woff2 font");
+                Cow::Borrowed(bytes)
+            }),
+        _ => Cow::Borrowed(bytes),
+    }
+}
+
+#[cfg(feature = "svg")]
+use std::sync::{Arc, LazyLock};
+#[cfg(feature = "svg")]
+use usvg::fontdb;
+#[cfg(feature = "svg")]
+pub(crate) static FONT_DB: LazyLock<Arc<fontdb::Database>> = LazyLock::new(|| {
+    let mut db = fontdb::Database::new();
+    db.load_system_fonts();
+    Arc::new(db)
+});
+
+/// Which kind of CSS image layer list (`background-image` or `mask-image`) to
+/// flush from style to dedicated storage on the node.
+#[derive(Clone, Copy, Debug)]
+pub enum ImageLayerKind {
+    Background,
+    Mask,
+}
+
+impl ImageLayerKind {
+    pub fn image_type(self, idx: usize) -> ImageType {
+        match self {
+            Self::Background => ImageType::Background(idx),
+            Self::Mask => ImageType::Mask(idx),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ImageType {
+    Image,
+    Background(usize),
+    Mask(usize),
+}
+
+/// A point
+#[derive(Clone, Debug, Copy, Eq, PartialEq)]
+pub struct Point<T> {
+    /// The x coordinate
+    pub x: T,
+    /// The y coordinate
+    pub y: T,
+}
+
+impl Point<f64> {
+    pub const ZERO: Self = Point { x: 0.0, y: 0.0 };
+}
+
+// Debug print an RcDom
+pub fn walk_tree(indent: usize, node: &Node) {
+    // Skip all-whitespace text nodes entirely
+    if let NodeData::Text(data) = &node.data {
+        if data.content.chars().all(|c| c.is_ascii_whitespace()) {
+            return;
+        }
+    }
+
+    print!("{}", " ".repeat(indent));
+    let id = node.id;
+    match &node.data {
+        NodeData::Document(_) => println!("#Document {id}"),
+
+        NodeData::Text(data) => {
+            if data.content.chars().all(|c| c.is_ascii_whitespace()) {
+                println!("{id} #text: <whitespace>");
+            } else {
+                let content = data.content.trim();
+                if content.len() > 10 {
+                    println!(
+                        "#text {id}: {}...",
+                        content
+                            .split_at(content.char_indices().take(10).last().unwrap().0)
+                            .0
+                            .escape_default()
+                    )
+                } else {
+                    println!("#text {id}: {}", data.content.trim().escape_default())
+                }
+            }
+        }
+
+        NodeData::Comment { .. } => println!("<!-- COMMENT {id} -->"),
+
+        NodeData::AnonymousBlock(_) => println!("{id} AnonymousBlock"),
+
+        NodeData::Element(data) => {
+            print!("<{} {id}", data.name.local);
+            for attr in data.attrs.iter() {
+                print!(" {}=\"{}\"", attr.name.local, attr.value);
+            }
+            if !node.children.is_empty() {
+                println!(">");
+            } else {
+                println!("/>");
+            }
+        } // NodeData::Doctype {
+          //     ref name,
+          //     ref public_id,
+          //     ref system_id,
+          // } => println!("<!DOCTYPE {} \"{}\" \"{}\">", name, public_id, system_id),
+          // NodeData::ProcessingInstruction { .. } => unreachable!(),
+    }
+
+    if !node.children.is_empty() {
+        for child_id in node.children.iter() {
+            walk_tree(indent + 2, node.with(*child_id));
+        }
+
+        if let NodeData::Element(data) = &node.data {
+            println!("{}</{}>", " ".repeat(indent), data.name.local);
+        }
+    }
+}
+
+/// Parse an SVG image.
+#[cfg(feature = "svg")]
+pub(crate) fn parse_svg_image(source: &[u8]) -> Result<crate::node::SvgImageData, usvg::Error> {
+    let options = usvg::Options {
+        fontdb: Arc::clone(&*FONT_DB),
+        ..Default::default()
+    };
+    crate::node::SvgImageData::from_data(source, &options)
+}
+
+pub trait ToColorColor {
+    /// Converts a color into the `AlphaColor<Srgb>` type from the `color` crate
+    fn as_color_color(&self) -> Color;
+}
+impl ToColorColor for AbsoluteColor {
+    fn as_color_color(&self) -> Color {
+        Color::new(
+            *self
+                .to_color_space(style::color::ColorSpace::Srgb)
+                .raw_components(),
+        )
+    }
+}
+
+#[cfg(all(test, feature = "svg"))]
+mod svg_tests {
+    use super::parse_svg_image;
+
+    #[test]
+    fn svg_without_xmlns_parses() {
+        let src = br#"<svg viewBox="0 0 24 24"><path d="M0 0h24v24H0z"/></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert!(!svg.tree.root().children().is_empty());
+    }
+
+    #[test]
+    fn missing_height_is_computed_from_width_and_viewbox_ratio() {
+        let src = br#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="200"><rect width="100%" height="100%" fill="green"/></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert_eq!(svg.intrinsic_width(), Some(200.0));
+        assert_eq!(svg.intrinsic_height(), None);
+        assert_eq!(svg.viewbox_aspect_ratio(), Some(1.0));
+        assert_eq!(svg.tree.size().width(), 200.0);
+        assert_eq!(svg.intrinsic_size(), (200.0, 200.0));
+    }
+
+    #[test]
+    fn viewbox_only_has_no_intrinsic_dimensions() {
+        let src = br#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 485 58"></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert_eq!(svg.intrinsic_width(), None);
+        assert_eq!(svg.intrinsic_height(), None);
+        // The aspect ratio is still available from the viewBox.
+        assert!((svg.aspect_ratio() - (485.0 / 58.0)).abs() < 1e-3);
+    }
+
+    #[test]
+    fn absolute_dimensions_are_intrinsic() {
+        let src = br#"<svg xmlns="http://www.w3.org/2000/svg" width="24" height="16" viewBox="0 0 48 32"></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert_eq!(svg.intrinsic_width(), Some(24.0));
+        assert_eq!(svg.intrinsic_height(), Some(16.0));
+    }
+
+    #[test]
+    fn percentage_dimensions_are_not_intrinsic() {
+        let src = br#"<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="50%" viewBox="0 0 200 100"></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert_eq!(svg.intrinsic_width(), None);
+        assert_eq!(svg.intrinsic_height(), None);
+    }
+
+    #[test]
+    fn unit_lengths_are_intrinsic() {
+        let src = br#"<svg xmlns="http://www.w3.org/2000/svg" width="24px" height="1.5em" viewBox="0 0 48 32"></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert!(svg.intrinsic_width().is_some());
+        assert!(svg.intrinsic_height().is_some());
+    }
+
+    #[test]
+    fn non_numeric_dimensions_are_not_intrinsic() {
+        let src = br#"<svg xmlns="http://www.w3.org/2000/svg" width="auto" height="foo" viewBox="0 0 200 100"></svg>"#;
+        let svg = parse_svg_image(src).unwrap();
+        assert_eq!(svg.intrinsic_width(), None);
+        assert_eq!(svg.intrinsic_height(), None);
+    }
+}
+
+/// Creates an markup5ever::QualName.
+/// Given a local name and an optional namespace
+#[macro_export]
+macro_rules! qual_name {
+    ($local:tt $(, $ns:ident)?) => {
+        $crate::QualName {
+            prefix: None,
+            ns: $crate::ns!($($ns)?),
+            local: $crate::local_name!($local),
+        }
+    };
+}