@akiojin/gwt 9.0.4 → 9.2.0

package/vendor/ratatui-core/src/layout/size.rs

@@ -1,147 +0,0 @@
-#![warn(missing_docs)]
-use core::fmt;
-
-use crate::layout::Rect;
-
-/// A simple size struct for representing dimensions in the terminal.
-///
-/// The width and height are stored as `u16` values and represent the number of columns and rows
-/// respectively. This is used throughout the layout system to represent dimensions of rectangular
-/// areas and other layout elements.
-///
-/// Size can be created from tuples, extracted from rectangular areas, or constructed directly.
-/// It's commonly used in conjunction with [`Position`](crate::layout::Position) to define
-/// rectangular areas.
-///
-/// # Construction
-///
-/// - [`new`](Self::new) - Create a new size from width and height
-/// - [`default`](Default::default) - Create with zero dimensions
-///
-/// # Conversion
-///
-/// - [`from((u16, u16))`](Self::from) - Create from `(u16, u16)` tuple
-/// - [`from(Rect)`](Self::from) - Create from [`Rect`] (uses width and height)
-/// - [`into((u16, u16))`] - Convert to `(u16, u16)` tuple
-///
-/// # Computation
-///
-/// - [`area`](Self::area) - Compute the total number of cells covered by the size
-///
-/// # Examples
-///
-/// ```rust
-/// use ratatui_core::layout::{Rect, Size};
-///
-/// let size = Size::new(80, 24);
-/// assert_eq!(size.area(), 1920);
-/// let size = Size::from((80, 24));
-/// let size = Size::from(Rect::new(0, 0, 80, 24));
-/// assert_eq!(size.area(), 1920);
-/// ```
-///
-/// 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 Size {
-    /// The width in columns
-    pub width: u16,
-    /// The height in rows
-    pub height: u16,
-}
-
-impl Size {
-    /// A zero sized Size
-    pub const ZERO: Self = Self::new(0, 0);
-
-    /// The minimum possible Size
-    pub const MIN: Self = Self::ZERO;
-
-    /// The maximum possible Size
-    pub const MAX: Self = Self::new(u16::MAX, u16::MAX);
-
-    /// Create a new `Size` struct
-    pub const fn new(width: u16, height: u16) -> Self {
-        Self { width, height }
-    }
-
-    /// Compute the total area of the size as a `u32`.
-    ///
-    /// The multiplication uses `u32` to avoid overflow when the width and height are at their
-    /// `u16` maximum values.
-    pub const fn area(self) -> u32 {
-        self.width as u32 * self.height as u32
-    }
-}
-
-impl From<(u16, u16)> for Size {
-    fn from((width, height): (u16, u16)) -> Self {
-        Self { width, height }
-    }
-}
-
-impl From<Size> for (u16, u16) {
-    fn from(size: Size) -> Self {
-        (size.width, size.height)
-    }
-}
-
-impl From<Rect> for Size {
-    fn from(rect: Rect) -> Self {
-        rect.as_size()
-    }
-}
-
-impl fmt::Display for Size {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}x{}", self.width, self.height)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use alloc::string::ToString;
-
-    use super::*;
-
-    #[test]
-    fn new() {
-        let size = Size::new(10, 20);
-        assert_eq!(size.width, 10);
-        assert_eq!(size.height, 20);
-    }
-
-    #[test]
-    fn from_tuple() {
-        let size = Size::from((10, 20));
-        assert_eq!(size.width, 10);
-        assert_eq!(size.height, 20);
-    }
-
-    #[test]
-    fn to_tuple() {
-        let size = Size::from((10, 20));
-        let (width, height) = size.into();
-        assert_eq!(size.width, width);
-        assert_eq!(size.height, height);
-    }
-
-    #[test]
-    fn from_rect() {
-        let size = Size::from(Rect::new(0, 0, 10, 20));
-        assert_eq!(size.width, 10);
-        assert_eq!(size.height, 20);
-    }
-
-    #[test]
-    fn display() {
-        assert_eq!(Size::new(10, 20).to_string(), "10x20");
-    }
-
-    #[test]
-    fn area() {
-        assert_eq!(Size::new(10, 20).area(), 200);
-        assert_eq!(Size::new(0, 0).area(), 0);
-        assert_eq!(Size::new(u16::MAX, u16::MAX).area(), 4_294_836_225_u32);
-    }
-}

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

@@ -1,333 +0,0 @@
-#![warn(clippy::missing_const_for_fn)]
-//! Layout and positioning in terminal user interfaces.
-//!
-//! This module provides a comprehensive set of types and traits for working with layout and
-//! positioning in terminal applications. It implements a flexible layout system that allows you to
-//! divide the terminal screen into different areas using constraints, manage positioning and
-//! sizing, and handle complex UI arrangements.
-//!
-//! The layout system in Ratatui is based on the Cassowary constraint solver algorithm, implemented
-//! through the [`kasuari`] crate. This allows for sophisticated constraint-based layouts where
-//! multiple requirements can be satisfied simultaneously, with priorities determining which
-//! constraints take precedence when conflicts arise.
-//!
-//! [`kasuari`]: https://crates.io/crates/kasuari
-//!
-//! # Core Concepts
-//!
-//! ## Coordinate System
-//!
-//! The coordinate system runs left to right, top to bottom, with the origin `(0, 0)` in the top
-//! left corner of the terminal. The x and y coordinates are represented by `u16` values.
-//!
-//! ```text
-//!      x (columns)
-//!   ┌─────────────→
-//! y │ (0,0)
-//!   │
-//! (rows)
-//!   ↓
-//! ```
-//!
-//! ## Layout Fundamentals
-//!
-//! Layouts form the structural foundation of your terminal UI. The [`Layout`] struct divides
-//! available screen space into rectangular areas using a constraint-based approach. You define
-//! multiple constraints for how space should be allocated, and the Cassowary solver determines
-//! the optimal layout that satisfies as many constraints as possible. These areas can then be
-//! used to render widgets or nested layouts.
-//!
-//! Note that the [`Layout`] struct is not required to create layouts - you can also manually
-//! calculate and create [`Rect`] areas using simple mathematics to divide up the terminal space
-//! if you prefer direct control over positioning and sizing.
-//!
-//! ## Rectangular Areas
-//!
-//! All layout operations work with rectangular areas represented by the [`Rect`] type. A [`Rect`]
-//! defines a position and size in the terminal, specified by its top-left corner coordinates and
-//! dimensions.
-//!
-//! # Available Types
-//!
-//! ## Core Layout Types
-//!
-//! - [`Layout`] - The primary layout engine that divides space using constraints and direction
-//! - [`Rect`] - Represents a rectangular area with position and dimensions
-//! - [`Constraint`] - Defines how space should be allocated (length, percentage, ratio, etc.)
-//! - [`Direction`] - Specifies layout orientation (horizontal or vertical)
-//! - [`Flex`] - Controls space distribution when constraints are satisfied
-//!
-//! ## Positioning and Sizing
-//!
-//! - [`Position`] - Represents a point in the terminal coordinate system
-//! - [`Size`] - Represents dimensions (width and height)
-//! - [`Margin`] - Defines spacing around rectangular areas
-//! - [`Offset`] - Represents relative movement in the coordinate system
-//! - [`Spacing`] - Controls spacing or overlap between layout segments
-//!
-//! ## Alignment
-//!
-//! - [`Alignment`] (alias for [`HorizontalAlignment`]) - Horizontal text/content alignment
-//! - [`HorizontalAlignment`] - Horizontal alignment options (left, center, right)
-//! - [`VerticalAlignment`] - Vertical alignment options (top, center, bottom)
-//!
-//! ## Iteration Support
-//!
-//! - [`Rows`] - Iterator over horizontal rows within a rectangular area
-//! - [`Columns`] - Iterator over vertical columns within a rectangular area
-//! - [`Positions`] - Iterator over all positions within a rectangular area
-//!
-//! # Quick Start
-//!
-//! Here's a simple example of creating a basic layout using the [`Layout`] struct:
-//!
-//! ```rust
-//! use ratatui_core::layout::{Constraint, Direction, Layout, Rect};
-//!
-//! // Create a terminal area
-//! let area = Rect::new(0, 0, 80, 24);
-//!
-//! // Divide it vertically into two equal parts using Layout
-//! let layout = Layout::vertical([Constraint::Percentage(50), Constraint::Percentage(50)]);
-//! let [top, bottom] = layout.areas(area);
-//!
-//! // Now you have two areas: top and bottom
-//! ```
-//!
-//! **Note**: When the number of layout areas is known at compile time, use destructuring
-//! assignment with descriptive variable names for better readability:
-//!
-//! ```rust
-//! use ratatui_core::layout::{Constraint, Layout, Rect};
-//!
-//! let area = Rect::new(0, 0, 80, 24);
-//! let [header, content, footer] = Layout::vertical([
-//!     Constraint::Length(3),
-//!     Constraint::Fill(1),
-//!     Constraint::Length(1),
-//! ])
-//! .areas(area);
-//! ```
-//!
-//! Use [`Layout::split`] when the number of areas is only known at runtime.
-//!
-//! Alternatively, you can create layouts manually using mathematics:
-//!
-//! ```rust
-//! use ratatui_core::layout::Rect;
-//!
-//! // Create a terminal area
-//! let area = Rect::new(0, 0, 80, 24);
-//!
-//! // Manually divide into two equal parts
-//! let top_half = Rect::new(area.x, area.y, area.width, area.height / 2);
-//! let bottom_half = Rect::new(
-//!     area.x,
-//!     area.y + area.height / 2,
-//!     area.width,
-//!     area.height / 2,
-//! );
-//! ```
-//!
-//! # Layout Examples
-//!
-//! ## Basic Vertical Split
-//!
-//! ```rust
-//! use ratatui_core::layout::{Constraint, Layout, Rect};
-//!
-//! let area = Rect::new(0, 0, 80, 24);
-//! let [header, content, footer] = Layout::vertical([
-//!     Constraint::Length(3), // Header: fixed height
-//!     Constraint::Fill(1),   // Content: flexible
-//!     Constraint::Length(1), // Footer: fixed height
-//! ])
-//! .areas(area);
-//! ```
-//!
-//! ## Horizontal Sidebar Layout
-//!
-//! ```rust
-//! use ratatui_core::layout::{Constraint, Layout, Rect};
-//!
-//! let area = Rect::new(0, 0, 80, 24);
-//! let [sidebar, main] = Layout::horizontal([
-//!     Constraint::Length(20), // Sidebar: fixed width
-//!     Constraint::Fill(1),    // Main content: flexible
-//! ])
-//! .areas(area);
-//! ```
-//!
-//! ## Complex Nested Layout
-//!
-//! ```rust
-//! use ratatui_core::layout::{Constraint, Layout, Rect};
-//!
-//! fn create_complex_layout(area: Rect) -> [Rect; 4] {
-//!     // First, split vertically
-//!     let [header, body, footer] = Layout::vertical([
-//!         Constraint::Length(3), // Header
-//!         Constraint::Fill(1),   // Body
-//!         Constraint::Length(1), // Footer
-//!     ])
-//!     .areas(area);
-//!
-//!     // Then split the body horizontally
-//!     let [sidebar, main] = Layout::horizontal([
-//!         Constraint::Length(20), // Sidebar
-//!         Constraint::Fill(1),    // Main
-//!     ])
-//!     .areas(body);
-//!
-//!     [header, sidebar, main, footer]
-//! }
-//! ```
-//!
-//! # Working with Constraints
-//!
-//! [`Constraint`]s define how space is allocated within a layout using the Cassowary constraint
-//! solver algorithm. The constraint solver attempts to satisfy all constraints simultaneously,
-//! with priorities determining which constraints take precedence when conflicts arise. Different
-//! constraint types serve different purposes:
-//!
-//! - [`Constraint::Min`] - Minimum size constraint
-//! - [`Constraint::Max`] - Maximum size constraint
-//! - [`Constraint::Length`] - Fixed size in character cells
-//! - [`Constraint::Percentage`] - Relative size as a percentage of available space
-//! - [`Constraint::Ratio`] - Proportional size using ratios
-//! - [`Constraint::Fill`] - Proportional fill of remaining space
-//!
-//! Constraints are resolved in priority order, with [`Constraint::Min`] having the highest
-//! priority and [`Constraint::Fill`] having the lowest. The constraint solver will satisfy as
-//! many constraints as possible while respecting these priorities.
-//!
-//! # Flexible Space Distribution
-//!
-//! The [`Flex`] enum controls how extra space is distributed when constraints are satisfied:
-//!
-//! - [`Flex::Start`] - Align content to the start, leaving excess space at the end
-//! - [`Flex::End`] - Align content to the end, leaving excess space at the start
-//! - [`Flex::Center`] - Center content, distributing excess space equally on both sides
-//! - [`Flex::SpaceBetween`] - Distribute excess space evenly *between* elements, none at the ends
-//! - [`Flex::SpaceAround`] - Distribute space *around* elements: equal padding on both sides of
-//!   each element; gaps between elements are twice the edge spacing
-//! - [`Flex::SpaceEvenly`] - Distribute space *evenly*: equal spacing between all elements,
-//!   including before the first and after the last.
-//! - [`Flex::Legacy`] - Legacy behavior (puts excess space in the last element)
-//!
-//! # Positioning and Alignment
-//!
-//! Use [`Position`] to represent specific points in the terminal, [`Size`] for dimensions, and the
-//! alignment types for controlling content positioning within areas:
-//!
-//! ```rust
-//! use ratatui_core::layout::{Alignment, Position, Rect, Size};
-//!
-//! let pos = Position::new(10, 5);
-//! let size = Size::new(80, 24);
-//! let rect = Rect::new(pos.x, pos.y, size.width, size.height);
-//!
-//! // Alignment for content within areas
-//! let center = Alignment::Center;
-//! ```
-//!
-//! # Advanced Features
-//!
-//! ## Margins and Spacing
-//!
-//! Add spacing around areas using uniform margins or between layout segments using [`Spacing`]:
-//!
-//! ```rust
-//! use ratatui_core::layout::{Constraint, Layout, Margin, Rect, Spacing};
-//!
-//! let layout = Layout::vertical([Constraint::Fill(1), Constraint::Fill(1)])
-//!     .margin(2) // 2-cell margin on all sides
-//!     .spacing(Spacing::Space(1)); // 1-cell spacing between segments
-//!
-//! // For asymmetric margins, use the Rect inner method directly
-//! let area = Rect::new(0, 0, 80, 24).inner(Margin::new(2, 1));
-//! ```
-//!
-//! ## Area Iteration
-//!
-//! Iterate over rows, columns, or all positions within a rectangular area. The `rows()` and
-//! `columns()` iterators return full [`Rect`] regions that can be used to render widgets or
-//! passed to other layout methods for more complex nested layouts. The `positions()` iterator
-//! returns [`Position`] values representing individual cell coordinates:
-//!
-//! ```rust
-//! use ratatui_core::buffer::Buffer;
-//! use ratatui_core::layout::{Constraint, Layout, Rect};
-//! use ratatui_core::widgets::Widget;
-//!
-//! let area = Rect::new(0, 0, 20, 10);
-//! let mut buffer = Buffer::empty(area);
-//!
-//! // Renders "Row 0", "Row 1", etc. in each horizontal row
-//! for (i, row) in area.rows().enumerate() {
-//!     format!("Row {i}").render(row, &mut buffer);
-//! }
-//!
-//! // Renders column indices (0-9 repeating) in each vertical column
-//! for (i, col) in area.columns().enumerate() {
-//!     format!("{}", i % 10).render(col, &mut buffer);
-//! }
-//!
-//! // Renders position indices (0-9 repeating) at each cell position
-//! for (i, pos) in area.positions().enumerate() {
-//!     buffer[pos].set_symbol(&format!("{}", i % 10));
-//! }
-//! ```
-//!
-//! # Performance Considerations
-//!
-//! The layout system includes optional caching to improve performance for repeated layout
-//! calculations. Layout caching is enabled by default in the main `ratatui` crate, but requires
-//! explicitly enabling the `layout-cache` feature when using `ratatui-core` directly. When
-//! enabled, layout results are cached based on the area and layout configuration.
-//!
-//! # Related Documentation
-//!
-//! For more detailed information and practical examples:
-//!
-//! - [Layout Concepts](https://ratatui.rs/concepts/layout/) - Comprehensive guide to layout
-//!   concepts
-//! - [Layout Recipes](https://ratatui.rs/recipes/layout/) - Practical layout examples and patterns
-//! - [Grid Layout Recipe](https://ratatui.rs/recipes/layout/grid/) - Creating grid-based layouts
-//! - [Center a Widget Recipe](https://ratatui.rs/recipes/layout/center-a-widget/) - Centering
-//!   content
-//! - [Dynamic Layouts Recipe](https://ratatui.rs/recipes/layout/dynamic/) - Creating responsive
-//!   layouts
-//!
-//! # Examples
-//!
-//! See the Ratatui repository for complete examples:
-//!
-//! - [`constraints`](https://github.com/ratatui/ratatui/blob/main/examples/apps/constraints/) -
-//!   Demonstrates different constraint types
-//! - [`flex`](https://github.com/ratatui/ratatui/blob/main/examples/apps/flex/) - Shows flex space
-//!   distribution
-//! - [`layout`](https://github.com/ratatui/ratatui/blob/main/examples/apps/layout/) - Basic layout
-//!   examples
-
-mod alignment;
-mod constraint;
-mod direction;
-mod flex;
-mod layout;
-mod margin;
-mod offset;
-mod position;
-mod rect;
-mod size;
-
-pub use alignment::{Alignment, HorizontalAlignment, VerticalAlignment};
-pub use constraint::Constraint;
-pub use direction::Direction;
-pub use flex::Flex;
-pub use layout::{Layout, Spacing};
-pub use margin::Margin;
-pub use offset::Offset;
-pub use position::Position;
-pub use rect::{Columns, Positions, Rect, Rows};
-pub use size::Size;

package/vendor/ratatui-core/src/lib.rs

@@ -1,82 +0,0 @@
-#![no_std]
-// show the feature flags in the generated documentation
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![doc(
-    html_logo_url = "https://raw.githubusercontent.com/ratatui/ratatui/main/assets/logo.png",
-    html_favicon_url = "https://raw.githubusercontent.com/ratatui/ratatui/main/assets/favicon.ico"
-)]
-//! **ratatui-core** is the core library of the [ratatui] project,
-//! providing the essential building blocks for creating rich terminal user interfaces in Rust.
-//!
-//! [ratatui]: https://github.com/ratatui/ratatui
-//!
-//! ## Why `ratatui-core`?
-//!
-//! The `ratatui-core` crate is split from the main [`ratatui`](https://crates.io/crates/ratatui) crate
-//! to offer better stability for widget library authors. Widget libraries should generally depend
-//! on `ratatui-core`, benefiting from a stable API and reducing the need for frequent updates.
-//!
-//! Applications, on the other hand, should depend on the main `ratatui` crate, which includes
-//! built-in widgets and additional features.
-//!
-//! # Installation
-//!
-//! Add `ratatui-core` to your `Cargo.toml`:
-//!
-//! ```shell
-//! cargo add ratatui-core
-//! ```
-//!
-//! # Crate Organization
-//!
-//! `ratatui-core` is part of the Ratatui workspace that was modularized in version 0.30.0 to
-//! improve compilation times, API stability, and dependency management. This crate provides the
-//! foundational types and traits that other crates in the workspace depend on.
-//!
-//! **When to use `ratatui-core`:**
-//!
-//! - Building widget libraries that implement [`Widget`] or [`StatefulWidget`]
-//! - Creating lightweight applications that don't need built-in widgets
-//! - You want minimal dependencies and faster compilation times
-//! - You need maximum API stability (core types change less frequently)
-//!
-//! **When to use the main [`ratatui`] crate:**
-//!
-//! - Building applications that use built-in widgets
-//! - You want convenience and don't mind slightly longer compilation times
-//! - You need backend implementations and terminal management utilities
-//!
-//! For detailed information about the workspace organization, see [ARCHITECTURE.md].
-//!
-//! [`ratatui`]: https://crates.io/crates/ratatui
-//! [`Widget`]: widgets::Widget
-//! [`StatefulWidget`]: widgets::StatefulWidget
-//! [ARCHITECTURE.md]: https://github.com/ratatui/ratatui/blob/main/ARCHITECTURE.md
-#![cfg_attr(feature = "document-features", doc = "\n## Features")]
-#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
-//!
-//! # Contributing
-//!
-//! We welcome contributions from the community! Please see our [CONTRIBUTING](../CONTRIBUTING.md)
-//! guide for more details on how to get involved.
-//!
-//! ## License
-//!
-//! This project is licensed under the MIT License. See the [LICENSE](../LICENSE) file for details.
-
-#![warn(clippy::std_instead_of_core)]
-#![warn(clippy::std_instead_of_alloc)]
-#![warn(clippy::alloc_instead_of_core)]
-
-extern crate alloc;
-#[cfg(feature = "std")]
-extern crate std;
-
-pub mod backend;
-pub mod buffer;
-pub mod layout;
-pub mod style;
-pub mod symbols;
-pub mod terminal;
-pub mod text;
-pub mod widgets;