Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::{
TABLE_MAX_INLINE_SIZE, TableCellSpanConstraint, TableColumnConstraint, TableLayoutMode,
};
use crate::LAYOUT_SUBPIXELS_PER_CSS_PIXEL;
/// Compare sizes at Blink's 26.6 `LayoutUnit` boundary.
///
/// Table distribution still uses floats internally, but the exact-maximum
/// branch is observable only after the shared layout quantization. Comparing
/// the corresponding fixed-point values avoids both addition-order noise and
/// a table-specific magic epsilon.
fn same_layout_unit(left: f32, right: f32) -> bool {
let raw = |value: f32| {
(f64::from(value.max(0.0)) * f64::from(LAYOUT_SUBPIXELS_PER_CSS_PIXEL)).trunc() as i64
};
raw(left) == raw(right)
}
/// Whether excess inline size came from a definite table constraint or from
/// an intrinsic colspan contribution.
///
/// The distinction only matters above the maximum guess: a definite table may
/// grow constrained columns, while an unconstrained intrinsic contribution
/// must leave their authored maximum intact.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(in crate::table) enum AutomaticTableSizingTarget {
Constrained,
Intrinsic,
}
impl AutomaticTableSizingTarget {
const fn grows_constrained_columns(self) -> bool {
matches!(self, Self::Constrained)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum AutomaticColumnClass {
Percentage,
Constrained,
Automatic,
}
impl AutomaticColumnClass {
fn classify(column: TableColumnConstraint) -> Self {
if column.percent.is_some() {
Self::Percentage
} else if column.is_constrained {
Self::Constrained
} else {
Self::Automatic
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum DistributionPhase {
Minimum,
Percentage,
Specified,
Maximum,
AboveMaximum,
}
/// The four guesses from CSS Tables 3's width-distribution algorithm.
/// Named fields make phase boundaries explicit and prevent an array index
/// from silently coupling two different guesses.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct AutomaticColumnGuesses {
minimum: f32,
percentage: f32,
specified: f32,
maximum: f32,
}
impl AutomaticColumnGuesses {
fn collect(target_inline_size: f32, constraints: &[TableColumnConstraint]) -> Self {
let mut guesses = Self::default();
for column in constraints.iter().copied() {
let min = column_min(column);
let max = column_max(column);
guesses.minimum += min;
match AutomaticColumnClass::classify(column) {
AutomaticColumnClass::Percentage => {
let percentage = resolved_percentage_size(column, target_inline_size);
guesses.percentage += percentage;
guesses.specified += percentage;
guesses.maximum += percentage;
}
AutomaticColumnClass::Constrained => {
guesses.percentage += min;
guesses.specified += max;
guesses.maximum += max;
}
AutomaticColumnClass::Automatic => {
guesses.percentage += min;
guesses.specified += min;
guesses.maximum += max;
}
}
}
guesses
}
fn phase_for(self, target_inline_size: f32) -> DistributionPhase {
if target_inline_size <= self.minimum {
DistributionPhase::Minimum
} else if target_inline_size <= self.percentage {
DistributionPhase::Percentage
} else if target_inline_size <= self.specified {
DistributionPhase::Specified
} else if target_inline_size <= self.maximum
|| same_layout_unit(target_inline_size, self.maximum)
{
DistributionPhase::Maximum
} else {
DistributionPhase::AboveMaximum
}
}
}
#[derive(Clone, Copy, Debug)]
enum GrowthRule {
PercentageTowardResolved { target_inline_size: f32 },
ConstrainedTowardMaximum,
AutomaticTowardMaximum,
AutomaticAboveMaximum,
ConstrainedAboveMaximum,
PercentageAboveMaximum,
}
impl GrowthRule {
fn receives(self, column: TableColumnConstraint) -> bool {
let class = AutomaticColumnClass::classify(column);
match self {
Self::PercentageTowardResolved { .. } | Self::PercentageAboveMaximum => {
class == AutomaticColumnClass::Percentage
}
Self::ConstrainedTowardMaximum | Self::ConstrainedAboveMaximum => {
class == AutomaticColumnClass::Constrained
}
Self::AutomaticTowardMaximum | Self::AutomaticAboveMaximum => {
class == AutomaticColumnClass::Automatic
}
}
}
fn weight(self, column: TableColumnConstraint) -> f32 {
match self {
Self::PercentageTowardResolved { target_inline_size } => {
resolved_percentage_size(column, target_inline_size) - column_min(column)
}
Self::ConstrainedTowardMaximum | Self::AutomaticTowardMaximum => {
column_max(column) - column_min(column)
}
Self::AutomaticAboveMaximum | Self::ConstrainedAboveMaximum => column_max(column),
Self::PercentageAboveMaximum => column.percent.unwrap_or(0.0),
}
.max(0.0)
}
}
fn column_min(column: TableColumnConstraint) -> f32 {
column.min_inline_size_or_zero().max(0.0)
}
fn column_max(column: TableColumnConstraint) -> f32 {
column
.max_inline_size
.unwrap_or(0.0)
.max(column_min(column))
}
fn resolved_percentage_size(column: TableColumnConstraint, target_inline_size: f32) -> f32 {
column
.resolved_percent(target_inline_size)
.unwrap_or_else(|| column_min(column))
}
/// Intrinsic border-box limits for a table grid.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub(in crate::table) struct TableGridInlineMinMax {
pub(in crate::table) min: f32,
pub(in crate::table) max: f32,
}
/// Compute CSS Tables GRID_MIN/GRID_MAX, including decorations and spacing
/// that cannot be assigned to an individual column.
pub(in crate::table) fn compute_grid_inline_min_max(
constraints: &[TableColumnConstraint],
undistributable_space: f32,
layout_mode: TableLayoutMode,
) -> TableGridInlineMinMax {
let mut min = 0.0f32;
let mut max = 0.0f32;
let mut percent_max_estimate = 0.0f32;
let mut non_percent_max_sum = 0.0f32;
let mut percent_sum = 0.0f32;
for column in constraints.iter().copied() {
let column_max = column
.max_inline_size
.unwrap_or(0.0)
.max(column.min_inline_size_or_zero());
if layout_mode.is_fixed() && column.fixed_inline_size().is_some() {
min += column_max;
} else {
min += column.min_inline_size_or_zero();
}
max += column_max;
if let Some(percent) = column.percent {
percent_sum += percent;
if percent > 0.0 && column_max > 0.0 {
percent_max_estimate = percent_max_estimate
.max((column_max - column.percent_border_padding).max(0.0) / percent);
}
} else {
non_percent_max_sum += column_max;
}
}
percent_sum = percent_sum.clamp(0.0, 1.0);
if percent_sum > 0.0 {
if non_percent_max_sum > 0.0 {
let size_from_percent_and_fixed = if percent_sum >= 1.0 {
TABLE_MAX_INLINE_SIZE
} else {
non_percent_max_sum / (1.0 - percent_sum)
};
max = max.max(size_from_percent_and_fixed);
}
max = max.max(percent_max_estimate);
}
let undistributable_space = undistributable_space.max(0.0);
min += undistributable_space;
max = max.max(min - undistributable_space) + undistributable_space;
TableGridInlineMinMax { min, max }
}
/// Distribute an automatic table's assignable inline size using the CSS
/// Tables minimum, percentage, specified and maximum guesses.
pub(in crate::table) fn distribute_auto_columns(
target_inline_size: f32,
constraints: &[TableColumnConstraint],
sizing_target: AutomaticTableSizingTarget,
) -> Vec<f32> {
if constraints.is_empty() {
return Vec::new();
}
let guesses = AutomaticColumnGuesses::collect(target_inline_size, constraints);
let target = target_inline_size.max(guesses.minimum).max(0.0);
let phase = guesses.phase_for(target);
let mut sizes = constraints
.iter()
.copied()
.map(column_min)
.collect::<Vec<_>>();
let fills_target = match phase {
DistributionPhase::Minimum => true,
DistributionPhase::Percentage => {
distribute_growth(
&mut sizes,
constraints,
target - guesses.minimum,
GrowthRule::PercentageTowardResolved {
target_inline_size: target,
},
);
true
}
DistributionPhase::Specified => {
set_percentage_columns(&mut sizes, constraints, target);
distribute_growth(
&mut sizes,
constraints,
target - guesses.percentage,
GrowthRule::ConstrainedTowardMaximum,
);
true
}
DistributionPhase::Maximum => {
let exact_match = same_layout_unit(target, guesses.maximum);
for (size, column) in sizes.iter_mut().zip(constraints.iter().copied()) {
*size = match AutomaticColumnClass::classify(column) {
AutomaticColumnClass::Percentage => resolved_percentage_size(column, target),
AutomaticColumnClass::Constrained => column_max(column),
AutomaticColumnClass::Automatic if exact_match => column_max(column),
AutomaticColumnClass::Automatic => column_min(column),
};
}
if !exact_match {
distribute_growth(
&mut sizes,
constraints,
target - guesses.specified,
GrowthRule::AutomaticTowardMaximum,
);
}
true
}
DistributionPhase::AboveMaximum => {
for (size, column) in sizes.iter_mut().zip(constraints.iter().copied()) {
*size = match AutomaticColumnClass::classify(column) {
AutomaticColumnClass::Percentage => resolved_percentage_size(column, target),
AutomaticColumnClass::Constrained | AutomaticColumnClass::Automatic => {
column_max(column)
}
};
}
let growth_rule = above_maximum_growth_rule(constraints, sizing_target);
if let Some(growth_rule) = growth_rule {
distribute_growth(
&mut sizes,
constraints,
target - guesses.maximum,
growth_rule,
);
true
} else {
// An intrinsic colspan maximum does not enlarge columns that
// are all explicitly constrained.
false
}
}
};
if fills_target {
absorb_remainder(&mut sizes, target);
}
sizes
}
fn distribute_growth(
sizes: &mut [f32],
constraints: &[TableColumnConstraint],
distributable: f32,
rule: GrowthRule,
) {
let recipient_count = constraints
.iter()
.copied()
.filter(|column| rule.receives(*column))
.count();
if recipient_count == 0 || distributable <= 0.0 {
return;
}
let total_weight = constraints
.iter()
.copied()
.filter(|column| rule.receives(*column))
.map(|column| rule.weight(column))
.sum::<f32>();
let mut remaining = distributable;
let mut last = None;
for (index, column) in constraints.iter().copied().enumerate() {
if !rule.receives(column) {
continue;
}
last = Some(index);
let delta = if total_weight > 0.0 {
distributable * rule.weight(column) / total_weight
} else {
distributable / recipient_count as f32
};
sizes[index] += delta;
remaining -= delta;
}
if let Some(index) = last {
sizes[index] = (sizes[index] + remaining).max(0.0);
}
}
fn set_percentage_columns(
sizes: &mut [f32],
constraints: &[TableColumnConstraint],
target_inline_size: f32,
) {
for (size, column) in sizes.iter_mut().zip(constraints.iter().copied()) {
if AutomaticColumnClass::classify(column) == AutomaticColumnClass::Percentage {
*size = resolved_percentage_size(column, target_inline_size);
}
}
}
fn above_maximum_growth_rule(
constraints: &[TableColumnConstraint],
sizing_target: AutomaticTableSizingTarget,
) -> Option<GrowthRule> {
let has_class = |class| {
constraints
.iter()
.copied()
.any(|column| AutomaticColumnClass::classify(column) == class)
};
if has_class(AutomaticColumnClass::Automatic) {
Some(GrowthRule::AutomaticAboveMaximum)
} else if sizing_target.grows_constrained_columns()
&& has_class(AutomaticColumnClass::Constrained)
{
Some(GrowthRule::ConstrainedAboveMaximum)
} else if has_class(AutomaticColumnClass::Percentage) {
Some(GrowthRule::PercentageAboveMaximum)
} else {
None
}
}
fn absorb_remainder(sizes: &mut [f32], target: f32) {
let assigned = sizes.iter().sum::<f32>();
if let Some(last) = sizes.last_mut() {
*last = (*last + target - assigned).max(0.0);
}
}
/// Project a wide automatic-layout cell onto the columns it spans. Existing
/// column measures form the lower guesses; the cell's min/max constraints are
/// distributed with the same allocator used for the final table width.
pub(super) fn distribute_auto_cell_spans(
columns: &mut [TableColumnConstraint],
cell_spans: &mut [TableCellSpanConstraint],
inline_border_spacing: f32,
) {
cell_spans.sort_by_key(|constraint| (constraint.span, constraint.start_column));
for constraint in cell_spans {
let Some(available_columns) = columns.get_mut(constraint.start_column..) else {
continue;
};
let effective_span = constraint.span.min(available_columns.len());
if effective_span == 0 {
continue;
}
let column_span = &mut available_columns[..effective_span];
let inner_spacing =
inline_border_spacing.max(0.0) * effective_span.saturating_sub(1) as f32;
let cell_min = (constraint.cell.min_inline_size - inner_spacing).max(0.0);
let cell_max = (constraint.cell.max_inline_size - inner_spacing).max(0.0);
if let Some(cell_percent) = constraint.cell.percent {
let columns_percent = column_span
.iter()
.filter_map(|column| column.percent)
.sum::<f32>();
let surplus = cell_percent - columns_percent;
let non_percent_count = column_span
.iter()
.filter(|column| column.percent.is_none())
.count();
if surplus > 0.0 && non_percent_count > 0 {
let total_max = column_span
.iter()
.filter(|column| column.percent.is_none())
.map(|column| column.max_inline_size.unwrap_or(0.0))
.sum::<f32>();
for column in column_span
.iter_mut()
.filter(|column| column.percent.is_none())
{
let share = if total_max > 0.0 {
surplus * column.max_inline_size.unwrap_or(0.0) / total_max
} else {
surplus / non_percent_count as f32
};
column.percent = Some(share);
}
}
}
let min_sizes = distribute_auto_columns(
cell_min,
column_span,
AutomaticTableSizingTarget::Constrained,
);
for (column, size) in column_span.iter_mut().zip(min_sizes) {
column.min_inline_size = Some(column.min_inline_size_or_zero().max(size));
}
let max_sizing_target = if constraint.cell.is_constrained {
AutomaticTableSizingTarget::Constrained
} else {
AutomaticTableSizingTarget::Intrinsic
};
let max_sizes = distribute_auto_columns(cell_max, column_span, max_sizing_target);
for (column, size) in column_span.iter_mut().zip(max_sizes) {
column.max_inline_size = Some(
column
.max_inline_size
.unwrap_or(0.0)
.max(column.min_inline_size_or_zero())
.max(size),
);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::table::columns::TableCellInlineConstraint;
const CONSTRAINED: AutomaticTableSizingTarget = AutomaticTableSizingTarget::Constrained;
const INTRINSIC: AutomaticTableSizingTarget = AutomaticTableSizingTarget::Intrinsic;
fn assert_sizes(actual_sizes: &[f32], expected_sizes: &[f32]) {
assert_eq!(actual_sizes.len(), expected_sizes.len());
for (index, (actual, expected)) in actual_sizes.iter().zip(expected_sizes).enumerate() {
assert!(
(actual - expected).abs() < 0.001,
"column {index}: expected {expected}, got {actual}; all={actual_sizes:?}",
);
}
}
fn minimum_sizes(columns: &[TableColumnConstraint]) -> Vec<f32> {
columns
.iter()
.map(|column| column.min_inline_size_or_zero())
.collect()
}
fn maximum_sizes(columns: &[TableColumnConstraint]) -> Vec<f32> {
columns
.iter()
.map(|column| column.max_inline_size.unwrap_or(0.0))
.collect()
}
fn automatic(min: f32, max: f32) -> TableColumnConstraint {
TableColumnConstraint {
min_inline_size: Some(min),
max_inline_size: Some(max),
..TableColumnConstraint::auto()
}
}
fn constrained(min: f32, max: f32) -> TableColumnConstraint {
TableColumnConstraint {
is_constrained: true,
..automatic(min, max)
}
}
fn percentage(min: f32, max: f32, ratio: f32, border_padding: f32) -> TableColumnConstraint {
TableColumnConstraint {
percent: Some(ratio),
percent_border_padding: border_padding,
..automatic(min, max)
}
}
#[test]
fn phase_selection_includes_each_guess_boundary() {
let guesses = AutomaticColumnGuesses {
minimum: 30.0,
percentage: 70.0,
specified: 110.0,
maximum: 170.0,
};
let layout_unit = 1.0 / LAYOUT_SUBPIXELS_PER_CSS_PIXEL;
for (target, expected) in [
(10.0, DistributionPhase::Minimum),
(30.0, DistributionPhase::Minimum),
(50.0, DistributionPhase::Percentage),
(70.0, DistributionPhase::Percentage),
(90.0, DistributionPhase::Specified),
(110.0, DistributionPhase::Specified),
(140.0, DistributionPhase::Maximum),
(170.0, DistributionPhase::Maximum),
(170.0 + layout_unit / 2.0, DistributionPhase::Maximum),
(170.0 + layout_unit, DistributionPhase::AboveMaximum),
(171.0, DistributionPhase::AboveMaximum),
] {
assert_eq!(guesses.phase_for(target), expected, "target={target}");
}
}
#[test]
fn minimum_guess_clamps_targets_below_the_intrinsic_floor() {
let constraints = [automatic(30.0, 60.0), constrained(20.0, 40.0)];
assert_sizes(
&distribute_auto_columns(10.0, &constraints, CONSTRAINED),
&[30.0, 20.0],
);
assert_sizes(
&distribute_auto_columns(-100.0, &constraints, CONSTRAINED),
&[30.0, 20.0],
);
assert!(distribute_auto_columns(100.0, &[], CONSTRAINED).is_empty());
}
#[test]
fn percentage_guess_grows_only_percentage_columns() {
let constraints = [percentage(10.0, 10.0, 0.8, 0.0), automatic(20.0, 60.0)];
assert_sizes(
&distribute_auto_columns(50.0, &constraints, CONSTRAINED),
&[30.0, 20.0],
);
assert_sizes(
&distribute_auto_columns(100.0, &constraints, CONSTRAINED),
&[80.0, 20.0],
);
}
#[test]
fn specified_guess_grows_only_constrained_columns() {
let constraints = [
percentage(10.0, 10.0, 0.25, 0.0),
constrained(20.0, 60.0),
automatic(30.0, 90.0),
];
assert_sizes(
&distribute_auto_columns(100.0, &constraints, CONSTRAINED),
&[25.0, 45.0, 30.0],
);
assert_sizes(
&distribute_auto_columns(120.0, &constraints, CONSTRAINED),
&[30.0, 60.0, 30.0],
);
}
#[test]
fn maximum_guess_grows_only_automatic_columns() {
let constraints = [
percentage(10.0, 10.0, 0.25, 0.0),
constrained(20.0, 60.0),
automatic(30.0, 90.0),
];
assert_sizes(
&distribute_auto_columns(150.0, &constraints, CONSTRAINED),
&[37.5, 60.0, 52.5],
);
assert_sizes(
&distribute_auto_columns(200.0, &constraints, CONSTRAINED),
&[50.0, 60.0, 90.0],
);
}
#[test]
fn exact_maximum_preserves_each_automatic_columns_max_content_size() {
// Mirrors Blink's DistributeColspanAutoExactMaxSize regression: when
// the target is exactly the maximum guess, redistributing the tracks
// can move a rounding remainder into one column and wrap content.
let maxima = [0.09375, 22.109_375, 33.781_25, 2_000.343_8];
let constraints = [
automatic(0.0, maxima[0]),
automatic(3.328_125, maxima[1]),
automatic(3.328_125, maxima[2]),
automatic(0.0, maxima[3]),
];
let target = maxima.iter().sum::<f32>();
assert_eq!(
distribute_auto_columns(target, &constraints, CONSTRAINED),
maxima
);
}
#[test]
fn mixed_columns_walk_specified_maximum_and_above_maximum_phases() {
let constraints = [
automatic(20.0, 100.0),
constrained(10.0, 50.0),
percentage(30.0, 30.0, 0.25, 0.0),
];
assert_sizes(
&distribute_auto_columns(90.0, &constraints, CONSTRAINED),
&[20.0, 40.0, 30.0],
);
assert_sizes(
&distribute_auto_columns(150.0, &constraints, CONSTRAINED),
&[62.5, 50.0, 37.5],
);
assert_sizes(
&distribute_auto_columns(400.0, &constraints, CONSTRAINED),
&[250.0, 50.0, 100.0],
);
}
#[test]
fn specified_guess_shrinks_conflicting_authored_widths_proportionally() {
let constraints = [constrained(0.0, 75.0), constrained(0.0, 80.0)];
assert_sizes(
&distribute_auto_columns(100.0, &constraints, CONSTRAINED),
&[48.387_096, 51.612_904],
);
}
#[test]
fn above_maximum_prefers_automatic_columns_and_weights_their_maxima() {
let constraints = [
percentage(10.0, 10.0, 0.25, 0.0),
constrained(20.0, 60.0),
automatic(10.0, 30.0),
automatic(20.0, 90.0),
];
assert_sizes(
&distribute_auto_columns(400.0, &constraints, CONSTRAINED),
&[100.0, 60.0, 60.0, 180.0],
);
}
#[test]
fn above_maximum_distinguishes_definite_tables_from_intrinsic_colspans() {
let constraints = [constrained(20.0, 40.0), constrained(10.0, 60.0)];
assert_sizes(
&distribute_auto_columns(200.0, &constraints, CONSTRAINED),
&[80.0, 120.0],
);
assert_sizes(
&distribute_auto_columns(200.0, &constraints, INTRINSIC),
&[40.0, 60.0],
);
}
#[test]
fn above_maximum_falls_back_to_percentage_then_equal_weight_distribution() {
let percentages = [
percentage(10.0, 10.0, 0.25, 0.0),
percentage(10.0, 10.0, 0.25, 0.0),
];
assert_sizes(
&distribute_auto_columns(200.0, &percentages, INTRINSIC),
&[100.0, 100.0],
);
let zero_weight_automatic = [automatic(0.0, 0.0), automatic(0.0, 0.0)];
assert_sizes(
&distribute_auto_columns(100.0, &zero_weight_automatic, CONSTRAINED),
&[50.0, 50.0],
);
}
#[test]
fn grid_min_max_accounts_for_percentages_fixed_columns_and_spacing() {
let constraints = [
automatic(20.0, 80.0),
constrained(10.0, 40.0),
percentage(30.0, 30.0, 0.25, 5.0),
];
assert_eq!(
compute_grid_inline_min_max(&constraints, 12.0, TableLayoutMode::Automatic),
TableGridInlineMinMax {
min: 72.0,
max: 172.0,
},
);
assert_eq!(
compute_grid_inline_min_max(&constraints, 12.0, TableLayoutMode::Fixed),
TableGridInlineMinMax {
min: 102.0,
max: 172.0,
},
);
}
#[test]
fn grid_max_caps_unbounded_full_percentage_estimates() {
let constraints = [automatic(0.0, 50.0), percentage(0.0, 0.0, 1.0, 0.0)];
assert_eq!(
compute_grid_inline_min_max(&constraints, 5.0, TableLayoutMode::Automatic),
TableGridInlineMinMax {
min: 5.0,
max: TABLE_MAX_INLINE_SIZE + 5.0,
},
);
}
#[test]
fn automatic_colspan_distributes_percentage_and_intrinsic_surplus_exactly() {
let mut columns = [percentage(20.0, 40.0, 0.2, 0.0), automatic(10.0, 60.0)];
let mut spans = [TableCellSpanConstraint {
start_column: 0,
span: 2,
cell: TableCellInlineConstraint {
min_inline_size: 100.0,
max_inline_size: 200.0,
percent: Some(0.5),
percent_border_padding: 0.0,
is_constrained: false,
},
}];
distribute_auto_cell_spans(&mut columns, &mut spans, 0.0);
assert_eq!(columns[0].percent, Some(0.2));
assert_eq!(columns[1].percent, Some(0.3));
assert_sizes(&minimum_sizes(&columns), &[40.0, 60.0]);
assert_sizes(&maximum_sizes(&columns), &[80.0, 120.0]);
}
#[test]
fn automatic_colspan_weights_percentage_surplus_by_existing_maxima() {
// Chromium distributes the unclaimed 30% in a 10:20 ratio while the
// existing percentage column retains its authored 30%.
let mut columns = [
automatic(0.0, 10.0),
automatic(0.0, 20.0),
percentage(0.0, 10.0, 0.3, 0.0),
];
let mut spans = [TableCellSpanConstraint {
start_column: 0,
span: 3,
cell: TableCellInlineConstraint {
percent: Some(0.6),
..TableCellInlineConstraint::auto()
},
}];
distribute_auto_cell_spans(&mut columns, &mut spans, 0.0);
for (column, expected) in columns.iter().zip([0.1, 0.2, 0.3]) {
assert!((column.percent.unwrap_or(0.0) - expected).abs() < 0.001);
}
}
#[test]
fn automatic_colspan_weights_intrinsic_minimum_by_existing_maxima() {
// This is the intrinsic-size companion to the percentage case above
// and matches Blink's 10:10:20 -> 25:25:50 regression.
let mut columns = [
automatic(0.0, 10.0),
automatic(0.0, 10.0),
automatic(0.0, 20.0),
];
let mut spans = [TableCellSpanConstraint {
start_column: 0,
span: 3,
cell: TableCellInlineConstraint {
min_inline_size: 100.0,
max_inline_size: 100.0,
..TableCellInlineConstraint::auto()
},
}];
distribute_auto_cell_spans(&mut columns, &mut spans, 0.0);
assert_sizes(&minimum_sizes(&columns), &[25.0, 25.0, 50.0]);
assert_sizes(&maximum_sizes(&columns), &[25.0, 25.0, 50.0]);
}
#[test]
fn automatic_colspan_excludes_inner_spacing_from_column_constraints() {
let mut columns = [automatic(0.0, 0.0), automatic(0.0, 0.0)];
let mut spans = [TableCellSpanConstraint {
start_column: 0,
span: 2,
cell: TableCellInlineConstraint {
min_inline_size: 110.0,
max_inline_size: 210.0,
percent: None,
percent_border_padding: 0.0,
is_constrained: false,
},
}];
distribute_auto_cell_spans(&mut columns, &mut spans, 10.0);
assert_sizes(&minimum_sizes(&columns), &[50.0, 50.0]);
assert_sizes(&maximum_sizes(&columns), &[100.0, 100.0]);
}
#[test]
fn automatic_colspan_constrainedness_controls_fixed_column_growth() {
let span = |is_constrained| TableCellSpanConstraint {
start_column: 0,
span: 2,
cell: TableCellInlineConstraint {
min_inline_size: 0.0,
max_inline_size: 200.0,
percent: None,
percent_border_padding: 0.0,
is_constrained,
},
};
let mut intrinsic_columns = [constrained(0.0, 40.0), constrained(0.0, 60.0)];
distribute_auto_cell_spans(&mut intrinsic_columns, &mut [span(false)], 0.0);
assert_sizes(&maximum_sizes(&intrinsic_columns), &[40.0, 60.0]);
let mut constrained_columns = [constrained(0.0, 40.0), constrained(0.0, 60.0)];
distribute_auto_cell_spans(&mut constrained_columns, &mut [span(true)], 0.0);
assert_sizes(&maximum_sizes(&constrained_columns), &[80.0, 120.0]);
}
#[test]
fn automatic_colspan_divides_percentage_evenly_when_columns_have_no_maxima() {
let mut columns = [TableColumnConstraint::auto(); 2];
let mut spans = [TableCellSpanConstraint {
start_column: 0,
span: 2,
cell: TableCellInlineConstraint {
min_inline_size: 0.0,
max_inline_size: 0.0,
percent: Some(0.6),
percent_border_padding: 0.0,
is_constrained: false,
},
}];
distribute_auto_cell_spans(&mut columns, &mut spans, 0.0);
assert_eq!(columns[0].percent, Some(0.3));
assert_eq!(columns[1].percent, Some(0.3));
}
#[test]
fn automatic_colspan_clips_to_remaining_columns_and_ignores_missing_starts() {
let mut columns = [
automatic(0.0, 10.0),
automatic(0.0, 10.0),
automatic(0.0, 10.0),
];
let mut spans = [
TableCellSpanConstraint {
start_column: 99,
span: 2,
cell: TableCellInlineConstraint {
min_inline_size: 500.0,
max_inline_size: 500.0,
..TableCellInlineConstraint::auto()
},
},
TableCellSpanConstraint {
start_column: 1,
span: 99,
cell: TableCellInlineConstraint {
min_inline_size: 80.0,
max_inline_size: 80.0,
..TableCellInlineConstraint::auto()
},
},
];
distribute_auto_cell_spans(&mut columns, &mut spans, 0.0);
assert_sizes(&minimum_sizes(&columns), &[0.0, 40.0, 40.0]);
assert_sizes(&maximum_sizes(&columns), &[10.0, 40.0, 40.0]);
}
}