use crate::html::unit::UnitValue;
use crate::{AutoDefault, CowStr, util};
// **< AutoFlow >***********************************************************************************
/// Mecanismo de colocación automática de los elementos en un contenedor [`Grid`].
///
/// Aplica en aquellos elementos que no tienen una posición explícita ([`ItemPlacement`]) en el
/// contenedor.
///
/// [`Grid`]: crate::base::component::Grid
/// [`ItemPlacement`]: super::ItemPlacement
#[derive(AutoDefault, Clone, Copy, Debug, PartialEq)]
pub enum AutoFlow {
/// Por defecto, coloca automáticamente rellenando filas (`grid-auto-flow: row` no explícito).
#[default]
Row,
/// Coloca automáticamente rellenando columnas (`grid-auto-flow: column`).
Column,
/// Como `Row`, pero rellena huecos anteriores si un elemento más pequeño cabe en ellos
/// (`grid-auto-flow: row dense`). Puede alterar el orden visual respecto al del documento con
/// la misma cautela de accesibilidad que ya documenta [`ItemOrder`] en Flex.
///
/// [`ItemOrder`]: crate::html::flex::ItemOrder
RowDense,
/// Como `Column`, con el mismo relleno de huecos (`grid-auto-flow: column dense`).
ColumnDense,
}
impl AutoFlow {
// Devuelve el valor CSS de `grid-auto-flow`, o "" para el valor por defecto.
pub(crate) fn value(self) -> CowStr {
match self {
Self::Row => "".into(),
Self::Column => "column".into(),
Self::RowDense => "row dense".into(),
Self::ColumnDense => "column dense".into(),
}
}
}
// **< DefaultJustify >*****************************************************************************
/// Alineación de los elementos en el eje de columnas (en línea) de un contenedor [`Grid`].
///
/// Es el valor por defecto que hereda cualquier elemento siempre que [`ItemJustify`] no lo
/// sobrescriba.
///
/// Es al eje de columnas lo que [`align::Items`] es al eje transversal de [`Flex`], pero Grid, a
/// diferencia de Flexbox, sí tiene una propiedad CSS propia para ello (`justify-items`), porque en
/// Grid ningún eje se resuelve "girando" al otro.
///
/// [`align::Items`]: crate::html::align::Items
/// [`Flex`]: crate::base::component::Flex
/// [`Grid`]: crate::base::component::Grid
/// [`ItemJustify`]: super::ItemJustify
#[derive(AutoDefault, Clone, Copy, Debug, PartialEq)]
pub enum DefaultJustify {
/// Por defecto, el navegador no fuerza ninguna alineación (`justify-items: normal` no
/// explícito, equivalente a `stretch` salvo que el elemento tenga su propio tamaño).
#[default]
Normal,
/// Alinea los elementos al inicio del eje de columnas (`justify-items: start`).
Start,
/// Alinea los elementos al final del eje de columnas (`justify-items: end`).
End,
/// Centra los elementos en el eje de columnas (`justify-items: center`).
Center,
/// Estira los elementos para ocupar toda su columna (`justify-items: stretch`).
Stretch,
}
impl DefaultJustify {
// Devuelve el valor CSS de `justify-items`, o "" para el valor por defecto.
pub(crate) fn value(self) -> CowStr {
match self {
Self::Normal => "".into(),
Self::Start => "start".into(),
Self::End => "end".into(),
Self::Center => "center".into(),
Self::Stretch => "stretch".into(),
}
}
}
// **< ContentJustify >*****************************************************************************
/// Alineación de las pistas en el eje de columnas de un contenedor [`Grid`].
///
/// Aplica cuando su tamaño total es menor que el del propio contenedor. No se reutiliza
/// [`flex::ContentJustify`] porque Grid admite `stretch` (estira las pistas para repartir el
/// espacio sobrante entre ellas), un valor sin efecto en Flexbox.
///
/// [`Grid`]: crate::base::component::Grid
/// [`flex::ContentJustify`]: crate::html::flex::ContentJustify
#[derive(AutoDefault, Clone, Copy, Debug, PartialEq)]
pub enum ContentJustify {
/// Por defecto, el navegador no fuerza ninguna alineación (`justify-content: normal` no
/// explícito).
#[default]
Normal,
/// Alinea las pistas al inicio del eje de columnas (`justify-content: start`).
Start,
/// Alinea las pistas al final del eje de columnas (`justify-content: end`).
End,
/// Centra las pistas en el eje de columnas (`justify-content: center`).
Center,
/// Estira las pistas para repartir el espacio sobrante entre ellas
/// (`justify-content: stretch`).
Stretch,
/// Reparte el espacio sobrante entre las pistas (`justify-content: space-between`).
SpaceBetween,
/// Reparte el espacio sobrante alrededor de cada pista (`justify-content: space-around`).
SpaceAround,
/// Reparte el espacio sobrante en partes iguales, incluidos los extremos
/// (`justify-content: space-evenly`).
SpaceEvenly,
}
impl ContentJustify {
// Devuelve el valor CSS de `justify-content`, o "" para el valor por defecto.
pub(crate) fn value(self) -> CowStr {
match self {
Self::Normal => "".into(),
Self::Start => "start".into(),
Self::End => "end".into(),
Self::Center => "center".into(),
Self::Stretch => "stretch".into(),
Self::SpaceBetween => "space-between".into(),
Self::SpaceAround => "space-around".into(),
Self::SpaceEvenly => "space-evenly".into(),
}
}
}
// **< AxisTrack >**********************************************************************************
/// Anchura o altura de una única pista en un contenedor [`Grid`].
///
/// Se aplica dentro de una lista [`Tracks`], o vía [`Grid::with_columns()`]/[`Grid::with_rows()`]
/// (la rejilla explícita); o suelto, vía [`Grid::with_auto_columns()`]/[`Grid::with_auto_rows()`]
/// (el tamaño de las pistas que el navegador genera automáticamente fuera de esa rejilla).
///
/// [`Grid`]: crate::base::component::Grid
/// [`Grid::with_columns()`]: crate::base::component::Grid::with_columns
/// [`Grid::with_rows()`]: crate::base::component::Grid::with_rows
/// [`Grid::with_auto_columns()`]: crate::base::component::Grid::with_auto_columns
/// [`Grid::with_auto_rows()`]: crate::base::component::Grid::with_auto_rows
#[derive(AutoDefault, Clone, Copy, Debug, PartialEq)]
pub enum AxisTrack {
/// Por defecto, ajusta al contenido repartiendo el espacio sobrante con las demás pistas `Auto`
/// (`auto`).
#[default]
Auto,
/// Medida fija o porcentual (p. ej. `AxisTrack::Fixed(UnitValue::Px(200))` o
/// `AxisTrack::Fixed(UnitValue::RelPct(50.0))`).
Fixed(UnitValue),
/// Fracción del espacio sobrante repartido entre todas las pistas `Fraction` del mismo
/// contenedor (`fr`). Es la unidad idiomática de Grid, sin equivalente en [`UnitValue`]
/// porque no es una medida absoluta ni relativa a nada fuera del propio reparto de Grid.
Fraction(f32),
/// El tamaño más pequeño en el que el contenido cabe sin desbordar. El texto se ajusta de línea
/// todo lo posible, así que el resultado es el ancho de su elemento indivisible más largo
/// (`min-content`).
MinContent,
/// El tamaño que ocuparía el contenido si no tuviera que ajustarse de línea en absoluto, siendo
/// su ancho natural, sin envolver (`max-content`).
MaxContent,
}
impl AxisTrack {
// Devuelve el valor CSS de esta pista. A diferencia del resto de propiedades de Grid/GridItem,
// un `AxisTrack::Auto` (el valor por defecto del enum) sí produce un valor no vacío ("auto").
// En vez de omitir la propiedad entera, una lista de pistas necesita un valor por cada hueco
// para que el número de pistas declaradas sea el correcto.
pub(crate) fn value(self) -> CowStr {
match self {
Self::Auto => "auto".into(),
Self::Fixed(unit) => unit.value(),
Self::Fraction(n) => util::join!(n.to_string(), "fr").into(),
Self::MinContent => "min-content".into(),
Self::MaxContent => "max-content".into(),
}
}
}
// **< Tracks >*************************************************************************************
/// Número máximo de pistas que admite [`Tracks`].
///
/// Ver la nota de la propia `Tracks` sobre por qué es una capacidad fija y no un `Vec`.
pub const MAX_TRACKS: usize = 12;
/// Lista ordenada de pistas para la rejilla explícita de un contenedor [`Grid`].
///
/// Sólo se aplica para [`Grid::with_columns()`] o [`Grid::with_rows()`].
///
/// [`Grid`]: crate::base::component::Grid
/// [`Grid::with_columns()`]: crate::base::component::Grid::with_columns
/// [`Grid::with_rows()`]: crate::base::component::Grid::with_rows
#[derive(AutoDefault, Clone, Copy, Debug, PartialEq)]
pub struct Tracks {
// Es un array de capacidad fija (`[Option; MAX_TRACKS]`), no un `Vec`,
// porque [`Responsive`](crate::core::theme::Responsive) exige `T: Copy` y un `Vec` no lo es;
// de lo contrario `Tracks` no podría variar por punto de corte (p. ej. una columna en móvil,
// tres en escritorio), que es precisamente el caso de uso más habitual de Grid con breakpoints.
// Doce pistas es más que suficiente para cualquier rejilla real (coincide, no por casualidad,
// con la tradición de 12 columnas de Bootstrap y otros frameworks CSS).
tracks: [Option; MAX_TRACKS],
}
impl Tracks {
/// Crea una lista de pistas vacía.
pub fn new() -> Self {
Self::default()
}
/// Añade una pista al final de la lista. Si ya hay [`MAX_TRACKS`] pistas, falla en desarrollo y
/// en pruebas, y en producción la llamada se ignora.
pub fn with_track(mut self, track: AxisTrack) -> Self {
let slot = self.tracks.iter_mut().find(|t| t.is_none());
debug_assert!(slot.is_some(), "a grid admits up to {MAX_TRACKS} tracks");
if let Some(slot) = slot {
*slot = Some(track);
}
self
}
/// Repite la misma pista `count` veces (equivalente a `repeat(count, track)` en CSS, para el
/// caso de uso más común con pistas idénticas). Si `count` supera [`MAX_TRACKS`], falla en
/// desarrollo y en pruebas, y en producción se trunca.
///
/// ```rust
/// # use pagetop::prelude::*;
/// let tracks = grid::Tracks::repeat(3, grid::AxisTrack::Fraction(1.0));
/// assert_eq!(tracks.to_string(), "1fr 1fr 1fr");
/// ```
pub fn repeat(count: usize, track: AxisTrack) -> Self {
debug_assert!(
count <= MAX_TRACKS,
"a grid admits up to {MAX_TRACKS} tracks, got {count}"
);
let mut tracks = Self::new();
for _ in 0..count.min(MAX_TRACKS) {
tracks = tracks.with_track(track);
}
tracks
}
// Serializa como valor CSS. Las pistas separadas por un espacio, en orden, ignorando los huecos
// vacíos. Cadena vacía si no hay ninguna pista (para que `apply!` no genere ninguna clase,
// igual que el resto de propiedades con valor "por defecto" de Flex).
pub(crate) fn value(self) -> CowStr {
self.tracks
.iter()
.flatten()
.map(|t| t.value())
.collect::>()
.join(" ")
.into()
}
}
// Único acceso público al valor CSS de `pub(crate) value()`, invisible fuera del crate, incluidos
// los propios doctests, que compilan como si fueran un crate externo (ver el ejemplo de `repeat()`,
// que depende de esta implementación para poder comprobar el resultado).
impl std::fmt::Display for Tracks {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.value())
}
}