taffy/compute/grid/types/

grid_item.rs

//! Contains GridItem used to represent a single grid item during layout
use super::GridTrack;
use crate::compute::common::sizing_keyword::{resolve_sizing_keyword, SizingKeywordResolution};
use crate::compute::grid::OriginZeroLine;
use crate::geometry::AbstractAxis;
use crate::geometry::{Line, Point, Rect, Size};
use crate::style::{AlignItems, AlignSelf, AvailableSpace, Dimension, LengthPercentageAuto, Overflow};
use crate::tree::{LayoutPartialTree, LayoutPartialTreeExt, NodeId, OofCandidates, SizingMode};
use crate::util::sys::f32_max;
use crate::util::{MaybeMath, MaybeResolve, ResolveOrZero};
use crate::{AlignItemsKeyword, BoxSizing, GridItemStyle, LengthPercentage};
use core::ops::Range;

/// The known_dimensions computed for a grid item for a given grid area size
#[derive(Debug, Clone, Copy)]
pub(in super::super) struct KnownDimensionsCacheEntry {
    /// The grid area size that `known_dimensions` was computed for
    grid_area_size: Size<Option<f32>>,
    /// The cached known_dimensions
    known_dimensions: Size<Option<f32>>,
}

/// Represents a single grid item
#[derive(Debug)]
pub(in super::super) struct GridItem {
    /// The id of the node that this item represents
    pub node: NodeId,

    /// The index of the item in the children array
    pub source_order: u16,

    /// The item's definite row-start and row-end, as resolved by the placement algorithm
    /// (in origin-zero coordinates). Set by the placement algorithm.
    pub row: Line<OriginZeroLine>,
    /// The items definite column-start and column-end, as resolved by the placement algorithm
    /// (in origin-zero coordinates). Set by the placement algorithm.
    pub column: Line<OriginZeroLine>,

    /// Is it a compressible replaced element?
    /// https://drafts.csswg.org/css-sizing-3/#min-content-zero
    pub is_compressible_replaced: bool,
    /// Whether the item is a replaced element. Such items are not stretched by `normal` alignment.
    pub is_replaced: bool,
    /// The item's overflow style
    pub overflow: Point<Overflow>,
    /// The item's box_sizing style
    pub box_sizing: BoxSizing,
    /// The item's size style
    pub size: Size<Dimension>,
    /// The item's min_size style
    pub min_size: Size<LengthPercentageAuto>,
    /// The item's max_size style
    pub max_size: Size<LengthPercentageAuto>,
    /// The item's aspect_ratio style
    pub aspect_ratio: Option<f32>,
    /// The item's padding style
    pub padding: Rect<LengthPercentage>,
    /// The item's border style
    pub border: Rect<LengthPercentage>,
    /// The item's margin style
    pub margin: Rect<LengthPercentageAuto>,
    /// The item's align_self property, or the parent's align_items property if it is `None`
    pub align_self: AlignSelf,
    /// The item's justify_self property, or the parent's justify_items property if it is `None`
    pub justify_self: AlignSelf,
    /// The item's first baseline (horizontal), measured from the top of its border box. Set from the item's
    /// intrinsic layout when resolving baseline alignment during track sizing, then from its final layout.
    pub baseline: Option<f32>,
    /// Shim for baseline alignment that acts like an extra top margin
    /// TODO: Support last baseline and vertical text baselines
    pub baseline_shim: f32,

    /// The item's definite row-start and row-end (same as `row` field, except in a different coordinate system)
    /// (as indexes into the Vec<GridTrack> stored in a grid's AbstractAxisTracks)
    pub row_indexes: Line<u16>,
    /// The items definite column-start and column-end (same as `column` field, except in a different coordinate system)
    /// (as indexes into the Vec<GridTrack> stored in a grid's AbstractAxisTracks)
    pub column_indexes: Line<u16>,

    /// Whether the item crosses a flexible row
    pub crosses_flexible_row: bool,
    /// Whether the item crosses a flexible column
    pub crosses_flexible_column: bool,
    /// Whether the item crosses a intrinsic row
    pub crosses_intrinsic_row: bool,
    /// Whether the item crosses a intrinsic column
    pub crosses_intrinsic_column: bool,

    // Caches for intrinsic size computation. These caches are only valid for a single run of the track-sizing algorithm.
    /// Cache for the known_dimensions input to intrinsic sizing computation
    pub grid_area_size_cache: Option<Size<Option<f32>>>,
    /// Cache for the known_dimensions passed to the child when computing its intrinsic contributions, stored along with
    /// the grid area size it was computed for. Must be cleared whenever `baseline_shim` changes.
    pub known_dimensions_cache: Option<KnownDimensionsCacheEntry>,
    /// Cache for the min-content size
    pub min_content_contribution_cache: Size<Option<f32>>,
    /// Cache for the minimum contribution
    pub minimum_contribution_cache: Size<Option<f32>>,
    /// Cache for the max-content size
    pub max_content_contribution_cache: Size<Option<f32>>,

    /// Final y position, excluding any relative offset (which does not affect the container's baseline).
    /// Used to compute baseline alignment for the container.
    pub y_position: f32,
    /// Final height. Used to compute baseline alignment for the container.
    pub height: f32,

    /// Out-of-flow candidates bubbled out of this item's subtree (anchors relative to the
    /// container's border box)
    pub oof_candidates: OofCandidates,
}

impl GridItem {
    /// Create a new item from its style. Its placement (`row`/`column`) is filled in by the placement algorithm.
    pub fn new_with_style_and_order<S: GridItemStyle>(
        node: NodeId,
        style: S,
        parent_align_items: AlignItems,
        parent_justify_items: AlignItems,
        source_order: u16,
    ) -> Self {
        const UNPLACED: Line<OriginZeroLine> = Line { start: OriginZeroLine(0), end: OriginZeroLine(0) };
        GridItem {
            node,
            source_order,
            row: UNPLACED,
            column: UNPLACED,
            is_compressible_replaced: style.is_compressible_replaced(),
            is_replaced: style.is_replaced(),
            overflow: style.overflow(),
            box_sizing: style.box_sizing(),
            size: style.size(),
            min_size: style.min_size(),
            max_size: style.max_size(),
            aspect_ratio: style.aspect_ratio(),
            padding: style.padding(),
            border: style.border(),
            margin: style.margin(),
            align_self: style.align_self().unwrap_or(parent_align_items),
            justify_self: style.justify_self().unwrap_or(parent_justify_items),
            baseline: None,
            baseline_shim: 0.0,
            row_indexes: Line { start: 0, end: 0 }, // Properly initialised later
            column_indexes: Line { start: 0, end: 0 }, // Properly initialised later
            crosses_flexible_row: false,            // Properly initialised later
            crosses_flexible_column: false,         // Properly initialised later
            crosses_intrinsic_row: false,           // Properly initialised later
            crosses_intrinsic_column: false,        // Properly initialised later
            grid_area_size_cache: None,
            min_content_contribution_cache: Size::NONE,
            max_content_contribution_cache: Size::NONE,
            known_dimensions_cache: None,
            minimum_contribution_cache: Size::NONE,
            y_position: 0.0,
            height: 0.0,
            oof_candidates: OofCandidates::NONE,
        }
    }

    /// Whether the item has an auto margin in the block axis
    #[inline(always)]
    pub fn has_auto_block_margin(&self) -> bool {
        self.margin.top.is_auto() || self.margin.bottom.is_auto()
    }

    /// Whether the item's block size depends on the size of its row(s), creating a cyclic
    /// dependency with baseline alignment (which affects row sizing). Per
    /// <https://www.w3.org/TR/css-grid-1/#row-align> such items do not participate in baseline
    /// alignment and are aligned using their fallback alignment instead.
    #[inline(always)]
    pub fn has_cyclic_block_size_dependency(&self) -> bool {
        self.size.height.0.uses_percentage() && (self.crosses_intrinsic_row || self.crosses_flexible_row)
    }

    /// Returns true if the item participates in baseline alignment: it has `align-self: baseline`
    /// and neither of its block-axis margins are `auto`.
    /// See <https://www.w3.org/TR/css-align-3/#baseline-align-self>
    #[inline(always)]
    pub fn participates_in_baseline_alignment(&self) -> bool {
        self.align_self.keyword == AlignItemsKeyword::Baseline
            && !self.has_auto_block_margin()
            && !self.has_cyclic_block_size_dependency()
    }

    /// This item's placement in the specified axis in OriginZero coordinates
    pub fn placement(&self, axis: AbstractAxis) -> Line<OriginZeroLine> {
        match axis {
            AbstractAxis::Block => self.row,
            AbstractAxis::Inline => self.column,
        }
    }

    /// This item's placement in the specified axis as GridTrackVec indices
    pub fn placement_indexes(&self, axis: AbstractAxis) -> Line<u16> {
        match axis {
            AbstractAxis::Block => self.row_indexes,
            AbstractAxis::Inline => self.column_indexes,
        }
    }

    /// Returns a range which can be used as an index into the GridTrackVec in the specified axis
    /// which will produce a sub-slice of covering all the tracks and lines that this item spans
    /// excluding the lines that bound it.
    pub fn track_range_excluding_lines(&self, axis: AbstractAxis) -> Range<usize> {
        let indexes = self.placement_indexes(axis);
        (indexes.start as usize + 1)..(indexes.end as usize)
    }

    /// Whether any track spanned by this item in the specified axis satisfies `predicate`
    pub fn spans_track_matching(
        &self,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        predicate: impl Fn(&GridTrack) -> bool,
    ) -> bool {
        axis_tracks[self.track_range_excluding_lines(axis)].iter().any(predicate)
    }

    /// Returns the number of tracks that this item spans in the specified axis
    pub fn span(&self, axis: AbstractAxis) -> u16 {
        match axis {
            AbstractAxis::Block => self.row.span(),
            AbstractAxis::Inline => self.column.span(),
        }
    }

    /// Returns the pre-computed value indicating whether the grid item crosses a flexible track in
    /// the specified axis
    pub fn crosses_flexible_track(&self, axis: AbstractAxis) -> bool {
        match axis {
            AbstractAxis::Inline => self.crosses_flexible_column,
            AbstractAxis::Block => self.crosses_flexible_row,
        }
    }

    /// Returns the pre-computed value indicating whether the grid item crosses an intrinsic track in
    /// the specified axis
    pub fn crosses_intrinsic_track(&self, axis: AbstractAxis) -> bool {
        match axis {
            AbstractAxis::Inline => self.crosses_intrinsic_column,
            AbstractAxis::Block => self.crosses_intrinsic_row,
        }
    }

    /// For an item spanning multiple tracks, the upper limit used to calculate its limited min-/max-content contribution is the
    /// sum of the fixed max track sizing functions of any tracks it spans, and is applied if it only spans such tracks.
    pub fn spanned_track_limit(
        &mut self,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        axis_parent_size: Option<f32>,
        resolve_calc_value: &dyn Fn(*const (), f32) -> f32,
    ) -> Option<f32> {
        let spanned_tracks = &axis_tracks[self.track_range_excluding_lines(axis)];
        let tracks_all_fixed = spanned_tracks.iter().all(|track| {
            track.max_track_sizing_function.definite_limit(axis_parent_size, resolve_calc_value).is_some()
        });
        if tracks_all_fixed {
            let limit: f32 = spanned_tracks
                .iter()
                .map(|track| {
                    track.max_track_sizing_function.definite_limit(axis_parent_size, resolve_calc_value).unwrap()
                })
                .sum();
            Some(limit)
        } else {
            None
        }
    }

    /// Similar to the spanned_track_limit, but excludes FitContent arguments from the limit.
    /// Used to clamp the automatic minimum contributions of an item
    pub fn spanned_fixed_track_limit(
        &mut self,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        axis_parent_size: Option<f32>,
        resolve_calc_value: &dyn Fn(*const (), f32) -> f32,
    ) -> Option<f32> {
        let spanned_tracks = &axis_tracks[self.track_range_excluding_lines(axis)];
        let tracks_all_fixed = spanned_tracks.iter().all(|track| {
            track.max_track_sizing_function.definite_value(axis_parent_size, resolve_calc_value).is_some()
        });
        if tracks_all_fixed {
            let limit: f32 = spanned_tracks
                .iter()
                .map(|track| {
                    track.max_track_sizing_function.definite_value(axis_parent_size, resolve_calc_value).unwrap()
                })
                .sum();
            Some(limit)
        } else {
            None
        }
    }

    /// Retrieve the known_dimensions for the given grid area size from the cache or compute them.
    /// The min-content and max-content contributions of an item are both computed from the same known_dimensions.
    #[inline(always)]
    fn known_dimensions_cached(
        &mut self,
        tree: &mut impl LayoutPartialTree,
        grid_area_size: Size<Option<f32>>,
    ) -> Size<Option<f32>> {
        if let Some(entry) = self.known_dimensions_cache {
            if entry.grid_area_size == grid_area_size {
                return entry.known_dimensions;
            }
        }
        let known_dimensions = self.known_dimensions(tree, grid_area_size);
        self.known_dimensions_cache = Some(KnownDimensionsCacheEntry { grid_area_size, known_dimensions });
        known_dimensions
    }

    /// Whether the given self-alignment stretches the item: `stretch`, or `normal` unless the item is replaced
    #[inline(always)]
    fn is_stretch_aligned(&self, alignment: AlignSelf) -> bool {
        match alignment.keyword {
            AlignItemsKeyword::Stretch => true,
            AlignItemsKeyword::Normal => !self.is_replaced,
            _ => false,
        }
    }

    /// Compute the known_dimensions to be passed to the child sizing functions
    /// The key thing that is being done here is applying stretch alignment, which is necessary to
    /// allow percentage sizes further down the tree to resolve properly in some cases
    fn known_dimensions(
        &self,
        tree: &mut impl LayoutPartialTree,
        grid_area_size: Size<Option<f32>>,
    ) -> Size<Option<f32>> {
        let margins = self.margins_axis_sums_with_baseline_shims(grid_area_size.width, tree);

        let aspect_ratio = self.aspect_ratio;
        // CSS resolves percentage padding and border against the inline size of the containing
        // block. For a grid item under intrinsic measurement, that inline-size basis is the grid
        // area's width when it is definite.
        // Spec:
        // https://www.w3.org/TR/css-grid-1/#item-margins
        // https://www.w3.org/TR/CSS22/box.html#padding-properties
        let padding = self.padding.resolve_or_zero(grid_area_size.width, |val, basis| tree.calc(val, basis));
        let border = self.border.resolve_or_zero(grid_area_size.width, |val, basis| tree.calc(val, basis));
        let padding_border_size = (padding + border).sum_axes();
        let box_sizing_adjustment =
            if self.box_sizing == BoxSizing::ContentBox { padding_border_size } else { Size::ZERO };
        let inherent_size = self
            .size
            .maybe_resolve(grid_area_size, |val, basis| tree.calc(val, basis))
            .maybe_apply_aspect_ratio(aspect_ratio)
            .maybe_add(box_sizing_adjustment);
        let min_size = self
            .min_size
            .maybe_resolve(grid_area_size, |val, basis| tree.calc(val, basis))
            .maybe_apply_aspect_ratio(aspect_ratio)
            .maybe_add(box_sizing_adjustment)
            // The size of the item is floored by its padding and border
            .or(padding_border_size.map(Some))
            .maybe_max(padding_border_size);
        let max_size = self
            .max_size
            .maybe_resolve(grid_area_size, |val, basis| tree.calc(val, basis))
            .maybe_apply_aspect_ratio(aspect_ratio)
            .maybe_add(box_sizing_adjustment);

        let grid_area_minus_item_margins_size = grid_area_size.maybe_sub(margins).maybe_max(Size::ZERO);

        // If node is absolutely positioned and width is not set explicitly, then deduce it
        // from left, right and container_content_box if both are set.
        let width = inherent_size.width.or_else(|| {
            // A width that is a sizing keyword is not auto, so it does not stretch. The stretch
            // keyword resolves to an exact width; the others resolve during content measurement.
            if self.size.width.is_sizing_keyword() {
                return match resolve_sizing_keyword(
                    self.size.width,
                    grid_area_minus_item_margins_size.width,
                    grid_area_size.width,
                    |val, basis| tree.calc(val, basis),
                ) {
                    Some(SizingKeywordResolution::Exact(width)) => Some(width),
                    _ => None,
                };
            }

            // Apply width based on stretch alignment if:
            //  - Alignment style is "stretch" or "normal". Note that "normal" is treated as "stretch"
            //    here regardless of whether the item has a preferred size or aspect ratio in this axis,
            //    which differs from the rule used when the item is finally aligned (see `align_and_position_item`).
            //    Replaced elements are not stretched by "normal".
            //  - The node is not absolutely positioned
            //  - The node does not have auto margins in this axis.
            if !self.margin.left.is_auto() && !self.margin.right.is_auto() && self.is_stretch_aligned(self.justify_self)
            {
                return grid_area_minus_item_margins_size.width;
            }

            None
        });
        // Reapply aspect ratio after stretch and absolute position width adjustments
        let Size { width, height } =
            Size { width, height: inherent_size.height }.maybe_apply_aspect_ratio(aspect_ratio);

        let height = height.or_else(|| {
            // A height that is a sizing keyword is not auto, so it does not stretch. The stretch
            // keyword resolves to an exact height; the others resolve during content measurement.
            if self.size.height.is_sizing_keyword() {
                return match resolve_sizing_keyword(
                    self.size.height,
                    grid_area_minus_item_margins_size.height,
                    grid_area_size.height,
                    |val, basis| tree.calc(val, basis),
                ) {
                    Some(SizingKeywordResolution::Exact(height)) => Some(height),
                    _ => None,
                };
            }

            // Apply height based on stretch alignment if:
            //  - Alignment style is "stretch" or "normal" (see the note on width above)
            //  - The node is not absolutely positioned
            //  - The node does not have auto margins in this axis.
            if !self.margin.top.is_auto() && !self.margin.bottom.is_auto() && self.is_stretch_aligned(self.align_self) {
                return grid_area_minus_item_margins_size.height;
            }

            None
        });
        // Reapply aspect ratio after stretch and absolute position height adjustments
        let Size { width, height } = Size { width, height }.maybe_apply_aspect_ratio(aspect_ratio);

        // Clamp size by min and max width/height
        let Size { width, height } = Size { width, height }.maybe_clamp(min_size, max_size);

        Size { width, height }
    }

    /// Returns the grid area's size in the specified axis when every spanned track has a definite fixed size.
    ///
    /// During intrinsic sizing, percentages on grid items resolve against the size of the grid area,
    /// not the grid container. If the spanned tracks in an axis are not all definite yet, the grid
    /// area is still indefinite in that axis and percentage-dependent values must stay unresolved here.
    ///
    /// Spec:
    /// https://www.w3.org/TR/css-grid-1/#grid-item-sizing
    /// https://www.w3.org/TR/css-grid-1/#algo-overview
    ///
    /// Compute the available_space to be passed to the child sizing functions
    /// These are estimates based on either the max track sizing function or the provisional base size in the opposite
    /// axis to the one currently being sized.
    /// https://www.w3.org/TR/css-grid-1/#algo-overview
    pub fn grid_area_size(
        &self,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        other_axis_tracks: &[GridTrack],
        available_space: Size<Option<f32>>,
        get_track_size_estimate: impl Fn(&GridTrack, Option<f32>) -> Option<f32>,
        resolve_calc_value: &impl Fn(*const (), f32) -> f32,
    ) -> Size<Option<f32>> {
        let mut size = Size::NONE;
        size.set(
            axis,
            axis_tracks[self.track_range_excluding_lines(axis)]
                .iter()
                .map(|track| {
                    let min_size = track
                        .min_track_sizing_function
                        .definite_value(available_space.get(axis), resolve_calc_value)?;
                    let max_size = track
                        .max_track_sizing_function
                        .definite_value(available_space.get(axis), resolve_calc_value)?;

                    if min_size == max_size {
                        Some(track.base_size)
                    } else {
                        None
                    }
                })
                .sum::<Option<f32>>(),
        );

        size.set(
            axis.other(),
            other_axis_tracks[self.track_range_excluding_lines(axis.other())]
                .iter()
                .map(|track| {
                    get_track_size_estimate(track, available_space.get(axis.other()))
                        .map(|size| size + track.content_alignment_adjustment)
                })
                .sum::<Option<f32>>(),
        );

        size
    }

    /// Retrieve the available_space from the cache or compute them using the passed parameters
    pub fn grid_area_size_cached(
        &mut self,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        other_axis_tracks: &[GridTrack],
        available_space: Size<Option<f32>>,
        get_track_size_estimate: impl Fn(&GridTrack, Option<f32>) -> Option<f32>,
        resolve_calc_value: &impl Fn(*const (), f32) -> f32,
    ) -> Size<Option<f32>> {
        self.grid_area_size_cache.unwrap_or_else(|| {
            let grid_area_size = self.grid_area_size(
                axis,
                axis_tracks,
                other_axis_tracks,
                available_space,
                get_track_size_estimate,
                resolve_calc_value,
            );
            self.grid_area_size_cache = Some(grid_area_size);
            grid_area_size
        })
    }

    /// Compute the item's resolved margins for size contributions. Horizontal percentage margins always resolve
    /// to zero if the container size is indefinite as otherwise this would introduce a cyclic dependency.
    #[inline(always)]
    pub fn margins_axis_sums_with_baseline_shims(
        &self,
        inner_node_width: Option<f32>,
        tree: &impl LayoutPartialTree,
    ) -> Size<f32> {
        Rect {
            left: self.margin.left.resolve_or_zero(Some(0.0), |val, basis| tree.calc(val, basis)),
            right: self.margin.right.resolve_or_zero(Some(0.0), |val, basis| tree.calc(val, basis)),
            top: self.margin.top.resolve_or_zero(inner_node_width, |val, basis| tree.calc(val, basis))
                + self.baseline_shim,
            bottom: self.margin.bottom.resolve_or_zero(inner_node_width, |val, basis| tree.calc(val, basis)),
        }
        .sum_axes()
    }

    /// Compute the item's min content contribution from the provided parameters
    pub fn min_content_contribution(
        &mut self,
        axis: AbstractAxis,
        tree: &mut impl LayoutPartialTree,
        grid_area_size: Size<Option<f32>>,
        available_space: Size<Option<f32>>,
    ) -> f32 {
        let known_dimensions = self.known_dimensions_cached(tree, grid_area_size);
        // If the item's size in the axis being measured is already known then that size is its contribution,
        // and we can avoid calling into the child entirely.
        if let Some(size) = known_dimensions.get(axis) {
            return size;
        }
        // The child sees the grid area as its containing block during intrinsic measurement, so
        // percentage box properties resolve against the grid area when that size is definite.
        // Spec:
        // https://www.w3.org/TR/css-grid-1/#grid-item-sizing
        // https://www.w3.org/TR/css-grid-1/#algo-overview
        tree.measure_child_size(
            self.node,
            known_dimensions,
            grid_area_size,
            self.keyword_adjusted_available_space(
                grid_area_size,
                self.available_space_minus_margins(grid_area_size, available_space, tree).map(|opt| match opt {
                    Some(size) => AvailableSpace::Definite(size),
                    None => AvailableSpace::MinContent,
                }),
                tree,
            ),
            SizingMode::InherentSize,
            axis.as_abs_naive(),
            Line::FALSE,
        )
    }

    /// Retrieve the item's min content contribution from the cache or compute it using the provided parameters
    #[inline(always)]
    pub fn min_content_contribution_cached(
        &mut self,
        axis: AbstractAxis,
        tree: &mut impl LayoutPartialTree,
        grid_area_size: Size<Option<f32>>,
        available_space: Size<Option<f32>>,
    ) -> f32 {
        self.min_content_contribution_cache.get(axis).unwrap_or_else(|| {
            let size = self.min_content_contribution(axis, tree, grid_area_size, available_space);
            self.min_content_contribution_cache.set(axis, Some(size));
            size
        })
    }

    /// Compute the item's max content contribution from the provided parameters
    pub fn max_content_contribution(
        &mut self,
        axis: AbstractAxis,
        tree: &mut impl LayoutPartialTree,
        grid_area_size: Size<Option<f32>>,
        available_space: Size<Option<f32>>,
    ) -> f32 {
        let known_dimensions = self.known_dimensions_cached(tree, grid_area_size);
        // If the item's size in the axis being measured is already known then that size is its contribution,
        // and we can avoid calling into the child entirely.
        if let Some(size) = known_dimensions.get(axis) {
            return size;
        }
        // See the min-content path above. Max-content measurement uses the same containing-block
        // basis so percentage-dependent item geometry is measured from the grid area rather than
        // from the container.
        tree.measure_child_size(
            self.node,
            known_dimensions,
            grid_area_size,
            self.keyword_adjusted_available_space(
                grid_area_size,
                self.available_space_minus_margins(grid_area_size, available_space, tree).map(|opt| match opt {
                    Some(size) => AvailableSpace::Definite(size),
                    None => AvailableSpace::MaxContent,
                }),
                tree,
            ),
            SizingMode::InherentSize,
            axis.as_abs_naive(),
            Line::FALSE,
        )
    }

    /// Subtract the item's margins (and baseline shim) from the definite axes of the space available
    /// to the item's margin box, giving the available space that is passed to the item.
    /// As when the item is laid out into its final position, margins resolve against the width
    /// of the grid area and `auto` margins are treated as zero.
    #[inline(always)]
    fn available_space_minus_margins(
        &self,
        grid_area_size: Size<Option<f32>>,
        available_space: Size<Option<f32>>,
        tree: &impl LayoutPartialTree,
    ) -> Size<Option<f32>> {
        if available_space.width.is_none() && available_space.height.is_none() {
            return available_space;
        }
        let margin = self.margin.resolve_or_zero(grid_area_size.width, |val, basis| tree.calc(val, basis));
        Size {
            width: available_space.width.map(|width| f32_max(width - margin.horizontal_axis_sum(), 0.0)),
            height: available_space
                .height
                .map(|height| f32_max(height - margin.vertical_axis_sum() - self.baseline_shim, 0.0)),
        }
    }

    /// Override the available space in each axis whose size style is a sizing keyword that
    /// measures the item under a specific available space constraint
    /// (min-content, max-content, fit-content, fit-content(...))
    fn keyword_adjusted_available_space(
        &self,
        grid_area_size: Size<Option<f32>>,
        available_space: Size<AvailableSpace>,
        tree: &impl LayoutPartialTree,
    ) -> Size<AvailableSpace> {
        if !self.size.width.is_sizing_keyword() && !self.size.height.is_sizing_keyword() {
            return available_space;
        }
        let margins = self.margins_axis_sums_with_baseline_shims(grid_area_size.width, tree);
        let mut adjusted = available_space;
        for axis in [AbstractAxis::Inline, AbstractAxis::Block] {
            let size_style = self.size.get(axis);
            if !size_style.is_sizing_keyword() {
                continue;
            }
            let stretch_size = grid_area_size.get(axis).maybe_sub(margins.get(axis)).maybe_max(0.0);
            if let Some(SizingKeywordResolution::Measure(available)) =
                resolve_sizing_keyword(size_style, stretch_size, grid_area_size.get(axis), |val, basis| {
                    tree.calc(val, basis)
                })
            {
                adjusted.set(axis, available);
            }
        }
        adjusted
    }

    /// Retrieve the item's max content contribution from the cache or compute it using the provided parameters
    #[inline(always)]
    pub fn max_content_contribution_cached(
        &mut self,
        axis: AbstractAxis,
        tree: &mut impl LayoutPartialTree,
        grid_area_size: Size<Option<f32>>,
        available_space: Size<Option<f32>>,
    ) -> f32 {
        self.max_content_contribution_cache.get(axis).unwrap_or_else(|| {
            let size = self.max_content_contribution(axis, tree, grid_area_size, available_space);
            self.max_content_contribution_cache.set(axis, Some(size));
            size
        })
    }

    /// The minimum contribution of an item is the smallest outer size it can have.
    /// Specifically:
    ///   - If the item’s computed preferred size behaves as auto or depends on the size of its containing block in the relevant axis:
    ///     Its minimum contribution is the outer size that would result from assuming the item’s used minimum size as its preferred size;
    ///   - Else the item’s minimum contribution is its min-content contribution.
    ///
    /// Because the minimum contribution often depends on the size of the item’s content, it is considered a type of intrinsic size contribution.
    /// See: https://www.w3.org/TR/css-grid-1/#min-size-auto
    pub fn minimum_contribution(
        &mut self,
        tree: &mut impl LayoutPartialTree,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        grid_area_size: Size<Option<f32>>,
        inner_node_size: Size<Option<f32>>,
    ) -> f32 {
        let padding = self.padding.resolve_or_zero(grid_area_size.width, |val, basis| tree.calc(val, basis));
        let border = self.border.resolve_or_zero(grid_area_size.width, |val, basis| tree.calc(val, basis));
        let padding_border_size = (padding + border).sum_axes();
        let box_sizing_adjustment =
            if self.box_sizing == BoxSizing::ContentBox { padding_border_size } else { Size::ZERO };
        self.size
            .maybe_resolve(grid_area_size, |val, basis| tree.calc(val, basis))
            .maybe_apply_aspect_ratio(self.aspect_ratio)
            .maybe_add(box_sizing_adjustment)
            .get(axis)
            .map(|size| {
                // A definite preferred size is clamped by the minimum and maximum sizes. For a replaced element (but
                // not a form control), an indefinite percentage maximum size is resolved against zero. The spec also
                // applies this to form controls (https://drafts.csswg.org/css-sizing-3/#min-content-zero) but no
                // browser does (https://github.com/w3c/csswg-drafts/issues/6348).
                let min_size = self.min_size.get(axis);
                let max_size = self.max_size.get(axis);
                if min_size.is_auto() && max_size.is_auto() {
                    return size;
                }
                let basis = grid_area_size.get(axis);
                let max_size_basis = if self.is_replaced { basis.or(Some(0.0)) } else { basis };
                let adjustment = box_sizing_adjustment.get(axis);
                let min_size = min_size.maybe_resolve(basis, |val, basis| tree.calc(val, basis));
                let max_size = max_size.maybe_resolve(max_size_basis, |val, basis| tree.calc(val, basis));
                size.maybe_clamp(min_size.maybe_add(adjustment), max_size.maybe_add(adjustment))
            })
            .or_else(|| {
                // A preferred size that is a sizing keyword other than `stretch` does not behave as auto,
                // so the minimum contribution is the min-content contribution.
                let size = self.size.get(axis);
                (size.is_sizing_keyword() && !size.is_stretch())
                    .then(|| self.min_content_contribution_cached(axis, tree, grid_area_size, grid_area_size))
            })
            .or_else(|| {
                self.min_size
                    .maybe_resolve(grid_area_size.map(|size| size.unwrap_or(0.0)), |val, basis| tree.calc(val, basis))
                    .maybe_apply_aspect_ratio(self.aspect_ratio)
                    .maybe_add(box_sizing_adjustment)
                    .get(axis)
            })
            .or_else(|| self.overflow.get(axis).maybe_into_automatic_min_size())
            .unwrap_or_else(|| {
                // Automatic minimum size. See https://www.w3.org/TR/css-grid-1/#min-size-auto

                // To provide a more reasonable default minimum size for grid items, the used value of its automatic minimum size
                // in a given axis is the content-based minimum size if all of the following are true:
                let item_axis_tracks = &axis_tracks[self.track_range_excluding_lines(axis)];

                // it is not a scroll container (handled above)

                // it spans at least one track in that axis whose min track sizing function is auto
                let spans_auto_min_track = item_axis_tracks
                    .iter()
                    .any(|track| track.min_track_sizing_function.behaves_as_auto(inner_node_size.get(axis)));

                // if it spans more than one track in that axis, none of those tracks are flexible
                let only_span_one_track = item_axis_tracks.len() == 1;
                let use_content_based_minimum = spans_auto_min_track
                    && (only_span_one_track
                        || !item_axis_tracks.iter().any(|track| track.max_track_sizing_function.is_fr()));

                // Otherwise, the automatic minimum size is zero, as usual.
                if use_content_based_minimum {
                    let mut minimum_contribution =
                        self.min_content_contribution_cached(axis, tree, grid_area_size, grid_area_size);

                    // If the item is a compressible replaced element, and has a definite preferred size or maximum size in the
                    // relevant axis, the size suggestion is capped by those sizes; for this purpose, any indefinite percentages
                    // in these sizes are resolved against zero (and considered definite).
                    if self.is_compressible_replaced {
                        let size = self.size.get(axis).maybe_resolve(Some(0.0), |val, basis| tree.calc(val, basis));
                        let max_size =
                            self.max_size.get(axis).maybe_resolve(Some(0.0), |val, basis| tree.calc(val, basis));
                        minimum_contribution = minimum_contribution.maybe_min(size).maybe_min(max_size);
                    }

                    // The content-based minimum size is additionally clamped by the sum of any fixed max track sizing
                    // functions of the tracks the item spans. Note that this clamp does not apply to explicitly specified
                    // preferred or minimum sizes, and that the argument to fit-content() does not clamp the content-based
                    // minimum size in the same way as a fixed max track sizing function. The clamp is a stretch fit into
                    // the limit, so it does not shrink the item below its padding + border.
                    let limit =
                        self.spanned_fixed_track_limit(axis, axis_tracks, inner_node_size.get(axis), &|val, basis| {
                            tree.resolve_calc_value(val, basis)
                        });
                    minimum_contribution.maybe_min(limit.map(|limit| f32_max(limit, padding_border_size.get(axis))))
                } else {
                    0.0
                }
            })
    }

    /// Retrieve the item's minimum contribution from the cache or compute it using the provided parameters
    #[inline(always)]
    pub fn minimum_contribution_cached(
        &mut self,
        tree: &mut impl LayoutPartialTree,
        axis: AbstractAxis,
        axis_tracks: &[GridTrack],
        grid_area_size: Size<Option<f32>>,
        inner_node_size: Size<Option<f32>>,
    ) -> f32 {
        self.minimum_contribution_cache.get(axis).unwrap_or_else(|| {
            let size = self.minimum_contribution(tree, axis, axis_tracks, grid_area_size, inner_node_size);
            self.minimum_contribution_cache.set(axis, Some(size));
            size
        })
    }
}