ratatui_core/layout/

rect.rs

#![warn(missing_docs)]
use core::array::TryFromSliceError;
use core::cmp::{max, min};
use core::fmt;

pub use self::iter::{Columns, Positions, Rows};
use crate::layout::{Margin, Offset, Position, Size};

mod iter;
mod ops;

use super::{Constraint, Flex, Layout};

/// A rectangular area in the terminal.
///
/// A `Rect` represents a rectangular region in the terminal coordinate system, defined by its
/// top-left corner position and dimensions. This is the fundamental building block for all layout
/// operations and widget rendering in Ratatui.
///
/// Rectangles are used throughout the layout system to define areas where widgets can be rendered.
/// They are typically created by [`Layout`] operations that divide terminal space, but can also be
/// manually constructed for specific positioning needs.
///
/// The coordinate system uses the top-left corner as the origin (0, 0), with x increasing to the
/// right and y increasing downward. All measurements are in character cells.
///
/// # Construction and Conversion
///
/// - [`new`](Self::new) - Create a new rectangle from coordinates and dimensions
/// - [`as_position`](Self::as_position) - Convert to a position at the top-left corner
/// - [`as_size`](Self::as_size) - Convert to a size representing the dimensions
/// - [`from((Position, Size))`](Self::from) - Create from `(Position, Size)` tuple
/// - [`from(((u16, u16), (u16, u16)))`](Self::from) - Create from `((u16, u16), (u16, u16))`
///   coordinate and dimension tuples
/// - [`into((Position, Size))`] - Convert to `(Position, Size)` tuple
/// - [`default`](Self::default) - Create a zero-sized rectangle at origin
///
/// # Geometry and Properties
///
/// - [`area`](Self::area) - Calculate the total area in character cells
/// - [`is_empty`](Self::is_empty) - Check if the rectangle has zero area
/// - [`left`](Self::left), [`right`](Self::right), [`top`](Self::top), [`bottom`](Self::bottom) -
///   Get edge coordinates
///
/// # Spatial Operations
///
/// - [`inner`](Self::inner), [`outer`](Self::outer) - Apply margins to shrink or expand
/// - [`offset`](Self::offset) - Move the rectangle by a relative amount
/// - [`resize`](Self::resize) - Change the rectangle size while keeping the bottom/right in range
/// - [`union`](Self::union) - Combine with another rectangle to create a bounding box
/// - [`intersection`](Self::intersection) - Find the overlapping area with another rectangle
/// - [`clamp`](Self::clamp) - Constrain the rectangle to fit within another
///
/// # Positioning and Centering
///
/// - [`centered_horizontally`](Self::centered_horizontally) - Center horizontally within a
///   constraint
/// - [`centered_vertically`](Self::centered_vertically) - Center vertically within a constraint
/// - [`centered`](Self::centered) - Center both horizontally and vertically
///
/// # Testing and Iteration
///
/// - [`contains`](Self::contains) - Check if a position is within the rectangle
/// - [`intersects`](Self::intersects) - Check if it overlaps with another rectangle
/// - [`rows`](Self::rows) - Iterate over horizontal rows within the rectangle
/// - [`columns`](Self::columns) - Iterate over vertical columns within the rectangle
/// - [`positions`](Self::positions) - Iterate over all positions within the rectangle
///
/// # Examples
///
/// To create a new `Rect`, use [`Rect::new`]. The size of the `Rect` will be clamped to keep the
/// right and bottom coordinates within `u16`. Note that this clamping does not occur when creating
/// a `Rect` directly.
///
/// ```rust
/// use ratatui_core::layout::Rect;
///
/// let rect = Rect::new(1, 2, 3, 4);
/// assert_eq!(
///     rect,
///     Rect {
///         x: 1,
///         y: 2,
///         width: 3,
///         height: 4
///     }
/// );
/// ```
///
/// You can also create a `Rect` from a [`Position`] and a [`Size`].
///
/// ```rust
/// use ratatui_core::layout::{Position, Rect, Size};
///
/// let position = Position::new(1, 2);
/// let size = Size::new(3, 4);
/// let rect = Rect::from((position, size));
/// assert_eq!(
///     rect,
///     Rect {
///         x: 1,
///         y: 2,
///         width: 3,
///         height: 4
///     }
/// );
/// ```
///
/// To move a `Rect` without modifying its size, add or subtract an [`Offset`] to it.
///
/// ```rust
/// use ratatui_core::layout::{Offset, Rect};
///
/// let rect = Rect::new(1, 2, 3, 4);
/// let offset = Offset::new(5, 6);
/// let moved_rect = rect + offset;
/// assert_eq!(moved_rect, Rect::new(6, 8, 3, 4));
/// ```
///
/// To resize a `Rect` while ensuring it stays within bounds, use [`Rect::resize`]. The size is
/// clamped so that `right()` and `bottom()` do not exceed `u16::MAX`.
///
/// ```rust
/// use ratatui_core::layout::{Rect, Size};
///
/// let rect = Rect::new(u16::MAX - 1, u16::MAX - 1, 1, 1).resize(Size::new(10, 10));
/// assert_eq!(rect, Rect::new(u16::MAX - 1, u16::MAX - 1, 1, 1));
/// ```
///
/// For comprehensive layout documentation and examples, see the [`layout`](crate::layout) module.

#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Rect {
    /// The x coordinate of the top left corner of the `Rect`.
    pub x: u16,
    /// The y coordinate of the top left corner of the `Rect`.
    pub y: u16,
    /// The width of the `Rect`.
    pub width: u16,
    /// The height of the `Rect`.
    pub height: u16,
}

impl fmt::Display for Rect {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}x{}+{}+{}", self.width, self.height, self.x, self.y)
    }
}

impl Rect {
    /// A zero sized Rect at position 0,0
    pub const ZERO: Self = Self {
        x: 0,
        y: 0,
        width: 0,
        height: 0,
    };

    /// The minimum possible Rect
    pub const MIN: Self = Self::ZERO;

    /// The maximum possible Rect
    pub const MAX: Self = Self::new(0, 0, u16::MAX, u16::MAX);

    /// Creates a new `Rect`, with width and height limited to keep both bounds within `u16`.
    ///
    /// If the width or height would cause the right or bottom coordinate to be larger than the
    /// maximum value of `u16`, the width or height will be clamped to keep the right or bottom
    /// coordinate within `u16`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::Rect;
    ///
    /// let rect = Rect::new(1, 2, 3, 4);
    /// ```
    pub const fn new(x: u16, y: u16, width: u16, height: u16) -> Self {
        let width = x.saturating_add(width) - x;
        let height = y.saturating_add(height) - y;
        Self {
            x,
            y,
            width,
            height,
        }
    }

    /// The area of the `Rect`.
    pub const fn area(self) -> u32 {
        (self.width as u32) * (self.height as u32)
    }

    /// Returns true if the `Rect` has no area.
    pub const fn is_empty(self) -> bool {
        self.width == 0 || self.height == 0
    }

    /// Returns the left coordinate of the `Rect`.
    pub const fn left(self) -> u16 {
        self.x
    }

    /// Returns the right coordinate of the `Rect`. This is the first coordinate outside of the
    /// `Rect`.
    ///
    /// If the right coordinate is larger than the maximum value of u16, it will be clamped to
    /// `u16::MAX`.
    pub const fn right(self) -> u16 {
        self.x.saturating_add(self.width)
    }

    /// Returns the top coordinate of the `Rect`.
    pub const fn top(self) -> u16 {
        self.y
    }

    /// Returns the bottom coordinate of the `Rect`. This is the first coordinate outside of the
    /// `Rect`.
    ///
    /// If the bottom coordinate is larger than the maximum value of u16, it will be clamped to
    /// `u16::MAX`.
    pub const fn bottom(self) -> u16 {
        self.y.saturating_add(self.height)
    }

    /// Returns a new `Rect` inside the current one, with the given margin on each side.
    ///
    /// If the margin is larger than the `Rect`, the returned `Rect` will have no area.
    #[must_use = "method returns the modified value"]
    pub const fn inner(self, margin: Margin) -> Self {
        let doubled_margin_horizontal = margin.horizontal.saturating_mul(2);
        let doubled_margin_vertical = margin.vertical.saturating_mul(2);

        if self.width < doubled_margin_horizontal || self.height < doubled_margin_vertical {
            Self::ZERO
        } else {
            Self {
                x: self.x.saturating_add(margin.horizontal),
                y: self.y.saturating_add(margin.vertical),
                width: self.width.saturating_sub(doubled_margin_horizontal),
                height: self.height.saturating_sub(doubled_margin_vertical),
            }
        }
    }

    /// Returns a new `Rect` outside the current one, with the given margin applied on each side.
    ///
    /// If the margin causes the `Rect`'s bounds to be outside the range of a `u16`, the `Rect` will
    /// be truncated to keep the bounds within `u16`. This will cause the size of the `Rect` to
    /// change.
    ///
    /// The generated `Rect` may not fit inside the buffer or containing area, so it consider
    /// constraining the resulting `Rect` with [`Rect::clamp`] before using it.
    #[must_use = "method returns the modified value"]
    pub const fn outer(self, margin: Margin) -> Self {
        let x = self.x.saturating_sub(margin.horizontal);
        let y = self.y.saturating_sub(margin.vertical);
        let width = self
            .right()
            .saturating_add(margin.horizontal)
            .saturating_sub(x);
        let height = self
            .bottom()
            .saturating_add(margin.vertical)
            .saturating_sub(y);
        Self {
            x,
            y,
            width,
            height,
        }
    }

    /// Moves the `Rect` without modifying its size.
    ///
    /// Moves the `Rect` according to the given offset without modifying its [`width`](Rect::width)
    /// or [`height`](Rect::height).
    /// - Positive `x` moves the whole `Rect` to the right, negative to the left.
    /// - Positive `y` moves the whole `Rect` to the bottom, negative to the top.
    ///
    /// See [`Offset`] for details.
    #[must_use = "method returns the modified value"]
    pub fn offset(self, offset: Offset) -> Self {
        self + offset
    }

    /// Resizes the `Rect`, clamping to keep the right and bottom within `u16::MAX`.
    ///
    /// The position is preserved. If the requested size would push the `Rect` beyond the bounds of
    /// `u16`, the width or height is reduced so that [`right`](Self::right) and
    /// [`bottom`](Self::bottom) remain within range.
    #[must_use = "method returns the modified value"]
    pub const fn resize(self, size: Size) -> Self {
        Self {
            width: self.x.saturating_add(size.width).saturating_sub(self.x),
            height: self.y.saturating_add(size.height).saturating_sub(self.y),
            ..self
        }
    }

    /// Returns a new `Rect` that contains both the current one and the given one.
    #[must_use = "method returns the modified value"]
    pub fn union(self, other: Self) -> Self {
        let x1 = min(self.x, other.x);
        let y1 = min(self.y, other.y);
        let x2 = max(self.right(), other.right());
        let y2 = max(self.bottom(), other.bottom());
        Self {
            x: x1,
            y: y1,
            width: x2.saturating_sub(x1),
            height: y2.saturating_sub(y1),
        }
    }

    /// Returns a new `Rect` that is the intersection of the current one and the given one.
    ///
    /// If the two `Rect`s do not intersect, the returned `Rect` will have no area.
    #[must_use = "method returns the modified value"]
    pub fn intersection(self, other: Self) -> Self {
        let x1 = max(self.x, other.x);
        let y1 = max(self.y, other.y);
        let x2 = min(self.right(), other.right());
        let y2 = min(self.bottom(), other.bottom());
        Self {
            x: x1,
            y: y1,
            width: x2.saturating_sub(x1),
            height: y2.saturating_sub(y1),
        }
    }

    /// Returns true if the two `Rect`s intersect.
    pub const fn intersects(self, other: Self) -> bool {
        self.x < other.right()
            && self.right() > other.x
            && self.y < other.bottom()
            && self.bottom() > other.y
    }

    /// Returns true if the given position is inside the `Rect`.
    ///
    /// The position is considered inside the `Rect` if it is on the `Rect`'s border.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use ratatui_core::layout::{Position, Rect};
    ///
    /// let rect = Rect::new(1, 2, 3, 4);
    /// assert!(rect.contains(Position { x: 1, y: 2 }));
    /// ````
    pub const fn contains(self, position: Position) -> bool {
        position.x >= self.x
            && position.x < self.right()
            && position.y >= self.y
            && position.y < self.bottom()
    }

    /// Clamp this `Rect` to fit inside the other `Rect`.
    ///
    /// If the width or height of this `Rect` is larger than the other `Rect`, it will be clamped to
    /// the other `Rect`'s width or height.
    ///
    /// If the left or top coordinate of this `Rect` is smaller than the other `Rect`, it will be
    /// clamped to the other `Rect`'s left or top coordinate.
    ///
    /// If the right or bottom coordinate of this `Rect` is larger than the other `Rect`, it will be
    /// clamped to the other `Rect`'s right or bottom coordinate.
    ///
    /// This is different from [`Rect::intersection`] because it will move this `Rect` to fit inside
    /// the other `Rect`, while [`Rect::intersection`] instead would keep this `Rect`'s position and
    /// truncate its size to only that which is inside the other `Rect`.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use ratatui_core::layout::Rect;
    ///
    /// let area = Rect::new(0, 0, 100, 100);
    /// let rect = Rect::new(80, 80, 30, 30).clamp(area);
    /// assert_eq!(rect, Rect::new(70, 70, 30, 30));
    /// ```
    #[must_use = "method returns the modified value"]
    pub fn clamp(self, other: Self) -> Self {
        let width = self.width.min(other.width);
        let height = self.height.min(other.height);
        let x = self.x.clamp(other.x, other.right().saturating_sub(width));
        let y = self.y.clamp(other.y, other.bottom().saturating_sub(height));
        Self::new(x, y, width, height)
    }

    /// An iterator over rows within the `Rect`.
    ///
    /// Each row is a full `Rect` region with height 1 that can be used for rendering widgets
    /// or as input to further layout methods.
    ///
    /// # Example
    ///
    /// ```
    /// use ratatui_core::buffer::Buffer;
    /// use ratatui_core::layout::{Constraint, Layout, Rect};
    /// use ratatui_core::widgets::Widget;
    ///
    /// fn render_list(area: Rect, buf: &mut Buffer) {
    ///     // Renders "Item 0", "Item 1", etc. in each row
    ///     for (i, row) in area.rows().enumerate() {
    ///         format!("Item {i}").render(row, buf);
    ///     }
    /// }
    ///
    /// fn render_with_nested_layout(area: Rect, buf: &mut Buffer) {
    ///     // Splits each row into left/right areas and renders labels and content
    ///     for (i, row) in area.rows().take(3).enumerate() {
    ///         let [left, right] =
    ///             Layout::horizontal([Constraint::Percentage(30), Constraint::Fill(1)]).areas(row);
    ///
    ///         format!("{i}:").render(left, buf);
    ///         "Content".render(right, buf);
    ///     }
    /// }
    /// ```
    pub const fn rows(self) -> Rows {
        Rows::new(self)
    }

    /// An iterator over columns within the `Rect`.
    ///
    /// Each column is a full `Rect` region with width 1 that can be used for rendering widgets
    /// or as input to further layout methods.
    ///
    /// # Example
    ///
    /// ```
    /// use ratatui_core::buffer::Buffer;
    /// use ratatui_core::layout::Rect;
    /// use ratatui_core::widgets::Widget;
    ///
    /// fn render_columns(area: Rect, buf: &mut Buffer) {
    ///     // Renders column indices (0-9 repeating) in each column
    ///     for (i, column) in area.columns().enumerate() {
    ///         format!("{}", i % 10).render(column, buf);
    ///     }
    /// }
    /// ```
    pub const fn columns(self) -> Columns {
        Columns::new(self)
    }

    /// An iterator over the positions within the `Rect`.
    ///
    /// The positions are returned in a row-major order (left-to-right, top-to-bottom).
    /// Each position is a `Position` that represents a single cell coordinate.
    ///
    /// # Example
    ///
    /// ```
    /// use ratatui_core::buffer::Buffer;
    /// use ratatui_core::layout::{Position, Rect};
    /// use ratatui_core::widgets::Widget;
    ///
    /// fn render_positions(area: Rect, buf: &mut Buffer) {
    ///     // Renders position indices (0-9 repeating) at each cell position
    ///     for (i, position) in area.positions().enumerate() {
    ///         buf[position].set_symbol(&format!("{}", i % 10));
    ///     }
    /// }
    /// ```
    pub const fn positions(self) -> Positions {
        Positions::new(self)
    }

    /// Returns a [`Position`] with the same coordinates as this `Rect`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::Rect;
    ///
    /// let rect = Rect::new(1, 2, 3, 4);
    /// let position = rect.as_position();
    /// ````
    pub const fn as_position(self) -> Position {
        Position {
            x: self.x,
            y: self.y,
        }
    }

    /// Converts the `Rect` into a size struct.
    pub const fn as_size(self) -> Size {
        Size {
            width: self.width,
            height: self.height,
        }
    }

    /// Returns a new Rect, centered horizontally based on the provided constraint.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::Constraint;
    /// use ratatui_core::terminal::Frame;
    ///
    /// fn render(frame: &mut Frame) {
    ///     let area = frame.area().centered_horizontally(Constraint::Ratio(1, 2));
    /// }
    /// ```
    #[must_use]
    pub fn centered_horizontally(self, constraint: Constraint) -> Self {
        let [area] = self.layout(&Layout::horizontal([constraint]).flex(Flex::Center));
        area
    }

    /// Returns a new Rect, centered vertically based on the provided constraint.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::Constraint;
    /// use ratatui_core::terminal::Frame;
    ///
    /// fn render(frame: &mut Frame) {
    ///     let area = frame.area().centered_vertically(Constraint::Ratio(1, 2));
    /// }
    /// ```
    #[must_use]
    pub fn centered_vertically(self, constraint: Constraint) -> Self {
        let [area] = self.layout(&Layout::vertical([constraint]).flex(Flex::Center));
        area
    }

    /// Returns a new Rect, centered horizontally and vertically based on the provided constraints.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::Constraint;
    /// use ratatui_core::terminal::Frame;
    ///
    /// fn render(frame: &mut Frame) {
    ///     let area = frame
    ///         .area()
    ///         .centered(Constraint::Ratio(1, 2), Constraint::Ratio(1, 3));
    /// }
    /// ```
    #[must_use]
    pub fn centered(
        self,
        horizontal_constraint: Constraint,
        vertical_constraint: Constraint,
    ) -> Self {
        self.centered_horizontally(horizontal_constraint)
            .centered_vertically(vertical_constraint)
    }

    /// Split the rect into a number of sub-rects according to the given [`Layout`].
    ///
    /// An ergonomic wrapper around [`Layout::split`] that returns an array of `Rect`s instead of
    /// `Rc<[Rect]>`.
    ///
    /// This method requires the number of constraints to be known at compile time. If you don't
    /// know the number of constraints at compile time, use [`Layout::split`] instead.
    ///
    /// # Panics
    ///
    /// Panics if the number of constraints is not equal to the length of the returned array.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::{Constraint, Layout, Rect};
    ///
    /// let area = Rect::new(0, 0, 10, 10);
    /// let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
    /// let [top, main] = area.layout(&layout);
    /// assert_eq!(top, Rect::new(0, 0, 10, 1));
    /// assert_eq!(main, Rect::new(0, 1, 10, 9));
    ///
    /// // or explicitly specify the number of constraints:
    /// let areas = area.layout::<2>(&layout);
    /// assert_eq!(areas, [Rect::new(0, 0, 10, 1), Rect::new(0, 1, 10, 9),]);
    /// ```
    #[must_use]
    pub fn layout<const N: usize>(self, layout: &Layout) -> [Self; N] {
        let areas = layout.split(self);
        areas.as_ref().try_into().unwrap_or_else(|_| {
            panic!(
                "invalid number of rects: expected {N}, found {}",
                areas.len()
            )
        })
    }

    /// Split the rect into a number of sub-rects according to the given [`Layout`].
    ///
    /// An ergonomic wrapper around [`Layout::split`] that returns a [`Vec`] of `Rect`s instead of
    /// `Rc<[Rect]>`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::{Constraint, Layout, Rect};
    ///
    /// let area = Rect::new(0, 0, 10, 10);
    /// let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
    /// let areas = area.layout_vec(&layout);
    /// assert_eq!(areas, vec![Rect::new(0, 0, 10, 1), Rect::new(0, 1, 10, 9),]);
    /// ```
    ///
    /// [`Vec`]: alloc::vec::Vec
    #[must_use]
    pub fn layout_vec(self, layout: &Layout) -> alloc::vec::Vec<Self> {
        layout.split(self).as_ref().to_vec()
    }

    /// Try to split the rect into a number of sub-rects according to the given [`Layout`].
    ///
    /// An ergonomic wrapper around [`Layout::split`] that returns an array of `Rect`s instead of
    /// `Rc<[Rect]>`.
    ///
    /// # Errors
    ///
    /// Returns an error if the number of constraints is not equal to the length of the returned
    /// array.
    ///
    /// # Examples
    ///
    /// ```
    /// use ratatui_core::layout::{Constraint, Layout, Rect};
    ///
    /// let area = Rect::new(0, 0, 10, 10);
    /// let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
    /// let [top, main] = area.try_layout(&layout)?;
    /// assert_eq!(top, Rect::new(0, 0, 10, 1));
    /// assert_eq!(main, Rect::new(0, 1, 10, 9));
    ///
    /// // or explicitly specify the number of constraints:
    /// let areas = area.try_layout::<2>(&layout)?;
    /// assert_eq!(areas, [Rect::new(0, 0, 10, 1), Rect::new(0, 1, 10, 9),]);
    /// # Ok::<(), core::array::TryFromSliceError>(())
    /// ``````
    pub fn try_layout<const N: usize>(
        self,
        layout: &Layout,
    ) -> Result<[Self; N], TryFromSliceError> {
        layout.split(self).as_ref().try_into()
    }

    /// indents the x value of the `Rect` by a given `offset`
    ///
    /// This is pub(crate) for now as we need to stabilize the naming / design of this API.
    #[must_use]
    pub(crate) const fn indent_x(self, offset: u16) -> Self {
        Self {
            x: self.x.saturating_add(offset),
            width: self.width.saturating_sub(offset),
            ..self
        }
    }
}

impl From<(Position, Size)> for Rect {
    fn from((position, size): (Position, Size)) -> Self {
        Self {
            x: position.x,
            y: position.y,
            width: size.width,
            height: size.height,
        }
    }
}

impl From<Size> for Rect {
    /// Creates a new `Rect` with the given size at [`Position::ORIGIN`] (0, 0).
    fn from(size: Size) -> Self {
        Self {
            x: 0,
            y: 0,
            width: size.width,
            height: size.height,
        }
    }
}

#[cfg(test)]
mod tests {
    use alloc::string::ToString;
    use alloc::vec;
    use alloc::vec::Vec;

    use pretty_assertions::assert_eq;
    use rstest::rstest;

    use super::*;
    use crate::layout::{Constraint, Layout};

    #[test]
    fn to_string() {
        assert_eq!(Rect::new(1, 2, 3, 4).to_string(), "3x4+1+2");
    }

    #[test]
    fn new() {
        assert_eq!(
            Rect::new(1, 2, 3, 4),
            Rect {
                x: 1,
                y: 2,
                width: 3,
                height: 4
            }
        );
    }

    #[test]
    fn area() {
        assert_eq!(Rect::new(1, 2, 3, 4).area(), 12);
    }

    #[test]
    fn is_empty() {
        assert!(!Rect::new(1, 2, 3, 4).is_empty());
        assert!(Rect::new(1, 2, 0, 4).is_empty());
        assert!(Rect::new(1, 2, 3, 0).is_empty());
    }

    #[test]
    fn left() {
        assert_eq!(Rect::new(1, 2, 3, 4).left(), 1);
    }

    #[test]
    fn right() {
        assert_eq!(Rect::new(1, 2, 3, 4).right(), 4);
    }

    #[test]
    fn top() {
        assert_eq!(Rect::new(1, 2, 3, 4).top(), 2);
    }

    #[test]
    fn bottom() {
        assert_eq!(Rect::new(1, 2, 3, 4).bottom(), 6);
    }

    #[test]
    fn inner() {
        assert_eq!(
            Rect::new(1, 2, 3, 4).inner(Margin::new(1, 2)),
            Rect::new(2, 4, 1, 0)
        );
    }

    #[test]
    fn outer() {
        // enough space to grow on all sides
        assert_eq!(
            Rect::new(100, 200, 10, 20).outer(Margin::new(20, 30)),
            Rect::new(80, 170, 50, 80)
        );

        // left / top saturation should truncate the size (10 less on left / top)
        assert_eq!(
            Rect::new(10, 20, 10, 20).outer(Margin::new(20, 30)),
            Rect::new(0, 0, 40, 70),
        );

        // right / bottom saturation should truncate the size (10 less on bottom / right)
        assert_eq!(
            Rect::new(u16::MAX - 20, u16::MAX - 40, 10, 20).outer(Margin::new(20, 30)),
            Rect::new(u16::MAX - 40, u16::MAX - 70, 40, 70),
        );
    }

    #[test]
    fn offset() {
        assert_eq!(
            Rect::new(1, 2, 3, 4).offset(Offset { x: 5, y: 6 }),
            Rect::new(6, 8, 3, 4),
        );
    }

    #[test]
    fn negative_offset() {
        assert_eq!(
            Rect::new(4, 3, 3, 4).offset(Offset { x: -2, y: -1 }),
            Rect::new(2, 2, 3, 4),
        );
    }

    #[test]
    fn negative_offset_saturate() {
        assert_eq!(
            Rect::new(1, 2, 3, 4).offset(Offset { x: -5, y: -6 }),
            Rect::new(0, 0, 3, 4),
        );
    }

    /// Offsets a [`Rect`] making it go outside [`u16::MAX`], it should keep its size.
    #[test]
    fn offset_saturate_max() {
        assert_eq!(
            Rect::new(u16::MAX - 500, u16::MAX - 500, 100, 100).offset(Offset { x: 1000, y: 1000 }),
            Rect::new(u16::MAX - 100, u16::MAX - 100, 100, 100),
        );
    }

    #[test]
    fn union() {
        assert_eq!(
            Rect::new(1, 2, 3, 4).union(Rect::new(2, 3, 4, 5)),
            Rect::new(1, 2, 5, 6)
        );
    }

    #[test]
    fn intersection() {
        assert_eq!(
            Rect::new(1, 2, 3, 4).intersection(Rect::new(2, 3, 4, 5)),
            Rect::new(2, 3, 2, 3)
        );
    }

    #[test]
    fn intersection_underflow() {
        assert_eq!(
            Rect::new(1, 1, 2, 2).intersection(Rect::new(4, 4, 2, 2)),
            Rect::new(4, 4, 0, 0)
        );
    }

    #[test]
    fn intersects() {
        assert!(Rect::new(1, 2, 3, 4).intersects(Rect::new(2, 3, 4, 5)));
        assert!(!Rect::new(1, 2, 3, 4).intersects(Rect::new(5, 6, 7, 8)));
    }

    #[rstest]
    #[case::corner(Rect::new(0, 0, 10, 10), Rect::new(10, 10, 20, 20))]
    #[case::edge(Rect::new(0, 0, 10, 10), Rect::new(10, 0, 20, 10))]
    #[case::no_intersect(Rect::new(0, 0, 10, 10), Rect::new(11, 11, 20, 20))]
    #[case::contains(Rect::new(0, 0, 20, 20), Rect::new(5, 5, 10, 10))]
    fn mutual_intersect(#[case] rect0: Rect, #[case] rect1: Rect) {
        assert_eq!(rect0.intersection(rect1), rect1.intersection(rect0));
        assert_eq!(rect0.intersects(rect1), rect1.intersects(rect0));
    }

    // the bounds of this rect are x: [1..=3], y: [2..=5]
    #[rstest]
    #[case::inside_top_left(Rect::new(1, 2, 3, 4), Position { x: 1, y: 2 }, true)]
    #[case::inside_top_right(Rect::new(1, 2, 3, 4), Position { x: 3, y: 2 }, true)]
    #[case::inside_bottom_left(Rect::new(1, 2, 3, 4), Position { x: 1, y: 5 }, true)]
    #[case::inside_bottom_right(Rect::new(1, 2, 3, 4), Position { x: 3, y: 5 }, true)]
    #[case::outside_left(Rect::new(1, 2, 3, 4), Position { x: 0, y: 2 }, false)]
    #[case::outside_right(Rect::new(1, 2, 3, 4), Position { x: 4, y: 2 }, false)]
    #[case::outside_top(Rect::new(1, 2, 3, 4), Position { x: 1, y: 1 }, false)]
    #[case::outside_bottom(Rect::new(1, 2, 3, 4), Position { x: 1, y: 6 }, false)]
    #[case::outside_top_left(Rect::new(1, 2, 3, 4), Position { x: 0, y: 1 }, false)]
    #[case::outside_bottom_right(Rect::new(1, 2, 3, 4), Position { x: 4, y: 6 }, false)]
    fn contains(#[case] rect: Rect, #[case] position: Position, #[case] expected: bool) {
        assert_eq!(
            rect.contains(position),
            expected,
            "rect: {rect:?}, position: {position:?}",
        );
    }

    #[test]
    fn size_truncation() {
        assert_eq!(
            Rect::new(u16::MAX - 100, u16::MAX - 1000, 200, 2000),
            Rect {
                x: u16::MAX - 100,
                y: u16::MAX - 1000,
                width: 100,
                height: 1000
            }
        );
    }

    #[test]
    fn size_preservation() {
        assert_eq!(
            Rect::new(u16::MAX - 100, u16::MAX - 1000, 100, 1000),
            Rect {
                x: u16::MAX - 100,
                y: u16::MAX - 1000,
                width: 100,
                height: 1000
            }
        );
    }

    #[test]
    fn resize_updates_size() {
        let rect = Rect::new(10, 20, 5, 5).resize(Size::new(30, 40));
        assert_eq!(rect, Rect::new(10, 20, 30, 40));
    }

    #[test]
    fn resize_clamps_at_bounds() {
        let rect = Rect::new(u16::MAX - 2, u16::MAX - 3, 1, 1).resize(Size::new(10, 10));
        assert_eq!(rect, Rect::new(u16::MAX - 2, u16::MAX - 3, 2, 3));
    }

    #[test]
    fn can_be_const() {
        const RECT: Rect = Rect {
            x: 0,
            y: 0,
            width: 10,
            height: 10,
        };
        const _AREA: u32 = RECT.area();
        const _LEFT: u16 = RECT.left();
        const _RIGHT: u16 = RECT.right();
        const _TOP: u16 = RECT.top();
        const _BOTTOM: u16 = RECT.bottom();
        assert!(RECT.intersects(RECT));
    }

    #[test]
    fn split() {
        let [a, b] = Layout::horizontal([Constraint::Percentage(50), Constraint::Percentage(50)])
            .areas(Rect::new(0, 0, 2, 1));
        assert_eq!(a, Rect::new(0, 0, 1, 1));
        assert_eq!(b, Rect::new(1, 0, 1, 1));
    }

    #[test]
    #[should_panic(expected = "invalid number of rects")]
    fn split_invalid_number_of_recs() {
        let layout = Layout::horizontal([Constraint::Percentage(50), Constraint::Percentage(50)]);
        let [_a, _b, _c] = layout.areas(Rect::new(0, 0, 2, 1));
    }

    #[rstest]
    #[case::inside(Rect::new(20, 20, 10, 10), Rect::new(20, 20, 10, 10))]
    #[case::up_left(Rect::new(5, 5, 10, 10), Rect::new(10, 10, 10, 10))]
    #[case::up(Rect::new(20, 5, 10, 10), Rect::new(20, 10, 10, 10))]
    #[case::up_right(Rect::new(105, 5, 10, 10), Rect::new(100, 10, 10, 10))]
    #[case::left(Rect::new(5, 20, 10, 10), Rect::new(10, 20, 10, 10))]
    #[case::right(Rect::new(105, 20, 10, 10), Rect::new(100, 20, 10, 10))]
    #[case::down_left(Rect::new(5, 105, 10, 10), Rect::new(10, 100, 10, 10))]
    #[case::down(Rect::new(20, 105, 10, 10), Rect::new(20, 100, 10, 10))]
    #[case::down_right(Rect::new(105, 105, 10, 10), Rect::new(100, 100, 10, 10))]
    #[case::too_wide(Rect::new(5, 20, 200, 10), Rect::new(10, 20, 100, 10))]
    #[case::too_tall(Rect::new(20, 5, 10, 200), Rect::new(20, 10, 10, 100))]
    #[case::too_large(Rect::new(0, 0, 200, 200), Rect::new(10, 10, 100, 100))]
    fn clamp(#[case] rect: Rect, #[case] expected: Rect) {
        let other = Rect::new(10, 10, 100, 100);
        assert_eq!(rect.clamp(other), expected);
    }

    #[test]
    fn rows() {
        let area = Rect::new(0, 0, 3, 2);
        let rows: Vec<Rect> = area.rows().collect();

        let expected_rows: Vec<Rect> = vec![Rect::new(0, 0, 3, 1), Rect::new(0, 1, 3, 1)];

        assert_eq!(rows, expected_rows);
    }

    #[test]
    fn columns() {
        let area = Rect::new(0, 0, 3, 2);
        let columns: Vec<Rect> = area.columns().collect();

        let expected_columns: Vec<Rect> = vec![
            Rect::new(0, 0, 1, 2),
            Rect::new(1, 0, 1, 2),
            Rect::new(2, 0, 1, 2),
        ];

        assert_eq!(columns, expected_columns);
    }

    #[test]
    fn as_position() {
        let rect = Rect::new(1, 2, 3, 4);
        let position = rect.as_position();
        assert_eq!(position.x, 1);
        assert_eq!(position.y, 2);
    }

    #[test]
    fn as_size() {
        assert_eq!(
            Rect::new(1, 2, 3, 4).as_size(),
            Size {
                width: 3,
                height: 4
            }
        );
    }

    #[test]
    fn from_position_and_size() {
        let position = Position { x: 1, y: 2 };
        let size = Size {
            width: 3,
            height: 4,
        };
        assert_eq!(
            Rect::from((position, size)),
            Rect {
                x: 1,
                y: 2,
                width: 3,
                height: 4
            }
        );
    }

    #[test]
    fn from_size() {
        let size = Size {
            width: 3,
            height: 4,
        };
        assert_eq!(
            Rect::from(size),
            Rect {
                x: 0,
                y: 0,
                width: 3,
                height: 4
            }
        );
    }

    #[test]
    fn centered_horizontally() {
        let rect = Rect::new(0, 0, 5, 5);
        assert_eq!(
            rect.centered_horizontally(Constraint::Length(3)),
            Rect::new(1, 0, 3, 5)
        );
    }

    #[test]
    fn centered_vertically() {
        let rect = Rect::new(0, 0, 5, 5);
        assert_eq!(
            rect.centered_vertically(Constraint::Length(1)),
            Rect::new(0, 2, 5, 1)
        );
    }

    #[test]
    fn centered() {
        let rect = Rect::new(0, 0, 5, 5);
        assert_eq!(
            rect.centered(Constraint::Length(3), Constraint::Length(1)),
            Rect::new(1, 2, 3, 1)
        );
    }

    #[test]
    fn layout() {
        let layout = Layout::horizontal([Constraint::Length(3), Constraint::Min(0)]);

        let [a, b] = Rect::new(0, 0, 10, 10).layout(&layout);
        assert_eq!(a, Rect::new(0, 0, 3, 10));
        assert_eq!(b, Rect::new(3, 0, 7, 10));

        let areas = Rect::new(0, 0, 10, 10).layout::<2>(&layout);
        assert_eq!(areas[0], Rect::new(0, 0, 3, 10));
        assert_eq!(areas[1], Rect::new(3, 0, 7, 10));
    }

    #[test]
    #[should_panic(expected = "invalid number of rects: expected 3, found 1")]
    fn layout_invalid_number_of_rects() {
        let layout = Layout::horizontal([Constraint::Length(1)]);
        let [_, _, _] = Rect::new(0, 0, 10, 10).layout(&layout);
    }

    #[test]
    fn layout_vec() {
        let layout = Layout::horizontal([Constraint::Length(3), Constraint::Min(0)]);

        let areas = Rect::new(0, 0, 10, 10).layout_vec(&layout);
        assert_eq!(areas[0], Rect::new(0, 0, 3, 10));
        assert_eq!(areas[1], Rect::new(3, 0, 7, 10));
    }

    #[test]
    fn try_layout() {
        let layout = Layout::horizontal([Constraint::Length(3), Constraint::Min(0)]);

        let [a, b] = Rect::new(0, 0, 10, 10).try_layout(&layout).unwrap();
        assert_eq!(a, Rect::new(0, 0, 3, 10));
        assert_eq!(b, Rect::new(3, 0, 7, 10));

        let areas = Rect::new(0, 0, 10, 10).try_layout::<2>(&layout).unwrap();
        assert_eq!(areas[0], Rect::new(0, 0, 3, 10));
        assert_eq!(areas[1], Rect::new(3, 0, 7, 10));
    }

    #[test]
    fn try_layout_invalid_number_of_rects() {
        let layout = Layout::horizontal([Constraint::Length(1)]);
        Rect::new(0, 0, 10, 10)
            .try_layout::<3>(&layout)
            .unwrap_err();
    }
}