blitz-pdf 0.1.2 → 0.1.4

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

@@ -0,0 +1,439 @@
+use markup5ever::{LocalName, local_name};
+use taffy::{
+    AvailableSpace, BoxSizing, CoreStyle, LayoutInput, LayoutOutput, MaybeMath, MaybeResolve,
+    RequestedAxis, ResolveOrZero as _, RunMode, Size, SizingMode,
+};
+
+/// Whether an element is a replaced element laid out as a leaf box with an
+/// intrinsic size. Note: `<object>` is deliberately excluded as its fallback
+/// children should render when no resource is loaded.
+pub(crate) fn is_replaced_element(tag_name: &LocalName) -> bool {
+    *tag_name == local_name!("img")
+        || *tag_name == local_name!("svg")
+        || *tag_name == local_name!("canvas")
+        || *tag_name == local_name!("video")
+        || *tag_name == local_name!("embed")
+        || *tag_name == local_name!("iframe")
+}
+
+/// The intrinsic dimensions of a replaced element per CSS Images 3
+/// (https://drafts.csswg.org/css-images/#intrinsic-dimensions): an intrinsic
+/// width, an intrinsic height, and an intrinsic aspect ratio, each of which
+/// may independently be absent.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct IntrinsicSizes {
+    pub width: Option<f32>,
+    pub height: Option<f32>,
+    pub ratio: Option<f32>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ReplacedContext {
+    /// The element's intrinsic dimensions, each possibly absent.
+    pub intrinsic_sizes: IntrinsicSizes,
+    /// The default object size (https://drafts.csswg.org/css-images/#default-object-size)
+    /// used to fill in dimensions the intrinsic sizes leave unresolved. 300x150
+    /// for most replaced elements; zero for an image with no loaded resource.
+    pub default_object_size: taffy::Size<f32>,
+}
+
+/// Whether a height/width value is violating it's min- and max- constraints
+/// The min- and max- constraints cannot both be violated because the max
+/// constraint if floored by the min constraint (min constraint takes priority)
+enum Violation {
+    /// Constraints are not violated
+    None,
+    /// Min constraint is violated
+    Min,
+    /// Max constraint is violated
+    Max,
+}
+
+pub fn compute_replaced_layout(
+    inputs: LayoutInput,
+    style: &impl CoreStyle,
+    resolve_calc_value: impl Fn(*const (), f32) -> f32,
+    context: &ReplacedContext,
+) -> LayoutOutput {
+    let LayoutInput {
+        known_dimensions,
+        parent_size,
+        available_space,
+        sizing_mode,
+        run_mode,
+        axis: requested_axis,
+        ..
+    } = inputs;
+
+    let padding = style
+        .padding()
+        .resolve_or_zero(parent_size.width, &resolve_calc_value);
+    let border = style
+        .border()
+        .resolve_or_zero(parent_size.width, &resolve_calc_value);
+    let padding_border = padding + border;
+    let pb_sum = Size {
+        width: padding_border.left + padding_border.right,
+        height: padding_border.top + padding_border.bottom,
+    };
+    let box_sizing_adjustment = if style.box_sizing() == BoxSizing::BorderBox {
+        pb_sum
+    } else {
+        Size::ZERO
+    };
+
+    // The scrollable overflow rect is measured from the scroll origin at the
+    // padding-box corner: the content-box size offset by the start padding. A
+    // scroll container's own padding at the end of the content is part of its
+    // scrollable overflow region, so it is included. Boxes that are not scroll
+    // containers do not extend their overflow region by their own padding.
+    let is_scroll_container = {
+        let overflow = style.overflow();
+        overflow.x.is_scroll_container() || overflow.y.is_scroll_container()
+    };
+    let is_rtl = style.direction() == taffy::Direction::Rtl;
+    let overflow_rect_for = |content_box_size: Size<f32>| {
+        let start_padding = if is_rtl { padding.right } else { padding.left };
+        let end_padding = if is_rtl { padding.left } else { padding.right };
+        taffy::Rect {
+            left: 0.0,
+            right: start_padding
+                + content_box_size.width
+                + if is_scroll_container {
+                    end_padding
+                } else {
+                    0.0
+                },
+            top: 0.0,
+            bottom: padding.top
+                + content_box_size.height
+                + if is_scroll_container {
+                    padding.bottom
+                } else {
+                    0.0
+                },
+        }
+    };
+
+    // Return early if both width and height are known
+    if run_mode == RunMode::ComputeSize {
+        if let Size {
+            width: Some(width),
+            height: Some(height),
+        } = known_dimensions
+        {
+            return LayoutOutput::from_outer_size(Size {
+                width: width.max(pb_sum.width),
+                height: height.max(pb_sum.height),
+            });
+        }
+    }
+
+    // Use aspect_ratio from style, fall back to inherent aspect ratio (if any).
+    //
+    // A degenerate ratio -- zero, infinite, or NaN -- is discarded. Transferring
+    // such a ratio between axes computes `width / ratio` or `height * ratio`,
+    // which yields an infinite (ratio == 0) or NaN (ratio is NaN) size in the
+    // other axis. CSS Sizing 4 4.1 says a degenerate ratio behaves as `auto`,
+    // so each source is filtered *before* the fallback: a degenerate style
+    // ratio falls back to the inherent one (that is what `auto` means for a
+    // replaced element), and only if both are degenerate or absent does the
+    // element get no preferred aspect ratio at all.
+    let is_usable_ratio = |ratio: &f32| ratio.is_finite() && *ratio > 0.0;
+    let intrinsic = context.intrinsic_sizes;
+    let aspect_ratio: Option<f32> = style
+        .aspect_ratio()
+        .filter(is_usable_ratio)
+        .or(intrinsic.ratio.filter(is_usable_ratio));
+
+    // Concrete object size per the CSS default sizing algorithm with no
+    // specified size (https://drafts.csswg.org/css-images/#default-sizing):
+    // missing intrinsic dimensions are derived from the aspect ratio when
+    // possible, otherwise taken from the default object size. An element with
+    // only an intrinsic aspect ratio uses the stretch-fit width in normal flow
+    // (CSS2 §10.3.2) when the available width is definite; shrink-to-fit
+    // contexts (min/max-content) contain it within the default object size.
+    //
+    // Only the intrinsic ratio participates here: the `aspect-ratio` property
+    // affects the sizing of the box, not the natural dimensions of its content.
+    let intrinsic_ratio = intrinsic.ratio.filter(is_usable_ratio);
+    let default_size = context.default_object_size;
+    let inherent_size = match (intrinsic.width, intrinsic.height) {
+        (Some(w), Some(h)) => Size {
+            width: w,
+            height: h,
+        },
+        (Some(w), None) => Size {
+            width: w,
+            height: intrinsic_ratio
+                .map(|r| w / r)
+                .unwrap_or(default_size.height),
+        },
+        (None, Some(h)) => Size {
+            width: intrinsic_ratio.map(|r| h * r).unwrap_or(default_size.width),
+            height: h,
+        },
+        (None, None) => match intrinsic_ratio {
+            Some(ratio) => {
+                // A ratio-only replaced element stretches to fit the width it is laid out
+                // in: the available width if definite, else (under a max-content constraint)
+                // its containing block, per CSS2 §10.3.2.
+                let stretch_fit_width = match available_space.width {
+                    AvailableSpace::Definite(width) => Some(width),
+                    AvailableSpace::MaxContent => parent_size.width,
+                    AvailableSpace::MinContent => None,
+                };
+                if let Some(width) = stretch_fit_width {
+                    Size {
+                        width,
+                        height: width / ratio,
+                    }
+                } else {
+                    // Contain within the default object size
+                    let scale = (default_size.width / ratio).min(default_size.height);
+                    Size {
+                        width: scale * ratio,
+                        height: scale,
+                    }
+                }
+            }
+            None => default_size,
+        },
+    };
+
+    // Percentages are only resolved against zero in the inline axis.
+    // See https://www.w3.org/TR/css-sizing-3/#replaced-percentage-min-contribution
+    let basis_for_max_and_preferred = Size {
+        width: if available_space.width == AvailableSpace::MinContent {
+            Some(0.0)
+        } else {
+            parent_size.width
+        },
+        height: parent_size.height,
+    };
+
+    // `stretch` fills the containing block (less margins) when its size is definite, and
+    // behaves as `auto` otherwise. The content size can't be negative.
+    // See https://drafts.csswg.org/css-sizing-4/#stretch-fit-sizing
+    let margin = style
+        .margin()
+        .resolve_or_zero(parent_size.width, &resolve_calc_value);
+    let stretch_size = Size {
+        width: parent_size
+            .width
+            .filter(|_| available_space.width.is_definite())
+            .map(|width| (width - margin.horizontal_axis_sum() - pb_sum.width).max(0.0)),
+        height: parent_size
+            .height
+            .filter(|_| available_space.height.is_definite())
+            .map(|height| (height - margin.vertical_axis_sum() - pb_sum.height).max(0.0)),
+    };
+
+    // Resolve sizes
+    let size_style = style.size();
+    let style_size = size_style
+        .maybe_resolve(basis_for_max_and_preferred, &resolve_calc_value)
+        .maybe_sub(box_sizing_adjustment);
+    let style_size = Size {
+        width: if size_style.width.is_stretch() {
+            stretch_size.width
+        } else {
+            style_size.width
+        },
+        height: if size_style.height.is_stretch() {
+            stretch_size.height
+        } else {
+            style_size.height
+        },
+    };
+    let mut min_size = style
+        .min_size()
+        .maybe_resolve(parent_size, &resolve_calc_value)
+        .maybe_sub(box_sizing_adjustment);
+    let max_size = style
+        .max_size()
+        .maybe_resolve(basis_for_max_and_preferred, &resolve_calc_value)
+        .maybe_max(min_size)
+        .maybe_sub(box_sizing_adjustment);
+
+    // For ContentSize mode, ignore preferred/min size styles in the axis being measured: the
+    // parent layout algorithm applies them itself, and content-based measurement should return
+    // the content size (the intrinsic size for replaced elements). Constraints in the opposite
+    // axis are retained as they transfer through the aspect ratio (transferred size suggestion).
+    let mut style_size = style_size;
+    if sizing_mode == SizingMode::ContentSize {
+        match requested_axis {
+            RequestedAxis::Horizontal => {
+                style_size.width = None;
+                min_size.width = None;
+            }
+            RequestedAxis::Vertical => {
+                style_size.height = None;
+                min_size.height = None;
+            }
+            RequestedAxis::Both => {}
+        }
+    }
+
+    // Known dimensions are the parent's current sizing inputs. Clamp them before transferring
+    // an aspect ratio so provisional cross-axis sizes do not bypass replaced-element limits.
+    if known_dimensions.width.is_some() | known_dimensions.height.is_some() {
+        // Style max sizes without the available-space fallback: available space must not
+        // constrain the aspect-ratio transfer of parent-resolved dimensions.
+        let style_max_size = style
+            .max_size()
+            .maybe_resolve(basis_for_max_and_preferred, &resolve_calc_value)
+            .maybe_sub(box_sizing_adjustment)
+            .maybe_max(min_size);
+
+        let content_box_known_dimensions = known_dimensions.maybe_sub(pb_sum);
+        let transferred = content_box_known_dimensions
+            .maybe_clamp(min_size, style_max_size)
+            .maybe_apply_aspect_ratio(aspect_ratio)
+            .unwrap_or(inherent_size);
+
+        // Known axes are authoritative (already resolved by the parent); only the axis
+        // derived via aspect-ratio transfer (or falling back to the intrinsic size) is
+        // clamped by this element's min/max sizes.
+        let size = content_box_known_dimensions
+            .unwrap_or(transferred.maybe_clamp(min_size, style_max_size));
+
+        let size = size.map(|s| s.max(0.0));
+        return LayoutOutput::from_sizes(size + pb_sum, overflow_rect_for(size));
+    }
+
+    let unclamped_size = if style_size.width.is_some() | style_size.height.is_some() {
+        style_size
+            .maybe_apply_aspect_ratio(aspect_ratio)
+            .unwrap_or(inherent_size)
+    } else {
+        inherent_size
+    };
+
+    // Floor size at zero
+    let size = unclamped_size.map(|s| s.max(0.0));
+
+    // Violations
+    let width_violation = if size.width < min_size.width.unwrap_or(0.0) {
+        Violation::Min
+    } else if size.width > max_size.width.unwrap_or(f32::INFINITY) {
+        Violation::Max
+    } else {
+        Violation::None
+    };
+
+    let height_violation = if size.height < min_size.height.unwrap_or(0.0) {
+        Violation::Min
+    } else if size.height > max_size.height.unwrap_or(f32::INFINITY) {
+        Violation::Max
+    } else {
+        Violation::None
+    };
+
+    // Without an intrinsic aspect ratio, each axis is clamped independently
+    let Some(aspect_ratio) = aspect_ratio else {
+        let size = size.maybe_clamp(min_size, max_size);
+        return LayoutOutput::from_sizes(size + pb_sum, overflow_rect_for(size));
+    };
+    let inv_aspect_ratio = 1.0 / aspect_ratio;
+
+    // Clamp following rules in table at
+    // https://www.w3.org/TR/CSS22/visudet.html#min-max-widths
+    let size = match (width_violation, height_violation) {
+        // No constraint violation
+        (Violation::None, Violation::None) => size,
+        // w > max-width
+        (Violation::Max, Violation::None) => {
+            let max_width = max_size.width.unwrap();
+            Size {
+                width: max_width,
+                height: (max_width * inv_aspect_ratio).maybe_max(min_size.height),
+            }
+        }
+        // w < min-width
+        (Violation::Min, Violation::None) => {
+            let min_width = min_size.width.unwrap();
+            Size {
+                width: min_width,
+                height: (min_width * inv_aspect_ratio).maybe_min(max_size.height),
+            }
+        }
+        // h > max-height
+        (Violation::None, Violation::Max) => {
+            let max_height = max_size.height.unwrap();
+            Size {
+                width: (max_height * aspect_ratio).maybe_max(min_size.width),
+                height: max_height,
+            }
+        }
+        // h < min-height
+        (Violation::None, Violation::Min) => {
+            let min_height = min_size.height.unwrap();
+            Size {
+                width: (min_height * aspect_ratio).maybe_min(max_size.width),
+                height: min_height,
+            }
+        }
+        // (w > max-width) and (h > max-height)
+        (Violation::Max, Violation::Max) => {
+            let max_width = max_size.width.unwrap();
+            let max_height = max_size.height.unwrap();
+            if max_width / size.width <= max_height / size.height {
+                Size {
+                    width: max_width,
+                    height: (max_width * inv_aspect_ratio).maybe_max(min_size.height),
+                }
+            } else {
+                Size {
+                    width: (max_height * aspect_ratio).maybe_max(min_size.width),
+                    height: max_height,
+                }
+            }
+        }
+        // (w < min-width) and (h < min-height)
+        (Violation::Min, Violation::Min) => {
+            let min_width = min_size.width.unwrap();
+            let min_height = min_size.height.unwrap();
+            if min_width / size.width <= min_height / size.height {
+                Size {
+                    width: (min_height * aspect_ratio).maybe_min(max_size.width),
+                    height: min_height,
+                }
+            } else {
+                Size {
+                    width: min_width,
+                    height: (min_width * inv_aspect_ratio).maybe_min(max_size.height),
+                }
+            }
+        }
+        // (w < min-width) and (h > max-height)
+        (Violation::Min, Violation::Max) => {
+            let min_width = min_size.width.unwrap();
+            let max_height = max_size.height.unwrap();
+            Size {
+                width: min_width,
+                height: max_height,
+            }
+        }
+        // (w < min-width) and (h > max-height)
+        (Violation::Max, Violation::Min) => {
+            let max_width = max_size.width.unwrap();
+            let min_height = min_size.height.unwrap();
+            Size {
+                width: max_width,
+                height: min_height,
+            }
+        }
+    };
+
+    LayoutOutput::from_sizes(size + pb_sum, overflow_rect_for(size))
+}
+
+/// Inline-level elements that are laid out as atomic inline boxes (with their own
+/// layout box) rather than being flattened into the surrounding text layout.
+pub(crate) fn is_inline_box_element(tag_name: &LocalName) -> bool {
+    is_replaced_element(tag_name)
+        || *tag_name == local_name!("input")
+        || *tag_name == local_name!("textarea")
+        || *tag_name == local_name!("button")
+}