Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(layout): resolve table row and section block sizes before Grid

ldm01a75321d368d
diff --git a/moli-layout/src/table.rs b/moli-layout/src/table.rs
index 904f08a3c..948d44d77 100644
--- a/moli-layout/src/table.rs
+++ b/moli-layout/src/table.rs
@@ -25,8 +25,10 @@ use crate::{
style::{LayoutInlineAlignment, resolve_stylo_calc_value},
};
+mod block;
mod collapsed_borders;
mod columns;
+mod rows;
pub(crate) use collapsed_borders::CollapsedTableBorders;
use collapsed_borders::{prepare_collapsed_table_borders, set_collapsed_border_geometry};
@@ -45,6 +47,7 @@ struct TableCell {
column: usize,
row_span: usize,
column_span: usize,
+ block_layout: Option<block::CellBlockLayout>,
}
#[derive(Clone, Copy)]
@@ -52,7 +55,7 @@ struct TableRow {
id: LayoutBoxId,
group: Option<LayoutBoxId>,
index: usize,
- track: taffy::TrackSizingFunction,
+ grid_index: usize,
}
#[derive(Clone, Copy)]
@@ -133,8 +136,13 @@ struct TableContext {
collapsed_borders: bool,
column_count: usize,
column_constraints: Vec<TableColumnConstraint>,
+ column_sizes: Vec<f32>,
+ sections: Vec<rows::SectionConstraint>,
+ section_boxes: Vec<LayoutBoxId>,
+ section_tracks: Vec<std::ops::Range<usize>>,
layout_mode: TableLayoutMode,
inline_border_spacing: f32,
+ block_border_spacing: f32,
writing_mode: WritingMode,
}
@@ -274,7 +282,31 @@ where
{
let mut context = build_table_context(world, root);
context.collect_cell_inline_constraints(world);
- let grid_inputs = context.resolve_column_tracks(inputs);
+ let mut grid_inputs = context.resolve_column_tracks(inputs);
+ let allocated_wrapper = world.boxes[root.index()]
+ .layout_parent
+ .is_some_and(|parent| {
+ let display = world.boxes[parent.index()].style.display();
+ display.is_flex_container() || display.is_grid_container()
+ });
+ if allocated_wrapper && !context.captions.is_empty() {
+ let mut space = grid_inputs.constraint_space(context.writing_mode);
+ if let Some(block_size) = space.known_size.block_size {
+ // Flex/Grid allocate the complete wrapper. Caption space must not
+ // be allocated to the table grid a second time.
+ let captions = layout_captions(
+ world,
+ &context.captions,
+ space.known_size.inline_size.unwrap_or(0.0),
+ 0.0,
+ context.writing_mode,
+ RunMode::ComputeSize,
+ );
+ space.known_size.block_size = Some((block_size - captions).max(0.0));
+ grid_inputs = space.into_layout_input();
+ }
+ }
+ let grid_inputs = context.resolve_row_tracks(world, grid_inputs);
let mut output = {
let mut wrapper = TableTreeWrapper {
world,
@@ -283,7 +315,7 @@ where
compute_grid_layout(&mut wrapper, NodeId::from(0usize), grid_inputs)
};
- if inputs.run_mode == RunMode::PerformLayout {
+ {
let caption_parent_writing_mode = world.boxes[root.index()].style.writing_mode();
let top_captions = context
.captions
@@ -303,16 +335,21 @@ where
output.size.width,
0.0,
caption_parent_writing_mode,
+ inputs.run_mode,
);
- shift_grid_children(world, &context.cells, top_height);
let bottom_height = layout_captions(
world,
&bottom_captions,
output.size.width,
top_height + output.size.height,
caption_parent_writing_mode,
+ inputs.run_mode,
);
- apply_structural_layout(world, root, &context, top_height, output.size);
+ if inputs.run_mode == RunMode::PerformLayout {
+ context.align_row_baselines(world, &mut output);
+ shift_grid_children(world, &context.cells, top_height);
+ apply_structural_layout(world, root, &context, top_height, output.size);
+ }
if let Some(first_baseline) = &mut output.first_baselines.y {
*first_baseline += top_height;
}
@@ -351,6 +388,8 @@ where
let mut columns = Vec::new();
let mut max_columns = 0usize;
let mut column_tracks = Vec::new();
+ let mut sections = Vec::new();
+ let mut section_boxes = Vec::new();
let layout_mode = if root_style.uses_fixed_table_layout() {
TableLayoutMode::Fixed
} else {
@@ -361,7 +400,31 @@ where
collect_columns(world, column, None, &mut columns, &mut column_tracks);
}
for section in grouped_children.sections() {
+ let start = rows.len();
collect_rows(world, section, None, &mut rows, &mut cells);
+ {
+ let dimension = writing_mode
+ .to_logical(world.boxes[section.index()].style.taffy.size)
+ .block_size;
+ let is_group = matches!(
+ world.boxes[section.index()].kind,
+ LayoutBoxKind::TableRowGroup
+ | LayoutBoxKind::TableHeaderGroup
+ | LayoutBoxKind::TableFooterGroup
+ | LayoutBoxKind::AnonymousTableRowGroup
+ );
+ sections.push(rows::SectionConstraint {
+ rows: start..rows.len(),
+ fixed: (is_group && dimension.tag() == taffy::CompactLength::LENGTH_TAG)
+ .then(|| dimension.value().max(0.0)),
+ percent: (is_group && dimension.tag() == taffy::CompactLength::PERCENT_TAG)
+ .then(|| dimension.value().max(0.0)),
+ is_body: Some(section) != grouped_children.header
+ && Some(section) != grouped_children.footer,
+ size: 0.0,
+ });
+ section_boxes.push(section);
+ }
}
place_table_cells(&mut cells, &rows, &mut max_columns);
max_columns = max_columns.max(column_tracks.len()).max(1);
@@ -376,7 +439,7 @@ where
end: style_helpers::span(cell.row_span as u16),
};
clear_table_cell_inline_sizing(&mut cell.style, writing_mode);
- normalize_table_cell_block_sizing(&mut cell.style, writing_mode);
+ block::clear_cell_block_sizing(&mut cell.style, writing_mode);
}
let placeholder_track: taffy::TrackSizingFunction = style_helpers::auto();
style.grid_template_columns =
@@ -384,7 +447,7 @@ where
style.grid_template_rows = if rows.is_empty() {
vec![style_helpers::auto()]
} else {
- rows.iter().map(|row| row.track.into()).collect()
+ vec![style_helpers::auto(); rows.len()]
};
style.gap = Size {
width: style_helpers::length(spacing.width),
@@ -411,8 +474,13 @@ where
collapsed_borders: collapsed,
column_count: max_columns,
column_constraints: column_tracks,
+ column_sizes: Vec::new(),
+ sections,
+ section_boxes,
+ section_tracks: Vec::new(),
layout_mode,
inline_border_spacing: spacing.width,
+ block_border_spacing: spacing.height,
writing_mode,
}
}
@@ -518,12 +586,13 @@ impl TableContext {
)
};
self.style.grid_template_columns = column_sizes
- .into_iter()
- .map(|size| {
+ .iter()
+ .map(|&size| {
let track: taffy::TrackSizingFunction = style_helpers::length(size);
track.into()
})
.collect();
+ self.column_sizes = column_sizes;
let numeric_inline_size = if self.style.box_sizing == taffy::BoxSizing::ContentBox {
(used_inline_size - inline_insets).max(0.0)
@@ -718,9 +787,7 @@ fn collect_rows<N>(
id: current,
group,
index: row_index,
- track: minimum_dimension_track(
- world.boxes[current.index()].style.taffy.size.height,
- ),
+ grid_index: row_index,
});
for cell in world.boxes[current.index()].children.iter().copied() {
if !matches!(
@@ -752,6 +819,7 @@ fn collect_rows<N>(
column: 0,
row_span,
column_span,
+ block_layout: None,
});
}
}
@@ -848,20 +916,6 @@ fn dimension_track(dimension: Dimension) -> TableColumnConstraint {
}
}
-fn minimum_dimension_track(dimension: Dimension) -> taffy::TrackSizingFunction {
- match dimension.tag() {
- taffy::CompactLength::LENGTH_TAG => style_helpers::minmax(
- style_helpers::length(dimension.value()),
- style_helpers::auto(),
- ),
- taffy::CompactLength::PERCENT_TAG => style_helpers::minmax(
- style_helpers::percent(dimension.value()),
- style_helpers::auto(),
- ),
- _ => style_helpers::auto(),
- }
-}
-
fn authored_table_cell_inline_constraint(
style: &Style<Atom>,
table_writing_mode: WritingMode,
@@ -1047,22 +1101,6 @@ fn clear_table_cell_inline_sizing(style: &mut Style<Atom>, writing_mode: Writing
set_physical_inline_dimension(writing_mode, &mut style.max_size, Dimension::auto());
}
-fn normalize_table_cell_block_sizing(style: &mut Style<Atom>, writing_mode: WritingMode) {
- let size = writing_mode.to_logical(style.size).block_size;
- let min_size = writing_mode.to_logical(style.min_size).block_size;
- if writing_mode.is_horizontal() {
- if min_size.is_auto() {
- style.min_size.height = size;
- }
- style.size.height = Dimension::auto();
- } else {
- if min_size.is_auto() {
- style.min_size.width = size;
- }
- style.size.width = Dimension::auto();
- }
-}
-
fn set_physical_inline_dimension(
writing_mode: WritingMode,
size: &mut Size<Dimension>,
@@ -1081,6 +1119,7 @@ fn layout_captions<N>(
width: f32,
mut y: f32,
parent_writing_mode: WritingMode,
+ run_mode: RunMode,
) -> f32
where
N: Copy + Debug + Eq + Hash,
@@ -1112,20 +1151,22 @@ where
},
sizing_mode: SizingMode::InherentSize,
sizing_purpose: SizingPurpose::Layout,
- run_mode: RunMode::PerformLayout,
+ run_mode,
axis: taffy::RequestedAxis::Both,
block_auto_behavior: AutoSizeBehavior::FitContent,
vertical_margins_are_collapsible: Line::FALSE,
};
let output = world.compute_child_layout(caption.to_taffy(), inputs);
- set_box_layout(
- world,
- caption,
- Point { x: margin.left, y },
- output,
- order,
- Some(width),
- );
+ if run_mode == RunMode::PerformLayout {
+ set_box_layout(
+ world,
+ caption,
+ Point { x: margin.left, y },
+ output,
+ order,
+ Some(width),
+ );
+ }
y += output.size.height + margin.bottom;
}
y - start
@@ -1169,9 +1210,50 @@ fn apply_structural_layout<N>(
let row_starts = track_starts(origin.y, &detailed.rows.sizes, &detailed.rows.gutters);
let column_starts = track_starts(origin.x, &detailed.columns.sizes, &detailed.columns.gutters);
let content_width = track_extent(&detailed.columns.sizes, &detailed.columns.gutters);
- let content_height = track_extent(&detailed.rows.sizes, &detailed.rows.gutters);
+ // Empty tables retain spacing in their intrinsic inline contribution,
+ // while their row/group rectangles span the content box when no real
+ // columns exist. Keep that distinction out of column sizing.
+ let empty_inline_spacing = if context.cells.is_empty() && context.columns.is_empty() {
+ context.inline_border_spacing
+ } else {
+ 0.0
+ };
+ let part_x = origin.x - empty_inline_spacing;
+ let part_width = content_width + 2.0 * empty_inline_spacing;
+ let occupied_sections = || {
+ context
+ .sections
+ .iter()
+ .zip(&context.section_tracks)
+ .filter(|(section, _)| !section.rows.is_empty() || section.size > 0.0)
+ };
+ let first_section_track = occupied_sections()
+ .next()
+ .map_or(0, |(_, range)| range.start);
+ let last_section_track = occupied_sections()
+ .next_back()
+ .map_or(detailed.rows.sizes.len(), |(_, range)| range.end);
+ let content_top = row_starts
+ .get(first_section_track)
+ .copied()
+ .unwrap_or(origin.y);
+ let content_height = track_range_extent(
+ &detailed.rows.sizes,
+ &detailed.rows.gutters,
+ first_section_track,
+ last_section_track,
+ );
if context.collapsed_borders {
- let mut row_lines = row_starts.clone();
+ // Border conflicts are indexed by actual rows. Empty-section tracks
+ // occupy space but must not change the conflict grid's row count.
+ let mut row_lines: Vec<_> = context
+ .rows
+ .iter()
+ .map(|row| row_starts[row.grid_index])
+ .collect();
+ if let Some(first) = row_lines.first_mut() {
+ *first = origin.y;
+ }
row_lines.push(origin.y + content_height);
let mut column_lines = column_starts.clone();
column_lines.push(origin.x + content_width);
@@ -1179,31 +1261,33 @@ fn apply_structural_layout<N>(
}
for row in &context.rows {
- let y = row_starts.get(row.index).copied().unwrap_or(origin.y);
- let height = detailed.rows.sizes.get(row.index).copied().unwrap_or(0.0);
- set_table_part_layout(world, row.id, origin.x, y, content_width, height);
+ let y = row_starts.get(row.grid_index).copied().unwrap_or(origin.y);
+ let height = detailed
+ .rows
+ .sizes
+ .get(row.grid_index)
+ .copied()
+ .unwrap_or(0.0);
+ set_table_part_layout(world, row.id, part_x, y, part_width, height);
}
- let mut groups = context
- .rows
- .iter()
- .filter_map(|row| row.group)
- .collect::<Vec<_>>();
- groups.sort_by_key(|id| id.index());
- groups.dedup();
- for group in groups {
- let group_rows = context.rows.iter().filter(|row| row.group == Some(group));
- let mut start = usize::MAX;
- let mut end = 0usize;
- for row in group_rows {
- start = start.min(row.index);
- end = end.max(row.index + 1);
- }
- if start != usize::MAX {
- let y = row_starts.get(start).copied().unwrap_or(origin.y);
- let height =
- track_range_extent(&detailed.rows.sizes, &detailed.rows.gutters, start, end);
- set_table_part_layout(world, group, origin.x, y, content_width, height);
+ for (&group, tracks) in context.section_boxes.iter().zip(&context.section_tracks) {
+ if matches!(
+ world.boxes[group.index()].kind,
+ LayoutBoxKind::TableRow | LayoutBoxKind::AnonymousTableRow
+ ) {
+ continue;
}
+ let y = row_starts
+ .get(tracks.start)
+ .copied()
+ .unwrap_or(origin.y + content_height);
+ let height = track_range_extent(
+ &detailed.rows.sizes,
+ &detailed.rows.gutters,
+ tracks.start,
+ tracks.end,
+ );
+ set_table_part_layout(world, group, part_x, y, part_width, height);
}
for column in &context.columns {
let x = column_starts.get(column.start).copied().unwrap_or(origin.x);
@@ -1213,7 +1297,7 @@ fn apply_structural_layout<N>(
column.start,
column.start.saturating_add(column.span),
);
- set_table_part_layout(world, column.id, x, origin.y, width, content_height);
+ set_table_part_layout(world, column.id, x, content_top, width, content_height);
}
let mut column_groups = context
.columns
@@ -1241,7 +1325,7 @@ fn apply_structural_layout<N>(
start,
end,
);
- set_table_part_layout(world, group, x, origin.y, width, content_height);
+ set_table_part_layout(world, group, x, content_top, width, content_height);
}
}
@@ -1451,19 +1535,26 @@ where
fn compute_child_layout(&mut self, node_id: NodeId, inputs: LayoutInput) -> LayoutOutput {
let cell_index = usize::from(node_id);
+ let layout = self.context.cells[cell_index].block_layout;
+ let mode = self.context.writing_mode;
// The virtual table grid owns the used grid-item style: margins are
// zero, column sizing has consumed every applicable inline constraint,
// and cell block size is a minimum contribution.
- self.with_grid_cell_style(cell_index, |world, cell| {
- world.compute_child_layout(cell.to_taffy(), inputs)
- })
+ let output = self.with_grid_cell_style(cell_index, |world, cell| {
+ block::layout_cell(world, cell, inputs, mode, layout)
+ });
+ if inputs.run_mode == RunMode::PerformLayout
+ && let Some(layout) = &mut self.context.cells[cell_index].block_layout
+ && layout.baseline.is_some()
+ {
+ layout.baseline = output.first_baselines.y;
+ }
+ output
}
fn compute_child_size(&mut self, node_id: NodeId, inputs: LayoutInput) -> IntrinsicSizeResult {
- let cell_index = usize::from(node_id);
- self.with_grid_cell_style(cell_index, |world, cell| {
- world.compute_child_size(cell.to_taffy(), inputs)
- })
+ self.compute_child_layout(node_id, inputs)
+ .into_intrinsic_size_result()
}
}
@@ -1496,6 +1587,127 @@ where
mod tests {
use super::*;
+ #[test]
+ fn row_group_and_caption_sizes_agree_in_cold_measurement_and_warm_layout() {
+ use crate::{LayoutDisplay, PaintColor, ResolvedLayoutStyle};
+
+ let make_box = |kind, display, height: Option<f32>| {
+ LayoutWorld::<usize>::new_box(
+ None,
+ None,
+ None,
+ "table-height-test".into(),
+ None,
+ None,
+ None,
+ kind,
+ ResolvedLayoutStyle::synthetic(
+ display,
+ Style {
+ size: Size {
+ width: Dimension::length(200.0),
+ height: height.map_or(Dimension::auto(), Dimension::length),
+ },
+ ..Style::default()
+ },
+ PaintColor::TRANSPARENT,
+ ),
+ None,
+ )
+ };
+ let mut world = LayoutWorld::new(
+ make_box(LayoutBoxKind::TableWrapper, LayoutDisplay::Table, None),
+ false,
+ );
+ let root = world.root();
+ let caption = world.allocate(make_box(
+ LayoutBoxKind::TableCaption,
+ LayoutDisplay::TableCaption,
+ Some(20.0),
+ ));
+ let group = world.allocate(make_box(
+ LayoutBoxKind::TableRowGroup,
+ LayoutDisplay::TableRowGroup,
+ Some(80.0),
+ ));
+ world.boxes[root.index()].children = vec![caption, group];
+ let mut cells = Vec::new();
+ for height in [10.0, 30.0] {
+ let row = world.allocate(make_box(
+ LayoutBoxKind::TableRow,
+ LayoutDisplay::TableRow,
+ None,
+ ));
+ let cell = world.allocate(make_box(
+ LayoutBoxKind::TableCell,
+ LayoutDisplay::TableCell,
+ Some(height),
+ ));
+ world.boxes[group.index()].children.push(row);
+ world.boxes[row.index()].children.push(cell);
+ cells.push(cell);
+ }
+ prepare_table_layout_trees(&mut world);
+ let inputs = LayoutInput {
+ known_dimensions: Size {
+ width: Some(200.0),
+ height: None,
+ },
+ definite_dimensions: Size {
+ width: Some(200.0),
+ height: None,
+ },
+ parent_size: Size {
+ width: Some(200.0),
+ height: None,
+ },
+ parent_writing_mode: WritingMode::HorizontalTb,
+ available_space: Size {
+ width: AvailableSpace::Definite(200.0),
+ height: AvailableSpace::MaxContent,
+ },
+ run_mode: RunMode::ComputeSize,
+ sizing_mode: SizingMode::InherentSize,
+ sizing_purpose: SizingPurpose::Layout,
+ axis: RequestedAxis::Both,
+ block_auto_behavior: AutoSizeBehavior::FitContent,
+ vertical_margins_are_collapsible: Line::FALSE,
+ };
+ let cold = world.compute_child_layout(root.to_taffy(), inputs);
+ assert_eq!(
+ cold.size,
+ Size {
+ width: 200.0,
+ height: 100.0
+ }
+ );
+ for id in cells.iter().chain([&caption, &group]) {
+ assert_eq!(world.boxes[id.index()].unrounded_layout.size, Size::ZERO);
+ }
+ let final_layout = world.compute_child_layout(
+ root.to_taffy(),
+ LayoutInput {
+ run_mode: RunMode::PerformLayout,
+ ..inputs
+ },
+ );
+ let warm = world.compute_child_layout(root.to_taffy(), inputs);
+ assert_eq!(cold.size, final_layout.size);
+ assert_eq!(cold.size, warm.size);
+ assert_eq!(
+ world.boxes[group.index()].unrounded_layout.size.height,
+ 80.0
+ );
+ assert_eq!(
+ world.boxes[cells[0].index()].unrounded_layout.size.height,
+ 20.0
+ );
+ assert_eq!(
+ world.boxes[cells[1].index()].unrounded_layout.size.height,
+ 60.0
+ );
+ }
+
#[test]
fn percentage_dependent_fixed_table_has_unbounded_parent_max_content_size() {
let grid = columns::TableGridInlineMinMax { min: 4.0, max: 4.0 };
diff --git a/moli-layout/src/table/block.rs b/moli-layout/src/table/block.rs
new file mode 100644
index 000000000..b62eb7592
--- /dev/null
+++ b/moli-layout/src/table/block.rs
@@ -0,0 +1,536 @@
+//! Measure cells at resolved column widths and pass solved rows to Grid.
+use super::*;
+use rows::{RowConstraint, RowspanConstraint};
+
+#[derive(Clone, Copy)]
+pub(super) struct CellBlockLayout {
+ pub size: f32,
+ pub natural_size: f32,
+ pub definite: bool,
+ pub baseline: Option<f32>,
+}
+
+pub(super) fn set_block<T>(mode: WritingMode, size: &mut Size<T>, value: T) {
+ if mode.is_horizontal() {
+ size.height = value;
+ } else {
+ size.width = value;
+ }
+}
+
+pub(super) fn clear_cell_block_sizing(style: &mut Style<Atom>, mode: WritingMode) {
+ set_block(mode, &mut style.size, Dimension::auto());
+ set_block(mode, &mut style.min_size, Dimension::auto());
+ set_block(mode, &mut style.max_size, Dimension::auto());
+}
+
+fn fixed(dimension: Dimension) -> Option<f32> {
+ (dimension.tag() == taffy::CompactLength::LENGTH_TAG).then(|| dimension.value().max(0.0))
+}
+
+fn percent(dimension: Dimension) -> Option<f32> {
+ (dimension.tag() == taffy::CompactLength::PERCENT_TAG).then(|| dimension.value().max(0.0))
+}
+
+fn block_sum(mode: WritingMode, rect: Rect<f32>) -> f32 {
+ if mode.is_horizontal() {
+ rect.top + rect.bottom
+ } else {
+ rect.left + rect.right
+ }
+}
+
+impl TableContext {
+ pub(super) fn align_row_baselines<N>(
+ &self,
+ world: &mut LayoutWorld<N>,
+ output: &mut LayoutOutput,
+ ) where
+ N: Copy + Debug + Eq + Hash,
+ {
+ let mut baselines: Vec<Option<f32>> = vec![None; self.rows.len()];
+ for cell in &self.cells {
+ if let Some(baseline) = cell.block_layout.and_then(|layout| layout.baseline) {
+ baselines[cell.row] = Some(baselines[cell.row].unwrap_or(0.0).max(baseline));
+ }
+ }
+ for cell in &self.cells {
+ if let Some(baseline) = cell.block_layout.and_then(|layout| layout.baseline) {
+ let offset = baselines[cell.row].unwrap_or(baseline) - baseline;
+ if offset > 0.0 {
+ shift_cell_contents(world, cell.id, offset);
+ }
+ }
+ }
+ if let Some(detailed) = &self.detailed {
+ let padding = self
+ .style
+ .padding
+ .resolve_or_zero(Some(output.size.width), resolve_stylo_calc_value);
+ let border = self
+ .style
+ .border
+ .resolve_or_zero(Some(output.size.width), resolve_stylo_calc_value);
+ let starts = track_starts(
+ padding.top + border.top,
+ &detailed.rows.sizes,
+ &detailed.rows.gutters,
+ );
+ if let Some(Some(baseline)) = baselines.first() {
+ output.first_baselines.y = Some(starts[self.rows[0].grid_index] + baseline);
+ }
+ if let Some(Some(baseline)) = baselines.last() {
+ output.last_baselines.y =
+ Some(starts[self.rows.last().unwrap().grid_index] + baseline);
+ }
+ }
+ }
+
+ pub(super) fn resolve_row_tracks<N>(
+ &mut self,
+ world: &mut LayoutWorld<N>,
+ inputs: LayoutInput,
+ ) -> LayoutInput
+ where
+ N: Copy + Debug + Eq + Hash,
+ {
+ let mode = self.writing_mode;
+ // Inline-only intrinsic probes do not need a second cell measurement.
+ if inputs.run_mode == RunMode::ComputeSize
+ && inputs.axis == RequestedAxis::from(mode.inline_axis())
+ {
+ return inputs;
+ }
+ let mut space = inputs.constraint_space(mode);
+ let percentage_basis = space.margin_padding_percentage_basis();
+ let padding = self
+ .style
+ .padding
+ .resolve_or_zero(percentage_basis, resolve_stylo_calc_value);
+ let border = self
+ .style
+ .border
+ .resolve_or_zero(percentage_basis, resolve_stylo_calc_value);
+ let insets = block_sum(mode, padding) + block_sum(mode, border);
+ let preferred = mode.to_logical(self.style.size).block_size;
+ let adjustment = if self.style.box_sizing == taffy::BoxSizing::ContentBox {
+ // Outer cell spacing is projected as Grid padding, but belongs
+ // inside the CSS table's content box.
+ insets - 2.0 * self.block_border_spacing
+ } else {
+ 0.0
+ };
+ let resolve = |d: Dimension| {
+ d.maybe_resolve(
+ space.percentage_resolution_size.block_size,
+ resolve_stylo_calc_value,
+ )
+ .map(|v| v + adjustment)
+ };
+ let authored = inputs.sizing_mode == SizingMode::InherentSize;
+ let target = space
+ .known_size
+ .block_size
+ .or_else(|| authored.then(|| resolve(preferred)).flatten());
+ let min = authored
+ .then(|| resolve(mode.to_logical(self.style.min_size).block_size))
+ .flatten();
+ let max = authored
+ .then(|| resolve(mode.to_logical(self.style.max_size).block_size))
+ .flatten();
+ let target = target
+ .map(|v| v.min(max.unwrap_or(f32::INFINITY)))
+ .unwrap_or(0.0)
+ .max(min.unwrap_or(0.0));
+ let mut rows: Vec<_> = self
+ .rows
+ .iter()
+ .map(|row| {
+ let dimension = mode
+ .to_logical(world.boxes[row.id.index()].style.taffy.size)
+ .block_size;
+ RowConstraint {
+ size: fixed(dimension).unwrap_or(0.0),
+ percent: percent(dimension),
+ constrained: fixed(dimension).is_some() || percent(dimension).is_some(),
+ ..Default::default()
+ }
+ })
+ .collect();
+ let mut spans = Vec::new();
+ for index in 0..self.cells.len() {
+ let cell = &self.cells[index];
+ let authored_style = &world.boxes[cell.id.index()].style.taffy;
+ let dimension = mode.to_logical(authored_style.size).block_size;
+ let cell_padding = authored_style
+ .padding
+ .resolve_or_zero(space.known_size.inline_size, resolve_stylo_calc_value);
+ let cell_border = authored_style
+ .border
+ .resolve_or_zero(space.known_size.inline_size, resolve_stylo_calc_value);
+ let cell_insets = block_sum(mode, cell_padding) + block_sum(mode, cell_border);
+ let css_size = outer_fixed_size(dimension, cell_insets, authored_style.box_sizing);
+ let cell_percent = percent(dimension);
+ let baseline_aligned = matches!(
+ world.boxes[cell.id.index()].style.vertical_align().kind,
+ LayoutInlineAlignment::Baseline
+ ) && authored_style.align_content.is_none();
+ let inline = self.column_sizes[cell.column..cell.column + cell.column_span]
+ .iter()
+ .sum::<f32>()
+ + self.inline_border_spacing * cell.column_span.saturating_sub(1) as f32;
+ let measure_inputs = LayoutInput {
+ known_dimensions: mode.to_physical(LogicalSize {
+ inline_size: Some(inline),
+ block_size: None,
+ }),
+ definite_dimensions: mode.to_physical(LogicalSize {
+ inline_size: Some(inline),
+ block_size: None,
+ }),
+ parent_size: mode.to_physical(LogicalSize {
+ inline_size: space.known_size.inline_size,
+ block_size: None,
+ }),
+ parent_writing_mode: mode,
+ available_space: mode.to_physical(LogicalSize {
+ inline_size: AvailableSpace::Definite(inline),
+ block_size: AvailableSpace::MaxContent,
+ }),
+ run_mode: RunMode::ComputeSize,
+ sizing_mode: SizingMode::InherentSize,
+ sizing_purpose: SizingPurpose::Layout,
+ axis: RequestedAxis::Both,
+ block_auto_behavior: AutoSizeBehavior::FitContent,
+ vertical_margins_are_collapsible: Line::FALSE,
+ };
+ // Percentage padding is relative to the table, not the cell's
+ // Grid area. Freeze that basis across both measurement and layout.
+ self.cells[index].style.padding = cell_padding.map(style_helpers::length);
+ let restricted = !preferred.is_auto() || fixed(dimension).is_some();
+ let cell_id = self.cells[index].id;
+ let restored =
+ restrict_scrollable_percentage_children(world, cell_id, mode, restricted);
+ let mut wrapper = TableTreeWrapper {
+ world,
+ context: self,
+ };
+ let output = wrapper.with_grid_cell_style(index, |world, cell| {
+ world.compute_child_layout(cell.to_taffy(), measure_inputs)
+ });
+ for (id, style) in restored {
+ world.boxes[id.index()].style.taffy = style;
+ world.cache_clear(id.to_taffy());
+ }
+ let natural = mode.to_logical(output.size).block_size;
+ let cell = &mut self.cells[index];
+ let baseline = if mode.is_horizontal() {
+ output.first_baselines.y
+ } else {
+ output.first_baselines.x
+ };
+ let end_inset = if mode.is_horizontal() {
+ cell_padding.bottom + cell_border.bottom
+ } else {
+ cell_padding.left + cell_border.left
+ };
+ let baseline = (baseline_aligned && !world.boxes[cell.id.index()].children.is_empty())
+ .then(|| baseline.unwrap_or((natural - end_inset).max(0.0)));
+ cell.block_layout = Some(CellBlockLayout {
+ size: 0.0,
+ natural_size: natural,
+ definite: fixed(dimension).is_some(),
+ baseline,
+ });
+ let row = &mut rows[cell.row];
+ if baseline_aligned && !world.boxes[cell.id.index()].children.is_empty() {
+ row.ascent = Some(row.ascent.unwrap_or(0.0).max(baseline.unwrap_or(0.0)));
+ if cell.row_span == 1 {
+ row.descent = row.descent.max(natural - baseline.unwrap_or(0.0));
+ }
+ }
+ let minimum = natural.max(css_size.unwrap_or(0.0));
+ if cell.row_span == 1 {
+ row.size = row.size.max(minimum);
+ row.constrained |= css_size.is_some() || cell_percent.is_some();
+ if let Some(p) = cell_percent {
+ row.percent = Some(row.percent.unwrap_or(0.0).max(p));
+ }
+ } else {
+ row.has_rowspan_start = true;
+ spans.push(RowspanConstraint {
+ rows: cell.row..cell.row + cell.row_span,
+ size: minimum,
+ });
+ }
+ }
+ rows::resolve_minimums(
+ &mut rows,
+ &mut self.sections,
+ &mut spans,
+ self.block_border_spacing,
+ );
+ let nonempty_sections = self
+ .sections
+ .iter()
+ .filter(|section| !section.rows.is_empty())
+ .count();
+ let minimum = self
+ .sections
+ .iter()
+ .map(|section| section.size)
+ .sum::<f32>()
+ + nonempty_sections.saturating_sub(1) as f32 * self.block_border_spacing
+ + insets
+ - if nonempty_sections == 0 {
+ 2.0 * self.block_border_spacing
+ } else {
+ 0.0
+ };
+ let used = minimum.max(target);
+ rows::distribute_table(
+ &mut rows,
+ &mut self.sections,
+ (used - insets).max(0.0),
+ self.block_border_spacing,
+ );
+ for cell in &mut self.cells {
+ let layout = cell.block_layout.as_mut().unwrap();
+ layout.size = rows[cell.row..cell.row + cell.row_span]
+ .iter()
+ .map(|row| row.size)
+ .sum::<f32>()
+ + cell.row_span.saturating_sub(1) as f32 * self.block_border_spacing;
+ layout.definite |= !preferred.is_auto() && layout.size > layout.natural_size;
+ }
+ let mut tracks = Vec::new();
+ // Empty sections take up height, but do not introduce cell spacing.
+ // With such sections, explicit spacer tracks express the gaps before
+ // real rows and after the table that a uniform Grid gap cannot model.
+ let explicit_spacing = (self.rows.is_empty()
+ || self.sections.iter().any(|section| section.rows.is_empty()))
+ && self.block_border_spacing > 0.0;
+ if explicit_spacing {
+ self.style.gap.height = style_helpers::length(0.0);
+ self.style.padding.top =
+ style_helpers::length((padding.top - self.block_border_spacing).max(0.0));
+ self.style.padding.bottom =
+ style_helpers::length((padding.bottom - self.block_border_spacing).max(0.0));
+ }
+ for section in &self.sections {
+ let mut start = tracks.len();
+ if section.rows.is_empty() {
+ // A section can have height even without a DOM row. Reserve a
+ // numeric track without creating an anonymous CSS row box.
+ tracks.push(section.size);
+ } else {
+ for index in section.rows.clone() {
+ if explicit_spacing {
+ tracks.push(self.block_border_spacing);
+ if index == section.rows.start {
+ start += 1;
+ }
+ }
+ self.rows[index].grid_index = tracks.len();
+ tracks.push(rows[index].size);
+ }
+ }
+ self.section_tracks.push(start..tracks.len());
+ }
+ if explicit_spacing && !self.rows.is_empty() {
+ tracks.push(self.block_border_spacing);
+ }
+ for cell in &mut self.cells {
+ cell.style.grid_row.start = style_helpers::line(
+ (self.rows[cell.row].grid_index + 1).min(i16::MAX as usize) as i16,
+ );
+ cell.style.grid_row.end = style_helpers::span(
+ (self.rows[cell.row + cell.row_span - 1].grid_index
+ - self.rows[cell.row].grid_index
+ + 1)
+ .min(u16::MAX as usize) as u16,
+ );
+ }
+ if tracks.is_empty() {
+ tracks.push(
+ (used - insets
+ + if explicit_spacing {
+ 2.0 * self.block_border_spacing
+ } else {
+ 0.0
+ })
+ .max(0.0),
+ );
+ }
+ self.style.grid_template_rows = tracks
+ .into_iter()
+ .map(|size| {
+ let track: taffy::TrackSizingFunction = style_helpers::length(size);
+ track.into()
+ })
+ .collect();
+ self.style.align_content = Some(taffy::AlignContent::START);
+ set_block(
+ mode,
+ &mut self.style.size,
+ style_helpers::length(if self.style.box_sizing == taffy::BoxSizing::ContentBox {
+ (used - insets
+ + if explicit_spacing {
+ 2.0 * self.block_border_spacing
+ } else {
+ 0.0
+ })
+ .max(0.0)
+ } else {
+ used
+ }),
+ );
+ set_block(mode, &mut self.style.min_size, Dimension::auto());
+ set_block(mode, &mut self.style.max_size, Dimension::auto());
+ space.known_size.block_size = Some(used);
+ // Used geometry alone is not a new percentage-resolution guarantee.
+ space.into_layout_input()
+ }
+}
+
+pub(super) fn layout_cell<N>(
+ world: &mut LayoutWorld<N>,
+ cell: LayoutBoxId,
+ mut inputs: LayoutInput,
+ mode: WritingMode,
+ layout: Option<CellBlockLayout>,
+) -> LayoutOutput
+where
+ N: Copy + Debug + Eq + Hash,
+{
+ let Some(layout) = layout else {
+ return world.compute_child_layout(cell.to_taffy(), inputs);
+ };
+ set_block(mode, &mut inputs.parent_size, None);
+ set_block(
+ mode,
+ &mut inputs.known_dimensions,
+ layout.definite.then_some(layout.size),
+ );
+ set_block(
+ mode,
+ &mut inputs.definite_dimensions,
+ layout.definite.then_some(layout.size),
+ );
+ if !layout.definite {
+ set_block(
+ mode,
+ &mut inputs.available_space,
+ AvailableSpace::MaxContent,
+ );
+ }
+ let mut output = world.compute_child_layout(cell.to_taffy(), inputs);
+ let free = (layout.size - mode.to_logical(output.size).block_size).max(0.0);
+ let alignment = world.boxes[cell.index()].style.taffy.align_content;
+ let offset = if layout.baseline.is_some() {
+ 0.0
+ } else {
+ crate::taffy_tree::single_subject_block_alignment_offset(alignment, free)
+ };
+ if inputs.run_mode == RunMode::PerformLayout && offset != 0.0 {
+ shift_cell_contents(world, cell, offset);
+ }
+ if let Some(baseline) = &mut output.first_baselines.y {
+ *baseline += offset;
+ }
+ if let Some(baseline) = &mut output.last_baselines.y {
+ *baseline += offset;
+ }
+ if layout.baseline.is_some() && output.first_baselines.y.is_none() {
+ // Cells with no line baseline use the content's block-end edge. This
+ // must be sampled again after percentage descendants have laid out.
+ let padding = world.boxes[cell.index()]
+ .style
+ .taffy
+ .padding
+ .resolve_or_zero(inputs.parent_size.width, resolve_stylo_calc_value);
+ output.first_baselines.y = Some(if inputs.run_mode == RunMode::PerformLayout {
+ (output.content_size.height - padding.bottom).max(0.0)
+ } else {
+ layout.baseline.unwrap_or(0.0)
+ });
+ }
+ output.content_size.height += offset;
+ set_block(mode, &mut output.size, layout.size);
+ output
+}
+
+/// Blink's restricted-cell first pass sizes direct scrollable percentage
+/// children to their initial minimum. The normal second pass restores the
+/// authored style and resolves the percentage against the final cell height.
+fn restrict_scrollable_percentage_children<N>(
+ world: &mut LayoutWorld<N>,
+ cell: LayoutBoxId,
+ mode: WritingMode,
+ restricted: bool,
+) -> Vec<(LayoutBoxId, Style<Atom>)>
+where
+ N: Copy + Debug + Eq + Hash,
+{
+ if !restricted {
+ return Vec::new();
+ }
+ let mut restored = Vec::new();
+ for id in world.boxes[cell.index()].layout_children.clone() {
+ let child = &world.boxes[id.index()];
+ let style = &child.style.taffy;
+ if !child.is_replaced()
+ && mode
+ .to_logical(style.size)
+ .block_size
+ .may_have_percentage_dependence()
+ && matches!(
+ child.style.overflow_modes()[usize::from(mode.is_horizontal())],
+ crate::style::LayoutOverflowMode::Auto | crate::style::LayoutOverflowMode::Scroll
+ )
+ {
+ let minimum = mode
+ .to_logical(style.min_size)
+ .block_size
+ .maybe_resolve(None, resolve_stylo_calc_value)
+ .unwrap_or(0.0);
+ restored.push((id, style.clone()));
+ set_block(
+ mode,
+ &mut world.boxes[id.index()].style.taffy.size,
+ Dimension::length(minimum),
+ );
+ world.cache_clear(id.to_taffy());
+ }
+ }
+ restored
+}
+
+fn shift_cell_contents<N>(world: &mut LayoutWorld<N>, cell: LayoutBoxId, offset: f32)
+where
+ N: Copy + Debug + Eq + Hash,
+{
+ for child in world.boxes[cell.index()].layout_children.clone() {
+ if world.boxes[child.index()].style.taffy.position != taffy::Position::Absolute {
+ world.boxes[child.index()].unrounded_layout.location.y += offset;
+ }
+ }
+ if let Some(context) = &mut world.boxes[cell.index()].inline_layout {
+ for line in &mut context.line_placements {
+ line.translate_block_axis(offset);
+ }
+ for line in &mut context.fragments.lines {
+ line.rect.y += offset;
+ line.baseline += offset;
+ if let crate::inline::InlinePaintBounds::Bounded(rect) = &mut line.paint_bounds {
+ rect.y += offset;
+ }
+ }
+ for text in &mut context.fragments.text {
+ text.rect.y += offset;
+ }
+ for fragment in &mut context.fragments.boxes {
+ fragment.rect.y += offset;
+ }
+ }
+}
diff --git a/moli-layout/src/table/rows.rs b/moli-layout/src/table/rows.rs
new file mode 100644
index 000000000..e0a176ed1
--- /dev/null
+++ b/moli-layout/src/table/rows.rs
@@ -0,0 +1,269 @@
+//! CSS table block-size constraints, independent of the Grid backend.
+//!
+//! Distribution follows Blink's table_layout_utils.cc: rowspan deficits,
+//! fixed section sizes, then table -> sections -> rows. Content minima are
+//! never shrunk. Percentages retain their section-specific resolution basis.
+
+use std::{cmp::Ordering, ops::Range};
+
+#[derive(Clone, Copy, Debug, Default)]
+pub(super) struct RowConstraint {
+ pub size: f32,
+ pub percent: Option<f32>,
+ pub constrained: bool,
+ pub has_rowspan_start: bool,
+ pub ascent: Option<f32>,
+ pub descent: f32,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct SectionConstraint {
+ pub rows: Range<usize>,
+ pub fixed: Option<f32>,
+ pub percent: Option<f32>,
+ pub is_body: bool,
+ pub size: f32,
+}
+
+#[derive(Clone, Debug)]
+pub(super) struct RowspanConstraint {
+ pub rows: Range<usize>,
+ pub size: f32,
+}
+
+fn extent(rows: &[RowConstraint], spacing: f32) -> f32 {
+ rows.iter().map(|row| row.size).sum::<f32>() + rows.len().saturating_sub(1) as f32 * spacing
+}
+
+// Blink uses LayoutUnit (1/64 CSS px), giving the rounding remainder to the
+// last eligible track. Keep that deterministic behavior for fractional shares.
+fn shares(extra: f32, weights: &[f32]) -> Vec<f32> {
+ let sum = weights.iter().sum::<f32>();
+ let mut remaining = extra;
+ weights
+ .iter()
+ .enumerate()
+ .map(|(index, weight)| {
+ let value = if index + 1 == weights.len() {
+ remaining
+ } else {
+ let ratio = if sum > 0.0 {
+ *weight / sum
+ } else {
+ 1.0 / weights.len() as f32
+ };
+ (extra * ratio * 64.0).floor() / 64.0
+ };
+ remaining -= value;
+ value
+ })
+ .collect()
+}
+
+fn grow_rows(rows: &mut [RowConstraint], indices: &[usize], extra: f32, proportional: bool) {
+ let weights: Vec<_> = indices
+ .iter()
+ .map(|&i| if proportional { rows[i].size } else { 1.0 })
+ .collect();
+ for (&i, delta) in indices.iter().zip(shares(extra, &weights)) {
+ rows[i].size += delta;
+ }
+}
+
+fn distribute_rows(
+ rows: &mut [RowConstraint],
+ target: f32,
+ spacing: f32,
+ basis: Option<f32>,
+ rowspan: bool,
+) {
+ let mut extra = target - extent(rows, spacing);
+ if extra <= 0.0 || rows.is_empty() {
+ return;
+ }
+
+ let deficits: Vec<_> = rows
+ .iter()
+ .map(|row| {
+ row.percent.zip(basis).map_or(0.0, |(percent, basis)| {
+ (percent * basis - row.size).max(0.0)
+ })
+ })
+ .collect();
+ let deficit = deficits.iter().sum::<f32>();
+ if deficit > 0.0 {
+ let amount = extra.min(deficit);
+ let eligible: Vec<_> = deficits
+ .iter()
+ .enumerate()
+ .filter_map(|(i, &d)| (d > 0.0).then_some(i))
+ .collect();
+ let weights: Vec<_> = eligible.iter().map(|&i| deficits[i]).collect();
+ for (&i, delta) in eligible.iter().zip(shares(amount, &weights)) {
+ rows[i].size += delta;
+ }
+ extra -= amount;
+ }
+ if extra <= 0.0 {
+ return;
+ }
+
+ if rowspan {
+ let origins: Vec<_> = (1..rows.len())
+ .filter(|&i| rows[i].has_rowspan_start)
+ .collect();
+ if !origins.is_empty() {
+ grow_rows(rows, &origins, extra, false);
+ return;
+ }
+ }
+ let constrained =
+ |row: &RowConstraint| row.constrained && (row.percent.is_none() || basis.is_some());
+ let auto_nonempty: Vec<_> = (0..rows.len())
+ .filter(|&i| rows[i].size > 0.0 && !constrained(&rows[i]))
+ .collect();
+ if !auto_nonempty.is_empty() {
+ grow_rows(rows, &auto_nonempty, extra, true);
+ return;
+ }
+ let empty: Vec<_> = (0..rows.len()).filter(|&i| rows[i].size == 0.0).collect();
+ if !empty.is_empty() {
+ if rowspan && empty.len() == rows.len() {
+ rows[*empty.last().unwrap()].size += extra;
+ return;
+ }
+ if !rowspan {
+ let auto_empty: Vec<_> = empty
+ .iter()
+ .copied()
+ .filter(|&i| !constrained(&rows[i]))
+ .collect();
+ grow_rows(
+ rows,
+ if auto_empty.is_empty() {
+ &empty
+ } else {
+ &auto_empty
+ },
+ extra,
+ false,
+ );
+ return;
+ }
+ }
+ let nonempty: Vec<_> = (0..rows.len()).filter(|&i| rows[i].size > 0.0).collect();
+ grow_rows(rows, &nonempty, extra, true);
+}
+
+/// Establish the content minimum before resolving the table's own height.
+pub(super) fn resolve_minimums(
+ rows: &mut [RowConstraint],
+ sections: &mut [SectionConstraint],
+ spans: &mut [RowspanConstraint],
+ spacing: f32,
+) {
+ for row in rows.iter_mut() {
+ row.size = row.size.max(row.ascent.unwrap_or(0.0) + row.descent);
+ }
+ for section in sections.iter() {
+ let mut total = 0.0_f32;
+ for row in &mut rows[section.rows.clone()] {
+ if let Some(percent) = &mut row.percent {
+ *percent = percent.min((1.0 - total).max(0.0));
+ total += *percent;
+ }
+ }
+ }
+ spans.sort_by(|a, b| {
+ if a.rows == b.rows {
+ return b.size.total_cmp(&a.size);
+ }
+ if a.rows.start >= b.rows.start && a.rows.end <= b.rows.end {
+ return Ordering::Less;
+ }
+ if b.rows.start >= a.rows.start && b.rows.end <= a.rows.end {
+ return Ordering::Greater;
+ }
+ a.rows.start.cmp(&b.rows.start)
+ });
+ for span in spans {
+ distribute_rows(&mut rows[span.rows.clone()], span.size, spacing, None, true);
+ }
+ for section in sections {
+ let group_rows = &mut rows[section.rows.clone()];
+ let minimum = extent(group_rows, spacing);
+ if let Some(fixed) = section.fixed.filter(|&fixed| fixed > minimum) {
+ distribute_rows(group_rows, fixed, spacing, Some(fixed), false);
+ }
+ section.size = extent(group_rows, spacing).max(section.fixed.unwrap_or(0.0));
+ }
+}
+
+/// `target` excludes outer decorations and outer cell spacing, but includes
+/// the gaps between nonempty sections. Empty sections have no grid tracks.
+pub(super) fn distribute_table(
+ rows: &mut [RowConstraint],
+ sections: &mut [SectionConstraint],
+ target: f32,
+ spacing: f32,
+) {
+ if sections.is_empty() {
+ return;
+ }
+ let target = (target - sections.len().saturating_sub(1) as f32 * spacing).max(0.0);
+ let mut extra = target - sections.iter().map(|s| s.size).sum::<f32>();
+ if extra <= 0.0 {
+ return;
+ }
+ let original: Vec<_> = sections.iter().map(|s| s.size).collect();
+ let deficits: Vec<_> = sections
+ .iter()
+ .map(|s| s.percent.map_or(0.0, |p| (p * target - s.size).max(0.0)))
+ .collect();
+ let deficit = deficits.iter().sum::<f32>();
+ if deficit > 0.0 {
+ let amount = extra.min(deficit);
+ let eligible: Vec<_> = (0..sections.len()).filter(|&i| deficits[i] > 0.0).collect();
+ let weights: Vec<_> = eligible.iter().map(|&i| deficits[i]).collect();
+ for (&i, delta) in eligible.iter().zip(shares(amount, &weights)) {
+ sections[i].size += delta;
+ }
+ extra -= amount;
+ }
+ if extra > 0.0 {
+ let has_body = sections.iter().any(|s| s.is_body);
+ let priority = |s: &SectionConstraint| {
+ if s.percent.is_some() {
+ 2
+ } else if s.fixed.is_some() {
+ 1
+ } else {
+ 0
+ }
+ };
+ let rank = sections
+ .iter()
+ .filter(|s| !has_body || s.is_body)
+ .map(priority)
+ .min()
+ .unwrap();
+ let eligible: Vec<_> = (0..sections.len())
+ .filter(|&i| (!has_body || sections[i].is_body) && priority(&sections[i]) == rank)
+ .collect();
+ let weights: Vec<_> = eligible.iter().map(|&i| sections[i].size).collect();
+ for (&i, delta) in eligible.iter().zip(shares(extra, &weights)) {
+ sections[i].size += delta;
+ }
+ }
+ for (section, original) in sections.iter().zip(original) {
+ if section.size > original {
+ distribute_rows(
+ &mut rows[section.rows.clone()],
+ section.size,
+ spacing,
+ Some(section.size),
+ false,
+ );
+ }
+ }
+}
diff --git a/moli-layout/src/taffy_tree.rs b/moli-layout/src/taffy_tree.rs
index b26dd18a1..a56fb6e71 100644
--- a/moli-layout/src/taffy_tree.rs
+++ b/moli-layout/src/taffy_tree.rs
@@ -3115,7 +3115,10 @@ impl InlineMeasurement {
/// this adapter boundary instead. This is the leaf equivalent of Chromium's
/// `AlignBlockContent` plus `BoxFragmentBuilder::MoveChildrenInDirection`, not
/// a post-layout paint translation.
-fn single_subject_block_alignment_offset(alignment: Option<AlignContent>, free_space: f32) -> f32 {
+pub(crate) fn single_subject_block_alignment_offset(
+ alignment: Option<AlignContent>,
+ free_space: f32,
+) -> f32 {
let Some(alignment) = alignment else {
return 0.0;
};