@akiojin/gwt 9.0.3 → 9.1.0

package/vendor/ratatui-core/src/layout/rect/iter.rs

@@ -1,356 +0,0 @@
-use crate::layout::{Position, Rect};
-
-/// An iterator over rows within a `Rect`.
-pub struct Rows {
-    /// The `Rect` associated with the rows.
-    rect: Rect,
-    /// The y coordinate of the row within the `Rect` when iterating forwards.
-    current_row_fwd: u16,
-    /// The y coordinate of the row within the `Rect` when iterating backwards.
-    current_row_back: u16,
-}
-
-impl Rows {
-    /// Creates a new `Rows` iterator.
-    pub const fn new(rect: Rect) -> Self {
-        Self {
-            rect,
-            current_row_fwd: rect.y,
-            current_row_back: rect.bottom(),
-        }
-    }
-}
-
-impl Iterator for Rows {
-    type Item = Rect;
-
-    /// Retrieves the next row within the `Rect`.
-    ///
-    /// Returns `None` when there are no more rows to iterate through.
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current_row_fwd >= self.current_row_back {
-            return None;
-        }
-        let row = Rect::new(self.rect.x, self.current_row_fwd, self.rect.width, 1);
-        self.current_row_fwd += 1;
-        Some(row)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let start_count = self.current_row_fwd.saturating_sub(self.rect.top());
-        let end_count = self.rect.bottom().saturating_sub(self.current_row_back);
-        let count = self
-            .rect
-            .height
-            .saturating_sub(start_count)
-            .saturating_sub(end_count) as usize;
-        (count, Some(count))
-    }
-}
-
-impl DoubleEndedIterator for Rows {
-    /// Retrieves the previous row within the `Rect`.
-    ///
-    /// Returns `None` when there are no more rows to iterate through.
-    fn next_back(&mut self) -> Option<Self::Item> {
-        if self.current_row_back <= self.current_row_fwd {
-            return None;
-        }
-        self.current_row_back -= 1;
-        let row = Rect::new(self.rect.x, self.current_row_back, self.rect.width, 1);
-        Some(row)
-    }
-}
-
-/// An iterator over columns within a `Rect`.
-pub struct Columns {
-    /// The `Rect` associated with the columns.
-    rect: Rect,
-    /// The x coordinate of the column within the `Rect` when iterating forwards.
-    current_column_fwd: u16,
-    /// The x coordinate of the column within the `Rect` when iterating backwards.
-    current_column_back: u16,
-}
-
-impl Columns {
-    /// Creates a new `Columns` iterator.
-    pub const fn new(rect: Rect) -> Self {
-        Self {
-            rect,
-            current_column_fwd: rect.x,
-            current_column_back: rect.right(),
-        }
-    }
-}
-
-impl Iterator for Columns {
-    type Item = Rect;
-
-    /// Retrieves the next column within the `Rect`.
-    ///
-    /// Returns `None` when there are no more columns to iterate through.
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current_column_fwd >= self.current_column_back {
-            return None;
-        }
-        let column = Rect::new(self.current_column_fwd, self.rect.y, 1, self.rect.height);
-        self.current_column_fwd += 1;
-        Some(column)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let start_count = self.current_column_fwd.saturating_sub(self.rect.left());
-        let end_count = self.rect.right().saturating_sub(self.current_column_back);
-        let count = self
-            .rect
-            .width
-            .saturating_sub(start_count)
-            .saturating_sub(end_count) as usize;
-        (count, Some(count))
-    }
-}
-
-impl DoubleEndedIterator for Columns {
-    /// Retrieves the previous column within the `Rect`.
-    ///
-    /// Returns `None` when there are no more columns to iterate through.
-    fn next_back(&mut self) -> Option<Self::Item> {
-        if self.current_column_back <= self.current_column_fwd {
-            return None;
-        }
-        self.current_column_back -= 1;
-        let column = Rect::new(self.current_column_back, self.rect.y, 1, self.rect.height);
-        Some(column)
-    }
-}
-
-/// An iterator over positions within a `Rect`.
-///
-/// The iterator will yield all positions within the `Rect` in a row-major order.
-pub struct Positions {
-    /// The `Rect` associated with the positions.
-    rect: Rect,
-    /// The current position within the `Rect`.
-    current_position: Position,
-}
-
-impl Positions {
-    /// Creates a new `Positions` iterator.
-    pub const fn new(rect: Rect) -> Self {
-        Self {
-            rect,
-            current_position: Position::new(rect.x, rect.y),
-        }
-    }
-}
-
-impl Iterator for Positions {
-    type Item = Position;
-
-    /// Retrieves the next position within the `Rect`.
-    ///
-    /// Returns `None` when there are no more positions to iterate through.
-    fn next(&mut self) -> Option<Self::Item> {
-        if !self.rect.contains(self.current_position) {
-            return None;
-        }
-        let position = self.current_position;
-        self.current_position.x += 1;
-        if self.current_position.x >= self.rect.right() {
-            self.current_position.x = self.rect.x;
-            self.current_position.y += 1;
-        }
-        Some(position)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let row_count = self.rect.bottom().saturating_sub(self.current_position.y);
-        if row_count == 0 {
-            return (0, Some(0));
-        }
-        let column_count = self.rect.right().saturating_sub(self.current_position.x);
-        // subtract 1 from the row count to account for the current row
-        let count = (row_count - 1)
-            .saturating_mul(self.rect.width)
-            .saturating_add(column_count) as usize;
-        (count, Some(count))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn rows() {
-        let rect = Rect::new(0, 0, 2, 3);
-        let mut rows = Rows::new(rect);
-        assert_eq!(rows.size_hint(), (3, Some(3)));
-        assert_eq!(rows.next(), Some(Rect::new(0, 0, 2, 1)));
-        assert_eq!(rows.size_hint(), (2, Some(2)));
-        assert_eq!(rows.next(), Some(Rect::new(0, 1, 2, 1)));
-        assert_eq!(rows.size_hint(), (1, Some(1)));
-        assert_eq!(rows.next(), Some(Rect::new(0, 2, 2, 1)));
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-        assert_eq!(rows.next(), None);
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-        assert_eq!(rows.next_back(), None);
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn rows_back() {
-        let rect = Rect::new(0, 0, 2, 3);
-        let mut rows = Rows::new(rect);
-        assert_eq!(rows.size_hint(), (3, Some(3)));
-        assert_eq!(rows.next_back(), Some(Rect::new(0, 2, 2, 1)));
-        assert_eq!(rows.size_hint(), (2, Some(2)));
-        assert_eq!(rows.next_back(), Some(Rect::new(0, 1, 2, 1)));
-        assert_eq!(rows.size_hint(), (1, Some(1)));
-        assert_eq!(rows.next_back(), Some(Rect::new(0, 0, 2, 1)));
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-        assert_eq!(rows.next_back(), None);
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-        assert_eq!(rows.next(), None);
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn rows_meet_in_the_middle() {
-        let rect = Rect::new(0, 0, 2, 4);
-        let mut rows = Rows::new(rect);
-        assert_eq!(rows.size_hint(), (4, Some(4)));
-        assert_eq!(rows.next(), Some(Rect::new(0, 0, 2, 1)));
-        assert_eq!(rows.size_hint(), (3, Some(3)));
-        assert_eq!(rows.next_back(), Some(Rect::new(0, 3, 2, 1)));
-        assert_eq!(rows.size_hint(), (2, Some(2)));
-        assert_eq!(rows.next(), Some(Rect::new(0, 1, 2, 1)));
-        assert_eq!(rows.size_hint(), (1, Some(1)));
-        assert_eq!(rows.next_back(), Some(Rect::new(0, 2, 2, 1)));
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-        assert_eq!(rows.next(), None);
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-        assert_eq!(rows.next_back(), None);
-        assert_eq!(rows.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn columns() {
-        let rect = Rect::new(0, 0, 3, 2);
-        let mut columns = Columns::new(rect);
-        assert_eq!(columns.size_hint(), (3, Some(3)));
-        assert_eq!(columns.next(), Some(Rect::new(0, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (2, Some(2)));
-        assert_eq!(columns.next(), Some(Rect::new(1, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (1, Some(1)));
-        assert_eq!(columns.next(), Some(Rect::new(2, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-        assert_eq!(columns.next(), None);
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-        assert_eq!(columns.next_back(), None);
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn columns_back() {
-        let rect = Rect::new(0, 0, 3, 2);
-        let mut columns = Columns::new(rect);
-        assert_eq!(columns.size_hint(), (3, Some(3)));
-        assert_eq!(columns.next_back(), Some(Rect::new(2, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (2, Some(2)));
-        assert_eq!(columns.next_back(), Some(Rect::new(1, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (1, Some(1)));
-        assert_eq!(columns.next_back(), Some(Rect::new(0, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-        assert_eq!(columns.next_back(), None);
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-        assert_eq!(columns.next(), None);
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn columns_meet_in_the_middle() {
-        let rect = Rect::new(0, 0, 4, 2);
-        let mut columns = Columns::new(rect);
-        assert_eq!(columns.size_hint(), (4, Some(4)));
-        assert_eq!(columns.next(), Some(Rect::new(0, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (3, Some(3)));
-        assert_eq!(columns.next_back(), Some(Rect::new(3, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (2, Some(2)));
-        assert_eq!(columns.next(), Some(Rect::new(1, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (1, Some(1)));
-        assert_eq!(columns.next_back(), Some(Rect::new(2, 0, 1, 2)));
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-        assert_eq!(columns.next(), None);
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-        assert_eq!(columns.next_back(), None);
-        assert_eq!(columns.size_hint(), (0, Some(0)));
-    }
-
-    /// We allow a total of `65536` columns in the range `(0..=65535)`.  In this test we iterate
-    /// forward and skip the first `65534` columns, and expect the next column to be `65535` and
-    /// the subsequent columns to be `None`.
-    #[test]
-    fn columns_max() {
-        let rect = Rect::new(0, 0, u16::MAX, 1);
-        let mut columns = Columns::new(rect).skip(usize::from(u16::MAX - 1));
-        assert_eq!(columns.next(), Some(Rect::new(u16::MAX - 1, 0, 1, 1)));
-        assert_eq!(columns.next(), None);
-    }
-
-    /// We allow a total of `65536` columns in the range `(0..=65535)`.  In this test we iterate
-    /// backward and skip the last `65534` columns, and expect the next column to be `0` and the
-    /// subsequent columns to be `None`.
-    #[test]
-    fn columns_min() {
-        let rect = Rect::new(0, 0, u16::MAX, 1);
-        let mut columns = Columns::new(rect).rev().skip(usize::from(u16::MAX - 1));
-        assert_eq!(columns.next(), Some(Rect::new(0, 0, 1, 1)));
-        assert_eq!(columns.next(), None);
-        assert_eq!(columns.next(), None);
-    }
-
-    #[test]
-    fn positions() {
-        let rect = Rect::new(0, 0, 2, 2);
-        let mut positions = Positions::new(rect);
-        assert_eq!(positions.size_hint(), (4, Some(4)));
-        assert_eq!(positions.next(), Some(Position::new(0, 0)));
-        assert_eq!(positions.size_hint(), (3, Some(3)));
-        assert_eq!(positions.next(), Some(Position::new(1, 0)));
-        assert_eq!(positions.size_hint(), (2, Some(2)));
-        assert_eq!(positions.next(), Some(Position::new(0, 1)));
-        assert_eq!(positions.size_hint(), (1, Some(1)));
-        assert_eq!(positions.next(), Some(Position::new(1, 1)));
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-        assert_eq!(positions.next(), None);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn positions_zero_width() {
-        let rect = Rect::new(0, 0, 0, 1);
-        let mut positions = Positions::new(rect);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-        assert_eq!(positions.next(), None);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn positions_zero_height() {
-        let rect = Rect::new(0, 0, 1, 0);
-        let mut positions = Positions::new(rect);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-        assert_eq!(positions.next(), None);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn positions_zero_by_zero() {
-        let rect = Rect::new(0, 0, 0, 0);
-        let mut positions = Positions::new(rect);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-        assert_eq!(positions.next(), None);
-        assert_eq!(positions.size_hint(), (0, Some(0)));
-    }
-}

package/vendor/ratatui-core/src/layout/rect/ops.rs

@@ -1,136 +0,0 @@
-use core::ops::{Add, AddAssign, Neg, Sub, SubAssign};
-
-use super::{Offset, Rect};
-
-impl Neg for Offset {
-    type Output = Self;
-
-    /// Negates the offset.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the negated value overflows (i.e. `x` or `y` is `i32::MIN`).
-    fn neg(self) -> Self {
-        Self {
-            x: self.x.neg(),
-            y: self.y.neg(),
-        }
-    }
-}
-
-impl Add<Offset> for Rect {
-    type Output = Self;
-
-    /// Moves the rect by an offset without changing its size.
-    ///
-    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
-    /// rect's position is clamped to the nearest edge.
-    fn add(self, offset: Offset) -> Self {
-        let max_x = i32::from(u16::MAX - self.width);
-        let max_y = i32::from(u16::MAX - self.height);
-        let x = i32::from(self.x).saturating_add(offset.x).clamp(0, max_x) as u16;
-        let y = i32::from(self.y).saturating_add(offset.y).clamp(0, max_y) as u16;
-        Self { x, y, ..self }
-    }
-}
-
-impl Add<Rect> for Offset {
-    type Output = Rect;
-
-    /// Moves the rect by an offset without changing its size.
-    ///
-    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
-    /// rect's position is clamped to the nearest edge.
-    fn add(self, rect: Rect) -> Rect {
-        rect + self
-    }
-}
-
-impl Sub<Offset> for Rect {
-    type Output = Self;
-
-    /// Subtracts an offset from the rect without changing its size.
-    ///
-    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
-    /// rect's position is clamped to the nearest
-    fn sub(self, offset: Offset) -> Self {
-        // Note this cannot be simplified to `self + -offset` because `Offset::MIN` would overflow
-        let max_x = i32::from(u16::MAX - self.width);
-        let max_y = i32::from(u16::MAX - self.height);
-        let x = i32::from(self.x).saturating_sub(offset.x).clamp(0, max_x) as u16;
-        let y = i32::from(self.y).saturating_sub(offset.y).clamp(0, max_y) as u16;
-        Self { x, y, ..self }
-    }
-}
-
-impl AddAssign<Offset> for Rect {
-    /// Moves the rect by an offset in place without changing its size.
-    ///
-    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
-    /// rect's position is clamped to the nearest edge.
-    fn add_assign(&mut self, offset: Offset) {
-        *self = *self + offset;
-    }
-}
-
-impl SubAssign<Offset> for Rect {
-    /// Moves the rect by an offset in place without changing its size.
-    ///
-    /// If the offset would move the any of the rect's edges outside the bounds of `u16`, the
-    /// rect's position is clamped to the nearest edge.
-    fn sub_assign(&mut self, offset: Offset) {
-        *self = *self - offset;
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use rstest::rstest;
-
-    use super::*;
-
-    #[rstest]
-    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
-    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(4, 6, 5, 6))]
-    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(2, 2, 5, 6))]
-    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MIN, Rect::new(0, 0, 5, 6))]
-    #[case::saturate_positive(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(u16::MAX- 5, u16::MAX - 6, 5, 6))]
-    fn add_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
-        assert_eq!(rect + offset, expected);
-        assert_eq!(offset + rect, expected);
-    }
-
-    #[rstest]
-    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
-    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(2, 2, 5, 6))]
-    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(4, 6, 5, 6))]
-    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(0, 0, 5, 6))]
-    #[case::saturate_positive(Rect::new(3, 4, 5, 6), -Offset::MAX, Rect::new(u16::MAX - 5, u16::MAX - 6, 5, 6))]
-    fn sub_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
-        assert_eq!(rect - offset, expected);
-    }
-
-    #[rstest]
-    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
-    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(4, 6, 5, 6))]
-    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(2, 2, 5, 6))]
-    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MIN, Rect::new(0, 0, 5, 6))]
-    #[case::saturate_positive(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(u16::MAX - 5, u16::MAX - 6, 5, 6))]
-    fn add_assign_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
-        let mut rect = rect;
-        rect += offset;
-        assert_eq!(rect, expected);
-    }
-
-    #[rstest]
-    #[case::zero(Rect::new(3, 4, 5, 6), Offset::ZERO, Rect::new(3, 4, 5, 6))]
-    #[case::positive(Rect::new(3, 4, 5, 6), Offset::new(1, 2), Rect::new(2, 2, 5, 6))]
-    #[case::negative(Rect::new(3, 4, 5, 6), Offset::new(-1, -2), Rect::new(4, 6, 5, 6))]
-    #[case::saturate_negative(Rect::new(3, 4, 5, 6), Offset::MAX, Rect::new(0, 0, 5, 6))]
-    #[case::saturate_positive(Rect::new(3, 4, 5, 6), -Offset::MAX, Rect::new(u16::MAX - 5, u16::MAX - 6, 5, 6))]
-    fn sub_assign_offset(#[case] rect: Rect, #[case] offset: Offset, #[case] expected: Rect) {
-        let mut rect = rect;
-        rect -= offset;
-        assert_eq!(rect, expected);
-    }
-}