use super::{
AlignContent, AlignItems, AlignSelf, AspectRatioCalculationBox, BoxSizing, ComputedStyle,
ContentAlignmentKeyword, ContentBoxLength, Direction,
FlexAutomaticMinimumAutomaticPreferredCrossSize, FlexAutomaticMinimumContentSizeSource,
FlexAutomaticMinimumCrossIntrinsicContributions, FlexAutomaticMinimumInputs,
FlexAvailablePercentageBasis, FlexAvailableSizeSource, FlexAvailableSpace, FlexCrossSize,
FlexCrossSizeProperty, FlexCrossSizingPhase, FlexDirection, FlexHypotheticalAutomaticCrossSize,
FlexItemAvailableSpace, FlexItemBaselineEstimate, FlexItemEstimate, FlexMainSize,
IntrinsicItemMetrics, JustifyContent, LayoutLength, LogicalAxis, LogicalInlineContentSize,
LogicalInlinePercentageBasis, NonContentLength, PercentageBasis, PhysicalAxis,
PhysicalContentHeight, PhysicalContentWidth, RatioOnlyReplacedFlexBaseSize,
ReplacedPreferredSize, ReplacedPreferredSizeAxes, ReplacedSizeConstraints, ResolvedAspectRatio,
SelfAlignmentKeyword, SemanticLengthExt, TaffyPoint, TaffyRect, TaffySize, WritingModeAxes,
constrain_height_with_intrinsic, constrain_width_with_intrinsic, content_box_pt,
content_box_size_pt, content_box_to_border_box_length, css, flex_main_content_box_length,
horizontal_border_width, layout_pt, measure_intrinsic_item_leaf, non_content_pt,
percentage_basis_from_points, resolve_replaced_size_with_aspect_ratio,
stretch_fit_content_box_size, taffy_layout, used_border_widths,
used_box_metrics_for_logical_inline_basis, used_content_box_height_or_auto_with_basis,
used_content_box_width_or_auto_with_basis, used_length_percentage_or_auto,
used_length_percentage_or_auto_with_basis, used_max_width, used_min_width,
vertical_border_width,
};
use crate::layout::taffy_bridge;
mod alignment;
pub(super) use alignment::*;
type FlexLogicalInlinePercentageBasis = LogicalInlinePercentageBasis<FlexAvailableSizeSource>;
pub(super) fn taffy_rect_from_layout(layout: &taffy_layout::Layout) -> TaffyRect {
TaffyRect::new(
TaffyPoint::new(layout.location.x, layout.location.y),
TaffySize::new(layout.size.width, layout.size.height),
)
}
pub(super) fn taffy_margin(
style: &ComputedStyle,
containing_style: &ComputedStyle,
available: FlexAvailableSpace,
) -> taffy_layout::Rect<taffy_layout::LengthPercentageAuto> {
let percentage_basis = logical_inline_percentage_basis(containing_style, available);
taffy_bridge::margin(
style,
percentage_basis,
taffy_bridge::TaffyCyclicPercentage::PreservePurePercentage,
)
}
pub(super) fn taffy_padding(
style: &ComputedStyle,
containing_style: &ComputedStyle,
available: FlexAvailableSpace,
) -> taffy_layout::Rect<taffy_layout::LengthPercentage> {
let percentage_basis = logical_inline_percentage_basis(containing_style, available);
taffy_bridge::padding(style, percentage_basis)
}
pub(super) fn flex_item_used_padding(
style: &ComputedStyle,
containing_style: &ComputedStyle,
available: FlexAvailableSpace,
) -> css::Edges {
let percentage_basis = logical_inline_percentage_basis(containing_style, available);
if percentage_basis.is_definite() {
used_box_metrics_for_logical_inline_basis(style, percentage_basis.map_source(|_| ()))
.padding
.to_css_edges()
} else {
style.padding
}
}
pub(super) fn flex_item_used_margin(
style: &ComputedStyle,
containing_style: &ComputedStyle,
available: FlexAvailableSpace,
) -> css::Edges {
let percentage_basis = logical_inline_percentage_basis(containing_style, available);
if percentage_basis.is_definite() {
used_box_metrics_for_logical_inline_basis(style, percentage_basis.map_source(|_| ()))
.margin
.to_css_edges()
} else {
style.margin
}
}
fn logical_inline_percentage_basis(
containing_style: &ComputedStyle,
available: FlexAvailableSpace,
) -> FlexLogicalInlinePercentageBasis {
if WritingModeAxes::new(
containing_style.writing_mode,
containing_style.used_direction(),
)
.swaps_physical_axes()
{
available.height_basis
} else {
available.width_basis
}
.map_value(LogicalInlineContentSize::new)
}
pub(super) fn taffy_edges(edges: css::Edges) -> taffy_layout::Rect<taffy_layout::LengthPercentage> {
taffy_bridge::border_edges(edges)
}
pub(super) fn taffy_gap(
value: css::ComputedGap,
percentage_basis: FlexAvailablePercentageBasis,
) -> taffy_layout::LengthPercentage {
taffy_bridge::gap(value, percentage_basis)
}
pub(super) fn flex_item_size_dimension(
value: css::ComputedLengthPercentageOrAuto,
fallback: ContentBoxLength,
min_content: ContentBoxLength,
max_content: ContentBoxLength,
context: FlexItemSizeDimensionContext,
) -> taffy_layout::Dimension {
if context
.flex_direction
.shares_axis_with(context.dimension_axis)
{
if context.flex_basis_overrides_main_size {
return taffy_layout::Dimension::auto();
}
if matches!(value, css::ComputedLengthPercentageOrAuto::LengthPercentage(ref value) if value.needs_percentage_basis() && !context.percentage_basis.is_definite())
{
return taffy_layout::Dimension::auto();
}
match value {
css::ComputedLengthPercentageOrAuto::Auto => {
taffy_layout::Dimension::length(fallback.points().max(1.0))
}
_ => taffy_intrinsic_dimension_with_basis_and_stretch(
value,
context.percentage_basis,
min_content,
max_content,
context.stretch,
),
}
} else {
match value {
css::ComputedLengthPercentageOrAuto::Auto => match context.cross_sizing_phase {
FlexCrossSizingPhase::Hypothetical => {
match context.hypothetical_automatic_cross_size {
FlexHypotheticalAutomaticCrossSize::Intrinsic => {
taffy_layout::Dimension::auto()
}
FlexHypotheticalAutomaticCrossSize::FitContent { used_content_size } => {
taffy_layout::Dimension::length(used_content_size.points().max(0.0))
}
}
}
FlexCrossSizingPhase::StretchToLine {
line_outer_cross_size,
} => taffy_stretch_fit_dimension(FlexStretchFitContext {
available_margin_box_size: Some(layout_pt(line_outer_cross_size.points())),
..context.stretch
}),
},
_ => taffy_intrinsic_dimension_with_basis_and_stretch(
value,
context.percentage_basis,
min_content,
max_content,
context.stretch,
),
}
}
}
#[derive(Debug, Clone, Copy)]
pub(super) struct FlexItemSizeDimensionContext {
pub(super) flex_direction: FlexDirection,
pub(super) dimension_axis: FlexDirection,
pub(super) percentage_basis: FlexAvailablePercentageBasis,
pub(super) stretch: FlexStretchFitContext,
pub(super) flex_basis_overrides_main_size: bool,
pub(super) cross_sizing_phase: FlexCrossSizingPhase,
pub(super) hypothetical_automatic_cross_size: FlexHypotheticalAutomaticCrossSize,
}
#[derive(Debug, Clone, Copy)]
pub(super) struct FlexStretchFitContext {
pub(super) available_margin_box_size: Option<LayoutLength>,
pub(super) margin_size: LayoutLength,
pub(super) non_content_size: NonContentLength,
pub(super) box_sizing: BoxSizing,
}
fn taffy_stretch_fit_dimension(context: FlexStretchFitContext) -> taffy_layout::Dimension {
let Some(content_size) = resolved_stretch_fit_content_box_size(context) else {
return taffy_layout::Dimension::auto();
};
let size = match context.box_sizing {
BoxSizing::ContentBox => content_size.points(),
BoxSizing::BorderBox => {
content_box_to_border_box_length(content_size, context.non_content_size).points()
}
};
taffy_layout::Dimension::length(size.max(0.0))
}
fn resolved_stretch_fit_content_box_size(
context: FlexStretchFitContext,
) -> Option<ContentBoxLength> {
context.available_margin_box_size.map(|available| {
stretch_fit_content_box_size(available, context.margin_size, context.non_content_size)
})
}
pub(super) fn taffy_optional_dimension_with_basis(
value: css::ComputedLengthPercentageOrAuto,
percentage_basis: FlexAvailablePercentageBasis,
) -> taffy_layout::Dimension {
taffy_flex_optional_dimension(
value,
FlexTaffyPercentagePolicy::ResolveAgainstDefiniteBasis(percentage_basis),
)
}
#[derive(Debug, Clone, Copy)]
enum FlexTaffyPercentagePolicy {
PreservePurePercentage,
ResolveAgainstDefiniteBasis(FlexAvailablePercentageBasis),
}
fn taffy_flex_optional_dimension(
value: css::ComputedLengthPercentageOrAuto,
percentage_policy: FlexTaffyPercentagePolicy,
) -> taffy_layout::Dimension {
match value {
css::ComputedLengthPercentageOrAuto::LengthPercentage(value) => {
taffy_flex_length_percentage_dimension(value, percentage_policy)
}
css::ComputedLengthPercentageOrAuto::Auto
| css::ComputedLengthPercentageOrAuto::Stretch
| css::ComputedLengthPercentageOrAuto::MinContent
| css::ComputedLengthPercentageOrAuto::MaxContent
| css::ComputedLengthPercentageOrAuto::FitContent(_)
| css::ComputedLengthPercentageOrAuto::CalcSize(_) => taffy_layout::Dimension::auto(),
}
}
fn taffy_flex_length_percentage_dimension(
value: css::ComputedLengthPercentage,
percentage_policy: FlexTaffyPercentagePolicy,
) -> taffy_layout::Dimension {
let FlexTaffyPercentagePolicy::ResolveAgainstDefiniteBasis(percentage_basis) =
percentage_policy
else {
return taffy_dimension_from_length_percentage(value);
};
let percentage_basis = percentage_basis.points();
if let Some(basis) = percentage_basis
&& let Some(resolved) = value
.used_length_with_percentage_basis(PercentageBasis::definite(layout_pt(basis.max(0.0))))
{
return taffy_layout::Dimension::length(resolved.points());
}
if value.needs_percentage_basis() && percentage_basis.is_none() {
return taffy_layout::Dimension::auto();
}
if !value.is_definitely_absolute()
&& value
.used_length_with_percentage_basis(PercentageBasis::<ContentBoxLength>::indefinite())
.is_none()
{
return taffy_layout::Dimension::auto();
}
taffy_dimension_from_length_percentage(value)
}
pub(super) fn taffy_intrinsic_dimension_with_basis(
value: css::ComputedLengthPercentageOrAuto,
percentage_basis: FlexAvailablePercentageBasis,
min_content: ContentBoxLength,
max_content: ContentBoxLength,
) -> taffy_layout::Dimension {
taffy_intrinsic_dimension_with_basis_and_stretch(
value,
percentage_basis,
min_content,
max_content,
FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
)
}
pub(super) fn taffy_intrinsic_dimension_with_basis_and_stretch(
value: css::ComputedLengthPercentageOrAuto,
percentage_basis: FlexAvailablePercentageBasis,
min_content: ContentBoxLength,
max_content: ContentBoxLength,
stretch: FlexStretchFitContext,
) -> taffy_layout::Dimension {
let min_content = min_content.points().max(0.0);
let max_content = max_content.points().max(min_content);
match value {
css::ComputedLengthPercentageOrAuto::Auto => taffy_layout::Dimension::auto(),
css::ComputedLengthPercentageOrAuto::Stretch => taffy_stretch_fit_dimension(stretch),
css::ComputedLengthPercentageOrAuto::LengthPercentage(_) => {
taffy_optional_dimension_with_basis(value, percentage_basis)
}
css::ComputedLengthPercentageOrAuto::MinContent => {
taffy_layout::Dimension::length(min_content.max(0.0))
}
css::ComputedLengthPercentageOrAuto::MaxContent => {
taffy_layout::Dimension::length(max_content.max(min_content).max(0.0))
}
css::ComputedLengthPercentageOrAuto::FitContent(limit) => {
let stretch = limit
.and_then(|value| {
if value.is_definitely_absolute() {
Some(value.length_max_zero().points())
} else {
percentage_basis.points().and_then(|basis| {
value
.used_length_with_percentage_basis(PercentageBasis::definite(
layout_pt(basis.max(0.0)),
))
.map(|length| length.points())
})
}
})
.unwrap_or_else(|| max_content.max(min_content).max(0.0));
taffy_layout::Dimension::length(
max_content
.max(min_content)
.min(stretch.max(min_content))
.max(0.0),
)
}
css::ComputedLengthPercentageOrAuto::CalcSize(value) => {
let percentage_basis = percentage_basis.points().unwrap_or(0.0);
let stretch_size = stretch
.available_margin_box_size
.map(|value| value.points())
.unwrap_or(percentage_basis)
.max(0.0);
let fit_content = max_content.min(min_content.max(stretch_size));
taffy_layout::Dimension::length(
value
.used_value(
max_content,
min_content,
max_content,
fit_content,
stretch_size,
PercentageBasis::definite(layout_pt(percentage_basis)),
)
.max(layout_pt(0.0))
.points(),
)
}
}
}
pub(super) fn measure_flex_item(
known_dimensions: taffy_layout::Size<Option<f32>>,
_available_space: taffy_layout::Size<taffy_layout::AvailableSpace>,
estimate: Option<&mut FlexItemEstimate>,
) -> taffy_layout::Size<f32> {
let estimate = estimate.copied().unwrap_or_else(|| {
FlexItemEstimate::new(
IntrinsicItemMetrics::zero(),
FlexItemBaselineEstimate::default(),
)
});
let metrics = estimate.legacy_metrics();
measure_intrinsic_item_leaf(
known_dimensions,
metrics.preferred_aspect_ratio,
taffy_layout::Size {
width: metrics.width.points(),
height: metrics.height.points(),
},
)
}
pub(super) fn taffy_flex_measurement(
input: ::taffy::tree::LayoutInput,
estimate: Option<&mut FlexItemEstimate>,
) -> ::taffy::tree::LayoutOutput {
let baselines = estimate
.as_deref()
.map(|estimate| (*estimate).legacy_metrics())
.map(|metrics| (metrics.first_baseline, metrics.last_baseline))
.unwrap_or((None, None));
let size = measure_flex_item(input.known_dimensions, input.available_space, estimate);
taffy_bridge::measured_leaf_output(size, baselines.0, baselines.1)
}
pub(super) fn taffy_optional_dimension(
value: css::ComputedLengthPercentageOrAuto,
) -> taffy_layout::LengthPercentageAuto {
taffy_bridge::min_max_constraint(taffy_flex_optional_dimension(
value,
FlexTaffyPercentagePolicy::PreservePurePercentage,
))
}
fn taffy_dimension_from_length_percentage(
value: css::ComputedLengthPercentage,
) -> taffy_layout::Dimension {
if let Some(percent) = value
.pure_percentage_coefficient()
.filter(|percent| *percent != 0.0)
{
taffy_layout::Dimension::percent(percent.max(0.0))
} else {
taffy_layout::Dimension::length(value.length_max_zero().points())
}
}
pub(super) fn taffy_min_dimension(
value: css::ComputedLengthPercentageOrAuto,
percentage_basis: FlexAvailablePercentageBasis,
) -> taffy_layout::LengthPercentageAuto {
used_length_percentage_or_auto(value, percentage_basis)
.map(|length| taffy_layout::LengthPercentageAuto::length(length.points()))
.unwrap_or_else(|| taffy_layout::LengthPercentageAuto::length(0.0))
}
pub(super) fn table_length_percentage_min_dimension(
value: css::ComputedLengthPercentageOrAuto,
percentage_basis: FlexAvailablePercentageBasis,
table_min_content: ContentBoxLength,
) -> taffy_layout::LengthPercentageAuto {
debug_assert!(matches!(
value,
css::ComputedLengthPercentageOrAuto::LengthPercentage(_)
));
let table_min_content = table_min_content.max(content_box_pt(0.0));
let table_min_layout = layout_pt(table_min_content.points());
let authored = used_length_percentage_or_auto(value, percentage_basis)
.unwrap_or(table_min_layout)
.max(table_min_layout);
taffy_layout::LengthPercentageAuto::length(authored.points())
}
pub(super) fn flex_min_size_dimension(
specified: css::ComputedLengthPercentageOrAuto,
estimated_min_content: ContentBoxLength,
estimated_max_content: ContentBoxLength,
context: FlexMinSizeDimensionContext<'_>,
) -> taffy_layout::LengthPercentageAuto {
let Some(automatic_minimum) = resolve_automatic_flex_minimum(specified.clone(), context) else {
return taffy_bridge::min_max_constraint(taffy_intrinsic_dimension_with_basis_and_stretch(
specified,
context.percentage_basis,
estimated_min_content,
estimated_max_content,
context.stretch,
));
};
taffy_layout::LengthPercentageAuto::length(automatic_minimum.used_content_box.points())
}
#[derive(Debug, Clone, Copy)]
pub(super) struct AutomaticFlexMinimum {
pub(super) content_size_suggestion: ContentBoxLength,
pub(super) transferred_size_suggestion: Option<ContentBoxLength>,
pub(super) specified_size_suggestion: Option<ContentBoxLength>,
pub(super) used_content_box: ContentBoxLength,
}
impl AutomaticFlexMinimum {
pub(super) fn from_suggestions(
content_size_suggestion: ContentBoxLength,
transferred_size_suggestion: Option<ContentBoxLength>,
specified_size_suggestion: Option<ContentBoxLength>,
is_replaced: bool,
) -> Self {
let mut used_content_box = content_size_suggestion.max(content_box_pt(0.0));
if let Some(transferred) = transferred_size_suggestion {
let transferred = transferred.max(content_box_pt(0.0));
used_content_box = if is_replaced {
used_content_box.min(transferred)
} else {
used_content_box.max(transferred)
};
}
if let Some(specified) = specified_size_suggestion {
used_content_box = used_content_box.min(specified.max(content_box_pt(0.0)));
}
Self {
content_size_suggestion,
transferred_size_suggestion,
specified_size_suggestion,
used_content_box,
}
}
pub(super) fn debug_assert_consistent(self, is_replaced: bool) {
debug_assert!(self.used_content_box >= content_box_pt(0.0));
if let Some(specified) = self.specified_size_suggestion {
debug_assert!(self.used_content_box <= specified.max(content_box_pt(0.0)));
}
if let Some(transferred) = self.transferred_size_suggestion {
let transferred = transferred.max(content_box_pt(0.0));
if is_replaced {
debug_assert!(self.used_content_box <= transferred);
} else {
debug_assert!(
self.used_content_box >= self.content_size_suggestion.max(content_box_pt(0.0))
);
}
}
}
}
pub(super) fn resolve_automatic_flex_minimum(
specified: css::ComputedLengthPercentageOrAuto,
context: FlexMinSizeDimensionContext<'_>,
) -> Option<AutomaticFlexMinimum> {
let minimum_kind =
flex_main_axis_content_based_minimum_kind(&specified, context.style, context.direction)?;
if !context.is_main_axis {
return None;
}
if minimum_kind == FlexContentBasedMinimumKind::CssAutomatic && context.overflow.is_scrollable()
{
return Some(AutomaticFlexMinimum {
content_size_suggestion: content_box_pt(0.0),
transferred_size_suggestion: None,
specified_size_suggestion: None,
used_content_box: content_box_pt(0.0),
});
}
let inputs = context.automatic_minimum_inputs?;
let intrinsic_content_size_suggestion = if specified.calc_size_with_auto_basis().is_some() {
inputs
.content_size_source
.content_size_suggestion()
.min(inputs.max_content_size)
} else {
inputs.content_size_source.content_size_suggestion()
};
let authored_stretch_fit_cross_size = authored_cross_stretch_fit_content_box_size(
context.style,
context.direction,
context.cross_stretch,
);
let transferred_size_suggestion = automatic_minimum_transferred_size_suggestion(
context.style,
context.direction,
inputs.preferred_aspect_ratio,
FlexCrossSizeSuggestionContext {
available_cross_size: context.available_cross_size,
authored_stretch_fit_cross_size,
stretched_cross_size: context.stretched_cross_size,
automatic_preferred_cross_size: inputs
.automatic_preferred_cross_size
.content_box_size(),
intrinsic: FlexCrossIntrinsicContributions {
min_content: inputs.cross_intrinsic.min_content,
max_content: inputs.cross_intrinsic.max_content,
},
},
)
.map(|suggestion| {
inputs
.aspect_ratio_sizing
.map(|sizing| {
if context.direction.is_row_axis() {
sizing.constraints.constrain_width(suggestion)
} else {
sizing.constraints.constrain_height(suggestion)
}
})
.unwrap_or(suggestion)
});
let content_size_suggestion = if inputs.is_replaced && authored_stretch_fit_cross_size.is_some()
{
transferred_size_suggestion.unwrap_or(intrinsic_content_size_suggestion)
} else {
intrinsic_content_size_suggestion
};
let selection = AutomaticFlexMinimum::from_suggestions(
content_size_suggestion,
transferred_size_suggestion,
inputs.definite_preferred_content_size,
inputs.is_replaced,
);
selection.debug_assert_consistent(inputs.is_replaced);
let automatic_minimum = selection.used_content_box.points();
let automatic_minimum = specified
.calc_size_with_auto_basis()
.map(|value| {
value
.used_value(
automatic_minimum,
content_size_suggestion.points(),
inputs.max_content_size.points(),
automatic_minimum,
context
.stretch
.available_margin_box_size
.map(SemanticLengthExt::points)
.unwrap_or(0.0),
PercentageBasis::definite(layout_pt(
context.percentage_basis.points().unwrap_or(0.0),
)),
)
.points()
})
.unwrap_or(automatic_minimum);
Some(AutomaticFlexMinimum {
content_size_suggestion,
transferred_size_suggestion,
specified_size_suggestion: inputs.definite_preferred_content_size,
used_content_box: content_box_pt(automatic_minimum.max(0.0)),
})
}
#[derive(Debug, Clone, Copy)]
pub(super) struct FlexMinSizeDimensionContext<'a> {
pub(super) style: &'a ComputedStyle,
pub(super) direction: FlexDirection,
pub(super) automatic_minimum_inputs: Option<FlexAutomaticMinimumInputs>,
pub(super) available_cross_size: Option<FlexCrossSize>,
pub(super) cross_stretch: FlexStretchFitContext,
pub(super) stretched_cross_size: Option<FlexCrossSize>,
pub(super) is_main_axis: bool,
pub(super) overflow: css::Overflow,
pub(super) percentage_basis: FlexAvailablePercentageBasis,
pub(super) stretch: FlexStretchFitContext,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum FlexContentBasedMinimumKind {
CssAutomatic,
BlockAxisMinContent,
}
pub(super) fn flex_main_axis_content_based_minimum_kind(
value: &css::ComputedLengthPercentageOrAuto,
style: &ComputedStyle,
physical_direction: FlexDirection,
) -> Option<FlexContentBasedMinimumKind> {
if value.is_auto() || value.calc_size_with_auto_basis().is_some() {
return Some(FlexContentBasedMinimumKind::CssAutomatic);
}
if matches!(value, css::ComputedLengthPercentageOrAuto::MinContent)
&& flex_main_axis_is_item_block_axis(style, physical_direction)
{
return Some(FlexContentBasedMinimumKind::BlockAxisMinContent);
}
None
}
fn flex_main_axis_is_item_block_axis(
style: &ComputedStyle,
physical_direction: FlexDirection,
) -> bool {
match WritingModeAxes::new(style.writing_mode, style.used_direction())
.physical_axis(LogicalAxis::Block)
{
PhysicalAxis::Horizontal => physical_direction.is_row_axis(),
PhysicalAxis::Vertical => physical_direction.is_column_axis(),
}
}
pub(super) fn flex_item_main_axis_overflow(
style: &ComputedStyle,
direction: FlexDirection,
) -> css::Overflow {
if direction.is_row_axis() {
style.overflow_x
} else {
style.overflow_y
}
}
pub(super) fn resolve_taffy_flex_basis(
style: &ComputedStyle,
estimate: &FlexItemEstimate,
context: FlexBasisContext,
) -> ResolvedFlexBasis {
match &style.flex_basis {
css::ComputedFlexBasis::LengthPercentage(length) => {
let main_size_basis = context.main_size_basis.points();
if length.contains_percentage() && main_size_basis.is_none() {
return ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(
style,
if context.direction.is_row_axis() {
estimate.content_width
} else {
estimate.content_height
},
context.direction,
)
.points(),
));
}
return ResolvedFlexBasis::definite_flex_basis(taffy_optional_dimension_with_basis(
css::ComputedLengthPercentageOrAuto::LengthPercentage(length.value.clone()),
context.main_size_basis,
));
}
css::ComputedFlexBasis::Content | css::ComputedFlexBasis::MaxContent => {
if let Some(size) = context.ratio_only_replaced_base_size {
return ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(
style,
size.main_content_size(context.direction),
context.direction,
)
.points(),
));
}
let fallback = if context.direction.is_row_axis() {
estimate.content_width
} else {
estimate.content_height
};
return aspect_ratio_transferred_flex_basis(
style,
estimate,
context.direction,
context.available_cross_size,
context.stretched_cross_size,
context.preferred_aspect_ratio,
)
.map(|basis| {
ResolvedFlexBasis::aspect_ratio_transfer(taffy_layout::Dimension::length(
basis.points(),
))
})
.unwrap_or_else(|| {
ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(style, fallback, context.direction).points(),
))
});
}
css::ComputedFlexBasis::MinContent => {
return ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(
style,
if context.direction.is_row_axis() {
estimate.min_width
} else {
estimate.min_height
},
context.direction,
)
.points(),
));
}
css::ComputedFlexBasis::FitContent(limit) => {
let min_content = if context.direction.is_row_axis() {
estimate.min_width
} else {
estimate.min_height
};
let max_content = if context.direction.is_row_axis() {
estimate.content_width
} else {
estimate.content_height
};
let limit = limit
.clone()
.and_then(|limit| {
if limit.is_definitely_absolute() {
Some(content_box_pt(limit.length_max_zero().points()))
} else {
context.main_size_basis.points().and_then(|basis| {
limit
.used_length_with_percentage_basis(PercentageBasis::definite(
layout_pt(basis),
))
.map(|length| content_box_pt(length.points()))
})
}
})
.unwrap_or_else(|| flex_main_content_box_length(context.available_main_size));
return ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(
style,
fit_content_basis(min_content, max_content, limit),
context.direction,
)
.points(),
));
}
css::ComputedFlexBasis::Auto => {}
}
if context.direction.is_row_axis() {
if !style.box_values.width.is_auto() {
let dimension = taffy_flex_basis_from_main_size(
style,
style.box_values.width.clone(),
estimate,
context.main_size_basis,
FlexDirection::Row,
);
if main_size_property_needs_content_fallback(
&style.box_values.width,
context.main_size_basis,
) {
ResolvedFlexBasis::normal_flow_content(dimension)
} else {
ResolvedFlexBasis::main_size_property(dimension)
}
} else if let Some(size) = context.ratio_only_replaced_base_size {
ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(
style,
size.main_content_size(FlexDirection::Row),
FlexDirection::Row,
)
.points(),
))
} else if let Some(transferred) = aspect_ratio_transferred_flex_basis(
style,
estimate,
context.direction,
context.available_cross_size,
context.stretched_cross_size,
context.preferred_aspect_ratio,
) {
ResolvedFlexBasis::aspect_ratio_transfer(taffy_layout::Dimension::length(
transferred.points(),
))
} else {
ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(style, estimate.content_width, FlexDirection::Row).points(),
))
}
} else if !style.box_values.height.is_auto() {
let dimension = taffy_flex_basis_from_main_size(
style,
style.box_values.height.value().clone(),
estimate,
context.main_size_basis,
FlexDirection::Column,
);
if main_size_property_needs_content_fallback(
style.box_values.height.value(),
context.main_size_basis,
) {
ResolvedFlexBasis::normal_flow_content(dimension)
} else {
ResolvedFlexBasis::main_size_property(dimension)
}
} else if let Some(size) = context.ratio_only_replaced_base_size {
ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(
style,
size.main_content_size(FlexDirection::Column),
FlexDirection::Column,
)
.points(),
))
} else if let Some(transferred) = aspect_ratio_transferred_flex_basis(
style,
estimate,
context.direction,
context.available_cross_size,
context.stretched_cross_size,
context.preferred_aspect_ratio,
) {
ResolvedFlexBasis::aspect_ratio_transfer(taffy_layout::Dimension::length(
transferred.points(),
))
} else {
ResolvedFlexBasis::normal_flow_content(taffy_layout::Dimension::length(
flex_auto_content_basis(style, estimate.content_height, FlexDirection::Column).points(),
))
}
}
fn main_size_property_needs_content_fallback(
main_size: &css::ComputedLengthPercentageOrAuto,
main_size_basis: FlexAvailablePercentageBasis,
) -> bool {
matches!(main_size, css::ComputedLengthPercentageOrAuto::LengthPercentage(value)
if value.needs_percentage_basis() && !main_size_basis.is_definite())
}
#[derive(Debug, Clone, Copy)]
pub(super) struct FlexBasisContext {
pub(super) direction: FlexDirection,
pub(super) available_main_size: FlexMainSize,
pub(super) available_cross_size: Option<FlexCrossSize>,
pub(super) stretched_cross_size: Option<FlexCrossSize>,
pub(super) main_size_basis: FlexAvailablePercentageBasis,
pub(super) preferred_aspect_ratio: Option<f32>,
pub(super) ratio_only_replaced_base_size: Option<RatioOnlyReplacedFlexBaseSize>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum FlexMainSizeProvenance {
NormalFlowContent,
AspectRatioTransfer,
MainSizeProperty,
DefiniteFlexBasis,
}
impl FlexMainSizeProvenance {
pub(super) fn permits_final_normal_flow_block_span(self) -> bool {
matches!(self, Self::NormalFlowContent)
}
pub(super) fn is_definite(self) -> bool {
matches!(
self,
Self::AspectRatioTransfer | Self::MainSizeProperty | Self::DefiniteFlexBasis
)
}
}
#[derive(Debug, Clone, Copy)]
pub(super) struct ResolvedFlexBasis {
pub(super) dimension: taffy_layout::Dimension,
pub(super) provenance: FlexMainSizeProvenance,
}
impl ResolvedFlexBasis {
fn normal_flow_content(dimension: taffy_layout::Dimension) -> Self {
Self {
dimension,
provenance: FlexMainSizeProvenance::NormalFlowContent,
}
}
fn aspect_ratio_transfer(dimension: taffy_layout::Dimension) -> Self {
Self {
dimension,
provenance: FlexMainSizeProvenance::AspectRatioTransfer,
}
}
fn main_size_property(dimension: taffy_layout::Dimension) -> Self {
Self {
dimension,
provenance: FlexMainSizeProvenance::MainSizeProperty,
}
}
fn definite_flex_basis(dimension: taffy_layout::Dimension) -> Self {
Self {
dimension,
provenance: FlexMainSizeProvenance::DefiniteFlexBasis,
}
}
pub(super) fn is_definite(self) -> bool {
self.provenance.is_definite()
}
}
fn aspect_ratio_transferred_flex_basis(
style: &ComputedStyle,
estimate: &FlexItemEstimate,
direction: FlexDirection,
available_cross_size: Option<FlexCrossSize>,
stretched_cross_size: Option<FlexCrossSize>,
preferred_aspect_ratio: Option<f32>,
) -> Option<LayoutLength> {
let transferred = aspect_ratio_transferred_content_main_size_with_cross_constraints(
style,
direction,
preferred_aspect_ratio,
FlexCrossSizeSuggestionContext {
available_cross_size,
authored_stretch_fit_cross_size: None,
stretched_cross_size,
automatic_preferred_cross_size: None,
intrinsic: FlexCrossIntrinsicContributions {
min_content: if direction.is_row_axis() {
estimate.min_height
} else {
estimate.min_width
},
max_content: if direction.is_row_axis() {
estimate.content_height
} else {
estimate.content_width
},
},
},
)
.map(|size| {
estimate
.aspect_ratio_sizing
.map(|sizing| {
if direction.is_row_axis() {
sizing.constraints.constrain_width(size)
} else {
sizing.constraints.constrain_height(size)
}
})
.unwrap_or(size)
});
let transferred = transferred.or_else(|| {
let sizing = estimate.aspect_ratio_sizing?;
if !style.box_values.width.is_auto() || !style.box_values.height.is_auto() {
return None;
}
Some(if direction.is_row_axis() {
let cross = sizing
.authored_height_constraints
.constrain(sizing.intrinsic_height);
sizing.ratio.width_from_height(cross)
} else {
let cross = sizing
.authored_width_constraints
.constrain(sizing.intrinsic_width);
sizing.ratio.height_from_width(cross)
})
})?;
Some(flex_aspect_ratio_basis_from_content_box(
style,
transferred,
direction,
))
}
#[derive(Debug, Clone, Copy)]
pub(super) struct FlexCrossIntrinsicContributions {
pub(super) min_content: ContentBoxLength,
pub(super) max_content: ContentBoxLength,
}
#[derive(Debug, Clone, Copy)]
pub(super) struct FlexCrossSizeSuggestionContext {
pub(super) available_cross_size: Option<FlexCrossSize>,
pub(super) authored_stretch_fit_cross_size: Option<ContentBoxLength>,
pub(super) stretched_cross_size: Option<FlexCrossSize>,
pub(super) automatic_preferred_cross_size: Option<ContentBoxLength>,
pub(super) intrinsic: FlexCrossIntrinsicContributions,
}
pub(super) fn aspect_ratio_transferred_content_main_size_with_cross_constraints(
style: &ComputedStyle,
direction: FlexDirection,
preferred_aspect_ratio: Option<f32>,
cross: FlexCrossSizeSuggestionContext,
) -> Option<ContentBoxLength> {
let ratio = preferred_aspect_ratio?;
let cross_non_content = if direction.is_row_axis() {
non_content_pt(style.padding.top + style.padding.bottom + vertical_border_width(style))
} else {
non_content_pt(style.padding.left + style.padding.right + horizontal_border_width(style))
};
let specified_cross_size = if direction.is_row_axis() {
used_content_box_height_or_auto_with_basis(
style,
percentage_basis_from_points(cross.available_cross_size.map(FlexCrossSize::points)),
cross_non_content,
)
} else {
used_content_box_width_or_auto_with_basis(
style,
percentage_basis_from_points(cross.available_cross_size.map(FlexCrossSize::points)),
cross_non_content,
)
};
let cross_content_size = specified_cross_size
.or(cross.authored_stretch_fit_cross_size)
.or_else(|| {
cross
.stretched_cross_size
.map(|size| content_box_pt((size.points() - cross_non_content.points()).max(0.0)))
})
.or(cross.automatic_preferred_cross_size)?;
let cross_percentage_basis =
percentage_basis_from_points(cross.available_cross_size.map(FlexCrossSize::points));
let constrained_cross = if direction.is_row_axis() {
constrain_height_with_intrinsic(
style,
cross_content_size,
cross.intrinsic.min_content,
cross.intrinsic.max_content,
cross_percentage_basis,
non_content_pt(style.padding.top + style.padding.bottom + vertical_border_width(style)),
)
} else {
constrain_width_with_intrinsic(
style,
cross_content_size,
cross.intrinsic.min_content,
cross.intrinsic.max_content,
cross_percentage_basis,
non_content_pt(
style.padding.left + style.padding.right + horizontal_border_width(style),
),
)
};
Some(flex_aspect_ratio_transferred_content_main_size(
style,
constrained_cross,
direction,
ratio,
))
}
pub(super) fn automatic_minimum_transferred_size_suggestion(
style: &ComputedStyle,
direction: FlexDirection,
preferred_aspect_ratio: Option<f32>,
cross: FlexCrossSizeSuggestionContext,
) -> Option<ContentBoxLength> {
if let Some(transferred) = aspect_ratio_transferred_content_main_size_with_cross_constraints(
style,
direction,
preferred_aspect_ratio,
cross,
) {
return Some(transferred);
}
let ratio = preferred_aspect_ratio?;
let percentage_basis =
percentage_basis_from_points(cross.available_cross_size.map(FlexCrossSize::points));
let constrained_minimum_cross = if direction.is_row_axis() {
constrain_height_with_intrinsic(
style,
content_box_pt(0.0),
cross.intrinsic.min_content,
cross.intrinsic.max_content,
percentage_basis,
non_content_pt(style.padding.top + style.padding.bottom + vertical_border_width(style)),
)
} else {
constrain_width_with_intrinsic(
style,
content_box_pt(0.0),
cross.intrinsic.min_content,
cross.intrinsic.max_content,
percentage_basis,
non_content_pt(
style.padding.left + style.padding.right + horizontal_border_width(style),
),
)
};
(constrained_minimum_cross.points() > 0.0).then(|| {
flex_aspect_ratio_transferred_content_main_size(
style,
constrained_minimum_cross,
direction,
ratio,
)
})
}
fn authored_cross_stretch_fit_content_box_size(
style: &ComputedStyle,
direction: FlexDirection,
stretch: FlexStretchFitContext,
) -> Option<ContentBoxLength> {
let cross_size = if direction.is_row_axis() {
&style.box_values.height
} else {
&style.box_values.width
};
matches!(cross_size, css::ComputedLengthPercentageOrAuto::Stretch)
.then(|| resolved_stretch_fit_content_box_size(stretch))
.flatten()
}
pub(super) fn automatic_preferred_cross_content_size(
style: &ComputedStyle,
estimate: &FlexItemEstimate,
direction: FlexDirection,
) -> Option<ContentBoxLength> {
automatic_preferred_content_size_on_axis(
style,
estimate,
if direction.is_row_axis() {
FlexDirection::Column
} else {
FlexDirection::Row
},
)
}
pub(super) fn flex_automatic_minimum_inputs(
style: &ComputedStyle,
estimate: &FlexItemEstimate,
direction: FlexDirection,
content_size_source: FlexAutomaticMinimumContentSizeSource,
preferred_aspect_ratio: Option<f32>,
is_replaced: bool,
available: FlexAvailableSpace,
) -> FlexAutomaticMinimumInputs {
let (max_content_size, automatic_preferred_cross_size, cross_intrinsic) =
if direction.is_row_axis() {
(
estimate.content_width,
automatic_preferred_cross_content_size(style, estimate, FlexDirection::Row),
FlexAutomaticMinimumCrossIntrinsicContributions {
min_content: estimate.min_height,
max_content: estimate.content_height,
},
)
} else {
(
estimate.content_height,
automatic_preferred_cross_content_size(style, estimate, FlexDirection::Column),
FlexAutomaticMinimumCrossIntrinsicContributions {
min_content: estimate.min_width,
max_content: estimate.content_width,
},
)
};
let definite_preferred_content_size = if style.display.is_table() {
None
} else if direction.is_row_axis() {
used_content_box_width_or_auto_with_basis(
style,
available.width_basis,
non_content_pt(
style.padding.left + style.padding.right + horizontal_border_width(style),
),
)
} else {
used_content_box_height_or_auto_with_basis(
style,
available.height_basis,
non_content_pt(style.padding.top + style.padding.bottom + vertical_border_width(style)),
)
};
FlexAutomaticMinimumInputs {
content_size_source,
max_content_size,
automatic_preferred_cross_size: automatic_preferred_cross_size.map_or(
FlexAutomaticMinimumAutomaticPreferredCrossSize::None,
FlexAutomaticMinimumAutomaticPreferredCrossSize::CssImagesDefaultObjectSize,
),
cross_intrinsic,
preferred_aspect_ratio,
aspect_ratio_sizing: estimate.aspect_ratio_sizing,
is_replaced,
definite_preferred_content_size,
}
}
pub(super) fn set_flex_item_automatic_main_minimum_inputs(
estimate: &mut FlexItemEstimate,
style: &ComputedStyle,
direction: FlexDirection,
automatic_main_min_content: Option<ContentBoxLength>,
preferred_aspect_ratio: Option<f32>,
is_replaced: bool,
available: FlexAvailableSpace,
) {
let content_size_source = if is_replaced && estimate.automatic_preferred_physical_size.is_some()
{
FlexAutomaticMinimumContentSizeSource::RatioOnlyReplaced
} else {
FlexAutomaticMinimumContentSizeSource::Intrinsic(automatic_main_min_content.unwrap_or_else(
|| {
if direction.is_row_axis() {
estimate.min_width
} else {
estimate.min_height
}
},
))
};
estimate.set_automatic_main_minimum_inputs(flex_automatic_minimum_inputs(
style,
estimate,
direction,
content_size_source,
preferred_aspect_ratio,
is_replaced,
available,
));
}
pub(super) fn flex_item_cross_size_property(
style: &ComputedStyle,
direction: FlexDirection,
) -> FlexCrossSizeProperty {
let is_auto = if direction.is_row_axis() {
style.box_values.height.is_auto()
} else {
style.box_values.width.is_auto()
};
if is_auto {
FlexCrossSizeProperty::Auto
} else {
FlexCrossSizeProperty::NonAuto
}
}
pub(super) fn flex_item_cross_size_is_auto(
style: &ComputedStyle,
direction: FlexDirection,
) -> bool {
flex_item_cross_size_property(style, direction).is_auto()
}
pub(super) fn ratio_only_replaced_flex_base_size(
style: &ComputedStyle,
estimate: &FlexItemEstimate,
available: FlexItemAvailableSpace,
margin: css::Edges,
padding: css::Edges,
borders: css::Edges,
preferred_aspect_ratio: Option<f32>,
) -> Option<RatioOnlyReplacedFlexBaseSize> {
if !style.box_values.width.is_auto() || !style.box_values.height.is_auto() {
return None;
}
let automatic = estimate.automatic_preferred_physical_size?;
let ratio = preferred_aspect_ratio.filter(|ratio| ratio.is_finite() && *ratio > 0.0)?;
let axes = WritingModeAxes::new(style.writing_mode, style.used_direction());
let (available_inline, default_inline, inline_margin, inline_non_content) =
if axes.swaps_physical_axes() {
(
available
.height
.map(PhysicalContentHeight::content_box_length)?,
automatic.height.content_box_length(),
margin.top + margin.bottom,
padding.top + padding.bottom + borders.top + borders.bottom,
)
} else {
(
available.width.content_box_length(),
automatic.width.content_box_length(),
margin.left + margin.right,
padding.left + padding.right + borders.left + borders.right,
)
};
let inline = default_inline.min(content_box_pt(
(available_inline.points() - inline_margin - inline_non_content).max(0.0),
));
let (width, height) = if axes.swaps_physical_axes() {
(inline.points() * ratio, inline.points())
} else {
(inline.points(), inline.points() / ratio)
};
let constrained = resolve_replaced_size_with_aspect_ratio(
content_box_size_pt(width, height),
ratio,
ReplacedPreferredSizeAxes {
width: ReplacedPreferredSize::Automatic,
height: ReplacedPreferredSize::Automatic,
},
ReplacedSizeConstraints {
min_width: used_min_width(style, available.width_basis)
.map(|width| width.max(content_box_pt(0.0))),
max_width: used_max_width(style, available.width_basis)
.map(|width| width.max(content_box_pt(0.0))),
min_height: used_length_percentage_or_auto_with_basis(
style.box_values.min_height.clone(),
available.height_basis,
)
.map(|height| content_box_pt(height.points().max(0.0))),
max_height: used_length_percentage_or_auto_with_basis(
style.box_values.max_height.clone(),
available.height_basis,
)
.map(|height| content_box_pt(height.points().max(0.0))),
},
);
Some(RatioOnlyReplacedFlexBaseSize::new(
PhysicalContentWidth::new(content_box_pt(constrained.width)),
PhysicalContentHeight::new(content_box_pt(constrained.height)),
))
}
pub(super) fn automatic_preferred_content_size_on_axis(
style: &ComputedStyle,
estimate: &FlexItemEstimate,
axis: FlexDirection,
) -> Option<ContentBoxLength> {
let size = estimate.automatic_preferred_physical_size?;
if axis.is_row_axis() {
style
.box_values
.width
.is_auto()
.then(|| size.width.content_box_length())
} else {
style
.box_values
.height
.is_auto()
.then(|| size.height.content_box_length())
}
}
fn taffy_flex_basis_from_main_size(
style: &ComputedStyle,
value: css::ComputedLengthPercentageOrAuto,
estimate: &FlexItemEstimate,
main_size_basis: FlexAvailablePercentageBasis,
direction: FlexDirection,
) -> taffy_layout::Dimension {
let (min_content, max_content) = if direction.is_row_axis() {
(estimate.min_width, estimate.content_width)
} else {
(estimate.min_height, estimate.content_height)
};
if matches!(value, css::ComputedLengthPercentageOrAuto::LengthPercentage(ref value) if value.needs_percentage_basis() && !main_size_basis.is_definite())
{
return taffy_layout::Dimension::length(
flex_auto_content_basis(style, max_content, direction).points(),
);
}
taffy_intrinsic_dimension_with_basis(value, main_size_basis, min_content, max_content)
}
fn fit_content_basis(
min_content: ContentBoxLength,
max_content: ContentBoxLength,
limit: ContentBoxLength,
) -> ContentBoxLength {
content_box_pt(
max_content
.points()
.max(0.0)
.min(min_content.points().max(0.0).max(limit.points().max(0.0))),
)
}
pub(in crate::layout::flex) fn flex_aspect_ratio_transferred_content_main_size(
style: &ComputedStyle,
cross_content_size: ContentBoxLength,
direction: FlexDirection,
ratio: f32,
) -> ContentBoxLength {
let border_widths = used_border_widths(style);
let horizontal_non_content = non_content_pt(
style.padding.left + style.padding.right + border_widths.left + border_widths.right,
);
let vertical_non_content = non_content_pt(
style.padding.top + style.padding.bottom + border_widths.top + border_widths.bottom,
);
let calculation_box = if style.aspect_ratio.uses_content_box_for_non_replaced()
|| style.box_sizing == BoxSizing::ContentBox
{
AspectRatioCalculationBox::ContentBox
} else {
AspectRatioCalculationBox::BorderBox
};
let resolved = ResolvedAspectRatio::new(
ratio,
calculation_box,
horizontal_non_content,
vertical_non_content,
)
.expect("preferred aspect ratios are positive and finite");
if direction.is_row_axis() {
resolved.width_from_height(cross_content_size)
} else {
resolved.height_from_width(cross_content_size)
}
}
fn main_axis_extras(style: &ComputedStyle, direction: FlexDirection) -> NonContentLength {
let border_widths = used_border_widths(style);
non_content_pt(if direction.is_row_axis() {
style.padding.left + style.padding.right + border_widths.left + border_widths.right
} else {
style.padding.top + style.padding.bottom + border_widths.top + border_widths.bottom
})
}
pub(super) fn flex_auto_content_basis(
style: &ComputedStyle,
length: ContentBoxLength,
direction: FlexDirection,
) -> LayoutLength {
flex_auto_content_basis_from_content_box(style, length, direction)
}
fn flex_auto_content_basis_from_content_box(
style: &ComputedStyle,
length: ContentBoxLength,
direction: FlexDirection,
) -> LayoutLength {
let length = content_box_pt(length.points().max(0.0));
if style.box_sizing == BoxSizing::BorderBox {
crate::units::IntoLayoutLength::into_layout_length(content_box_to_border_box_length(
length,
main_axis_extras(style, direction),
))
} else {
crate::units::IntoLayoutLength::into_layout_length(length)
}
}
fn flex_aspect_ratio_basis_from_content_box(
style: &ComputedStyle,
length: ContentBoxLength,
direction: FlexDirection,
) -> LayoutLength {
let length = content_box_pt(length.points().max(0.0));
if style.box_sizing == BoxSizing::BorderBox {
crate::units::IntoLayoutLength::into_layout_length(content_box_to_border_box_length(
length,
main_axis_extras(style, direction),
))
} else {
crate::units::IntoLayoutLength::into_layout_length(length)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::layout::flex::{
FlexAspectRatioSizing, FlexAutomaticPreferredPhysicalSize,
flex_available_percentage_basis_from_points,
};
use crate::layout::{AspectRatioAxisConstraints, ResolvedAspectRatioConstraints, WritingMode};
#[test]
fn automatic_content_basis_preserves_measured_width_with_preserved_whitespace() {
let mut style = ComputedStyle::initial();
style.white_space = css::WhiteSpace::Pre;
assert_eq!(
flex_auto_content_basis(&style, content_box_pt(18.65625), FlexDirection::Row).points(),
18.65625
);
}
#[test]
fn block_axis_min_content_preserves_its_authored_minimum_kind() {
let horizontal = ComputedStyle::initial();
assert_eq!(
flex_main_axis_content_based_minimum_kind(
&css::ComputedLengthPercentageOrAuto::MinContent,
&horizontal,
FlexDirection::Column,
),
Some(FlexContentBasedMinimumKind::BlockAxisMinContent),
);
assert_eq!(
flex_main_axis_content_based_minimum_kind(
&css::ComputedLengthPercentageOrAuto::MinContent,
&horizontal,
FlexDirection::Row,
),
None,
);
assert_eq!(
flex_main_axis_content_based_minimum_kind(
&css::ComputedLengthPercentageOrAuto::Auto,
&horizontal,
FlexDirection::Column,
),
Some(FlexContentBasedMinimumKind::CssAutomatic),
);
}
#[test]
fn flex_margin_adapter_preserves_negative_lengths_and_percentages() {
let mut style = ComputedStyle::initial();
style.box_values.margin.left = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(-50.0),
);
let length = taffy_bridge::margin(
&style,
PercentageBasis::<LogicalInlineContentSize>::indefinite(),
taffy_bridge::TaffyCyclicPercentage::PreservePurePercentage,
)
.left;
assert_eq!(length.resolve_to_option(200.0, |_, _| 0.0), Some(-50.0));
style.box_values.margin.left = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_percent(-0.25),
);
let percentage = taffy_bridge::margin(
&style,
PercentageBasis::<LogicalInlineContentSize>::indefinite(),
taffy_bridge::TaffyCyclicPercentage::PreservePurePercentage,
)
.left;
assert_eq!(percentage.resolve_to_option(200.0, |_, _| 0.0), Some(-50.0));
style.box_values.margin.left = css::ComputedLengthPercentageOrAuto::Auto;
let auto = taffy_bridge::margin(
&style,
PercentageBasis::<LogicalInlineContentSize>::indefinite(),
taffy_bridge::TaffyCyclicPercentage::PreservePurePercentage,
)
.left;
assert!(auto.is_auto());
}
#[test]
fn flex_size_adapter_still_clamps_negative_lengths_and_percentages() {
assert_eq!(
taffy_dimension_from_length_percentage(css::ComputedLengthPercentage::from_points(
-50.0
)),
taffy_layout::Dimension::length(0.0)
);
assert_eq!(
taffy_dimension_from_length_percentage(css::ComputedLengthPercentage::from_percent(
-0.25
)),
taffy_layout::Dimension::percent(0.0)
);
}
#[test]
fn flex_optional_dimension_policies_preserve_or_resolve_pure_percentages() {
let percent = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_percent(0.5),
);
let definite_basis = flex_available_percentage_basis_from_points(
Some(80.0),
FlexAvailableSizeSource::ContainingBlock,
);
let indefinite_basis = PercentageBasis::indefinite();
assert_eq!(
taffy_optional_dimension(percent.clone()),
taffy_layout::LengthPercentageAuto::percent(0.5),
);
assert_eq!(
taffy_optional_dimension_with_basis(percent.clone(), definite_basis),
taffy_layout::Dimension::length(40.0),
);
assert!(taffy_optional_dimension_with_basis(percent, indefinite_basis).is_auto());
}
#[test]
fn flex_optional_dimension_policies_share_fixed_lengths() {
let fixed = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(12.0),
);
let indefinite_basis = PercentageBasis::indefinite();
assert_eq!(
taffy_optional_dimension(fixed.clone()),
taffy_layout::LengthPercentageAuto::length(12.0),
);
assert_eq!(
taffy_optional_dimension_with_basis(fixed, indefinite_basis),
taffy_layout::Dimension::length(12.0),
);
}
#[test]
fn flex_size_adapter_does_not_treat_unresolved_metric_math_as_a_fixed_length() {
let value = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::sum(
css::ComputedLengthPercentage::from_points(12.0),
css::ComputedLengthPercentage::from_em(1.0),
),
);
assert!(
taffy_optional_dimension_with_basis(value, PercentageBasis::indefinite()).is_auto()
);
}
#[test]
fn unresolved_percentage_main_size_remains_auto_for_content_flex_basis() {
let value = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_percent(0.01),
);
let context = FlexItemSizeDimensionContext {
flex_direction: FlexDirection::Column,
dimension_axis: FlexDirection::Column,
percentage_basis: PercentageBasis::indefinite(),
stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
flex_basis_overrides_main_size: false,
cross_sizing_phase: FlexCrossSizingPhase::Hypothetical,
hypothetical_automatic_cross_size: FlexHypotheticalAutomaticCrossSize::Intrinsic,
};
assert!(
flex_item_size_dimension(
value,
content_box_pt(10.0),
content_box_pt(10.0),
content_box_pt(20.0),
context,
)
.is_auto()
);
}
#[test]
fn cross_size_property_and_adapter_phase_keep_orthogonal_auto_distinct_from_inline_size() {
let mut style = ComputedStyle::initial();
style.writing_mode = WritingMode::VerticalRl;
*style.box_values.height = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(6.0),
);
assert_eq!(
flex_item_cross_size_property(&style, FlexDirection::Row),
FlexCrossSizeProperty::NonAuto
);
assert_eq!(
flex_item_cross_size_property(&style, FlexDirection::Column),
FlexCrossSizeProperty::Auto
);
let context = FlexItemSizeDimensionContext {
flex_direction: FlexDirection::Row,
dimension_axis: FlexDirection::Column,
percentage_basis: PercentageBasis::indefinite(),
stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
flex_basis_overrides_main_size: false,
cross_sizing_phase: FlexCrossSizingPhase::Hypothetical,
hypothetical_automatic_cross_size: FlexHypotheticalAutomaticCrossSize::Intrinsic,
};
assert!(
flex_item_size_dimension(
css::ComputedLengthPercentageOrAuto::Auto,
content_box_pt(10.0),
content_box_pt(10.0),
content_box_pt(20.0),
context,
)
.is_auto()
);
let fit_content = FlexItemSizeDimensionContext {
hypothetical_automatic_cross_size: FlexHypotheticalAutomaticCrossSize::FitContent {
used_content_size: content_box_pt(36.0),
},
..context
};
assert_eq!(
flex_item_size_dimension(
css::ComputedLengthPercentageOrAuto::Auto,
content_box_pt(10.0),
content_box_pt(10.0),
content_box_pt(20.0),
fit_content,
),
taffy_layout::Dimension::length(36.0)
);
let stretched = FlexItemSizeDimensionContext {
cross_sizing_phase: FlexCrossSizingPhase::StretchToLine {
line_outer_cross_size: FlexCrossSize::new(44.0),
},
..context
};
assert_eq!(
flex_item_size_dimension(
css::ComputedLengthPercentageOrAuto::Auto,
content_box_pt(10.0),
content_box_pt(10.0),
content_box_pt(20.0),
stretched,
),
taffy_layout::Dimension::length(44.0)
);
}
#[test]
fn flex_container_min_dimension_uses_the_supplied_physical_basis() {
let fifty_percent = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_percent(0.5),
);
let width_basis = flex_available_percentage_basis_from_points(
Some(200.0),
FlexAvailableSizeSource::ContainingBlock,
);
let height_basis = flex_available_percentage_basis_from_points(
Some(80.0),
FlexAvailableSizeSource::ContainingBlock,
);
assert_eq!(
taffy_min_dimension(fifty_percent.clone(), width_basis),
taffy_layout::LengthPercentageAuto::length(100.0)
);
assert_eq!(
taffy_min_dimension(fifty_percent, height_basis),
taffy_layout::LengthPercentageAuto::length(40.0)
);
}
#[test]
fn flex_gap_resolves_percentages_only_with_definite_basis() {
let percent_gap =
css::ComputedGap::LengthPercentage(css::ComputedLengthPercentage::from_percent(0.5));
let mixed = css::ComputedLengthPercentage::from_affine(layout_pt(4.0), 0.5, true);
let mixed_gap = css::ComputedGap::LengthPercentage(mixed);
let indefinite_basis = PercentageBasis::indefinite();
let definite_basis = flex_available_percentage_basis_from_points(
Some(40.0),
FlexAvailableSizeSource::ContainingBlock,
);
assert_eq!(
taffy_gap(percent_gap.clone(), indefinite_basis),
taffy_layout::LengthPercentage::length(0.0)
);
assert_eq!(
taffy_gap(percent_gap, definite_basis),
taffy_layout::LengthPercentage::length(20.0)
);
assert_eq!(
taffy_gap(mixed_gap.clone(), indefinite_basis),
taffy_layout::LengthPercentage::length(4.0)
);
assert_eq!(
taffy_gap(mixed_gap, definite_basis),
taffy_layout::LengthPercentage::length(24.0)
);
}
fn test_flex_basis_context() -> FlexBasisContext {
FlexBasisContext {
direction: FlexDirection::Row,
available_main_size: FlexMainSize::new(200.0),
available_cross_size: None,
stretched_cross_size: None,
main_size_basis: PercentageBasis::definite_from(
content_box_pt(200.0),
FlexAvailableSizeSource::ContainingBlock,
),
preferred_aspect_ratio: None,
ratio_only_replaced_base_size: None,
}
}
fn test_flex_estimate() -> FlexItemEstimate {
FlexItemEstimate::new(
IntrinsicItemMetrics {
width: content_box_pt(60.0),
height: content_box_pt(30.0),
min_width: content_box_pt(20.0),
min_height: content_box_pt(10.0),
content_width: content_box_pt(80.0),
content_height: content_box_pt(40.0),
preferred_aspect_ratio: None,
first_baseline: None,
last_baseline: None,
},
FlexItemBaselineEstimate::default(),
)
}
fn ratio_only_replaced_estimate(width: f32, height: f32) -> FlexItemEstimate {
let mut estimate = test_flex_estimate();
estimate.set_automatic_preferred_physical_size(FlexAutomaticPreferredPhysicalSize {
width: PhysicalContentWidth::new(content_box_pt(width)),
height: PhysicalContentHeight::new(content_box_pt(height)),
});
estimate
}
fn ratio_only_available_space(width: f32, height: Option<f32>) -> FlexItemAvailableSpace {
FlexItemAvailableSpace {
width: PhysicalContentWidth::new(content_box_pt(width)),
width_basis: PercentageBasis::definite_from(
content_box_pt(width),
FlexAvailableSizeSource::ContainingBlock,
),
height: height.map(|height| PhysicalContentHeight::new(content_box_pt(height))),
height_basis: height.map_or_else(PercentageBasis::indefinite, |height| {
PercentageBasis::definite_from(
content_box_pt(height),
FlexAvailableSizeSource::ContainingBlock,
)
}),
stretched_width: None,
stretched_height: None,
}
}
#[test]
fn ratio_only_replaced_flex_base_uses_margin_adjusted_inline_space() {
let style = ComputedStyle::initial();
let estimate = ratio_only_replaced_estimate(225.0, 225.0);
let base = ratio_only_replaced_flex_base_size(
&style,
&estimate,
ratio_only_available_space(112.5, None),
css::Edges {
right: 37.5,
..css::Edges::ZERO
},
css::Edges::ZERO,
css::Edges::ZERO,
Some(1.0),
)
.expect("a ratio-only replaced item has a temporary flex base size");
assert_eq!(base.main_content_size(FlexDirection::Row).points(), 75.0);
assert_eq!(base.main_content_size(FlexDirection::Column).points(), 75.0);
assert_eq!(base.cross_content_size(FlexDirection::Row).points(), 75.0);
assert!(flex_item_cross_size_is_auto(&style, FlexDirection::Column));
assert_eq!(
automatic_preferred_cross_content_size(&style, &estimate, FlexDirection::Column)
.expect("the CSS Images fallback remains available to automatic minimum sizing")
.points(),
225.0,
);
let resolved = resolve_taffy_flex_basis(
&style,
&estimate,
FlexBasisContext {
ratio_only_replaced_base_size: Some(base),
..test_flex_basis_context()
},
);
assert_eq!(resolved.dimension, taffy_layout::Dimension::length(75.0));
assert_eq!(
resolved.provenance,
FlexMainSizeProvenance::NormalFlowContent
);
let column = resolve_taffy_flex_basis(
&style,
&estimate,
FlexBasisContext {
direction: FlexDirection::Column,
ratio_only_replaced_base_size: Some(base),
..test_flex_basis_context()
},
);
assert_eq!(column.dimension, taffy_layout::Dimension::length(75.0));
}
#[test]
fn ratio_only_replaced_flex_base_projects_vertical_inline_space() {
let mut style = ComputedStyle::initial();
style.writing_mode = WritingMode::VerticalRl;
let estimate = ratio_only_replaced_estimate(225.0, 112.5);
let base = ratio_only_replaced_flex_base_size(
&style,
&estimate,
ratio_only_available_space(400.0, Some(80.0)),
css::Edges {
top: 20.0,
..css::Edges::ZERO
},
css::Edges::ZERO,
css::Edges::ZERO,
Some(2.0),
)
.expect("a vertical ratio-only replaced item has a temporary flex base size");
assert_eq!(base.main_content_size(FlexDirection::Row).points(), 120.0);
assert_eq!(base.main_content_size(FlexDirection::Column).points(), 60.0);
assert_eq!(base.cross_content_size(FlexDirection::Row).points(), 60.0);
}
#[test]
fn flex_item_measurement_extracts_typed_content_box_lengths() {
let mut estimate = test_flex_estimate();
let measured = measure_flex_item(
taffy_layout::Size {
width: None,
height: None,
},
taffy_layout::Size {
width: taffy_layout::AvailableSpace::Definite(200.0),
height: taffy_layout::AvailableSpace::Definite(200.0),
},
Some(&mut estimate),
);
assert_eq!(measured.width, 60.0);
assert_eq!(measured.height, 30.0);
}
#[test]
fn flex_basis_uses_typed_content_and_min_content_estimates() {
let estimate = test_flex_estimate();
let mut style = ComputedStyle::initial();
style.flex_basis = css::ComputedFlexBasis::Content;
assert_eq!(
resolve_taffy_flex_basis(&style, &estimate, test_flex_basis_context()).dimension,
taffy_layout::Dimension::length(80.0)
);
style.flex_basis = css::ComputedFlexBasis::MinContent;
assert_eq!(
resolve_taffy_flex_basis(&style, &estimate, test_flex_basis_context()).dimension,
taffy_layout::Dimension::length(20.0)
);
style.flex_basis = css::ComputedFlexBasis::MaxContent;
assert_eq!(
resolve_taffy_flex_basis(&style, &estimate, test_flex_basis_context()).dimension,
taffy_layout::Dimension::length(80.0)
);
}
#[test]
fn flex_basis_indefinite_percentage_falls_back_to_typed_content_estimate() {
let estimate = test_flex_estimate();
let mut style = ComputedStyle::initial();
style.flex_basis = css::ComputedFlexBasis::LengthPercentage(
css::ComputedFlexBasisLength::new(css::ComputedLengthPercentage::from_percent(0.5)),
);
let context = FlexBasisContext {
main_size_basis: PercentageBasis::indefinite(),
..test_flex_basis_context()
};
let resolved = resolve_taffy_flex_basis(&style, &estimate, context);
assert_eq!(resolved.dimension, taffy_layout::Dimension::length(80.0));
assert_eq!(
resolved.provenance,
FlexMainSizeProvenance::NormalFlowContent,
"an indefinite percentage flex basis, including flex: 1's 0%, uses content sizing",
);
}
#[test]
fn resolved_flex_basis_retains_the_main_size_provenance() {
let estimate = test_flex_estimate();
let mut content = ComputedStyle::initial();
content.flex_basis = css::ComputedFlexBasis::Content;
assert_eq!(
resolve_taffy_flex_basis(&content, &estimate, test_flex_basis_context()).provenance,
FlexMainSizeProvenance::NormalFlowContent,
);
let mut main_size_property = ComputedStyle::initial();
main_size_property.box_values.width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(60.0),
);
assert_eq!(
resolve_taffy_flex_basis(&main_size_property, &estimate, test_flex_basis_context(),)
.provenance,
FlexMainSizeProvenance::MainSizeProperty,
);
let mut definite_basis = ComputedStyle::initial();
definite_basis.flex_basis = css::ComputedFlexBasis::LengthPercentage(
css::ComputedFlexBasisLength::new(css::ComputedLengthPercentage::from_points(60.0)),
);
assert_eq!(
resolve_taffy_flex_basis(&definite_basis, &estimate, test_flex_basis_context())
.provenance,
FlexMainSizeProvenance::DefiniteFlexBasis,
);
let mut transferred = ComputedStyle::initial();
transferred.flex_basis = css::ComputedFlexBasis::Content;
transferred.box_values.width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(80.0),
);
let context = FlexBasisContext {
direction: FlexDirection::Column,
available_cross_size: Some(FlexCrossSize::new(80.0)),
preferred_aspect_ratio: Some(1.0),
..test_flex_basis_context()
};
assert_eq!(
resolve_taffy_flex_basis(&transferred, &estimate, context).provenance,
FlexMainSizeProvenance::AspectRatioTransfer,
);
assert!(resolve_taffy_flex_basis(&transferred, &estimate, context).is_definite());
}
#[test]
fn auto_auto_ratio_column_basis_uses_fit_content_cross_and_ignores_main_minimum() {
let mut style = ComputedStyle::initial();
style.aspect_ratio = css::AspectRatio::from_ratio(1.0).unwrap();
let ratio = ResolvedAspectRatio::new(
1.0,
AspectRatioCalculationBox::ContentBox,
non_content_pt(0.0),
non_content_pt(0.0),
)
.unwrap();
let authored_width_constraints = AspectRatioAxisConstraints {
minimum: Some(content_box_pt(100.0)),
..Default::default()
};
let authored_height_constraints = AspectRatioAxisConstraints {
minimum: Some(content_box_pt(200.0)),
..Default::default()
};
let mut estimate = FlexItemEstimate::fixed(
PhysicalContentWidth::new(content_box_pt(100.0)),
PhysicalContentHeight::new(content_box_pt(100.0)),
);
estimate.set_aspect_ratio_sizing(FlexAspectRatioSizing {
ratio,
authored_width_constraints,
authored_height_constraints,
constraints: ResolvedAspectRatioConstraints::resolve(
ratio,
authored_width_constraints,
authored_height_constraints,
),
intrinsic_width: content_box_pt(1.0),
intrinsic_height: content_box_pt(0.0),
});
let context = FlexBasisContext {
direction: FlexDirection::Column,
preferred_aspect_ratio: Some(1.0),
..test_flex_basis_context()
};
let resolved = resolve_taffy_flex_basis(&style, &estimate, context);
assert_eq!(resolved.dimension, taffy_layout::Dimension::length(100.0));
assert_eq!(
resolved.provenance,
FlexMainSizeProvenance::AspectRatioTransfer
);
}
#[test]
fn automatic_minimum_transfers_a_definite_cross_minimum_through_ratio() {
let mut style = ComputedStyle::initial();
style.box_values.min_height = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(30.0),
);
let transferred = automatic_minimum_transferred_size_suggestion(
&style,
FlexDirection::Row,
Some(1.0),
FlexCrossSizeSuggestionContext {
available_cross_size: None,
authored_stretch_fit_cross_size: None,
stretched_cross_size: None,
automatic_preferred_cross_size: None,
intrinsic: FlexCrossIntrinsicContributions {
min_content: content_box_pt(10.0),
max_content: content_box_pt(100.0),
},
},
)
.expect("a definite cross minimum supplies a transferred suggestion");
assert_eq!(transferred.points(), 30.0);
}
#[test]
fn automatic_preferred_replaced_cross_size_transfers_through_max_constraints() {
let mut column_style = ComputedStyle::initial();
column_style.box_values.max_width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(100.0),
);
let column_transferred = automatic_minimum_transferred_size_suggestion(
&column_style,
FlexDirection::Column,
Some(1.0),
FlexCrossSizeSuggestionContext {
available_cross_size: None,
authored_stretch_fit_cross_size: None,
stretched_cross_size: None,
automatic_preferred_cross_size: Some(content_box_pt(225.0)),
intrinsic: FlexCrossIntrinsicContributions {
min_content: content_box_pt(0.0),
max_content: content_box_pt(225.0),
},
},
)
.expect("automatic width transfers through max-width");
assert_eq!(column_transferred.points(), 100.0);
let mut row_style = ComputedStyle::initial();
row_style.box_values.max_height = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(100.0),
);
let row_transferred = automatic_minimum_transferred_size_suggestion(
&row_style,
FlexDirection::Row,
Some(1.0),
FlexCrossSizeSuggestionContext {
available_cross_size: None,
authored_stretch_fit_cross_size: None,
stretched_cross_size: None,
automatic_preferred_cross_size: Some(content_box_pt(225.0)),
intrinsic: FlexCrossIntrinsicContributions {
min_content: content_box_pt(0.0),
max_content: content_box_pt(225.0),
},
},
)
.expect("automatic height transfers through max-height");
assert_eq!(row_transferred.points(), 100.0);
}
#[test]
fn ratio_only_automatic_minimum_keeps_css_images_fallback_transferred_only() {
let style = ComputedStyle::initial();
let inputs = FlexAutomaticMinimumInputs {
content_size_source: FlexAutomaticMinimumContentSizeSource::RatioOnlyReplaced,
max_content_size: content_box_pt(225.0),
automatic_preferred_cross_size:
FlexAutomaticMinimumAutomaticPreferredCrossSize::CssImagesDefaultObjectSize(
content_box_pt(225.0),
),
cross_intrinsic: FlexAutomaticMinimumCrossIntrinsicContributions {
min_content: content_box_pt(0.0),
max_content: content_box_pt(225.0),
},
preferred_aspect_ratio: Some(1.0),
aspect_ratio_sizing: None,
is_replaced: true,
definite_preferred_content_size: None,
};
let resolved = resolve_automatic_flex_minimum(
css::ComputedLengthPercentageOrAuto::Auto,
FlexMinSizeDimensionContext {
style: &style,
direction: FlexDirection::Row,
automatic_minimum_inputs: Some(inputs),
available_cross_size: None,
cross_stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
stretched_cross_size: None,
is_main_axis: true,
overflow: flex_item_main_axis_overflow(&style, FlexDirection::Row),
percentage_basis: PercentageBasis::indefinite(),
stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
},
)
.expect("a main-axis automatic minimum resolves");
assert_eq!(resolved.content_size_suggestion.points(), 0.0);
assert_eq!(
resolved
.transferred_size_suggestion
.expect("the CSS Images fallback transfers through the ratio")
.points(),
225.0
);
assert_eq!(resolved.used_content_box.points(), 0.0);
}
#[test]
fn intrinsic_replaced_automatic_minimum_retains_its_content_suggestion() {
let style = ComputedStyle::initial();
let inputs = FlexAutomaticMinimumInputs {
content_size_source: FlexAutomaticMinimumContentSizeSource::Intrinsic(content_box_pt(
50.0,
)),
max_content_size: content_box_pt(100.0),
automatic_preferred_cross_size: FlexAutomaticMinimumAutomaticPreferredCrossSize::None,
cross_intrinsic: FlexAutomaticMinimumCrossIntrinsicContributions {
min_content: content_box_pt(0.0),
max_content: content_box_pt(0.0),
},
preferred_aspect_ratio: None,
aspect_ratio_sizing: None,
is_replaced: true,
definite_preferred_content_size: None,
};
let resolved = resolve_automatic_flex_minimum(
css::ComputedLengthPercentageOrAuto::Auto,
FlexMinSizeDimensionContext {
style: &style,
direction: FlexDirection::Row,
automatic_minimum_inputs: Some(inputs),
available_cross_size: None,
cross_stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
stretched_cross_size: None,
is_main_axis: true,
overflow: flex_item_main_axis_overflow(&style, FlexDirection::Row),
percentage_basis: PercentageBasis::indefinite(),
stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
},
)
.expect("a main-axis automatic minimum resolves");
assert_eq!(resolved.used_content_box.points(), 50.0);
}
#[test]
fn scrollable_block_axis_min_content_does_not_take_auto_minimum_zero() {
let mut style = ComputedStyle::initial();
style.overflow_y = css::Overflow::Auto;
let inputs = FlexAutomaticMinimumInputs {
content_size_source: FlexAutomaticMinimumContentSizeSource::Intrinsic(content_box_pt(
50.0,
)),
max_content_size: content_box_pt(100.0),
automatic_preferred_cross_size: FlexAutomaticMinimumAutomaticPreferredCrossSize::None,
cross_intrinsic: FlexAutomaticMinimumCrossIntrinsicContributions {
min_content: content_box_pt(0.0),
max_content: content_box_pt(0.0),
},
preferred_aspect_ratio: None,
aspect_ratio_sizing: None,
is_replaced: true,
definite_preferred_content_size: None,
};
let context = FlexMinSizeDimensionContext {
style: &style,
direction: FlexDirection::Column,
automatic_minimum_inputs: Some(inputs),
available_cross_size: None,
cross_stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
stretched_cross_size: None,
is_main_axis: true,
overflow: flex_item_main_axis_overflow(&style, FlexDirection::Column),
percentage_basis: PercentageBasis::indefinite(),
stretch: FlexStretchFitContext {
available_margin_box_size: None,
margin_size: layout_pt(0.0),
non_content_size: non_content_pt(0.0),
box_sizing: BoxSizing::ContentBox,
},
};
let auto =
resolve_automatic_flex_minimum(css::ComputedLengthPercentageOrAuto::Auto, context)
.expect("a scrollable automatic minimum resolves");
let min_content = resolve_automatic_flex_minimum(
css::ComputedLengthPercentageOrAuto::MinContent,
context,
)
.expect("a block-axis min-content minimum resolves");
assert_eq!(auto.used_content_box.points(), 0.0);
assert_eq!(min_content.used_content_box.points(), 50.0);
}
#[test]
fn content_box_aspect_ratio_transfer_keeps_content_box_flex_basis() {
let mut style = ComputedStyle::initial();
style.box_sizing = BoxSizing::ContentBox;
style.box_values.width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(150.0),
);
style.padding.top = 75.0;
style.padding.bottom = 75.0;
let basis = aspect_ratio_transferred_flex_basis(
&style,
&test_flex_estimate(),
FlexDirection::Column,
Some(FlexCrossSize::new(300.0)),
None,
Some(1.0),
)
.expect("definite cross size should transfer through aspect ratio");
assert_eq!(basis.points(), 150.0);
}
#[test]
fn border_box_aspect_ratio_transfer_adds_extras_once() {
let mut style = ComputedStyle::initial();
style.box_sizing = BoxSizing::BorderBox;
style.box_values.width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(300.0),
);
style.padding.left = 75.0;
style.padding.right = 75.0;
style.padding.top = 75.0;
style.padding.bottom = 75.0;
let basis = aspect_ratio_transferred_flex_basis(
&style,
&test_flex_estimate(),
FlexDirection::Column,
Some(FlexCrossSize::new(300.0)),
None,
Some(1.0),
)
.expect("definite cross size should transfer through aspect ratio");
assert_eq!(basis.points(), 300.0);
}
#[test]
fn aspect_ratio_flex_basis_uses_max_constrained_cross_size() {
let mut style = ComputedStyle::initial();
style.box_values.width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_points(500.0),
);
style.box_values.max_width = css::ComputedLengthPercentageOrAuto::LengthPercentage(
css::ComputedLengthPercentage::from_percent(1.0),
);
let estimate = FlexItemEstimate::fixed(
PhysicalContentWidth::new(content_box_pt(100.0)),
PhysicalContentHeight::new(content_box_pt(100.0)),
);
let basis = aspect_ratio_transferred_flex_basis(
&style,
&estimate,
FlexDirection::Column,
Some(FlexCrossSize::new(100.0)),
None,
Some(1.0),
)
.expect("definite max-constrained cross size should transfer through aspect ratio");
assert_eq!(basis.points(), 100.0);
}
}