cranpose_ui/widgets/

lazy_list.rs

//! LazyColumn and LazyRow widget implementations.
//!
//! Provides virtualized scrolling lists that only compose visible items,
//! matching Jetpack Compose's `LazyColumn` and `LazyRow` APIs.

#![expect(non_snake_case)]

use std::{
    cell::{Cell, RefCell},
    rc::Rc,
};

use cranpose_core::{NodeId, SlotId, collections::map::HashMap};
use cranpose_foundation::lazy::{
    BeyondItem, LazyItemSource, LazyListIntervalContent, LazyListMeasureConfig,
    LazyListMeasureResult, LazyListMeasuredItem, LazyListState, SmallNodeVec, SmallOffsetVec,
    measure_lazy_list_with_beyond_bounds_policy,
};
pub use cranpose_foundation::lazy::{LazyListItemInfo, LazyListLayoutInfo};
use cranpose_ui_layout::{Constraints, LinearArrangement, MeasureResult, MeasureScope as _};
use smallvec::SmallVec;
use web_time::Instant;

use crate::{
    composable,
    layout::MeasuredNode,
    modifier::{Modifier, Size},
    scroll::{OverscrollEffect, ScrollMotionContextKey, scroll_motion_context_for_key},
    subcompose_layout::{
        MeasurePolicy, Placement, RetainedSlotChildren, SubcomposeChild, SubcomposeLayoutNode,
        SubcomposeMeasureScope, SubcomposeMeasureScopeImpl,
    },
};

const EXPENSIVE_RETAINED_REUSABLE_SLOTS: usize = 128;
const IDLE_PREFETCH_READY_BEYOND_BOUNDS_ITEMS: usize = 2;
const IDLE_PREFETCH_ITEMS_PER_PASS: usize = 1;
/// Where idle prefetch passes run, a scrolling frame composes the new items
/// beyond its viewport that its scroll would bring to the edge within this
/// many frames, and leaves the farther ones to the passes. A fast scroll
/// reaches the ready items, a slow one leaves them all.
const REACH_FRAMES: f32 = 2.0;

#[derive(Clone, Copy)]
struct LazyItemMeasureContext {
    index: usize,
    key_slot_id: u64,
    content_type: Option<u64>,
    is_vertical: bool,
    cross_axis_size: f32,
    measure_start: Instant,
}

/// Specification for LazyColumn layout behavior.
#[derive(Clone, Debug, PartialEq)]
pub struct LazyColumnSpec {
    /// Vertical arrangement for spacing between items.
    pub vertical_arrangement: LinearArrangement,
    /// Content padding before the first item.
    pub content_padding_top: f32,
    /// Content padding after the last item.
    pub content_padding_bottom: f32,
    /// Number of items to compose beyond the visible bounds.
    /// Higher values reduce jank during fast scrolling but use more memory.
    pub beyond_bounds_item_count: usize,
    /// Whether to reverse the layout direction (bottom-to-top).
    pub reverse_layout: bool,
}

impl Default for LazyColumnSpec {
    fn default() -> Self {
        Self {
            vertical_arrangement: LinearArrangement::Start,
            content_padding_top: 0.0,
            content_padding_bottom: 0.0,
            beyond_bounds_item_count: 2,
            reverse_layout: false,
        }
    }
}

impl LazyColumnSpec {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn vertical_arrangement(mut self, arrangement: LinearArrangement) -> Self {
        self.vertical_arrangement = arrangement;
        self
    }

    pub fn content_padding(mut self, top: f32, bottom: f32) -> Self {
        self.content_padding_top = top;
        self.content_padding_bottom = bottom;
        self
    }

    /// Sets uniform content padding for top and bottom.
    pub fn content_padding_all(mut self, padding: f32) -> Self {
        self.content_padding_top = padding;
        self.content_padding_bottom = padding;
        self
    }

    pub fn reverse_layout(mut self, reverse: bool) -> Self {
        self.reverse_layout = reverse;
        self
    }
}

/// Specification for LazyRow layout behavior.
#[derive(Clone, Debug, PartialEq)]
pub struct LazyRowSpec {
    /// Horizontal arrangement for spacing between items.
    pub horizontal_arrangement: LinearArrangement,
    /// Content padding before the first item.
    pub content_padding_start: f32,
    /// Content padding after the last item.
    pub content_padding_end: f32,
    /// Number of items to compose beyond the visible bounds.
    pub beyond_bounds_item_count: usize,
    /// Whether to reverse the layout direction (end-to-start).
    pub reverse_layout: bool,
}

impl Default for LazyRowSpec {
    fn default() -> Self {
        Self {
            horizontal_arrangement: LinearArrangement::Start,
            content_padding_start: 0.0,
            content_padding_end: 0.0,
            beyond_bounds_item_count: 2,
            reverse_layout: false,
        }
    }
}

impl LazyRowSpec {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn horizontal_arrangement(mut self, arrangement: LinearArrangement) -> Self {
        self.horizontal_arrangement = arrangement;
        self
    }

    pub fn content_padding(mut self, start: f32, end: f32) -> Self {
        self.content_padding_start = start;
        self.content_padding_end = end;
        self
    }

    /// Sets uniform content padding for start and end.
    pub fn content_padding_all(mut self, padding: f32) -> Self {
        self.content_padding_start = padding;
        self.content_padding_end = padding;
        self
    }

    pub fn reverse_layout(mut self, reverse: bool) -> Self {
        self.reverse_layout = reverse;
        self
    }
}

struct LazyListItemMeasureInputs<'a> {
    is_vertical: bool,
    cross_axis_size: f32,
    content: &'a LazyListIntervalContent,
    state: &'a LazyListState,
    measured_item_cache: &'a Rc<RefCell<LazyMeasuredItemCache>>,
}

fn measure_lazy_list_item(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    index: usize,
    inputs: &LazyListItemMeasureInputs<'_>,
) -> LazyListMeasuredItem {
    let measure_start = Instant::now();
    let key = inputs.content.get_key(index);
    let key_slot_id = key.to_slot_id();
    let content_type = inputs.content.get_content_type(index);
    let slot_id = SlotId(key_slot_id);
    let item_context = LazyItemMeasureContext {
        index,
        key_slot_id,
        content_type,
        is_vertical: inputs.is_vertical,
        cross_axis_size: inputs.cross_axis_size,
        measure_start,
    };

    scope.update_content_type(slot_id, content_type);

    let candidate_cache = inputs.measured_item_cache.borrow();
    let cached_candidate = candidate_cache
        .candidate(index, key_slot_id, content_type)
        .map(|cached| cached.item.clone());
    let stale_candidate = cached_candidate.is_none() && candidate_cache.contains_index(index);
    drop(candidate_cache);

    if let Some(cached_item) = cached_candidate {
        match scope.activate_exact_retained_slot_with_known_children(slot_id, &cached_item.node_ids)
        {
            Some(RetainedSlotChildren::Clean) => {
                let cache = inputs.measured_item_cache.borrow();
                let current_candidate = cache.candidate(index, key_slot_id, content_type);
                if let Some(cached) =
                    current_candidate.filter(|cached| cached.item.node_ids == cached_item.node_ids)
                {
                    scope.register_retained_measurements(&cached.retained_children);
                    drop(cache);
                    let mut cache = inputs.measured_item_cache.borrow_mut();
                    cache.record_candidate_hit();
                    cache.record_exact_reuse();
                    return cached_item;
                }
                drop(cache);

                let mut cache = inputs.measured_item_cache.borrow_mut();
                cache.record_candidate_hit();
                cache.record_exact_miss();
            }
            Some(RetainedSlotChildren::Remeasure {
                children,
                children_match,
            }) => {
                let mut cache = inputs.measured_item_cache.borrow_mut();
                cache.record_candidate_hit();
                cache.remove(index);
                if children_match {
                    cache.record_dirty_children();
                } else {
                    cache.record_exact_miss();
                }
                drop(cache);
                return measure_lazy_list_children(
                    scope,
                    children,
                    inputs.measured_item_cache,
                    item_context,
                );
            }
            None => {
                let mut cache = inputs.measured_item_cache.borrow_mut();
                cache.record_candidate_hit();
                cache.record_exact_miss();
                cache.remove(index);
            }
        }
    } else {
        let mut cache = inputs.measured_item_cache.borrow_mut();
        cache.record_candidate_miss();
        if stale_candidate {
            cache.remove(index);
        }
    }

    let Some(root_children) = subcompose_lazy_list_item(scope, index, key, inputs) else {
        return LazyListMeasuredItem::new(index, key_slot_id, content_type, 1.0, 0.0);
    };

    let was_reused = scope.was_last_slot_reused().unwrap_or(false);
    inputs.state.record_composition(was_reused);

    let root_node_ids: SmallNodeVec = root_children
        .iter()
        .map(|child| child.node_id() as u64)
        .collect();

    let cache = inputs.measured_item_cache.borrow();
    let has_cached_item = cache
        .get(index, key_slot_id, content_type, &root_node_ids)
        .is_some();
    let mut remove_cache_entry = !has_cached_item && cache.contains_index(index);
    drop(cache);

    if has_cached_item {
        if !scope.children_need_relayout(&root_children) {
            let cache = inputs.measured_item_cache.borrow();
            if let Some(cached) = cache.get(index, key_slot_id, content_type, &root_node_ids) {
                scope.register_retained_measurements(&cached.retained_children);
                let item = cached.item.clone();
                drop(cache);
                return item;
            }
            drop(cache);
        }
        remove_cache_entry = true;
    }
    if remove_cache_entry {
        inputs.measured_item_cache.borrow_mut().remove(index);
    }

    let item = measure_lazy_list_children(
        scope,
        root_children,
        inputs.measured_item_cache,
        item_context,
    );
    crate::lazy_prefetch::record_lazy_item_cost(measure_start.elapsed());
    item
}

fn subcompose_lazy_list_item(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    index: usize,
    key: cranpose_foundation::lazy::LazyLayoutKey,
    inputs: &LazyListItemMeasureInputs<'_>,
) -> Option<Vec<SubcomposeChild>> {
    let key_slot_id = key.to_slot_id();
    let item_identity = key.is_user_key().then_some(key_slot_id);
    let item_content = inputs
        .content
        .with_interval(index, |local_index, interval| {
            let content = Rc::clone(&interval.content);
            move || {
                crate::lazy_item::ProvideLazyItemKey(item_identity, || (content)(local_index));
            }
        })?;
    Some(scope.subcompose(SlotId(key_slot_id), (), item_content))
}

fn keep_lazy_list_item(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    index: usize,
    inputs: &LazyListItemMeasureInputs<'_>,
) {
    let key = inputs.content.get_key(index);
    scope.update_content_type(
        SlotId(key.to_slot_id()),
        inputs.content.get_content_type(index),
    );
    let _ = subcompose_lazy_list_item(scope, index, key, inputs);
}

fn lazy_list_child_constraints(is_vertical: bool, cross_axis_size: f32) -> Constraints {
    if is_vertical {
        Constraints {
            min_width: 0.0,
            max_width: cross_axis_size,
            min_height: 0.0,
            max_height: f32::INFINITY,
        }
    } else {
        Constraints {
            min_width: 0.0,
            max_width: f32::INFINITY,
            min_height: 0.0,
            max_height: cross_axis_size,
        }
    }
}
fn register_visible_lazy_list_child_measurements(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    visible_items: &[LazyListMeasuredItem],
    is_vertical: bool,
    cross_axis_size: f32,
) {
    let child_constraints = lazy_list_child_constraints(is_vertical, cross_axis_size);
    scope.ensure_cached_measurement_node_ids(
        visible_items
            .iter()
            .flat_map(|item| item.node_ids.iter())
            .filter_map(|&node_id| NodeId::try_from(node_id).ok()),
        child_constraints,
    );
}

fn measure_lazy_list_children(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    root_children: Vec<SubcomposeChild>,
    measured_item_cache: &Rc<RefCell<LazyMeasuredItemCache>>,
    context: LazyItemMeasureContext,
) -> LazyListMeasuredItem {
    let child_constraints =
        lazy_list_child_constraints(context.is_vertical, context.cross_axis_size);

    let mut total_main_size: f32 = 0.0;
    let mut max_cross_size: f32 = 0.0;
    let mut node_ids: SmallNodeVec = SmallVec::with_capacity(root_children.len());
    let mut child_offsets: SmallOffsetVec = SmallVec::new();
    let mut child_cross_axis_sizes: SmallOffsetVec = SmallVec::new();
    let mut retained_children: SmallVec<[Rc<MeasuredNode>; 4]> =
        SmallVec::with_capacity(root_children.len());

    for child in root_children {
        let (placeable, retained) = scope.measure_retained(child, child_constraints);
        let size = retained.as_ref().map_or_else(
            || Size {
                width: placeable.width(),
                height: placeable.height(),
            },
            |measured| measured.size(),
        );
        let (main, cross) = if context.is_vertical {
            (size.height, size.width)
        } else {
            (size.width, size.height)
        };

        child_offsets.push(total_main_size);
        child_cross_axis_sizes.push(cross);
        node_ids.push(child.node_id() as u64);
        if let Some(retained) = retained {
            retained_children.push(retained);
        }

        total_main_size += main;
        max_cross_size = max_cross_size.max(cross);
    }

    let main_axis_size = total_main_size.max(1.0);
    let mut item = LazyListMeasuredItem::new(
        context.index,
        context.key_slot_id,
        context.content_type,
        main_axis_size,
        max_cross_size,
    );
    item.node_ids = node_ids;
    item.child_offsets = child_offsets;
    item.child_cross_axis_sizes = child_cross_axis_sizes;

    measured_item_cache
        .borrow_mut()
        .insert(item.clone(), retained_children);
    let elapsed = context.measure_start.elapsed();
    if cranpose_core::env_flag!("CRANPOSE_LAZY_ITEM_TELEMETRY") {
        log::warn!(
            "[lazy-item-telemetry] index={} children={} main={:.2} cross={:.2} elapsed_ms={:.2}",
            context.index,
            item.node_ids.len(),
            item.main_axis_size,
            item.cross_axis_size,
            elapsed.as_secs_f64() * 1000.0
        );
    }
    measured_item_cache.borrow_mut().record_uncached_measure();
    item
}

/// Recycles the active slots of items before `first_measured_index`, found
/// among the items `near` the viewport, where every slot a forward scroll
/// skips was active.
fn recycle_forward_skipped_active_slots(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    content: &LazyListIntervalContent,
    near: &std::ops::Range<usize>,
    first_measured_index: usize,
    scroll_delta: f32,
) -> bool {
    if scroll_delta >= -0.001 || first_measured_index == 0 {
        return false;
    }

    scope.recycle_active_slots_where(|slot_id| {
        content
            .get_index_by_slot_id_in_range(slot_id.raw(), near.clone())
            .is_some_and(|index| index < first_measured_index)
    });
    true
}

/// Internal helper to create a lazy list measure policy.
struct LazyListMeasureContext<'a> {
    state: &'a LazyListState,
    config: &'a LazyListMeasureConfig,
    measured_item_cache: &'a Rc<RefCell<LazyMeasuredItemCache>>,
    overscroll: &'a OverscrollEffect,
}

fn measure_lazy_list_internal(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    constraints: Constraints,
    is_vertical: bool,
    content: &LazyListIntervalContent,
    context: LazyListMeasureContext<'_>,
) -> MeasureResult {
    let state = context.state;
    let config = context.config;
    let measured_item_cache = context.measured_item_cache;
    let overscroll = context.overscroll;
    let raw_viewport_size = if is_vertical {
        constraints.max_height
    } else {
        constraints.max_width
    };
    let cross_axis_size = if is_vertical {
        constraints.max_width
    } else {
        constraints.max_height
    };

    let items_count = content.item_count();
    let retained_reusable_slots = EXPENSIVE_RETAINED_REUSABLE_SLOTS;
    scope.set_reusable_pool_limits(retained_reusable_slots, retained_reusable_slots);
    measured_item_cache
        .borrow_mut()
        .begin_pass(scope, is_vertical, cross_axis_size);
    let near = state.nearest_range();
    if items_count > 0 {
        state.update_scroll_position_if_item_moved(items_count, |slot_id| {
            content.get_index_by_slot_id_in_range(slot_id, near.clone())
        });
    }

    let scroll_delta_for_direction = state.peek_scroll_delta();
    let item_measure_inputs = LazyListItemMeasureInputs {
        is_vertical,
        cross_axis_size,
        content,
        state,
        measured_item_cache,
    };

    let focused_item = measure_focused_lazy_item(scope, &item_measure_inputs);
    let node_id = scope.root_id();
    let place_beyond = scope.focused_slot().is_some();

    let mut result = measure_lazy_viewport(
        LazyListItems {
            scope: &mut *scope,
            inputs: &item_measure_inputs,
            near,
            scroll_delta: scroll_delta_for_direction,
            skipped_slots_recycled: false,
            place_beyond,
            beyond: None,
        },
        config,
        raw_viewport_size,
        node_id,
    );
    if let Some(item) = focused_item {
        place_focused_lazy_item(&mut result, item, &item_measure_inputs, config.spacing);
    }
    register_visible_lazy_list_child_measurements(
        scope,
        &result.visible_items,
        is_vertical,
        cross_axis_size,
    );
    log_lazy_cache_telemetry(&result, measured_item_cache);
    let effective_viewport_size = result.viewport_size;
    overscroll.set_dimension(effective_viewport_size);

    state.cache_item_sizes(
        result
            .visible_items
            .iter()
            .map(|item| (item.index, item.main_axis_size)),
    );
    let truly_visible_count = result
        .visible_items
        .iter()
        .filter(|item| {
            let item_end = item.offset + item.main_axis_size;
            item.offset < effective_viewport_size && item_end > 0.0
        })
        .count();
    let in_pool = scope.reusable_slots_count();
    state.update_stats(truly_visible_count, in_pool);

    let resolve_main_axis = |content_size: f32, min: f32, max: f32| {
        if max.is_finite() {
            content_size.clamp(min, max)
        } else {
            content_size.min(effective_viewport_size).max(min)
        }
    };

    let width = if is_vertical {
        cross_axis_size
    } else {
        resolve_main_axis(
            result.total_content_size,
            constraints.min_width,
            constraints.max_width,
        )
    };
    let height = if is_vertical {
        resolve_main_axis(
            result.total_content_size,
            constraints.min_height,
            constraints.max_height,
        )
    } else {
        cross_axis_size
    };

    let density = scope.density();
    scope.layout_with_placement_builder(width, height, |placements| {
        push_lazy_list_placements(
            placements,
            density,
            &result.visible_items,
            items_count,
            is_vertical,
            effective_viewport_size,
            config,
            cross_axis_size,
        );
        let bounce = overscroll.offset();
        for placement in placements.iter_mut() {
            if is_vertical {
                placement.y += bounce;
            } else {
                placement.x += bounce;
            }
        }
    })
}

struct LazyListItems<'s, 'a, 'i> {
    scope: &'s mut SubcomposeMeasureScopeImpl<'a>,
    inputs: &'i LazyListItemMeasureInputs<'i>,
    near: std::ops::Range<usize>,
    scroll_delta: f32,
    skipped_slots_recycled: bool,
    place_beyond: bool,
    beyond: Option<BeyondBoundsComposition>,
}

impl LazyListItems<'_, '_, '_> {
    fn composed(&self, index: usize) -> bool {
        self.scope
            .slot_is_active(SlotId(self.inputs.content.get_key(index).to_slot_id()))
    }
}

impl LazyItemSource for LazyListItems<'_, '_, '_> {
    fn measure(&mut self, index: usize) -> LazyListMeasuredItem {
        if !self.skipped_slots_recycled
            && recycle_forward_skipped_active_slots(
                self.scope,
                self.inputs.content,
                &self.near,
                index,
                self.scroll_delta,
            )
        {
            self.skipped_slots_recycled = true;
        }
        // An item an idle pass composes afresh has its modifier slices built
        // before the frame it enters the screen in.
        let fresh =
            self.beyond.as_ref().is_some_and(|beyond| beyond.idle_pass) && !self.composed(index);
        let item = measure_lazy_list_item(self.scope, index, self.inputs);
        if fresh {
            crate::lazy_prefetch::note_prefetched_item(&item.node_ids);
        }
        item
    }

    fn keep_beyond(&mut self, index: usize, distance: f32) -> BeyondItem {
        let composed = self.composed(index);
        if let Some(beyond) = self.beyond.as_mut()
            && !beyond.admits(composed, distance)
        {
            return BeyondItem::Declined;
        }
        if self.place_beyond {
            return BeyondItem::Placed(self.measure(index));
        }
        if composed {
            keep_lazy_list_item(self.scope, index, self.inputs);
        } else {
            self.measure(index);
        }
        BeyondItem::Kept
    }
}

/// Measures the list's viewport. While it scrolls, and in an idle prefetch
/// pass, the items beyond it compose as [`BeyondBoundsComposition`] decides,
/// and an item left for later asks for a pass for the list `node_id`. So do
/// they at rest where the shell runs idle prefetch passes, unless the list
/// holds the focus and places them.
fn measure_lazy_viewport(
    mut items: LazyListItems<'_, '_, '_>,
    config: &LazyListMeasureConfig,
    viewport_size: f32,
    node_id: NodeId,
) -> LazyListMeasureResult {
    let inputs = items.inputs;
    let items_count = inputs.content.item_count();
    let idle_pass = crate::lazy_prefetch::in_lazy_prefetch_pass();
    if idle_pass {
        inputs.state.hold_scroll_window();
    }
    let scrolling = items.scroll_delta.abs() > 0.001;
    let passes_run = crate::lazy_prefetch::idle_prefetch_passes_run();
    if idle_pass {
        items.beyond = Some(BeyondBoundsComposition::new(true, f32::INFINITY));
    } else if scrolling || (passes_run && !items.place_beyond) {
        let reach = if passes_run {
            items.scroll_delta.abs() * REACH_FRAMES
        } else {
            f32::INFINITY
        };
        items.beyond = Some(BeyondBoundsComposition::new(false, reach));
    }
    let result = measure_lazy_list_with_beyond_bounds_policy(
        items_count,
        inputs.state,
        viewport_size,
        inputs.cross_axis_size,
        config,
        &mut items,
    );
    if items.beyond.is_some_and(|beyond| beyond.wants_prefetch) {
        crate::lazy_prefetch::request_lazy_prefetch(node_id);
    }
    result
}

/// Which items beyond the viewport a list composes, in order away from it.
/// Composed items stay composed. A frame composes new ones that start within
/// its reach until enough composed items lie ahead, counting its own; the
/// next is left for an idle prefetch pass, which composes one.
#[derive(Clone, Copy)]
struct BeyondBoundsComposition {
    idle_pass: bool,
    ready: usize,
    frontier: usize,
    /// How far past the viewport a new item may start for a frame to compose
    /// it. Where idle prefetch passes run, the distance its scroll covers in
    /// [`REACH_FRAMES`] frames, none at rest: the passes compose the rest.
    reach: f32,
    wants_prefetch: bool,
}

impl BeyondBoundsComposition {
    fn new(idle_pass: bool, reach: f32) -> Self {
        Self {
            idle_pass,
            ready: 0,
            frontier: if idle_pass {
                IDLE_PREFETCH_ITEMS_PER_PASS
            } else {
                IDLE_PREFETCH_READY_BEYOND_BOUNDS_ITEMS
            },
            reach,
            wants_prefetch: false,
        }
    }

    fn admits(&mut self, composed: bool, distance: f32) -> bool {
        if composed {
            self.ready += 1;
            return true;
        }
        let deferred = !self.idle_pass
            && (self.ready >= IDLE_PREFETCH_READY_BEYOND_BOUNDS_ITEMS || distance >= self.reach);
        if deferred || self.frontier == 0 {
            self.wants_prefetch = true;
            return false;
        }
        self.frontier -= 1;
        self.ready += 1;
        true
    }
}

fn measure_focused_lazy_item(
    scope: &mut SubcomposeMeasureScopeImpl<'_>,
    inputs: &LazyListItemMeasureInputs<'_>,
) -> Option<LazyListMeasuredItem> {
    let slot = scope.focused_slot()?.raw();
    let content = inputs.content;
    let last_measured = inputs.measured_item_cache.borrow().focused_index(slot);
    let found = last_measured
        .filter(|&index| {
            index < content.item_count() && content.get_key(index).to_slot_id() == slot
        })
        .or_else(|| content.get_index_by_slot_id_in_range(slot, inputs.state.nearest_range()))
        .or_else(|| content.get_index_by_slot_id(slot));
    let Some(index) = found else {
        let _ = cranpose_core::run_in_mutable_snapshot(|| crate::FocusManager.clear_focus());
        return None;
    };
    inputs
        .measured_item_cache
        .borrow_mut()
        .remember_focused(slot, index);
    Some(measure_lazy_list_item(scope, index, inputs))
}

fn place_focused_lazy_item(
    result: &mut LazyListMeasureResult,
    mut item: LazyListMeasuredItem,
    inputs: &LazyListItemMeasureInputs<'_>,
    spacing: f32,
) {
    let Err(position) = result
        .visible_items
        .binary_search_by_key(&item.index, |entry| entry.index)
    else {
        return;
    };
    let Some(anchor) = result.visible_items.first() else {
        return;
    };
    let start = item.index.min(anchor.index);
    let end = item.index.max(anchor.index);
    let estimate = anchor.main_axis_size;
    let mut distance = (end - start) as f32 * (estimate + spacing);
    for (&index, cached) in &inputs.measured_item_cache.borrow().entries {
        if (start..end).contains(&index)
            && cached.item.key == inputs.content.get_key(index).to_slot_id()
        {
            distance += cached.item.main_axis_size - estimate;
        }
    }
    item.offset = anchor.offset
        + if item.index < anchor.index {
            -distance
        } else {
            distance
        };
    result.visible_items.insert(position, item);
}

fn bind_layout_invalidation_callback(
    state: LazyListState,
    overscroll: OverscrollEffect,
    list_state_id: usize,
    node_id: NodeId,
) {
    let callback_owner =
        cranpose_core::remember(|| Rc::new(RefCell::new(None::<u64>))).with(Clone::clone);
    let app_context_id = crate::render_state::current_app_context_id();
    let callback_id = state.try_register_layout_callback(
        node_id,
        Rc::new(move || {
            let _ = crate::render_state::enter_app_context_by_id(app_context_id, || {
                crate::schedule_measure_repass(node_id);
            });
        }),
    );

    if let Some(previous_id) = callback_owner.replace(callback_id)
        && Some(previous_id) != callback_id
    {
        state.remove_invalidate_callback(previous_id);
    }

    let overscroll_callback_owner =
        cranpose_core::remember(|| Rc::new(RefCell::new(None::<u64>))).with(Clone::clone);
    let overscroll_callback_id = overscroll.add_invalidate_callback(Box::new(move || {
        let _ = crate::render_state::enter_app_context_by_id(app_context_id, || {
            crate::schedule_measure_repass(node_id);
            crate::schedule_semantics_invalidation(node_id);
        });
    }));
    if let Some(previous_id) = overscroll_callback_owner.replace(Some(overscroll_callback_id)) {
        overscroll.remove_invalidate_callback(previous_id);
    }

    cranpose_core::DisposableEffect(
        (list_state_id, node_id, callback_id, overscroll_callback_id),
        move |scope| {
            scope.on_dispose(move || {
                if let Some(callback_id) = callback_id {
                    state.remove_invalidate_callback(callback_id);
                }
                overscroll.remove_invalidate_callback(overscroll_callback_id);
            })
        },
    );
}

#[derive(Clone)]
struct LazyListContentHandle(Rc<LazyListIntervalContent>);

impl LazyListContentHandle {
    fn new(content: LazyListIntervalContent) -> Self {
        Self(Rc::new(content))
    }

    fn empty() -> Self {
        Self::new(LazyListIntervalContent::new())
    }

    fn content(&self) -> &LazyListIntervalContent {
        self.0.as_ref()
    }
}

impl PartialEq for LazyListContentHandle {
    fn eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.0, &other.0)
    }
}

#[derive(Default)]
struct LazyMeasuredItemCache {
    is_vertical: bool,
    cross_axis_bits: u32,
    telemetry: LazyCacheTelemetry,
    entries: HashMap<usize, CachedLazyMeasuredItem>,
    focused: Option<(u64, usize)>,
}

struct CachedLazyMeasuredItem {
    item: LazyListMeasuredItem,
    retained_children: SmallVec<[Rc<MeasuredNode>; 4]>,
}

#[derive(Clone, Copy, Default)]
struct LazyCacheTelemetry {
    candidate_hits: usize,
    candidate_misses: usize,
    exact_reuses: usize,
    exact_misses: usize,
    dirty_children: usize,
    uncached_measures: usize,
}

impl LazyCacheTelemetry {
    fn has_events(self) -> bool {
        self.candidate_hits > 0
            || self.candidate_misses > 0
            || self.exact_reuses > 0
            || self.exact_misses > 0
            || self.dirty_children > 0
            || self.uncached_measures > 0
    }
}

impl LazyMeasuredItemCache {
    /// The index the item in `slot` was last measured at while focused, the
    /// first place to look for it: a focused item scrolled far from the
    /// viewport is found there without scanning the list.
    fn focused_index(&self, slot: u64) -> Option<usize> {
        self.focused
            .filter(|(focused, _)| *focused == slot)
            .map(|(_, index)| index)
    }

    fn remember_focused(&mut self, slot: u64, index: usize) {
        self.focused = Some((slot, index));
    }

    fn retain_constraint_scope(&mut self, is_vertical: bool, cross_axis_size: f32) {
        let cross_axis_bits = normalized_axis_bits(cross_axis_size);
        if self.entries.is_empty() {
            self.is_vertical = is_vertical;
            self.cross_axis_bits = cross_axis_bits;
            return;
        }
        if self.is_vertical != is_vertical || self.cross_axis_bits != cross_axis_bits {
            self.clear();
            self.is_vertical = is_vertical;
            self.cross_axis_bits = cross_axis_bits;
        }
    }

    fn clear(&mut self) {
        self.entries.clear();
    }

    /// Drops what a new measure pass cannot reuse: everything, when the
    /// list's axis or cross size changed, and otherwise the items whose slots
    /// `scope` no longer holds.
    fn begin_pass(
        &mut self,
        scope: &SubcomposeMeasureScopeImpl<'_>,
        is_vertical: bool,
        cross_axis_size: f32,
    ) {
        self.retain_constraint_scope(is_vertical, cross_axis_size);
        self.retain_retained_slots(|slot_id| scope.slot_is_retained(slot_id));
    }

    /// Keeps only the items whose slots the subcompose state still holds.
    /// An item whose composition was disposed can never be reused, and its
    /// entry would keep the item's whole measured tree alive: an endless list
    /// scrolled past thousands of items kept them all.
    fn retain_retained_slots(&mut self, is_retained: impl Fn(SlotId) -> bool) {
        self.entries
            .retain(|_, cached| is_retained(SlotId(cached.item.key)));
    }

    fn get(
        &self,
        index: usize,
        key: u64,
        content_type: Option<u64>,
        node_ids: &SmallNodeVec,
    ) -> Option<&CachedLazyMeasuredItem> {
        let cached = self.entries.get(&index)?;
        if cached.item.key != key
            || cached.item.content_type != content_type
            || cached.item.node_ids != *node_ids
            || cached.retained_children.len() != cached.item.node_ids.len()
        {
            return None;
        }
        Some(cached)
    }

    fn contains_index(&self, index: usize) -> bool {
        self.entries.contains_key(&index)
    }

    fn candidate(
        &self,
        index: usize,
        key: u64,
        content_type: Option<u64>,
    ) -> Option<&CachedLazyMeasuredItem> {
        let cached = self.entries.get(&index)?;
        if cached.item.key != key
            || cached.item.content_type != content_type
            || cached.retained_children.len() != cached.item.node_ids.len()
        {
            return None;
        }
        Some(cached)
    }

    fn remove(&mut self, index: usize) {
        self.entries.remove(&index);
    }

    fn insert(
        &mut self,
        item: LazyListMeasuredItem,
        retained_children: SmallVec<[Rc<MeasuredNode>; 4]>,
    ) {
        let index = item.index;
        let cached = CachedLazyMeasuredItem {
            item,
            retained_children,
        };
        self.entries.insert(index, cached);
    }

    fn record_candidate_hit(&mut self) {
        self.telemetry.candidate_hits += 1;
    }

    fn record_candidate_miss(&mut self) {
        self.telemetry.candidate_misses += 1;
    }

    fn record_exact_reuse(&mut self) {
        self.telemetry.exact_reuses += 1;
    }

    fn record_exact_miss(&mut self) {
        self.telemetry.exact_misses += 1;
    }

    fn record_dirty_children(&mut self) {
        self.telemetry.dirty_children += 1;
    }

    fn take_telemetry(&mut self) -> LazyCacheTelemetry {
        std::mem::take(&mut self.telemetry)
    }

    fn record_uncached_measure(&mut self) {
        self.telemetry.uncached_measures += 1;
    }
}

fn log_lazy_cache_telemetry(
    result: &LazyListMeasureResult,
    measured_item_cache: &Rc<RefCell<LazyMeasuredItemCache>>,
) {
    if !cranpose_core::env_flag!("CRANPOSE_LAZY_CACHE_TELEMETRY") {
        return;
    }

    let telemetry = measured_item_cache.borrow_mut().take_telemetry();
    if !telemetry.has_events() {
        return;
    }

    let message = format!(
        "[lazy-cache-telemetry] first={} offset={:.2} visible={} candidate_hits={} candidate_misses={} exact_reuses={} exact_misses={} dirty_children={} uncached_measures={} cache_entries={}",
        result.first_visible_item_index,
        result.first_visible_item_scroll_offset,
        result.visible_items.len(),
        telemetry.candidate_hits,
        telemetry.candidate_misses,
        telemetry.exact_reuses,
        telemetry.exact_misses,
        telemetry.dirty_children,
        telemetry.uncached_measures,
        measured_item_cache.borrow().entries.len(),
    );
    log::warn!("{message}");
    #[cfg(test)]
    eprintln!("{message}");
}

fn normalized_axis_bits(size: f32) -> u32 {
    if size.is_finite() && size >= 0.0 {
        size.to_bits()
    } else {
        f32::INFINITY.to_bits()
    }
}

#[expect(clippy::too_many_arguments)]
fn push_lazy_list_placements(
    placements: &mut Vec<Placement>,
    density: f32,
    visible_items: &[LazyListMeasuredItem],
    items_count: usize,
    is_vertical: bool,
    viewport_size: f32,
    config: &LazyListMeasureConfig,
    cross_axis_size: f32,
) {
    use cranpose_ui_layout::Arrangement;

    placements.clear();
    placements.reserve(visible_items.iter().map(|item| item.node_ids.len()).sum());

    let arrangement = if is_vertical {
        config
            .vertical_arrangement
            .unwrap_or(LinearArrangement::Start)
    } else {
        config
            .horizontal_arrangement
            .unwrap_or(LinearArrangement::Start)
    };

    let spacing = config.spacing;
    let total_item_size: f32 = visible_items.iter().map(|i| i.main_axis_size).sum::<f32>()
        + (items_count.saturating_sub(1) as f32) * spacing;
    let available_main_axis =
        (viewport_size - config.before_content_padding - config.after_content_padding).max(0.0);
    let has_spare_space =
        total_item_size < available_main_axis && visible_items.len() == items_count;
    let should_apply_arrangement = has_spare_space
        && !matches!(
            arrangement,
            LinearArrangement::Start | LinearArrangement::SpacedBy(_)
        );

    if should_apply_arrangement {
        let content_offset = config.before_content_padding;

        let sizes: SmallVec<[f32; 32]> = visible_items.iter().map(|i| i.main_axis_size).collect();
        let mut positions: SmallVec<[f32; 32]> = SmallVec::from_elem(0.0, sizes.len());
        arrangement.arrange(density, available_main_axis, &sizes, &mut positions);

        for (item, &pos) in visible_items.iter().zip(positions.iter()) {
            push_lazy_item_placements(
                placements,
                item,
                content_offset + pos,
                is_vertical,
                viewport_size,
                cross_axis_size,
                config,
            );
        }
    } else {
        for item in visible_items {
            push_lazy_item_placements(
                placements,
                item,
                item.offset,
                is_vertical,
                viewport_size,
                cross_axis_size,
                config,
            );
        }
    }
}

fn push_lazy_item_placements(
    placements: &mut Vec<Placement>,
    item: &LazyListMeasuredItem,
    offset: f32,
    is_vertical: bool,
    viewport_size: f32,
    cross_axis_size: f32,
    config: &LazyListMeasureConfig,
) {
    let start = if config.reverse_layout {
        viewport_size - offset - item.main_axis_size
    } else {
        offset
    };
    for (index, (&node_id, &offset)) in item.node_ids.iter().zip(&item.child_offsets).enumerate() {
        let main = start + offset;
        let (mut x, y) = if is_vertical {
            (0.0, main)
        } else {
            (main, 0.0)
        };
        if config.is_rtl {
            x = if is_vertical {
                cross_axis_size
                    - item
                        .child_cross_axis_sizes
                        .get(index)
                        .copied()
                        .unwrap_or(item.cross_axis_size)
            } else {
                let end = item
                    .child_offsets
                    .get(index + 1)
                    .copied()
                    .unwrap_or(item.main_axis_size);
                viewport_size - x - (end - offset)
            };
        }
        placements.push(Placement::new(node_id as NodeId, x, y, 0));
    }
}

fn lazy_list_state_identity(state: &LazyListState) -> usize {
    let state_ptr = state.inner_ptr();
    debug_assert!(
        !state_ptr.is_null(),
        "lazy list identity requires a live LazyListState"
    );
    state_ptr as usize
}

fn lazy_list_state_only_recomposition(state: &LazyListState) -> bool {
    cranpose_core::current_recompose_scope_invalidated_only_by(state.reactive_state_ids())
        .unwrap_or(false)
}

/// Internal implementation for LazyColumn that takes pre-built content.
///
/// Users should prefer the DSL-based [`LazyColumn`] function instead.
fn LazyColumnImpl(
    modifier: Modifier,
    state: LazyListState,
    spec: LazyColumnSpec,
    content: LazyListContentHandle,
) -> NodeId {
    use std::cell::RefCell;

    let content_cell =
        cranpose_core::remember(|| Rc::new(RefCell::new(LazyListContentHandle::empty())))
            .with(Clone::clone);

    let refresh_content = !lazy_list_state_only_recomposition(&state);
    if refresh_content {
        *content_cell.borrow_mut() = content;
    }
    let caller_modifier_changed = super::layout::caller_modifier_changed(&modifier);

    let composed_density = crate::density::density();
    let config = LazyListMeasureConfig {
        is_vertical: true,
        is_rtl: crate::layout_direction().is_rtl(),
        reverse_layout: spec.reverse_layout,
        before_content_padding: spec.content_padding_top,
        after_content_padding: spec.content_padding_bottom,
        spacing: spec
            .vertical_arrangement
            .spacing(composed_density.density()),
        beyond_bounds_item_count: spec.beyond_bounds_item_count,
        vertical_arrangement: Some(spec.vertical_arrangement),
        horizontal_arrangement: None,
    };
    let config_cell =
        cranpose_core::remember(|| Rc::new(RefCell::new(config.clone()))).with(Clone::clone);
    let config_changed = {
        let mut current = config_cell.borrow_mut();
        let changed = *current != config;
        if changed {
            *current = config;
        }
        changed
    };
    let measured_item_cache =
        cranpose_core::remember(|| Rc::new(RefCell::new(LazyMeasuredItemCache::default())))
            .with(Clone::clone);
    let motion_context = scroll_motion_context_for_key(ScrollMotionContextKey::LazyList {
        state_identity: lazy_list_state_identity(&state),
        is_vertical: true,
        reverse_scrolling: spec.reverse_layout,
    });
    let overscroll = motion_context.overscroll();

    let measured_item_cache_for_policy = measured_item_cache.clone();
    let overscroll_for_policy = overscroll.clone();
    let policy: Rc<MeasurePolicy> = cranpose_core::remember(move || {
        let config_ref = config_cell.clone();
        let content_ref = content_cell.clone();
        let measured_item_cache = measured_item_cache_for_policy.clone();
        let overscroll = overscroll_for_policy.clone();
        let policy: Rc<MeasurePolicy> = Rc::new(
            move |scope: &mut SubcomposeMeasureScopeImpl<'_>, constraints: Constraints| {
                let content = content_ref.borrow();
                let config = config_ref.borrow().clone();
                measure_lazy_list_internal(
                    scope,
                    constraints,
                    true,
                    content.content(),
                    LazyListMeasureContext {
                        state: &state,
                        config: &config,
                        measured_item_cache: &measured_item_cache,
                        overscroll: &overscroll,
                    },
                )
            },
        );
        policy
    })
    .with(|p| p.clone());
    let list_state_id = lazy_list_state_identity(&state);

    let scroll_modifier = modifier.clip_to_bounds().lazy_vertical_scroll_with_context(
        state,
        spec.reverse_layout,
        (spec.content_padding_top, spec.content_padding_bottom),
        motion_context,
    );

    let node_id = cranpose_core::with_current_composer(|composer| {
        composer.with_key(&(list_state_id, "LazyColumnNode"), |composer| {
            composer.emit_node({
                let scroll_modifier = scroll_modifier.clone();
                let policy = Rc::clone(&policy);
                move || SubcomposeLayoutNode::with_content_type_policy(scroll_modifier, policy)
            })
        })
    });
    let captured_context =
        cranpose_core::with_current_composer(cranpose_core::Composer::capture_composition_context);
    if let Err(err) = cranpose_core::with_node_mut(node_id, |node: &mut SubcomposeLayoutNode| {
        let inputs_changed =
            refresh_content || config_changed || !node.modifier().structural_eq(&scroll_modifier);
        if inputs_changed || caller_modifier_changed {
            node.set_modifier(scroll_modifier.clone());
        }
        node.set_measure_policy(Rc::clone(&policy));
        node.set_captured_context(captured_context);
        node.set_density(composed_density);
        node.set_layout_direction(crate::layout_direction());
        if inputs_changed {
            measured_item_cache.borrow_mut().clear();
            node.invalidate_subcomposition();
        }
    }) {
        debug_assert!(false, "failed to update LazyColumn node: {err}");
    }
    bind_layout_invalidation_callback(state, overscroll, list_state_id, node_id);

    node_id
}

/// Internal implementation for LazyRow that takes pre-built content.
///
/// Users should prefer the DSL-based [`LazyRow`] function instead.
fn LazyRowImpl(
    modifier: Modifier,
    state: LazyListState,
    spec: LazyRowSpec,
    content: LazyListContentHandle,
) -> NodeId {
    use std::cell::RefCell;

    let content_cell =
        cranpose_core::remember(|| Rc::new(RefCell::new(LazyListContentHandle::empty())))
            .with(Clone::clone);

    let refresh_content = !lazy_list_state_only_recomposition(&state);
    if refresh_content {
        *content_cell.borrow_mut() = content;
    }
    let caller_modifier_changed = super::layout::caller_modifier_changed(&modifier);

    let composed_density = crate::density::density();
    let is_rtl = crate::layout_direction().is_rtl();
    let reverse_scrolling = spec.reverse_layout ^ is_rtl;
    let config = LazyListMeasureConfig {
        is_vertical: false,
        is_rtl,
        reverse_layout: spec.reverse_layout,
        before_content_padding: spec.content_padding_start,
        after_content_padding: spec.content_padding_end,
        spacing: spec
            .horizontal_arrangement
            .spacing(composed_density.density()),
        beyond_bounds_item_count: spec.beyond_bounds_item_count,
        vertical_arrangement: None,
        horizontal_arrangement: Some(spec.horizontal_arrangement),
    };
    let config_cell =
        cranpose_core::remember(|| Rc::new(RefCell::new(config.clone()))).with(Clone::clone);
    let config_changed = {
        let mut current = config_cell.borrow_mut();
        let changed = *current != config;
        if changed {
            *current = config;
        }
        changed
    };
    let measured_item_cache =
        cranpose_core::remember(|| Rc::new(RefCell::new(LazyMeasuredItemCache::default())))
            .with(Clone::clone);
    let motion_context = scroll_motion_context_for_key(ScrollMotionContextKey::LazyList {
        state_identity: lazy_list_state_identity(&state),
        is_vertical: false,
        reverse_scrolling,
    });
    let overscroll = motion_context.overscroll();

    let measured_item_cache_for_policy = measured_item_cache.clone();
    let overscroll_for_policy = overscroll.clone();
    let policy: Rc<MeasurePolicy> = cranpose_core::remember(move || {
        let config_ref = config_cell.clone();
        let content_ref = content_cell.clone();
        let measured_item_cache = measured_item_cache_for_policy.clone();
        let overscroll = overscroll_for_policy.clone();
        let policy: Rc<MeasurePolicy> = Rc::new(
            move |scope: &mut SubcomposeMeasureScopeImpl<'_>, constraints: Constraints| {
                let content = content_ref.borrow();
                let config = config_ref.borrow().clone();
                measure_lazy_list_internal(
                    scope,
                    constraints,
                    false,
                    content.content(),
                    LazyListMeasureContext {
                        state: &state,
                        config: &config,
                        measured_item_cache: &measured_item_cache,
                        overscroll: &overscroll,
                    },
                )
            },
        );
        policy
    })
    .with(|p| p.clone());
    let list_state_id = lazy_list_state_identity(&state);

    let scroll_modifier = modifier
        .clip_to_bounds()
        .lazy_horizontal_scroll_with_context(
            state,
            reverse_scrolling,
            (spec.content_padding_start, spec.content_padding_end),
            motion_context,
        );

    let node_id = cranpose_core::with_current_composer(|composer| {
        composer.with_key(&(list_state_id, "LazyRowNode"), |composer| {
            composer.emit_node({
                let scroll_modifier = scroll_modifier.clone();
                let policy = Rc::clone(&policy);
                move || SubcomposeLayoutNode::with_content_type_policy(scroll_modifier, policy)
            })
        })
    });
    let captured_context =
        cranpose_core::with_current_composer(cranpose_core::Composer::capture_composition_context);
    if let Err(err) = cranpose_core::with_node_mut(node_id, |node: &mut SubcomposeLayoutNode| {
        let inputs_changed =
            refresh_content || config_changed || !node.modifier().structural_eq(&scroll_modifier);
        if inputs_changed || caller_modifier_changed {
            node.set_modifier(scroll_modifier.clone());
        }
        node.set_measure_policy(Rc::clone(&policy));
        node.set_captured_context(captured_context);
        node.set_density(composed_density);
        node.set_layout_direction(crate::layout_direction());
        if inputs_changed {
            measured_item_cache.borrow_mut().clear();
            node.invalidate_subcomposition();
        }
    }) {
        debug_assert!(false, "failed to update LazyRow node: {err}");
    }
    bind_layout_invalidation_callback(state, overscroll, list_state_id, node_id);

    node_id
}

#[composable]
fn LazyColumnNode(
    modifier: Modifier,
    state: LazyListState,
    spec: LazyColumnSpec,
    content: LazyListContentHandle,
) -> NodeId {
    cranpose_core::debug_label_current_scope("LazyColumnNode");

    let viewport = cranpose_core::remember(|| {
        Rc::new(Cell::new(cranpose_ui_graphics::WindowCoordinates::default()))
    })
    .with(Rc::clone);
    let responder = {
        let viewport = Rc::clone(&viewport);
        cranpose_core::remember(move || {
            let viewport = Rc::clone(&viewport);
            crate::bring_into_view::BringIntoViewResponder::new(move |caret, ime_bottom| {
                let vp = viewport.get();
                if vp.size.width <= 0.0 || vp.size.height <= 0.0 {
                    return;
                }
                let delta =
                    crate::bring_into_view::local_scroll_delta_to_reveal(caret, vp, ime_bottom);
                if delta.abs() > 0.5 {
                    state.dispatch_scroll_delta(-delta);
                }
            })
        })
        .with(|r| r.clone())
    };
    let modifier = modifier.report_window_coordinates(Rc::clone(&viewport));

    let mut node: Option<NodeId> = None;
    {
        let node_slot = &mut node;
        cranpose_core::CompositionLocalProvider(
            [crate::bring_into_view::local_bring_into_view_responder().provides(Some(responder))],
            move || {
                *node_slot = Some(LazyColumnImpl(modifier, state, spec, content));
            },
        );
    }
    node.expect("LazyColumnImpl emits a node")
}

#[composable]
fn LazyRowNode(
    modifier: Modifier,
    state: LazyListState,
    spec: LazyRowSpec,
    content: LazyListContentHandle,
) -> NodeId {
    cranpose_core::debug_label_current_scope("LazyRowNode");
    LazyRowImpl(modifier, state, spec, content)
}

/// Composes and measures the rows needed for a vertical viewport. The content
/// closure declares rows through [`LazyListScope`](cranpose_foundation::lazy::LazyListScope).
/// Use stable keys for item identity across changes and content types for distinct row shapes.
/// The state retains the scroll position; the spec sets item space and content insets.
///
/// # Example
///
/// ```rust
/// use cranpose_ui::*;
///
/// #[composable]
/// fn Messages() {
///     let state = rememberLazyListState();
///     LazyColumn(
///         Modifier::empty().fill_max_size(),
///         state,
///         LazyColumnSpec::default(),
///         |scope| {
///             scope.items(LazyItems::new(1000), |index| {
///                 Text(
///                     format!("Message {index}"),
///                     Modifier::empty().padding(16.0),
///                     TextStyle::default(),
///                 );
///             });
///         },
///     );
/// }
/// ```
pub fn LazyColumn<F>(
    modifier: Modifier,
    state: LazyListState,
    spec: LazyColumnSpec,
    content: F,
) -> NodeId
where
    F: FnOnce(&mut LazyListIntervalContent),
{
    let mut interval_content = LazyListIntervalContent::new();
    content(&mut interval_content);
    LazyColumnNode(
        modifier,
        state,
        spec,
        LazyListContentHandle::new(interval_content),
    )
}

/// Composes and measures the items needed for a horizontal viewport.
/// Use [`LazyColumn`] for vertical lists.
///
/// # Example
///
/// ```rust
/// use cranpose_ui::*;
///
/// #[composable]
/// fn Choices() {
///     let state = rememberLazyListState();
///     LazyRow(Modifier::empty(), state, LazyRowSpec::default(), |scope| {
///         scope.items(LazyItems::new(10), |index| {
///             Text(
///                 format!("Choice {index}"),
///                 Modifier::empty().padding(8.0),
///                 TextStyle::default(),
///             );
///         });
///     });
/// }
/// ```
pub fn LazyRow<F>(modifier: Modifier, state: LazyListState, spec: LazyRowSpec, content: F) -> NodeId
where
    F: FnOnce(&mut LazyListIntervalContent),
{
    let mut interval_content = LazyListIntervalContent::new();
    content(&mut interval_content);
    LazyRowNode(
        modifier,
        state,
        spec,
        LazyListContentHandle::new(interval_content),
    )
}

#[cfg(test)]
#[path = "tests/lazy_list_tests.rs"]
mod tests;