orinium_browser/engine/layouter/

text_layouter.rs

use std::cell::RefCell;
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};

use ui_layout::{
    BoxModel, CustomLayouter, FloatAvoider, InlineBox, LayoutBox, LayoutContext, LineSpan,
    MeasureResult, Rect,
};

use crate::engine::bridge::text::GlyphCluster;
use crate::engine::layouter::builder::DEFAULT_LINE_FACTOR;
use crate::engine::layouter::types::{LineHeight, TextAlign, TextFlowStyle, WhiteSpace};

thread_local! {
    static TEXT_RESULTS: RefCell<HashMap<usize, Arc<TextLayoutResult>>> =
        RefCell::new(HashMap::new());
}

static NEXT_TEXT_ID: AtomicUsize = AtomicUsize::new(1);

/// Whether a line width is a real, constrained measure. The engine uses
/// `f32::MAX` as an "unbounded" sentinel during measure / shrink-to-fit
/// passes; alignment against such a width would resolve to `f32::MAX / 2`
/// and push text off-screen, and wrapping can never happen on it.
fn is_usable_width(width: f32) -> bool {
    width.is_finite() && width < f32::MAX / 2.0
}

/// Result of laying out a text chunk into lines.
#[derive(Debug, Clone)]
pub struct TextLayoutResult {
    /// Per-line spans (positions and extents).
    pub spans: Vec<LineSpan>,
    /// Per-line text strings (one per span).
    pub line_texts: Vec<String>,
}

/// A self-layouting text object that implements [`CustomLayouter`].
///
/// Constructed with pre-shaped cluster data from a text measurer.
/// During layout it wraps text at word boundaries using
/// `available_inline_size`. Results are cached in a thread-local store
/// keyed by a unique ID for the rendering layer to consume.
#[derive(Debug)]
pub struct TextFlowLayouter {
    /// Unique identifier for cache lookup.
    pub id: usize,
    text: String,
    clusters: Vec<GlyphCluster>,
    flow_style: TextFlowStyle,
}

impl TextFlowLayouter {
    pub fn new(text: String, flow_style: TextFlowStyle, mut clusters: Vec<GlyphCluster>) -> Self {
        clusters.sort_by_key(|c| c.byte_offset);
        let id = NEXT_TEXT_ID.fetch_add(1, Ordering::Relaxed);
        Self {
            id,
            text,
            flow_style,
            clusters,
        }
    }

    /// Resolved line height in pixels, derived from the flow style.
    fn line_height(&self) -> f32 {
        match self.flow_style.line_height {
            LineHeight::Number(factor) => self.flow_style.font_size * factor,
            LineHeight::Normal => self.flow_style.font_size * DEFAULT_LINE_FACTOR,
            LineHeight::Px(px) => px,
        }
        .max(1.0)
    }

    /// Retrieve the layout result for `id` from the thread-local cache.
    pub fn get_result(id: usize) -> Option<Arc<TextLayoutResult>> {
        TEXT_RESULTS.with(|cache| cache.borrow().get(&id).cloned())
    }

    fn remove_result(id: usize) {
        TEXT_RESULTS.with(|cache| {
            cache.borrow_mut().remove(&id);
        });
    }

    #[cfg(test)]
    fn compute_layout(
        &self,
        available_first_line_space: f32,
        available_space: f32,
        start_pos: (f32, f32),
    ) -> TextLayoutResult {
        self.compute_layout_inner(available_first_line_space, available_space, start_pos, None)
    }

    /// Float-aware [`Self::compute_layout`].
    ///
    /// `float_space`, when present, reports how much of each line the floats
    /// surrounding the object leave free. The first line is positioned by the
    /// engine (via `start_pos` / `available_first_line_space`); every later
    /// line is placed at, and wrapped to, the float-free span returned for its
    /// vertical position. Without this, only the first line of a paragraph
    /// would clear a float and the rest would overflow it.
    fn compute_layout_inner(
        &self,
        available_first_line_space: f32,
        available_space: f32,
        start_pos: (f32, f32),
        float_space: Option<&FloatAvoider>,
    ) -> TextLayoutResult {
        /*
         * `start_pos` is position of the FIRST LINE.
         * The first line starts at `start_pos.0` (which may already clear a
         * float). Subsequent lines start at the containing block's left edge
         * unless a float narrows them, in which case `float_space` supplies
         * the per-line origin and width.
         */
        let lh = self.line_height();
        let text_len = self.text.len();
        let clusters = &self.clusters;

        let align = self.flow_style.text_align;
        let white_space = self.flow_style.white_space;
        let wrap_overflow = matches!(
            white_space,
            WhiteSpace::Normal
                | WhiteSpace::PreWrap
                | WhiteSpace::PreLine
                | WhiteSpace::BreakSpaces
        );
        let forced_newline = matches!(
            white_space,
            WhiteSpace::Pre | WhiteSpace::PreWrap | WhiteSpace::PreLine | WhiteSpace::BreakSpaces
        );
        let split_unbreakable = matches!(white_space, WhiteSpace::Normal);

        // Edge-case: no clusters but non-empty text (e.g. spaces-only).
        if clusters.is_empty() && !self.text.is_empty() {
            if forced_newline && self.text.bytes().all(|b| b == b'\n') {
                // Every preserved newline is a segment break, so N newlines
                // produce N + 1 lines.
                let line_count = self.text.bytes().filter(|b| *b == b'\n').count() + 1;
                return TextLayoutResult {
                    spans: (0..line_count)
                        .map(|i| LineSpan {
                            x_range: start_pos.0..start_pos.0,
                            line_pos: (start_pos.0, start_pos.1 + i as f32 * lh),
                            line_index: i,
                        })
                        .collect(),
                    line_texts: vec![String::new(); line_count],
                };
            }
            return TextLayoutResult {
                spans: vec![LineSpan {
                    x_range: start_pos.0..start_pos.0,
                    line_pos: start_pos,
                    line_index: 0,
                }],
                line_texts: vec![self.text.clone()],
            };
        }
        if clusters.is_empty() && !self.text.is_empty() {
            return TextLayoutResult {
                spans: Vec::new(),
                line_texts: Vec::new(),
            };
        }

        // Resolved line widths. The first line may share its line with
        // preceding inline content, so it can be narrower than subsequent
        // lines. If a width is unknown (zero at the start of a layout pass
        // with no prior content), fall back to the other one, or to a large
        // value so nothing wraps unexpectedly.
        let first_line_width = if available_first_line_space > 0.0 {
            available_first_line_space
        } else {
            0.0
        };
        // Per-line origin and usable width. The first line starts where the
        // engine placed it (`start_pos`), which may already clear a float;
        // later lines start at the containing block's left edge unless a float
        // still overlaps them, in which case `float_space` supplies the origin
        // and the width remaining beside the float.
        let line_metrics = |line_index: usize| -> (f32, f32) {
            if line_index == 0 {
                (start_pos.0, first_line_width)
            } else if let Some(avoider) = float_space {
                let (start, end) = avoider.avail_at(line_index as f32 * lh);
                let start = start.max(0.0);
                (start, (end.min(available_space) - start).max(0.0))
            } else {
                (0.0, available_space)
            }
        };
        let line_width = |line_index: usize| line_metrics(line_index).1;

        let aligned_x = |line_index: usize, x_pos: f32, line_w: f32| {
            let available = line_width(line_index);
            // With an unbounded line width (sentinel f32::MAX from measure /
            // shrink-to-fit passes) there is no finite box to center or
            // right-align within: alignment must not push the text off toward
            // f32::MAX / 2.
            if !is_usable_width(available) {
                return x_pos;
            }

            x_pos
                + match align {
                    TextAlign::Left => 0.0,
                    TextAlign::Center => (available - line_w) / 2.0,
                    TextAlign::Right => available - line_w,
                }
        };

        let mut spans: Vec<LineSpan> = Vec::new();
        let mut line_texts: Vec<String> = Vec::new();

        let mut line_start: usize = 0; // byte offset where current line starts
        let mut x_pos = start_pos.0; // Actual line cordination
        let mut y_pos = start_pos.1;
        let mut line_index: usize = 0;
        let mut accumulated: f32 = 0.0; // Running width placed on the current line; used for wrap/overflow checks.
        let mut last_breakable_cluster: Option<usize> = None; // cluster index (exclusive)

        let clusters_between = |from_byte: usize, to_byte: usize| -> f32 {
            let from_idx = clusters.partition_point(|c| c.byte_offset < from_byte);
            let to_idx = clusters.partition_point(|c| c.byte_offset < to_byte);
            clusters[from_idx..to_idx].iter().map(|c| c.width).sum()
        };

        macro_rules! emit_line {
            ($end_byte:expr) => {{
                let end_byte = $end_byte;

                let line_w = clusters_between(line_start, end_byte);
                x_pos = aligned_x(line_index, x_pos, line_w);

                let line_str = &self.text[line_start..end_byte];
                let trimmed = line_str.trim_end_matches('\n');
                let line_text = if trimmed.is_empty() {
                    String::new()
                } else {
                    trimmed.to_string()
                };

                spans.push(LineSpan {
                    x_range: x_pos..(x_pos + line_w),
                    line_pos: (x_pos, y_pos),
                    line_index,
                });
                line_texts.push(line_text);
            }};
        }

        let mut i = 0;
        while i < clusters.len() {
            let frag = &clusters[i];
            let next_byte = clusters
                .get(i + 1)
                .map(|f| f.byte_offset)
                .unwrap_or(text_len);

            if forced_newline && let Some(rel) = self.text[line_start..next_byte].find('\n') {
                let nl_byte = line_start + rel;
                let nl_before_cluster = nl_byte < frag.byte_offset;

                if nl_byte > line_start {
                    emit_line!(nl_byte);
                } else {
                    // Empty line (e.g. consecutive newlines)
                    x_pos = aligned_x(line_index, x_pos, 0.0);
                    spans.push(LineSpan {
                        x_range: x_pos..x_pos,
                        line_pos: (x_pos, y_pos),
                        line_index,
                    });
                    line_texts.push(String::new());
                }

                line_start = nl_byte + 1;
                y_pos += lh;
                line_index += 1;
                x_pos = line_metrics(line_index).0;
                accumulated = 0.0;
                last_breakable_cluster = None;

                // A newline before this cluster's glyph means the cluster
                // starts the new line, so re-process it below.
                if !nl_before_cluster {
                    i += 1;
                }
                continue;
            }

            // Check if placing this cluster would overflow the line.
            let current_line_width = line_width(line_index);
            if wrap_overflow && accumulated > 0.0 && accumulated + frag.width > current_line_width {
                if let Some(break_at) = last_breakable_cluster {
                    // Break at the last known breakable cluster (word boundary).
                    let break_byte = if break_at < clusters.len() {
                        clusters[break_at].byte_offset
                    } else {
                        text_len
                    };

                    if break_byte > line_start || spans.is_empty() {
                        emit_line!(break_byte);

                        line_start = break_byte;
                        y_pos += lh;
                        line_index += 1;
                        x_pos = line_metrics(line_index).0;
                        last_breakable_cluster = None;

                        // Carry over the width of any non-breakable clusters
                        // that move to the new line together with this one.
                        accumulated = if break_at < i {
                            clusters_between(break_byte, clusters[i].byte_offset)
                        } else {
                            0.0
                        };
                    }
                } else if accumulated + frag.width <= line_width(line_index + 1) {
                    // The current line holds a single unbreakable run and the
                    // next line is wide enough to take the whole word: move it
                    // there instead of splitting it mid-word. This keeps the
                    // first word intact when the first line is narrower than
                    // the following ones.
                    y_pos += lh;
                    line_index += 1;
                    x_pos = line_metrics(line_index).0;
                    accumulated = clusters_between(line_start, clusters[i].byte_offset);
                    last_breakable_cluster = None;
                } else if split_unbreakable {
                    // Unbreakable run that is wider than the next line as well:
                    // split at the current cluster boundary.
                    let break_byte = clusters[i].byte_offset;
                    if break_byte > line_start || spans.is_empty() {
                        emit_line!(break_byte);

                        line_start = break_byte;
                        y_pos += lh;
                        line_index += 1;
                        x_pos = line_metrics(line_index).0;
                        last_breakable_cluster = None;
                        accumulated = 0.0;
                    }
                }
            }

            // Accumulate width
            accumulated += frag.width;

            if frag.break_allowed {
                last_breakable_cluster = Some(i + 1);
            }

            i += 1;
        }

        // Emit the final line(s). For preserved newlines we split the remaining
        // text exactly on '\n', so every newline yields a line and a trailing
        // newline adds one final empty line — identical to `str::split('\n')`.
        // The main loop above already emitted a line for each *internal*
        // newline; this pass emits the current line plus any lines opened by
        // trailing newlines, so newline tail handling lives in a single place.
        if forced_newline {
            let rest = &self.text[line_start..text_len];
            if rest.is_empty() {
                // The text ended on a newline (e.g. "abc\n"): split('\n') still
                // yields one trailing empty line. This line follows a break, so
                // its origin is the line's (float-free) start.
                x_pos = aligned_x(line_index, line_metrics(line_index).0, 0.0);
                spans.push(LineSpan {
                    x_range: x_pos..x_pos,
                    line_pos: (x_pos, y_pos),
                    line_index,
                });
                line_texts.push(String::new());
            } else {
                for seg in rest.split('\n') {
                    let seg_end = line_start + seg.len();
                    let line_w = clusters_between(line_start, seg_end);
                    // The first segment uses the incoming `x_pos` (the box
                    // origin for the first line, or 0 after a prior break); every
                    // later segment is an empty line following a break, so its
                    // origin is the box left edge. Resetting `x_pos` here keeps
                    // the carry-over value from accumulating across segments.
                    x_pos = aligned_x(line_index, x_pos, line_w);
                    spans.push(LineSpan {
                        x_range: x_pos..(x_pos + line_w),
                        line_pos: (x_pos, y_pos),
                        line_index,
                    });
                    line_texts.push(seg.to_string());
                    line_index += 1;
                    y_pos += lh;
                    line_start = seg_end + 1; // step over the '\n'
                    x_pos = line_metrics(line_index).0;
                }
            }
        } else if line_start < text_len {
            let line_w = clusters_between(line_start, text_len);
            let trimmed = &self.text[line_start..text_len];
            x_pos = aligned_x(line_index, x_pos, line_w);

            spans.push(LineSpan {
                x_range: x_pos..(x_pos + line_w),
                line_pos: (x_pos, y_pos),
                line_index,
            });
            line_texts.push(trimmed.trim_end_matches('\n').to_string());
        }

        if spans.is_empty() {
            // Empty text: produce one empty line so the node contributes height
            spans.push(LineSpan {
                x_range: start_pos.0..start_pos.0,
                line_pos: start_pos,
                line_index: 0,
            });
            line_texts.push(String::new());
        }

        TextLayoutResult { spans, line_texts }
    }
}

impl Drop for TextFlowLayouter {
    fn drop(&mut self) {
        Self::remove_result(self.id);
    }
}

impl CustomLayouter for TextFlowLayouter {
    fn layout(&mut self, ctx: &LayoutContext) -> LayoutBox {
        // Every line resolves its own usable span at its own vertical
        // position. The first line was already positioned and sized by the
        // engine (`start_pos` + `available_inline_size`), so its width already
        // accounts for floats and any inline content that shares the line.
        // Later lines either ask `float_space` how much room the floats leave
        // at their `y`, or use the containing block width directly. The
        // containing block width must NEVER be approximated by the first
        // line's remaining slice: text that started mid-line would otherwise
        // keep wrapping inside that narrow slice forever. When the width is
        // indeterminate (measure / shrink-to-fit passes) lines are left
        // unwrapped and the engine re-lays out with a definite width later.
        let available_inline = ctx.available_inline_size;
        let available_space = ctx
            .containing_block_width
            .filter(|w| is_usable_width(*w))
            .unwrap_or(f32::MAX);
        let result = self.compute_layout_inner(
            available_inline,
            available_space,
            ctx.start_pos,
            ctx.float_space.as_ref(),
        );
        let spans = result.spans.clone();

        TEXT_RESULTS.with(|cache| {
            cache.borrow_mut().insert(self.id, Arc::new(result));
        });

        let (start_x, start_y) = ctx.start_pos;
        let lh = self.line_height();
        // The box width is the widest *line content* — alignment offsets
        // (center/right within the line) must not widen the inline box,
        // otherwise an auto-width inline-block containing centered text
        // shrink-wraps to the alignment offset instead of the text.
        let total_width = spans
            .iter()
            .map(LineSpan::width)
            .filter(|w| !w.is_nan())
            .max_by(f32::total_cmp)
            .unwrap_or(0.0);
        let total_height = spans
            .iter()
            .map(|s| s.line_index)
            .max()
            .map(|line| (line as f32 + 1.0) * lh)
            .unwrap_or(0.0);
        let rect = Rect {
            x: start_x,
            y: start_y,
            width: total_width,
            height: total_height,
        };
        let box_model = BoxModel {
            sticky_edges: None,
            border_box: rect,
            padding_box: rect,
            content_box: rect,
            children_box: rect,
        };

        LayoutBox::InlineBox(InlineBox {
            box_model,
            line_spans: spans,
        })
    }

    fn measure(&self, _ctx: &LayoutContext) -> MeasureResult {
        let total_width: f32 = self.clusters.iter().map(|c| c.width).sum();
        let total_height = self.line_height();
        MeasureResult {
            width: total_width,
            height: total_height,
        }
    }

    fn write_debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "TextFlowLayouter [{}]", self.text.escape_debug())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::engine::layouter::types::TextFlowStyle;

    fn cluster(byte_offset: usize, width: f32, break_allowed: bool) -> GlyphCluster {
        GlyphCluster {
            byte_offset,
            width,
            break_allowed,
        }
    }

    fn layout(text: &str, clusters: Vec<GlyphCluster>, line_width: f32) -> TextLayoutResult {
        TextFlowLayouter::new(text.to_string(), TextFlowStyle::default(), clusters).compute_layout(
            line_width,
            line_width,
            (0.0, 0.0),
        )
    }

    fn layout_with(
        text: &str,
        clusters: Vec<GlyphCluster>,
        line_width: f32,
        white_space: WhiteSpace,
    ) -> TextLayoutResult {
        let flow = TextFlowStyle {
            white_space,
            ..TextFlowStyle::default()
        };
        TextFlowLayouter::new(text.to_string(), flow, clusters).compute_layout(
            line_width,
            line_width,
            (0.0, 0.0),
        )
    }

    #[test]
    fn wraps_at_word_boundaries() {
        let result = layout(
            "aaa bbb ccc",
            vec![
                cluster(0, 30.0, false),
                cluster(3, 5.0, true),
                cluster(4, 30.0, false),
                cluster(7, 5.0, true),
                cluster(8, 30.0, false),
            ],
            70.0,
        );
        assert_eq!(result.line_texts.len(), 2);
        assert_eq!(result.line_texts[0].trim_end(), "aaa bbb");
        assert_eq!(result.line_texts[1], "ccc");
        assert_eq!(result.spans[0].width(), 70.0);
        assert_eq!(result.spans[1].width(), 30.0);
        assert_eq!(result.spans[0].line_index, 0);
        assert_eq!(result.spans[1].line_index, 1);
    }

    #[test]
    fn aligns_each_line_within_the_available_inline_space() {
        let clusters = vec![
            cluster(0, 20.0, false),
            cluster(2, 10.0, true),
            cluster(3, 20.0, false),
        ];
        let centered = TextFlowStyle {
            text_align: TextAlign::Center,
            ..TextFlowStyle::default()
        };
        let result = TextFlowLayouter::new("aa bb".to_string(), centered, clusters.clone())
            .compute_layout(40.0, 40.0, (0.0, 0.0));
        assert_eq!(result.line_texts, vec!["aa ", "bb"]);
        assert_eq!(result.spans[0].line_pos.0, 5.0);
        assert_eq!(result.spans[1].line_pos.0, 10.0);
        assert_eq!(result.spans[0].x_range, 5.0..35.0);
        assert_eq!(result.spans[1].x_range, 10.0..30.0);

        let right = TextFlowStyle {
            text_align: TextAlign::Right,
            ..TextFlowStyle::default()
        };
        let result = TextFlowLayouter::new("aa".to_string(), right, clusters[..1].to_vec())
            .compute_layout(40.0, 40.0, (0.0, 0.0));
        assert_eq!(result.spans[0].line_pos.0, 20.0);
        assert_eq!(result.spans[0].x_range, 20.0..40.0);
    }

    #[test]
    fn wraps_cjk_per_character() {
        let clusters: Vec<GlyphCluster> = (0..10).map(|i| cluster(i, 10.0, true)).collect();
        let result = layout("aaaaaaaaaa", clusters, 40.0);
        assert_eq!(result.line_texts, vec!["aaaa", "aaaa", "aa"]);
        assert_eq!(result.spans.len(), 3);
        for span in &result.spans {
            assert!(span.width() <= 40.0);
        }
    }

    #[test]
    fn splits_unbreakable_run() {
        let clusters: Vec<GlyphCluster> = (0..6).map(|i| cluster(i, 20.0, false)).collect();
        let result = layout("abcdef", clusters, 80.0);
        assert_eq!(result.line_texts, vec!["abcd", "ef"]);
        assert_eq!(result.spans[0].width(), 80.0);
        assert_eq!(result.spans[1].width(), 40.0);
    }

    #[test]
    fn no_overhang_for_word_wider_than_line() {
        let result = layout(
            "hello supercalifragilistic",
            vec![
                cluster(0, 30.0, false),
                cluster(5, 5.0, true),
                cluster(6, 93.0, false),
            ],
            80.0,
        );
        assert_eq!(result.line_texts.len(), 2);
        assert_eq!(result.line_texts[0].trim_end(), "hello");
        assert_eq!(result.spans[0].width(), 35.0);
        assert_eq!(result.spans[1].width(), 93.0);
    }

    #[test]
    fn single_cluster_wider_than_line_stays_alone() {
        let result = layout("x", vec![cluster(0, 93.0, false)], 80.0);
        assert_eq!(result.line_texts, vec!["x"]);
        assert_eq!(result.spans.len(), 1);
        assert_eq!(result.spans[0].width(), 93.0);
    }

    #[test]
    fn first_line_uses_narrower_space() {
        let clusters = vec![
            cluster(0, 20.0, false),
            cluster(2, 4.0, true),
            cluster(3, 20.0, false),
            cluster(5, 4.0, true),
            cluster(6, 20.0, false),
            cluster(8, 4.0, true),
            cluster(9, 20.0, false),
        ];
        let result = TextFlowLayouter::new(
            "aa bb cc dd".to_string(),
            TextFlowStyle::default(),
            clusters,
        )
        .compute_layout(32.0, 64.0, (0.0, 0.0));
        let texts: Vec<String> = result
            .line_texts
            .iter()
            .map(|s| s.trim_end().to_string())
            .collect();
        assert_eq!(texts, vec!["aa", "bb cc", "dd"]);
        assert_eq!(result.spans[0].width(), 24.0);
        assert_eq!(result.spans[1].width(), 48.0);
        assert_eq!(result.spans[2].width(), 20.0);
    }

    #[test]
    fn first_word_moves_to_next_line_when_first_line_is_narrow() {
        let clusters = vec![
            cluster(0, 9.0, false),
            cluster(1, 9.0, false),
            cluster(2, 9.0, false),
            cluster(3, 9.0, false),
            cluster(4, 9.0, false),
            cluster(5, 4.0, true),
            cluster(6, 10.0, false),
            cluster(7, 10.0, false),
            cluster(8, 10.0, false),
            cluster(9, 10.0, false),
            cluster(10, 10.0, false),
        ];
        let result = TextFlowLayouter::new(
            "Hello world".to_string(),
            TextFlowStyle::default(),
            clusters,
        )
        .compute_layout(30.0, 100.0, (0.0, 0.0));
        assert_eq!(result.line_texts, vec!["Hello world"]);
        assert_eq!(result.spans.len(), 1);
        assert_eq!(result.spans[0].line_index, 1);
        assert_eq!(result.spans[0].width(), 99.0);
    }

    #[test]
    fn first_word_splits_when_too_wide_for_every_line() {
        let clusters = vec![
            cluster(0, 9.0, false),
            cluster(1, 9.0, false),
            cluster(2, 9.0, false),
            cluster(3, 9.0, false),
            cluster(4, 9.0, false),
        ];
        let result = TextFlowLayouter::new("Hello".to_string(), TextFlowStyle::default(), clusters)
            .compute_layout(30.0, 40.0, (0.0, 0.0));
        assert_eq!(result.line_texts, vec!["Hell", "o"]);
    }

    #[test]
    fn nowrap_never_wraps_on_overflow() {
        let clusters = vec![
            cluster(0, 30.0, false),
            cluster(3, 5.0, true),
            cluster(4, 30.0, false),
            cluster(7, 5.0, true),
            cluster(8, 30.0, false),
        ];
        let result = layout_with("aaa bbb ccc", clusters, 50.0, WhiteSpace::Nowrap);
        assert_eq!(result.line_texts, vec!["aaa bbb ccc"]);
        assert_eq!(result.spans.len(), 1);
        assert_eq!(result.spans[0].width(), 100.0);
    }

    #[test]
    fn pre_breaks_only_on_newline() {
        let no_wrap_clusters = vec![
            cluster(0, 40.0, false),
            cluster(3, 4.0, true),
            cluster(4, 40.0, false),
            cluster(7, 4.0, true),
            cluster(8, 40.0, false),
        ];
        let no_wrap = layout_with("aaa bbb ccc", no_wrap_clusters, 60.0, WhiteSpace::Pre);
        assert_eq!(no_wrap.line_texts, vec!["aaa bbb ccc"]);
        assert_eq!(no_wrap.spans.len(), 1);
        assert_eq!(no_wrap.spans[0].width(), 128.0);

        let newline_clusters = vec![
            cluster(0, 40.0, false),
            cluster(4, 4.0, true),
            cluster(5, 40.0, false),
        ];
        let forced = layout_with("aaaa\nbbbb", newline_clusters, 50.0, WhiteSpace::Pre);
        assert_eq!(forced.line_texts, vec!["aaaa", "bbbb"]);
        assert_eq!(forced.spans.len(), 2);
        assert_eq!(forced.spans[0].line_index, 0);
        assert_eq!(forced.spans[1].line_index, 1);
    }

    #[test]
    fn pre_wrap_breaks_on_newline_and_wraps() {
        let clusters = vec![
            cluster(0, 20.0, false),
            cluster(2, 4.0, true),
            cluster(3, 20.0, false),
            cluster(5, 4.0, true),
            cluster(6, 20.0, false),
        ];
        let result = layout_with("aa bb cc", clusters, 34.0, WhiteSpace::PreWrap);
        let texts: Vec<String> = result
            .line_texts
            .iter()
            .map(|s| s.trim_end().to_string())
            .collect();
        assert_eq!(texts, vec!["aa", "bb", "cc"]);
    }

    #[test]
    fn pre_line_breaks_on_newline_and_wraps() {
        let clusters = vec![
            cluster(0, 20.0, false),
            cluster(2, 4.0, true),
            cluster(3, 20.0, false),
            cluster(5, 4.0, true),
            cluster(6, 20.0, false),
        ];
        let result = layout_with("aa bb cc", clusters, 34.0, WhiteSpace::PreLine);
        let texts: Vec<String> = result
            .line_texts
            .iter()
            .map(|s| s.trim_end().to_string())
            .collect();
        assert_eq!(texts, vec!["aa", "bb", "cc"]);
        assert_eq!(result.spans.len(), 3);
    }

    #[test]
    fn break_spaces_wraps_inside_whitespace_run() {
        let clusters = vec![
            cluster(0, 20.0, false),
            cluster(2, 5.0, true),
            cluster(3, 5.0, true),
            cluster(4, 20.0, false),
            cluster(5, 20.0, false),
        ];
        let result = layout_with("aa  bb", clusters, 25.0, WhiteSpace::BreakSpaces);
        assert_eq!(result.line_texts, vec!["aa ", " ", "bb"]);
        assert_eq!(result.spans.len(), 3);
    }

    #[test]
    fn leading_newline_emits_empty_first_line() {
        let clusters = vec![
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
            cluster(3, 10.0, false),
        ];
        let result = layout_with("\nabc", clusters, 100.0, WhiteSpace::PreWrap);
        assert_eq!(result.line_texts, vec!["", "abc"]);
        assert_eq!(result.spans.len(), 2);
        assert_eq!(result.spans[0].line_index, 0);
        assert_eq!(result.spans[0].width(), 0.0);
        assert_eq!(result.spans[1].line_index, 1);
        assert_eq!(result.spans[1].width(), 30.0);
    }

    #[test]
    fn trailing_newline_emits_empty_last_line() {
        let clusters = vec![
            cluster(0, 10.0, false),
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
        ];
        let result = layout_with("abc\n", clusters, 100.0, WhiteSpace::PreWrap);
        // "abc\n" has one preserved segment break → "abc" plus an empty line.
        assert_eq!(result.line_texts, vec!["abc", ""]);
        assert_eq!(result.spans.len(), 2);
        assert_eq!(result.spans[1].width(), 0.0);
    }

    #[test]
    fn leading_and_trailing_newline_emit_empty_lines() {
        let clusters = vec![
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
            cluster(3, 10.0, false),
        ];
        let result = layout_with("\nabc\n", clusters, 100.0, WhiteSpace::PreWrap);
        assert_eq!(result.line_texts, vec!["", "abc", ""]);
        assert_eq!(result.spans.len(), 3);
    }

    #[test]
    fn multiple_trailing_newlines_emit_empty_lines() {
        let clusters = vec![
            cluster(0, 10.0, false),
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
        ];
        let result = layout_with("abc\n\n", clusters, 100.0, WhiteSpace::PreWrap);
        assert_eq!(result.line_texts, vec!["abc", "", ""]);
        assert_eq!(result.spans.len(), 3);
    }

    #[test]
    fn all_newlines_emit_n_plus_one_lines() {
        // No glyph clusters: every preserved newline is a segment break, so
        // N newlines produce N + 1 lines.
        let result = layout_with("\n\n", vec![], 100.0, WhiteSpace::PreWrap);
        assert_eq!(result.line_texts, vec!["", "", ""]);
        assert_eq!(result.spans.len(), 3);
    }

    #[test]
    fn trailing_newline_ignored_for_normal_whitespace() {
        let clusters = vec![
            cluster(0, 10.0, false),
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
        ];
        // For Normal whitespace a trailing newline is collapsed, not a forced
        // break, so no extra empty line is emitted.
        let result = layout_with("abc\n", clusters, 100.0, WhiteSpace::Normal);
        assert_eq!(result.line_texts, vec!["abc"]);
        assert_eq!(result.spans.len(), 1);
    }

    #[test]
    fn line_after_newline_starts_at_left_edge() {
        // After a line break, the new line must start at absolute x = 0,
        // regardless of the text node's position.
        let clusters = vec![
            cluster(0, 10.0, false),
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
            cluster(4, 10.0, false),
            cluster(5, 10.0, false),
            cluster(6, 10.0, false),
        ];
        let flow = TextFlowStyle {
            white_space: WhiteSpace::PreWrap,
            ..TextFlowStyle::default()
        };
        let result = TextFlowLayouter::new("abc\ndef".to_string(), flow, clusters).compute_layout(
            100.0,
            100.0,
            (0.0, 0.0),
        );
        assert_eq!(result.spans.len(), 2);
        assert_eq!(result.spans[0].line_pos.0, 0.0, "first line x");
        assert_eq!(result.spans[1].line_pos.0, 0.0, "line after newline x");
    }

    #[test]
    fn line_after_newline_resets_to_absolute_zero() {
        // After a line break, the new line starts at absolute x = 0,
        // not at the text node's start_pos.x.
        let clusters = vec![
            cluster(0, 10.0, false),
            cluster(1, 10.0, false),
            cluster(2, 10.0, false),
            cluster(4, 10.0, false),
            cluster(5, 10.0, false),
            cluster(6, 10.0, false),
        ];
        let flow = TextFlowStyle {
            white_space: WhiteSpace::PreWrap,
            ..TextFlowStyle::default()
        };
        let result = TextFlowLayouter::new("abc\ndef".to_string(), flow, clusters).compute_layout(
            100.0,
            100.0,
            (50.0, 0.0),
        );
        assert_eq!(result.spans.len(), 2);
        assert_eq!(result.spans[0].line_pos.0, 50.0, "first line x");
        assert_eq!(result.spans[1].line_pos.0, 0.0, "line after newline x");
    }

    #[test]
    fn wrapped_line_starts_at_absolute_zero() {
        // A width-triggered wrap (no newline) must also resume at absolute
        // x = 0, not at the text node's start_pos.x.
        let clusters = vec![
            cluster(0, 30.0, false),
            cluster(3, 5.0, true),
            cluster(4, 30.0, false),
        ];
        let result =
            TextFlowLayouter::new("aaa bbb".to_string(), TextFlowStyle::default(), clusters)
                .compute_layout(40.0, 40.0, (50.0, 0.0));
        assert_eq!(result.spans.len(), 2);
        assert_eq!(result.spans[0].line_pos.0, 50.0, "first line x");
        assert_eq!(result.spans[1].line_pos.0, 0.0, "wrapped line x");
    }

    #[test]
    fn consecutive_newlines_emit_empty_lines() {
        let clusters = vec![
            cluster(0, 10.0, false),
            cluster(1, 10.0, false),
            cluster(4, 10.0, false),
            cluster(5, 10.0, false),
        ];
        let result = layout_with("ab\n\ncd", clusters, 100.0, WhiteSpace::PreWrap);
        assert_eq!(result.line_texts, vec!["ab", "", "cd"]);
        assert_eq!(result.spans.len(), 3);
        assert_eq!(result.spans[0].width(), 20.0);
        assert_eq!(result.spans[1].width(), 0.0);
        assert_eq!(result.spans[2].width(), 20.0);
    }

    #[test]
    fn newline_between_paragraphs_keeps_span_width() {
        let clusters = vec![
            cluster(0, 15.0, false),
            cluster(1, 15.0, false),
            cluster(3, 15.0, false),
        ];
        let result = layout_with("ab\nc", clusters, 100.0, WhiteSpace::Pre);
        assert_eq!(result.line_texts, vec!["ab", "c"]);
        assert_eq!(result.spans[0].width(), 30.0);
        assert_eq!(result.spans[1].width(), 15.0);
    }

    #[test]
    fn pre_wrap_does_not_split_unbreakable_word() {
        let clusters: Vec<GlyphCluster> = (0..6).map(|i| cluster(i, 20.0, false)).collect();
        let result = layout_with("abcdef", clusters, 80.0, WhiteSpace::PreWrap);
        assert_eq!(result.line_texts, vec!["abcdef"]);
        assert_eq!(result.spans.len(), 1);
        assert_eq!(result.spans[0].width(), 120.0);
    }

    #[test]
    fn pre_line_does_not_split_unbreakable_word() {
        let clusters: Vec<GlyphCluster> = (0..6).map(|i| cluster(i, 20.0, false)).collect();
        let result = layout_with("abcdef", clusters, 80.0, WhiteSpace::PreLine);
        assert_eq!(result.line_texts, vec!["abcdef"]);
        assert_eq!(result.spans.len(), 1);
    }

    #[test]
    fn break_spaces_does_not_split_unbreakable_word() {
        let clusters: Vec<GlyphCluster> = (0..6).map(|i| cluster(i, 20.0, false)).collect();
        let result = layout_with("abcdef", clusters, 80.0, WhiteSpace::BreakSpaces);
        assert_eq!(result.line_texts, vec!["abcdef"]);
        assert_eq!(result.spans.len(), 1);
    }

    #[test]
    fn pre_wrap_wraps_at_whitespace_but_not_inside_word() {
        let clusters = vec![
            cluster(0, 20.0, false),
            cluster(1, 20.0, false),
            cluster(2, 20.0, false),
            cluster(3, 20.0, false),
            cluster(4, 4.0, true),
            cluster(5, 15.0, false),
            cluster(6, 15.0, false),
        ];
        let result = layout_with("abcd ef", clusters, 70.0, WhiteSpace::PreWrap);
        let texts: Vec<String> = result
            .line_texts
            .iter()
            .map(|s| s.trim_end().to_string())
            .collect();
        assert_eq!(texts, vec!["abcd", "ef"]);
    }

    #[test]
    fn empty_text_emits_one_empty_line() {
        let result = layout("", vec![], 100.0);
        assert_eq!(result.line_texts, vec![""]);
        assert_eq!(result.spans.len(), 1);
    }

    #[test]
    fn trailing_newlines_match_split_semantics() {
        // The whole tail is owned by a single split('\n') pass, so the line
        // count matches `str::split('\n')` exactly.
        let cases: &[(&str, &[&str])] = &[
            ("foo", &["foo"]),
            ("foo\n", &["foo", ""]),
            ("foo\n\n", &["foo", "", ""]),
            ("\n", &["", ""]),
            ("\n\n", &["", "", ""]),
        ];
        for (text, expected) in cases {
            let clusters: Vec<GlyphCluster> = text
                .chars()
                .enumerate()
                .filter(|(_, c)| !c.is_whitespace())
                .map(|(i, _)| cluster(i, 10.0, false))
                .collect();
            let result = layout_with(text, clusters, 100.0, WhiteSpace::Pre);
            assert_eq!(&result.line_texts[..], *expected, "text = {:?}", text);
        }
    }

    #[test]
    fn trailing_newlines_do_not_accumulate_x_pos() {
        // Multiple trailing newlines under center alignment must place every
        // empty line at the same centered x. The carry-over `x_pos` must reset
        // to 0 between segments so it does not accumulate across them.
        let clusters = vec![cluster(0, 10.0, false), cluster(1, 10.0, false)];
        let flow = TextFlowStyle {
            white_space: WhiteSpace::Pre,
            text_align: TextAlign::Center,
            ..TextFlowStyle::default()
        };
        let result = TextFlowLayouter::new("ab\n\n".to_string(), flow, clusters).compute_layout(
            100.0,
            100.0,
            (0.0, 0.0),
        );

        assert_eq!(result.line_texts, vec!["ab", "", ""]);
        // First line "ab" is centered: (100 - 20) / 2 == 40.
        assert_eq!(result.spans[0].line_pos.0, 40.0);
        // Both trailing empty lines are centered at x = 50
        // (aligned_x(0.0, 0.0) = (100 - 0) / 2 = 50) — no accumulation.
        assert_eq!(result.spans[1].line_pos.0, 50.0);
        assert_eq!(result.spans[2].line_pos.0, 50.0);
    }

    fn ctx_with_unbounded_containing_width(available_inline: f32) -> LayoutContext {
        LayoutContext {
            containing_block_width: None,
            containing_block_height: None,
            start_pos: (0.0, 0.0),
            available_inline_size: available_inline,
            float_space: None,
            line_height: 24.0,
            viewport_width: 1200.0,
            viewport_height: 900.0,
        }
    }

    #[test]
    fn subsequent_lines_are_not_capped_by_the_first_line_slice() {
        // GitHub-style hero subheading: containing_block_width is None inside a
        // centered flex item, and the first line only has a 60px slice left
        // (e.g. after a float or preceding inline content). That slice belongs
        // to the first line alone: later lines must not be wrapped inside it
        // forever. With an unbounded containing width they do not wrap at all,
        // and center alignment must never resolve to f32::MAX / 2.
        let flow = TextFlowStyle {
            text_align: TextAlign::Center,
            ..TextFlowStyle::default()
        };
        let clusters = vec![
            cluster(0, 40.0, false),
            cluster(4, 5.0, true),
            cluster(5, 40.0, false),
            cluster(9, 5.0, true),
            cluster(10, 40.0, false),
        ];
        let mut layouter = TextFlowLayouter::new("aaaa bbbb cccc".to_string(), flow, clusters);
        let LayoutBox::InlineBox(inline) =
            layouter.layout(&ctx_with_unbounded_containing_width(60.0))
        else {
            panic!("expected InlineBox");
        };

        // The first line wraps inside its genuine 60px slice; the next line
        // starts fresh and is not constrained by it.
        assert!(
            inline.line_spans.len() >= 2,
            "text must wrap on multiple lines"
        );
        assert_eq!(
            inline.line_spans[1].width(),
            85.0,
            "line 1 was capped by the first line's slice"
        );
        for span in &inline.line_spans {
            assert!(
                span.line_pos.0.is_finite(),
                "x must be finite, got {}",
                span.line_pos.0
            );
            assert!(
                span.line_pos.0 < 1000.0,
                "x must stay on-screen, got {}",
                span.line_pos.0
            );
        }
        // Line 0 ("aaaa ", 45px wide) is centered within its 60px slice.
        assert_eq!(inline.line_spans[0].line_pos.0, 7.5);
    }

    #[test]
    fn centered_text_with_infinite_first_line_width_keeps_position() {
        // Measure / shrink-to-fit passes hand out an unbounded inline size.
        // There is no finite box to center within, so alignment must not shift
        // the text toward f32::MAX / 2.
        let flow = TextFlowStyle {
            text_align: TextAlign::Center,
            ..TextFlowStyle::default()
        };
        let clusters = vec![cluster(0, 20.0, false), cluster(2, 20.0, false)];
        let mut layouter = TextFlowLayouter::new("aaa bbb".to_string(), flow, clusters);
        let LayoutBox::InlineBox(inline) =
            layouter.layout(&ctx_with_unbounded_containing_width(f32::MAX))
        else {
            panic!("expected InlineBox");
        };

        assert_eq!(inline.line_spans.len(), 1);
        assert_eq!(inline.line_spans[0].line_pos.0, 0.0);
    }

    fn float_flow() -> TextFlowStyle {
        TextFlowStyle {
            line_height: LineHeight::Px(20.0),
            ..TextFlowStyle::default()
        }
    }

    /// One cluster per word (4 bytes) plus a breakable 1-byte space between
    /// them, matching `"aaaa bbbb ..."`.
    fn word_clusters(words: usize, word_width: f32, space_width: f32) -> Vec<GlyphCluster> {
        let mut clusters = Vec::new();
        for word in 0..words {
            let start = word * 5;
            clusters.push(cluster(start, word_width, false));
            if word + 1 < words {
                clusters.push(cluster(start + 4, space_width, true));
            }
        }
        clusters
    }

    fn ctx_with_float_space(
        available_inline: f32,
        containing_width: f32,
        start_pos: (f32, f32),
        float_space: FloatAvoider,
    ) -> LayoutContext {
        LayoutContext {
            containing_block_width: Some(containing_width),
            containing_block_height: Some(1000.0),
            start_pos,
            available_inline_size: available_inline,
            float_space: Some(float_space),
            line_height: 20.0,
            viewport_width: 1200.0,
            viewport_height: 900.0,
        }
    }

    const FLOAT_TEXT: &str = "aaaa bbbb cccc dddd eeee ffff gggg hhhh iiii jjjj";

    #[test]
    fn continuation_line_origin_follows_the_float() {
        // The engine places the first line at `start_pos` (here x=100, e.g.
        // after preceding inline content), but the float only reaches x=60.
        // The second line must start at the float's right edge (60), not repeat
        // the first line's x.
        let clusters = word_clusters(4, 90.0, 10.0);
        let avoider =
            FloatAvoider::from_rects([(ui_layout::Float::Left, 0.0, 0.0, 60.0, 40.0)], 400.0);
        let ctx = ctx_with_float_space(300.0, 400.0, (100.0, 0.0), avoider);
        let mut layouter =
            TextFlowLayouter::new("aaaa bbbb cccc dddd".to_string(), float_flow(), clusters);
        let LayoutBox::InlineBox(inline) = layouter.layout(&ctx) else {
            panic!("expected InlineBox");
        };

        assert_eq!(inline.line_spans[0].line_pos.0, 100.0);
        assert!(inline.line_spans.len() >= 2, "text should wrap");
        assert_eq!(inline.line_spans[1].line_pos.0, 60.0);
    }

    #[test]
    fn continuation_lines_wrap_beside_a_left_float() {
        // A 100px-wide, 40px-tall left float in a 400px box leaves 300px for
        // the first two lines (y = 0 and 20); from y = 40 onward the full
        // width is usable again.
        let clusters = word_clusters(9, 90.0, 10.0);
        let avoider =
            FloatAvoider::from_rects([(ui_layout::Float::Left, 0.0, 0.0, 100.0, 40.0)], 400.0);
        let ctx = ctx_with_float_space(300.0, 400.0, (100.0, 0.0), avoider);
        let mut layouter = TextFlowLayouter::new(
            "aaaa bbbb cccc dddd eeee ffff gggg hhhh iiii".to_string(),
            float_flow(),
            clusters,
        );
        let LayoutBox::InlineBox(inline) = layouter.layout(&ctx) else {
            panic!("expected InlineBox");
        };

        // Lines overlapping the 40px-tall float start after it and wrap within
        // the 300px the float leaves.
        for span in inline.line_spans.iter().filter(|s| s.line_index < 2) {
            assert_eq!(
                span.line_pos.0, 100.0,
                "line {} must clear the float",
                span.line_index
            );
            assert!(
                span.width() <= 300.0 + 0.01,
                "line {} wrapped too wide ({})",
                span.line_index,
                span.width()
            );
        }
        // Past the float the line is laid out from the containing block's left
        // edge instead of after the float.
        let last = inline.line_spans.last().unwrap();
        assert!(last.line_index >= 2);
        assert_eq!(last.line_pos.0, 0.0);
    }

    #[test]
    fn continuation_lines_wrap_beside_a_right_float() {
        let clusters = word_clusters(10, 90.0, 10.0);
        let avoider =
            FloatAvoider::from_rects([(ui_layout::Float::Right, 300.0, 0.0, 100.0, 40.0)], 400.0);
        let ctx = ctx_with_float_space(300.0, 400.0, (0.0, 0.0), avoider);
        let mut layouter = TextFlowLayouter::new(FLOAT_TEXT.to_string(), float_flow(), clusters);
        let LayoutBox::InlineBox(inline) = layouter.layout(&ctx) else {
            panic!("expected InlineBox");
        };

        for span in inline.line_spans.iter().filter(|s| s.line_index < 2) {
            assert_eq!(span.line_pos.0, 0.0);
            assert!(
                span.width() <= 300.0 + 0.01,
                "line {} overlapped the right float: {}",
                span.line_index,
                span.width()
            );
        }
        // The line past the float may use the whole 400px containing block.
        let reclaimed = inline
            .line_spans
            .iter()
            .find(|s| s.line_index >= 2)
            .expect("a line past the float");
        assert!(reclaimed.width() > 300.0);
    }

    #[test]
    fn continuation_lines_start_at_the_containing_block_without_floats() {
        let clusters = word_clusters(4, 90.0, 10.0);
        // Narrow first line but no floats: later lines use the full width and
        // start at the containing block's left edge.
        let result =
            TextFlowLayouter::new("aaaa bbbb cccc dddd".to_string(), float_flow(), clusters)
                .compute_layout(120.0, 400.0, (100.0, 0.0));
        assert_eq!(result.spans[0].line_pos.0, 100.0);
        assert_eq!(result.spans[1].line_pos.0, 0.0);
        assert!(result.spans[1].width() > 120.0);
    }
}