diff --git a/migrations/0004_users_names.sql b/migrations/0004_users_names.sql new file mode 100644 index 0000000..c2339d5 --- /dev/null +++ b/migrations/0004_users_names.sql @@ -0,0 +1,6 @@ +-- Prénom et nom de l'utilisateur. +-- +-- Nullables en base : les comptes créés avant cette migration n'en ont pas, et on +-- n'invente pas de valeur. L'application exige les deux à l'inscription. +ALTER TABLE users ADD COLUMN first_name TEXT; +ALTER TABLE users ADD COLUMN last_name TEXT; diff --git a/migrations/0005_users_theme.sql b/migrations/0005_users_theme.sql new file mode 100644 index 0000000..dbb27a4 --- /dev/null +++ b/migrations/0005_users_theme.sql @@ -0,0 +1,3 @@ +-- Préférence d'apparence de l'utilisateur : suivre le système (défaut), clair ou sombre. +ALTER TABLE users ADD COLUMN theme TEXT NOT NULL DEFAULT 'system' + CHECK (theme IN ('system', 'light', 'dark')); diff --git a/src/app.rs b/src/app.rs index a6a3fec..1059b1c 100644 --- a/src/app.rs +++ b/src/app.rs @@ -1,10 +1,11 @@ use crate::{ auth::{self, Login, Logout, Register}, - pages::{HomePage, LoginPage, RegisterPage}, + pages::{HomePage, LoginPage, ProfilePage, RegisterPage}, + profile::UpdateProfile, ui::LINK, }; use leptos::prelude::*; -use leptos_meta::{MetaTags, Stylesheet, Title, provide_meta_context}; +use leptos_meta::{Html, MetaTags, Stylesheet, Title, provide_meta_context}; use leptos_router::{ SsrMode, StaticSegment, components::{A, Route, Router, Routes}, @@ -36,9 +37,10 @@ pub fn App() -> impl IntoView { let login = ServerAction::::new(); let register = ServerAction::::new(); let logout = ServerAction::::new(); + let save_profile = ServerAction::::new(); - // Recharge l'utilisateur courant après chaque connexion / inscription / déconnexion. - // Ne sert qu'à l'en-tête. Les pages protégées chargent leur propre ressource : elles ne + // Recharge l'utilisateur courant après chaque connexion / inscription / déconnexion / + // modification du profil. Ne sert qu'à l'en-tête et à l'apparence. Les pages protégées chargent leur propre ressource : elles ne // doivent jamais décider d'une redirection à partir de cette valeur, encore périmée // juste après une connexion, le temps que le rechargement se termine. let user = Resource::new( @@ -47,14 +49,30 @@ pub fn App() -> impl IntoView { login.version().get(), register.version().get(), logout.version().get(), + save_profile.version().get(), ) }, |_| auth::get_user(), ); + // Apparence choisie dans le profil, posée sur `` : `data-theme="dark"` ou `"light"` + // force le thème ; sans attribut (« automatique » ou visiteur anonyme), le CSS suit le système. + let theme = move || { + user.get() + .and_then(Result::ok) + .flatten() + .and_then(|user| user.theme.html_attr()) + }; + view! { + // Sous un `Transition` : le serveur attend la ressource avant de rendre `<html>` (sinon + // l'attribut serait absent du HTML initial, d'où un éclair de mauvais thème), et la vue + // reste montée pendant les rechargements, ce qui garde l'attribut réactif. + <Transition> + <Html {..} data-theme=theme /> + </Transition> <Router> <header class="flex items-center justify-between border-b border-zinc-200 bg-white px-4 py-3 dark:border-zinc-800 dark:bg-zinc-900"> @@ -67,8 +85,21 @@ pub fn App() -> impl IntoView { user.get() .map(|user| match user { Ok(Some(user)) => { + // Le prénom mène au profil (l'e-mail à défaut, pour les + // comptes créés avant l'ajout des noms). + let label = if user.first_name.is_empty() { + user.email + } else { + user.first_name + }; view! { - <span class="hidden font-semibold sm:inline">{user.email}</span> + <A + href="/profile" + attr:class="max-w-40 truncate font-semibold hover:underline" + attr:title="Mon profil" + > + {label} + </A> <ActionForm action=logout> <button type="submit" class=LINK> "Se déconnecter" @@ -95,13 +126,24 @@ pub fn App() -> impl IntoView { </header> <main class="mx-auto max-w-3xl px-4 py-8"> <Routes fallback=|| "Page introuvable.".into_view()> - // `Async` : le serveur attend `get_user` avant d'envoyer la réponse, ce qui permet - // un vrai « 302 vers /login » (et pas de flash de contenu) pour les visiteurs anonymes. + // `Async` : le serveur attend `get_user` avant d'envoyer la réponse. On obtient un + // vrai « 302 vers /login » pour les visiteurs anonymes, pas de flash de contenu, + // et l'apparence choisie est déjà sur `<html>` au premier affichage. <Route path=StaticSegment("") view=HomePage ssr=SsrMode::Async /> - <Route path=StaticSegment("login") view=move || view! { <LoginPage login /> } /> + <Route + path=StaticSegment("login") + view=move || view! { <LoginPage login /> } + ssr=SsrMode::Async + /> <Route path=StaticSegment("register") view=move || view! { <RegisterPage register /> } + ssr=SsrMode::Async + /> + <Route + path=StaticSegment("profile") + view=move || view! { <ProfilePage save=save_profile /> } + ssr=SsrMode::Async /> </Routes> </main> diff --git a/src/auth.rs b/src/auth.rs index a9a6808..86c629f 100644 --- a/src/auth.rs +++ b/src/auth.rs @@ -6,14 +6,23 @@ use leptos::prelude::*; use serde::{Deserialize, Serialize}; +use crate::profile::Theme; #[cfg(feature = "ssr")] -use crate::server::{self, USER_ID_KEY}; +use crate::{ + names, + server::{self, USER_ID_KEY}, +}; /// Utilisateur connecté, tel qu'exposé au front (jamais de hash de mot de passe ici). #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct User { pub id: i64, pub email: String, + /// Vide pour les comptes créés avant l'ajout des noms (l'inscription l'exige désormais). + pub first_name: String, + /// Idem. + pub last_name: String, + pub theme: Theme, } #[cfg(feature = "ssr")] @@ -100,14 +109,22 @@ pub async fn get_user() -> Result<Option<User>, ServerFnError> { return Ok(None); }; - let row = sqlx::query_as::<_, (i64, String)>("SELECT id, email FROM users WHERE id = ?1") - .bind(user_id) - .fetch_optional(&server::pool()?) - .await - .map_err(server::internal_error)?; + let row = sqlx::query_as::<_, (i64, String, Option<String>, Option<String>, String)>( + "SELECT id, email, first_name, last_name, theme FROM users WHERE id = ?1", + ) + .bind(user_id) + .fetch_optional(&server::pool()?) + .await + .map_err(server::internal_error)?; match row { - Some((id, email)) => Ok(Some(User { id, email })), + Some((id, email, first_name, last_name, theme)) => Ok(Some(User { + id, + email, + first_name: first_name.unwrap_or_default(), + last_name: last_name.unwrap_or_default(), + theme: Theme::parse(&theme).unwrap_or_default(), + })), None => { // L'utilisateur a été supprimé : on invalide la session orpheline. session.flush().await.map_err(server::internal_error)?; @@ -119,10 +136,14 @@ pub async fn get_user() -> Result<Option<User>, ServerFnError> { /// Crée un compte, puis connecte directement l'utilisateur. #[server] pub async fn register( + first_name: String, + last_name: String, email: String, password: String, password_confirmation: String, ) -> Result<(), ServerFnError> { + let first_name = names::parse_required("prénom", &first_name).map_err(ServerFnError::new)?; + let last_name = names::parse_required("nom", &last_name).map_err(ServerFnError::new)?; let email = normalize_email(&email); validate_email(&email).map_err(ServerFnError::new)?; validate_password(&password).map_err(ServerFnError::new)?; @@ -131,11 +152,15 @@ pub async fn register( } let password_hash = server::hash_password(password).await?; - let result = sqlx::query("INSERT INTO users (email, password_hash) VALUES (?1, ?2)") - .bind(&email) - .bind(&password_hash) - .execute(&server::pool()?) - .await; + let result = sqlx::query( + "INSERT INTO users (email, password_hash, first_name, last_name) VALUES (?1, ?2, ?3, ?4)", + ) + .bind(&email) + .bind(&password_hash) + .bind(&first_name) + .bind(&last_name) + .execute(&server::pool()?) + .await; let user_id = match result { Ok(done) => done.last_insert_rowid(), diff --git a/src/birthdays.rs b/src/birthdays.rs index d30bd3e..cce9c1f 100644 --- a/src/birthdays.rs +++ b/src/birthdays.rs @@ -4,13 +4,13 @@ //! formatage) est compilé des deux côtés et testé sans base de données ; seules les //! server functions et le calcul de la prochaine occurrence sont propres au serveur. +use crate::names; use leptos::prelude::*; use serde::{Deserialize, Serialize}; #[cfg(feature = "ssr")] use crate::server; -pub const NAME_MAX: usize = 100; /// Année de naissance minimale acceptée. pub const YEAR_MIN: i32 = 1900; @@ -87,21 +87,6 @@ pub fn days_in_month(month: u8, year: Option<i32>) -> u8 { } } -enum NameProblem { - TooLong, - Invalid, -} - -fn name_problem(name: &str) -> Option<NameProblem> { - if name.chars().count() > NAME_MAX { - Some(NameProblem::TooLong) - } else if name.chars().any(char::is_control) { - Some(NameProblem::Invalid) - } else { - None - } -} - /// Valide et normalise la saisie du formulaire (les valeurs arrivent en texte brut). /// /// - le prénom est obligatoire, le nom est facultatif (vide = absent) ; @@ -115,27 +100,8 @@ pub fn parse_new_birthday( year: &str, today: Today, ) -> Result<NewBirthday, String> { - let first_name = first_name.trim(); - if first_name.is_empty() { - return Err("Le prénom est obligatoire.".into()); - } - match name_problem(first_name) { - Some(NameProblem::TooLong) => { - return Err(format!("Le prénom est trop long ({NAME_MAX} caractères maximum).")); - } - Some(NameProblem::Invalid) => return Err("Le prénom contient des caractères non autorisés.".into()), - None => {} - } - - let last_name = last_name.trim(); - match name_problem(last_name) { - Some(NameProblem::TooLong) => { - return Err(format!("Le nom est trop long ({NAME_MAX} caractères maximum).")); - } - Some(NameProblem::Invalid) => return Err("Le nom contient des caractères non autorisés.".into()), - None => {} - } - let last_name = (!last_name.is_empty()).then(|| last_name.to_string()); + let first_name = names::parse_required("prénom", first_name)?; + let last_name = names::parse_optional("nom", last_name)?; let month: u8 = month .trim() @@ -169,7 +135,7 @@ pub fn parse_new_birthday( } Ok(NewBirthday { - first_name: first_name.to_string(), + first_name, last_name, day, month, @@ -453,10 +419,10 @@ mod tests { #[test] fn names_are_bounded_and_clean() { - let long = "a".repeat(NAME_MAX + 1); + let long = "a".repeat(names::NAME_MAX + 1); assert!(parse(&long, "", "1", "1", "").is_err()); assert!(parse("Camille", &long, "1", "1", "").is_err()); - assert!(parse(&"a".repeat(NAME_MAX), "", "1", "1", "").is_ok()); + assert!(parse(&"a".repeat(names::NAME_MAX), "", "1", "1", "").is_ok()); assert!(parse("Ca\nmille", "", "1", "1", "").is_err()); // Apostrophes, traits d'union, accents : légitimes. assert!(parse("Anne-Sophie", "D'Aubigné", "1", "1", "").is_ok()); diff --git a/src/lib.rs b/src/lib.rs index 5cc13ca..52a10f2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,7 +1,9 @@ pub mod app; pub mod auth; pub mod birthdays; +pub mod names; pub mod pages; +pub mod profile; pub mod ui; #[cfg(feature = "ssr")] pub mod server; diff --git a/src/names.rs b/src/names.rs new file mode 100644 index 0000000..226044a --- /dev/null +++ b/src/names.rs @@ -0,0 +1,73 @@ +//! Validation des prénoms et noms de personnes (utilisateurs comme anniversaires). + +/// Longueur maximale d'un prénom ou d'un nom, en caractères. +pub const NAME_MAX: usize = 100; + +/// Nettoie et valide un nom obligatoire. `label` est « prénom » ou « nom ». +pub fn parse_required(label: &str, raw: &str) -> Result<String, String> { + match parse_optional(label, raw)? { + Some(name) => Ok(name), + None => Err(format!("Le {label} est obligatoire.")), + } +} + +/// Nettoie et valide un nom facultatif : vide (ou que des espaces) = `None`. +pub fn parse_optional(label: &str, raw: &str) -> Result<Option<String>, String> { + let name = raw.trim(); + if name.is_empty() { + return Ok(None); + } + if name.chars().count() > NAME_MAX { + return Err(format!("Le {label} est trop long ({NAME_MAX} caractères maximum).")); + } + if name.chars().any(char::is_control) { + return Err(format!("Le {label} contient des caractères non autorisés.")); + } + Ok(Some(name.to_string())) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn required_name_is_trimmed() { + assert_eq!(parse_required("prénom", " Camille "), Ok("Camille".into())); + } + + #[test] + fn required_name_rejects_empty() { + assert_eq!(parse_required("prénom", "").unwrap_err(), "Le prénom est obligatoire."); + assert_eq!(parse_required("nom", " ").unwrap_err(), "Le nom est obligatoire."); + } + + #[test] + fn optional_name_may_be_empty() { + assert_eq!(parse_optional("nom", ""), Ok(None)); + assert_eq!(parse_optional("nom", " \t "), Ok(None)); + assert_eq!(parse_optional("nom", " Dupont "), Ok(Some("Dupont".into()))); + } + + #[test] + fn names_are_bounded() { + assert!(parse_required("nom", &"a".repeat(NAME_MAX)).is_ok()); + assert_eq!( + parse_required("nom", &"a".repeat(NAME_MAX + 1)).unwrap_err(), + "Le nom est trop long (100 caractères maximum)." + ); + assert!(parse_optional("nom", &"a".repeat(NAME_MAX + 1)).is_err()); + } + + #[test] + fn control_characters_are_rejected() { + assert!(parse_required("prénom", "Ca\nmille").is_err()); + assert!(parse_optional("nom", "Du\0pont").is_err()); + } + + #[test] + fn real_world_names_are_accepted() { + for name in ["Anne-Sophie", "D'Aubigné", "de La Fontaine", "José", "Nguyễn", "李"] { + assert!(parse_required("nom", name).is_ok(), "{name}"); + } + } +} diff --git a/src/pages.rs b/src/pages.rs index 1d18610..b12b3a0 100644 --- a/src/pages.rs +++ b/src/pages.rs @@ -1,9 +1,11 @@ use crate::{ - auth::{self, EMAIL_MAX, Login, PASSWORD_MAX, PASSWORD_MIN, Register}, + auth::{self, EMAIL_MAX, Login, PASSWORD_MAX, PASSWORD_MIN, Register, User}, birthdays::{ - self, AddBirthday, Birthday, DeleteBirthday, MONTHS, NAME_MAX, YEAR_MIN, format_age, + self, AddBirthday, Birthday, DeleteBirthday, MONTHS, YEAR_MIN, format_age, format_countdown, format_date, }, + names::NAME_MAX, + profile::{Theme, UpdateProfile}, ui::{Card, Field, FormError, LINK, Panel, Select, SubmitButton}, }; use leptos::{html, prelude::*}; @@ -34,7 +36,9 @@ pub fn HomePage() -> impl IntoView { {move || { user.get() .map(|user| match user { - Ok(Some(_)) => view! { <BirthdaysPage /> }.into_any(), + Ok(Some(user)) => { + view! { <BirthdaysPage first_name=user.first_name /> }.into_any() + } _ => view! { <Redirect path="/login" /> }.into_any(), }) }} @@ -43,7 +47,10 @@ pub fn HomePage() -> impl IntoView { } #[component] -fn BirthdaysPage() -> impl IntoView { +fn BirthdaysPage( + /// Prénom de l'utilisateur, pour le saluer. Vide pour les anciens comptes sans nom. + first_name: String, +) -> impl IntoView { let add = ServerAction::<AddBirthday>::new(); let delete = ServerAction::<DeleteBirthday>::new(); // Recharge la liste après chaque ajout ou suppression. @@ -88,6 +95,15 @@ fn BirthdaysPage() -> impl IntoView { view! { <Transition fallback=|| view! { <p>"Chargement…"</p> }> <div class="flex flex-col gap-6"> + // Juste le prénom (pas le nom). Absent pour les comptes créés avant l'ajout des noms. + {(!first_name.is_empty()) + .then(|| { + view! { + <p class="-mb-3 text-zinc-500 dark:text-zinc-400"> + "Bonjour " {first_name.clone()} " 👋" + </p> + } + })} <div class="flex items-center justify-between gap-4"> <h1 class="text-3xl font-bold">"Anniversaires"</h1> // Toujours présent dans le DOM (seule sa visibilité change), pour que la @@ -263,6 +279,101 @@ fn BirthdayItem(birthday: Birthday, delete: ServerAction<DeleteBirthday>) -> imp } } +/// Profil de l'utilisateur : prénom, nom et apparence. Réservé aux utilisateurs connectés. +#[component] +pub fn ProfilePage(save: ServerAction<UpdateProfile>) -> impl IntoView { + // Ressource propre à la page, comme pour `HomePage` : la valeur globale de l'en-tête peut + // être périmée juste après une connexion. + let user = Resource::new(|| (), |_| auth::get_user()); + + view! { + <Suspense fallback=|| view! { <p>"Chargement…"</p> }> + {move || { + user.get() + .map(|user| match user { + Ok(Some(user)) => view! { <ProfileForm user save /> }.into_any(), + _ => view! { <Redirect path="/login" /> }.into_any(), + }) + }} + </Suspense> + } +} + +#[component] +fn ProfileForm(user: User, save: ServerAction<UpdateProfile>) -> impl IntoView { + let current_theme = user.theme; + + // « Profil enregistré » : seulement pour un enregistrement fait depuis l'ouverture de cette + // page (l'action vit dans `App`, donc son ancien résultat survit à la navigation), et + // jusqu'à la prochaine modification d'un champ. + let baseline = save.version().get_untracked(); + let edited = RwSignal::new(false); + Effect::new(move |_| { + save.version().track(); + edited.set(false); + }); + let saved = move || { + save.version().get() > baseline + && !edited.get() + && matches!(save.value().get(), Some(Ok(()))) + }; + + view! { + <Card title="Mon profil"> + <p class="-mt-2 text-sm text-zinc-500 dark:text-zinc-400">{user.email}</p> + <ActionForm + action=save + attr:class="flex flex-col gap-4" + on:input=move |_| edited.set(true) + > + <div class="grid grid-cols-1 gap-4 sm:grid-cols-2"> + <Field + label="Prénom" + name="first_name" + autocomplete="given-name" + maxlength=NAME_MAX + value=user.first_name + /> + <Field + label="Nom" + name="last_name" + autocomplete="family-name" + maxlength=NAME_MAX + value=user.last_name + /> + </div> + <fieldset class="flex flex-col gap-2"> + <legend class="mb-1 text-sm font-semibold">"Apparence"</legend> + {Theme::ALL + .into_iter() + .map(|theme| { + view! { + <label class="flex items-center gap-2 text-sm"> + <input + type="radio" + name="theme" + value=theme.as_str() + checked=theme == current_theme + class="accent-accent" + /> + {theme.label()} + </label> + } + }) + .collect_view()} + </fieldset> + <FormError message=error_of(save.value()) /> + <Show when=saved> + <p class="text-sm text-green-700 dark:text-green-400" role="status"> + "Profil enregistré." + </p> + </Show> + <SubmitButton pending=save.pending()>"Enregistrer"</SubmitButton> + </ActionForm> + </Card> + } +} + #[component] pub fn LoginPage(login: ServerAction<Login>) -> impl IntoView { view! { @@ -299,13 +410,27 @@ pub fn RegisterPage(register: ServerAction<Register>) -> impl IntoView { view! { <Card title="Inscription"> <ActionForm action=register attr:class="flex flex-col gap-4"> + <div class="grid grid-cols-1 gap-4 sm:grid-cols-2"> + <Field + label="Prénom" + name="first_name" + autocomplete="given-name" + maxlength=NAME_MAX + autofocus=true + /> + <Field + label="Nom" + name="last_name" + autocomplete="family-name" + maxlength=NAME_MAX + /> + </div> <Field label="Adresse e-mail" name="email" kind="email" autocomplete="email" maxlength=EMAIL_MAX - autofocus=true /> <Field label="Mot de passe" diff --git a/src/profile.rs b/src/profile.rs new file mode 100644 index 0000000..6db8596 --- /dev/null +++ b/src/profile.rs @@ -0,0 +1,104 @@ +//! Profil de l'utilisateur : prénom, nom et apparence. + +use leptos::prelude::*; +use serde::{Deserialize, Serialize}; + +#[cfg(feature = "ssr")] +use crate::{names, server}; + +/// Apparence choisie par l'utilisateur. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +pub enum Theme { + /// Suit le réglage clair / sombre du système ou du navigateur. + #[default] + System, + Light, + Dark, +} + +impl Theme { + pub const ALL: [Theme; 3] = [Theme::System, Theme::Light, Theme::Dark]; + + /// Valeur stockée en base et envoyée par le formulaire. + pub fn as_str(self) -> &'static str { + match self { + Theme::System => "system", + Theme::Light => "light", + Theme::Dark => "dark", + } + } + + pub fn parse(value: &str) -> Option<Theme> { + Theme::ALL.into_iter().find(|theme| theme.as_str() == value) + } + + pub fn label(self) -> &'static str { + match self { + Theme::System => "Automatique (suit votre système)", + Theme::Light => "Clair", + Theme::Dark => "Sombre", + } + } + + /// Valeur de l'attribut `data-theme` de `<html>`. `None` pour « automatique » : sans + /// attribut, le CSS retombe sur `prefers-color-scheme`. + pub fn html_attr(self) -> Option<&'static str> { + match self { + Theme::System => None, + other => Some(other.as_str()), + } + } +} + +/// Met à jour le prénom, le nom et l'apparence de l'utilisateur connecté. +#[server] +pub async fn update_profile( + first_name: String, + last_name: String, + theme: String, +) -> Result<(), ServerFnError> { + let user_id = server::require_user_id().await?; + let first_name = names::parse_required("prénom", &first_name).map_err(ServerFnError::new)?; + let last_name = names::parse_required("nom", &last_name).map_err(ServerFnError::new)?; + let theme = Theme::parse(&theme).ok_or_else(|| ServerFnError::new("Apparence invalide."))?; + + let done = sqlx::query("UPDATE users SET first_name = ?1, last_name = ?2, theme = ?3 WHERE id = ?4") + .bind(&first_name) + .bind(&last_name) + .bind(theme.as_str()) + .bind(user_id) + .execute(&server::pool()?) + .await + .map_err(server::internal_error)?; + if done.rows_affected() == 0 { + return Err(ServerFnError::new("Compte introuvable.")); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn theme_round_trips_through_its_string_form() { + for theme in Theme::ALL { + assert_eq!(Theme::parse(theme.as_str()), Some(theme)); + } + } + + #[test] + fn unknown_themes_are_rejected() { + for value in ["", "System", "DARK", "auto", "dark ", "'; DROP TABLE users;--"] { + assert_eq!(Theme::parse(value), None, "{value:?}"); + } + } + + #[test] + fn default_is_system_and_sets_no_html_attribute() { + assert_eq!(Theme::default(), Theme::System); + assert_eq!(Theme::System.html_attr(), None); + assert_eq!(Theme::Light.html_attr(), Some("light")); + assert_eq!(Theme::Dark.html_attr(), Some("dark")); + } +} diff --git a/src/ui.rs b/src/ui.rs index 4514f5d..c7b6504 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -5,7 +5,7 @@ use leptos::{html, prelude::*}; /// Lien discret aux couleurs de l'application. pub const LINK: &str = "text-accent underline-offset-2 hover:underline"; -pub const INPUT: &str = "rounded-md border border-zinc-300 bg-white px-3 py-2 text-base shadow-sm \ +pub const INPUT: &str = "rounded-md border font-normal border-zinc-300 bg-white px-3 py-2 text-base shadow-sm \ focus:border-accent focus:outline-none focus:ring-2 focus:ring-accent/40 \ dark:border-zinc-700 dark:bg-zinc-900"; @@ -51,6 +51,8 @@ pub fn Field( #[prop(optional)] autofocus: bool, /// Référence vers l'`<input>`, pour lui donner le focus depuis l'extérieur. #[prop(optional)] node_ref: NodeRef<html::Input>, + /// Valeur initiale (formulaire d'édition). + #[prop(optional, into)] value: Option<String>, ) -> impl IntoView { view! { <label class="flex flex-col gap-1 text-sm font-semibold"> @@ -67,6 +69,7 @@ pub fn Field( max=max autofocus=autofocus required=required + value=value /> </label> } diff --git a/style/tailwind.css b/style/tailwind.css index a9a3791..b6465ae 100644 --- a/style/tailwind.css +++ b/style/tailwind.css @@ -4,6 +4,21 @@ la source explicitement : les vues Leptos vivent dans le dossier `src`. */ @source "../src"; +/* Variante `dark:` à trois états, pilotée par l'attribut `data-theme` de <html> : + - data-theme="dark" : sombre forcé ; + - data-theme="light" : clair forcé ; + - sans attribut : suit le réglage du système (prefers-color-scheme). */ +@custom-variant dark { + &:where([data-theme="dark"], [data-theme="dark"] *) { + @slot; + } + @media (prefers-color-scheme: dark) { + &:where(:not([data-theme="light"], [data-theme="light"] *)) { + @slot; + } + } +} + @theme { --color-accent: #d6336c; --color-accent-hover: #b82a5c; @@ -14,4 +29,10 @@ :root { color-scheme: light dark; } + :root[data-theme="light"] { + color-scheme: light; + } + :root[data-theme="dark"] { + color-scheme: dark; + } }