sinomo-ui-text 0.3.0

Text shaping, font registration, and layout for SUI.
Documentation
use super::*;
use crate::{
    FontFeature, FontWeight, RegisteredFont, TextAlign, TextDirection, TextParagraph, TextSpan,
    TextWrap,
    prepared::{ByteCache, PreparationCaches},
};
use sui_core::{Color, FontHandle, Point};

fn request(document: &TextDocument, width: f32) -> TextLayoutRequest {
    TextLayoutRequest::new(document.clone()).with_box_size(Size::new(width, 300.0))
}

fn discard_final_layouts(system: &TextSystem) {
    *system.layout_cache.lock().unwrap() = TextLayoutCache::default();
}

fn discard_preparation(system: &TextSystem) {
    system
        .font_context
        .lock()
        .unwrap()
        .as_mut()
        .unwrap()
        .context
        .preparation = PreparationCaches::default();
}

#[test]
fn size_only_requests_remain_visible_to_the_runtime_profiler() {
    if !text_timing_enabled() {
        return;
    }
    let system = TextSystem::with_bundled_fonts();
    begin_text_timing_collection();
    system
        .measure_text_size("profiled", TextStyle::default(), &FontRegistry::new())
        .unwrap();
    let timing = take_text_timing_collection();
    assert_eq!(timing.request_count, 1);
    assert_eq!(timing.size_only_request_count, 1);
    assert_eq!(timing.cache_hit_count + timing.cache_miss_count, 0);
    assert_eq!(timing.total_time_us, timing.size_only_time_us);
}

fn assert_geometry(left: &TextLayout, right: &TextLayout) {
    assert_eq!(left.metadata(), right.metadata());
    assert_eq!(left.measurement(), right.measurement());
    assert_eq!(left.paragraphs(), right.paragraphs());
    assert_eq!(left.lines(), right.lines());
    assert_eq!(left.runs(), right.runs());
    assert_eq!(left.clusters(), right.clusters());
    assert_eq!(left.glyphs(), right.glyphs());
    for offset in left
        .text()
        .char_indices()
        .map(|(offset, _)| offset)
        .chain([left.text().len()])
    {
        assert_eq!(left.caret_rect(offset), right.caret_rect(offset));
        assert_eq!(
            left.selection_rects(0..offset),
            right.selection_rects(0..offset)
        );
        let caret = left.caret_rect(offset);
        let point = Point::new(caret.x(), caret.y() + caret.height() * 0.5);
        assert_eq!(left.hit_test_point(point), right.hit_test_point(point));
    }
}

#[test]
fn resizing_reuses_shaping_and_intrinsic_metrics_without_changing_published_geometry() {
    let system = TextSystem::with_bundled_fonts();
    let fonts = FontRegistry::new();
    let document = TextDocument::from_plain_text(
        "office affinity e\u{301} العربية שָׁלוֹם 123",
        TextStyle::default(),
    );
    system
        .measure_document_size(request(&document, 320.0), &fonts)
        .unwrap();
    let prepared = system.preparation_cache_snapshot();
    assert_eq!(prepared.paragraphs.misses, 1);
    assert_eq!(
        prepared.glyphs.entries, 0,
        "size-only must not compute glyph bounds"
    );
    assert_eq!(
        system.layout_cache_snapshot().entries,
        0,
        "size-only must not build final layouts"
    );
    let first = system
        .layout_document_persistent(None, request(&document, 190.0), &fonts)
        .unwrap();
    let first_stats = system.preparation_cache_snapshot();
    let second = system
        .layout_document_persistent(Some(first.handle()), request(&document, 95.0), &fonts)
        .unwrap();
    let second_stats = system.preparation_cache_snapshot();
    assert_eq!(second_stats.paragraphs.misses, 1);
    assert_eq!(second_stats.glyphs.misses, first_stats.glyphs.misses);
    assert!(second_stats.paragraphs.hits > first_stats.paragraphs.hits);
    assert_eq!(first.handle(), second.handle());
    assert_ne!(first.version(), second.version());
    discard_final_layouts(&system);
    discard_preparation(&system);
    let fresh = system
        .layout_document(request(&document, 95.0), &fonts)
        .unwrap();
    assert_geometry(second.layout(), &fresh);
    assert_eq!(
        system.text_layout_registry().get(second.handle()),
        Some(second.layout())
    );
}

#[test]
fn alignment_and_wrapping_reuse_shapes_but_recompute_line_geometry() {
    for (text, direction) in [
        (
            "office affinity e\u{301} and more words",
            TextDirection::Auto,
        ),
        ("العربية שָׁלוֹם 123 office", TextDirection::Auto),
        ("العربية שָׁלוֹם 123 office", TextDirection::RightToLeft),
    ] {
        let system = TextSystem::with_bundled_fonts();
        let fonts = FontRegistry::new();
        let mut outputs = Vec::new();
        for width in [73.25, 320.0] {
            for wrap in [
                TextWrap::Word,
                TextWrap::NoWrap,
                TextWrap::Character,
                TextWrap::Word,
            ] {
                for align in [
                    TextAlign::Start,
                    TextAlign::Left,
                    TextAlign::Center,
                    TextAlign::Right,
                    TextAlign::End,
                    TextAlign::Justified,
                    TextAlign::Start,
                ] {
                    let mut document = TextDocument::from_plain_text(text, TextStyle::default());
                    document.paragraphs[0].style.direction = direction;
                    document.paragraphs[0].style.wrap = wrap;
                    document.paragraphs[0].style.align = align;
                    let request = request(&document, width);
                    let size = system
                        .measure_document_size(request.clone(), &fonts)
                        .unwrap();
                    let layout = system.layout_document(request.clone(), &fonts).unwrap();
                    assert_eq!(
                        size,
                        Size::new(layout.measurement().width, layout.measurement().height)
                    );
                    outputs.push((request, layout));
                    discard_final_layouts(&system);
                }
            }
        }
        assert_eq!(system.preparation_cache_snapshot().paragraphs.misses, 1);
        // Compare every result, including old retained geometry, with a new shape
        // in the same font context. Layout IDs and face identities stay comparable.
        for (request, cached) in outputs {
            discard_final_layouts(&system);
            discard_preparation(&system);
            let fresh = system.layout_document(request, &fonts).unwrap();
            assert_geometry(&cached, &fresh);
        }
    }
}

#[test]
fn size_and_materialized_reflow_agree_across_styles_breaks_bidi_and_empty_text() {
    let system = TextSystem::with_bundled_fonts();
    let fonts = FontRegistry::new();
    for text in [
        "",
        "a\n\nlast\n",
        "office e\u{301}\tword\u{a0}glue",
        "אבגדה العربية 123 office",
        "👨‍👩‍👧‍👦 👩🏽‍💻 中文日本語 ไทย",
    ] {
        for wrap in [TextWrap::NoWrap, TextWrap::Word, TextWrap::Character] {
            for direction in [
                TextDirection::Auto,
                TextDirection::LeftToRight,
                TextDirection::RightToLeft,
            ] {
                for align in [TextAlign::Start, TextAlign::Center, TextAlign::Justified] {
                    let mut body = TextStyle {
                        font_size: 15.25,
                        line_height: 19.125,
                        ..TextStyle::default()
                    };
                    body.features.disable(FontFeature::STANDARD_LIGATURES);
                    let mut emphasis = body.clone();
                    emphasis.font_size = 23.75;
                    emphasis.line_height = 28.625;
                    emphasis.weight = FontWeight::BOLD;
                    let mut document = TextDocument::from_plain_text(text, body);
                    for paragraph in &mut document.paragraphs {
                        paragraph.style.wrap = wrap;
                        paragraph.style.direction = direction;
                        paragraph.style.align = align;
                        paragraph
                            .spans
                            .push(TextSpan::new(" tail", emphasis.clone()));
                    }
                    for width in [0.0, 73.25, 320.0] {
                        let size = system
                            .measure_document_size(request(&document, width), &fonts)
                            .unwrap();
                        let layout = system
                            .layout_document(request(&document, width), &fonts)
                            .unwrap();
                        assert_eq!(
                            size,
                            Size::new(layout.measurement().width, layout.measurement().height),
                            "text={text:?}, wrap={wrap:?}, direction={direction:?}, align={align:?}, width={width}"
                        );
                        discard_final_layouts(&system);
                    }
                }
            }
        }
    }
    for document in [
        TextDocument::new(),
        TextDocument::from_plain_text("", TextStyle::default()),
    ] {
        let size = system
            .measure_document_size(TextLayoutRequest::new(document.clone()), &fonts)
            .unwrap();
        let layout = system
            .layout_document(TextLayoutRequest::new(document), &fonts)
            .unwrap();
        assert_eq!(
            size,
            Size::new(layout.measurement().width, layout.measurement().height)
        );
    }
}

#[test]
fn paragraph_reuse_remaps_local_span_metadata_after_document_edits() {
    let system = TextSystem::with_bundled_fonts();
    let fonts = FontRegistry::new();
    let paragraph = TextParagraph::from_spans(vec![
        TextSpan::new("one ", TextStyle::default()),
        TextSpan::new(
            "two",
            TextStyle {
                font_size: 27.0,
                ..TextStyle::default()
            },
        ),
    ]);
    let initial = TextDocument {
        paragraphs: vec![paragraph.clone()],
    };
    system
        .layout_document(request(&initial, 180.0), &fonts)
        .unwrap();
    let edited = TextDocument {
        paragraphs: vec![
            TextParagraph::new("inserted\n", TextStyle::default()),
            paragraph,
        ],
    };
    let reused = system
        .layout_document(request(&edited, 120.0), &fonts)
        .unwrap();
    assert!(system.preparation_cache_snapshot().paragraphs.hits >= 1);
    discard_final_layouts(&system);
    discard_preparation(&system);
    let fresh = system
        .layout_document(request(&edited, 120.0), &fonts)
        .unwrap();
    assert_geometry(&reused, &fresh);
}

#[test]
fn font_registry_replacement_drops_prepared_shapes_and_metrics() {
    let system = TextSystem::with_bundled_fonts();
    let handle = FontHandle::new(4);
    let mut fonts = FontRegistry::new();
    let style = TextStyle {
        font: Some(handle),
        ..TextStyle::default()
    };
    for font in [
        include_bytes!("../../assets/NotoSans-Regular.ttf").as_slice(),
        include_bytes!("../../assets/NotoSansHebrew-Regular.ttf").as_slice(),
    ] {
        fonts.insert(handle, RegisteredFont::from_bytes(font));
        let layout = system
            .shape_text("אבגדה", Size::new(120.0, 40.0), style.clone(), &fonts)
            .unwrap();
        let stats = system.preparation_cache_snapshot();
        assert_eq!(stats.paragraphs.misses, 1);
        assert_eq!(stats.paragraphs.hits, 0);
        assert!(stats.glyphs.misses > 0);
        assert!(layout.faces().iter().any(|face| face.bytes() == font));
    }
    assert_eq!(system.font_context_build_count(), 2);
}

#[test]
fn color_changes_reuse_preparation_but_features_and_metrics_do_not() {
    let system = TextSystem::with_bundled_fonts();
    let fonts = FontRegistry::new();
    let mut style = TextStyle::default();
    system
        .measure_text_size("office", style.clone(), &fonts)
        .unwrap();
    style.color = Color::BLACK;
    system
        .measure_text_size("office", style.clone(), &fonts)
        .unwrap();
    assert_eq!(system.preparation_cache_snapshot().paragraphs.misses, 1);
    style.features.disable(FontFeature::STANDARD_LIGATURES);
    system
        .measure_text_size("office", style.clone(), &fonts)
        .unwrap();
    style.line_height += 3.0;
    system.measure_text_size("office", style, &fonts).unwrap();
    assert_eq!(system.preparation_cache_snapshot().paragraphs.misses, 3);
}

#[test]
fn cache_churn_is_byte_bounded_and_does_not_invalidate_pinned_layouts() {
    let system = TextSystem::with_bundled_fonts();
    let fonts = FontRegistry::new();
    system
        .measure_text_size("prime", TextStyle::default(), &fonts)
        .unwrap();
    {
        let mut cached = system.font_context.lock().unwrap();
        let preparation = &mut cached.as_mut().unwrap().context.preparation;
        preparation.paragraphs = ByteCache::new(100, 24 * 1024);
        preparation.glyphs = ByteCache::new(100, 512);
    }
    let pinned = system
        .shape_text_persistent(
            None,
            "pinned",
            Size::new(120.0, 40.0),
            TextStyle::default(),
            &fonts,
        )
        .unwrap();
    for index in 0..50 {
        system
            .shape_text(
                format!("change {index} abcdefghijklmnopqrstuvwxyz"),
                Size::new(80.0 + index as f32, 40.0),
                TextStyle::default(),
                &fonts,
            )
            .unwrap();
        let stats = system.preparation_cache_snapshot();
        assert!(stats.paragraphs.retained_bytes <= 24 * 1024);
        assert!(stats.glyphs.retained_bytes <= 512);
    }
    let before = system.preparation_cache_snapshot();
    assert!(before.paragraphs.evictions > 0 && before.glyphs.evictions > 0);
    system
        .measure_text_size("oversized ".repeat(4_000), TextStyle::default(), &fonts)
        .unwrap();
    assert_eq!(
        system.preparation_cache_snapshot().paragraphs.entries,
        before.paragraphs.entries
    );
    assert_eq!(
        system.text_layout_registry().get(pinned.handle()),
        Some(pinned.layout())
    );
}