✨ (form): Añade campos de fecha y hora por idioma

Nuevo `form:📅:Field` (fecha, hora y fecha y hora) que muestra el
valor en el formato del idioma efectivo (dd/mm/aaaa, mm/dd/yyyy...) y no
con el selector nativo, que sigue el formato del navegador. Contextual
añade `parse_date()`, `parse_time()` y `parse_datetime()` para leer lo
escrito.
This commit is contained in:
Manuel Cillero 2026-10-09 00:47:26 +02:00
parent 144127776d
commit fc71a077ee
11 changed files with 940 additions and 2 deletions

View file

@ -29,6 +29,8 @@ pub use select_timezone::SelectTimezone;
pub mod input;
pub mod date;
mod number;
pub use number::Number;

View file

@ -0,0 +1,329 @@
//! Definiciones para crear campos de fecha y hora.
use crate::datetime::input;
use crate::prelude::*;
// **< Kind >***************************************************************************************
/// Tipo de dato de un [`form::date::Field`].
///
/// Se aplica al crear el campo con [`Field::date()`], [`Field::time()`] o [`Field::datetime()`].
#[derive(AutoDefault, Clone, Copy, Debug, PartialEq)]
pub enum Kind {
/// Fecha sin hora ([`NaiveDate`]). Es el tipo por defecto.
#[default]
Date,
/// Hora del día ([`NaiveTime`]).
Time,
/// Fecha y hora de un instante ([`DateTime<Utc>`](DateTime)), en la zona horaria efectiva.
DateTime,
}
impl Kind {
// Sufijo de la clase CSS del contenedor (`form-field-date`...).
const fn as_str(&self) -> &'static str {
match self {
Kind::Date => "date",
Kind::Time => "time",
Kind::DateTime => "datetime",
}
}
}
// Valor inicial del campo: un dato con su tipo, que se muestra con el formato del idioma, o el
// texto tal como lo escribió el usuario (para volver a mostrarlo, p. ej. si no se pudo leer).
#[derive(AutoDefault, Clone, Debug)]
enum Value {
#[default]
None,
Date(NaiveDate),
Time(NaiveTime),
DateTime(DateTime<Utc>),
Text(String),
}
// **< Field >**************************************************************************************
/// Componente para crear un **campo de fecha, de hora o de fecha y hora**.
///
/// Muestra el valor **con el formato del idioma efectivo** del documento, el mismo con el que se
/// muestra el resto de la página y con el que lo leen después los métodos `parse_*` de
/// [`Contextual`]. Por ejemplo, una fecha se escribe `dd/mm/aaaa` en español y `mm/dd/yyyy` en
/// inglés de Estados Unidos, y ese formato se indica en el propio campo (como texto indicativo y
/// como texto de ayuda asociado al campo). Una fecha y hora se muestra y se escribe en la **zona
/// horaria efectiva** del documento ([`Contextual::timezone()`]), normalmente la del usuario, y se
/// lee convertida a UTC.
///
/// Es un campo de texto (`type="text"`), no un selector nativo (`type="date"`): el navegador
/// muestra los selectores nativos con el formato de **su** configuración regional, no con el del
/// idioma de la página, y la página no puede cambiarlo.
///
/// - [`Field::date()`]: fecha sin hora ([`NaiveDate`]), p. ej. una fecha de caducidad. No se
/// convierte de zona horaria.
/// - [`Field::time()`]: hora del día ([`NaiveTime`]).
/// - [`Field::datetime()`]: fecha y hora de un instante ([`DateTime<Utc>`](DateTime)).
///
/// # Ejemplo
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// # fn build(expires: Option<NaiveDate>) {
/// let field = form::date::Field::date()
/// .with_name("expires")
/// .with_label(Lc::n("Expiry date"))
/// .with_date(expires)
/// .with_required(true);
/// # }
/// ```
///
/// El navegador envía el texto escrito, que se deserializa como `String` y se lee con
/// [`Contextual::parse_date()`], [`Contextual::parse_time()`] o [`Contextual::parse_datetime()`]
/// según el tipo de campo. Si no se puede leer, el error ([`DateInputError`]) tiene un mensaje
/// traducido, y [`with_text()`](Field::with_text) vuelve a mostrar lo que escribió el usuario:
///
/// ```rust,no_run
/// # use pagetop::prelude::*;
/// # fn handle(cx: &Context, text: String) {
/// match cx.parse_date(&text) {
/// Ok(expires) => { /* Guardar `expires` (`Option<NaiveDate>`). */ }
/// Err(error) => {
/// let field = form::date::Field::date().with_name("expires").with_text(text);
/// let message = error.message(); // Para mostrarlo junto al formulario.
/// }
/// }
/// # }
/// ```
#[derive(AutoDefault, Clone, Debug, Getters)]
pub struct Field {
/// Devuelve identificador, clases CSS, atributos HTML y valores extra del componente.
props: Props,
/// Devuelve el tipo de dato del campo.
#[getters(copy)]
kind: Kind,
/// Devuelve el nombre del campo.
name: AttrName,
#[getters(skip)]
value: Value,
/// Devuelve la etiqueta del campo.
label: Lc,
/// Devuelve el texto de ayuda del campo.
help_text: Lc,
/// Devuelve la configuración de autocompletado del campo; sin ella, se desactiva (`off`).
autocomplete: Option<form::Autocomplete>,
/// Devuelve si el campo recibe el foco automáticamente al cargar la página.
autofocus: bool,
/// Devuelve si el campo es de sólo lectura.
readonly: bool,
/// Devuelve si el campo es obligatorio.
required: bool,
/// Devuelve si el campo está deshabilitado.
disabled: bool,
}
#[async_trait]
impl Component for Field {
fn new() -> Self {
Self::default()
}
fn id(&self) -> Option<String> {
self.props.get_id()
}
fn setup(&mut self, _cx: &mut Context) {
if let Some(container_id) = self
.id()
.or_else(|| self.name().as_deref().map(|n| util::join!("edit-", n)))
{
self.alter_prop(PropsOp::ensure_id(container_id));
}
// Clases CSS del contenedor del campo.
self.alter_prop(PropsOp::prepend_classes(util::join!(
"form-field form-field-",
self.kind().as_str()
)));
}
async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
let container_id = self.id();
let input_id = container_id.as_deref().map(|id| util::join!(id, "-input"));
let format_id = input_id.as_deref().map(|id| util::join!(id, "-format"));
let tz = cx.timezone();
let value = match (self.kind(), &self.value) {
(_, Value::Text(text)) => Some(text.clone()),
(Kind::Date, Value::Date(date)) => Some(input::format_date(*date, cx)),
(Kind::Time, Value::Time(time)) => Some(input::format_time(*time, cx)),
(Kind::DateTime, Value::DateTime(dt)) => Some(input::format_datetime(*dt, cx, tz)),
_ => None,
};
let hint = match self.kind() {
Kind::Date => input::date_hint(cx),
Kind::Time => input::time_hint(cx),
Kind::DateTime => input::datetime_hint(cx),
};
let format = Lc::l("input_format_help").with_arg("format", hint.clone());
// Sin autocompletado explícito se desactiva: el navegador sugeriría fechas escritas antes
// en otros formularios, que rara vez son las que se quieren introducir.
let autocomplete = self.autocomplete().unwrap_or(&form::Autocomplete::Off);
Ok(html! {
div (self.props().unpack(cx)) {
@if let Some(label) = self.label().lookup(cx) {
label for=[input_id.as_deref()] class="form-label" {
(label)
@if *self.required() {
span
class="form-required"
title=[Lc::l("field_required").lookup(cx)]
{
"*"
}
}
}
}
input
type="text"
id=[input_id.as_deref()]
class="form-control"
name=[self.name().as_deref()]
value=[value]
placeholder=(hint)
aria-describedby=[format_id.as_deref()]
autocomplete=(autocomplete)
autofocus[*self.autofocus()]
readonly[*self.readonly()]
required[*self.required()]
disabled[*self.disabled()];
@if let Some(format) = format.lookup(cx) {
div id=[format_id.as_deref()] class="form-text" { (format) }
}
@if let Some(description) = self.help_text().lookup(cx) {
div class="form-text" { (description) }
}
}
})
}
}
#[builder_impl]
impl Field {
/// Crea un campo de **fecha sin hora** ([`NaiveDate`]), p. ej. una fecha de nacimiento o de
/// caducidad. Se lee con [`Contextual::parse_date()`].
pub fn date() -> Self {
Self::default()
}
/// Crea un campo de **hora del día** ([`NaiveTime`]). Se lee con
/// [`Contextual::parse_time()`].
pub fn time() -> Self {
Self {
kind: Kind::Time,
..Default::default()
}
}
/// Crea un campo de **fecha y hora de un instante** ([`DateTime<Utc>`](DateTime)), que el
/// usuario ve y escribe en su hora local. Se lee con [`Contextual::parse_datetime()`].
pub fn datetime() -> Self {
Self {
kind: Kind::DateTime,
..Default::default()
}
}
// **< Field BUILDER >**************************************************************************
/// Establece el identificador único del componente; igual a `with_prop(PropsOp::set_id(id))`.
pub fn with_id(mut self, id: impl Into<CowStr>) -> Self {
self.props.alter_id(id);
self
}
/// Modifica identificador, clases CSS, atributos HTML o valores extra del componente.
pub fn with_prop(mut self, op: impl Into<PropsOp>) -> Self {
self.props.alter_prop(op);
self
}
/// Establece el nombre del campo (atributo `name`).
pub fn with_name(mut self, name: impl AsRef<str>) -> Self {
self.name.alter_name(name);
self
}
/// Establece la fecha inicial de un campo de [`Field::date()`] (`None` para dejarlo vacío). En
/// un campo de otro tipo se ignora.
pub fn with_date(mut self, date: impl Into<Option<NaiveDate>>) -> Self {
self.value = date.into().map_or(Value::None, Value::Date);
self
}
/// Establece la hora inicial de un campo de [`Field::time()`] (`None` para dejarlo vacío). En
/// un campo de otro tipo se ignora.
pub fn with_time(mut self, time: impl Into<Option<NaiveTime>>) -> Self {
self.value = time.into().map_or(Value::None, Value::Time);
self
}
/// Establece el instante inicial de un campo de [`Field::datetime()`] (`None` para dejarlo
/// vacío). Se muestra en la zona horaria efectiva del documento. En un campo de otro tipo se
/// ignora.
pub fn with_datetime(mut self, dt: impl Into<Option<DateTime<Utc>>>) -> Self {
self.value = dt.into().map_or(Value::None, Value::DateTime);
self
}
/// Establece el texto inicial tal cual, sin interpretarlo. Útil para volver a mostrar lo que
/// escribió el usuario cuando no se ha podido leer.
pub fn with_text(mut self, text: impl Into<String>) -> Self {
self.value = Value::Text(text.into());
self
}
/// Establece la etiqueta visible del campo (usa [`Lc::none()`] para quitarla).
pub fn with_label(mut self, label: Lc) -> Self {
self.label = label;
self
}
/// Establece el texto de ayuda del campo (usa [`Lc::none()`] para quitarlo).
pub fn with_help_text(mut self, help_text: Lc) -> Self {
self.help_text = help_text;
self
}
/// Establece la configuración de autocompletado del campo (`None` para desactivarlo, que es lo
/// predeterminado). Por ejemplo, para una fecha de nacimiento:
/// `form::Autocomplete::token(form::AutofillField::Bday)`.
pub fn with_autocomplete(
mut self,
autocomplete: impl Into<Option<form::Autocomplete>>,
) -> Self {
self.autocomplete = autocomplete.into();
self
}
/// Establece si el campo recibe el foco automáticamente al cargar la página.
pub fn with_autofocus(mut self, autofocus: bool) -> Self {
self.autofocus = autofocus;
self
}
/// Establece si el campo es de sólo lectura.
pub fn with_readonly(mut self, readonly: bool) -> Self {
self.readonly = readonly;
self
}
/// Establece si el campo es obligatorio.
pub fn with_required(mut self, required: bool) -> Self {
self.required = required;
self
}
/// Establece si el campo está deshabilitado.
pub fn with_disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
}