♻️ [html] Cambia tipos Option... por Attr...

Renombra los tipos para atributos HTML `Id`, `Name`, `Value` (`String`),
`L10n` (`Translate`) y `Classes`. Y mueve `OptionComponent` al *core* de
componentes como `TypedSlot`.

src/html.rs

@@ -3,52 +3,82 @@
 mod maud;
 pub use maud::{display, html, html_private, Escaper, Markup, PreEscaped, Render, DOCTYPE};
 
+// HTML DOCUMENT ASSETS ****************************************************************************
+
 mod assets;
 pub use assets::favicon::Favicon;
 pub use assets::javascript::JavaScript;
 pub use assets::stylesheet::{StyleSheet, TargetMedia};
 pub(crate) use assets::Assets;
 
+// HTML DOCUMENT CONTEXT ***************************************************************************
+
 mod context;
 pub use context::{AssetsOp, Context, ErrorParam};
 
-mod opt_id;
-pub use opt_id::OptionId;
+// HTML ATTRIBUTES *********************************************************************************
 
-mod opt_name;
-pub use opt_name::OptionName;
+mod attr_id;
+pub use attr_id::AttrId;
+/// **Obsoleto desde la versión 0.4.0**: usar [`AttrId`] en su lugar.
+#[deprecated(since = "0.4.0", note = "Use `AttrId` instead")]
+pub type OptionId = AttrId;
 
-mod opt_string;
-pub use opt_string::OptionString;
+mod attr_name;
+pub use attr_name::AttrName;
+/// **Obsoleto desde la versión 0.4.0**: usar [`AttrName`] en su lugar.
+#[deprecated(since = "0.4.0", note = "Use `AttrName` instead")]
+pub type OptionName = AttrName;
 
-mod opt_translated;
-pub use opt_translated::OptionTranslated;
+mod attr_value;
+pub use attr_value::AttrValue;
+/// **Obsoleto desde la versión 0.4.0**: usar [`AttrValue`] en su lugar.
+#[deprecated(since = "0.4.0", note = "Use `AttrValue` instead")]
+pub type OptionString = AttrValue;
 
-mod opt_classes;
-pub use opt_classes::{ClassesOp, OptionClasses};
+mod attr_l10n;
+pub use attr_l10n::AttrL10n;
+/// **Obsoleto desde la versión 0.4.0**: usar [`AttrL10n`] en su lugar.
+#[deprecated(since = "0.4.0", note = "Use `AttrL10n` instead")]
+pub type OptionTranslated = AttrL10n;
 
-mod opt_component;
-pub use opt_component::OptionComponent;
+mod attr_classes;
+pub use attr_classes::{AttrClasses, ClassesOp};
+/// **Obsoleto desde la versión 0.4.0**: usar [`AttrClasses`] en su lugar.
+#[deprecated(since = "0.4.0", note = "Use `AttrClasses` instead")]
+pub type OptionClasses = AttrClasses;
 
-use crate::AutoDefault;
+use crate::{core, AutoDefault};
+
+/// **Obsoleto desde la versión 0.4.0**: usar [`TypedSlot`](crate::core::component::TypedSlot) en su
+/// lugar.
+#[deprecated(
+    since = "0.4.0",
+    note = "Use `pagetop::core::component::TypedSlot` instead"
+)]
+#[allow(type_alias_bounds)]
+pub type OptionComponent<C: core::component::Component> = core::component::TypedSlot<C>;
 
 /// Prepara contenido HTML para su conversión a [`Markup`].
 ///
-/// Este tipo encapsula distintos orígenes de contenido HTML (texto plano, HTML escapado o marcado
-/// ya procesado) para renderizar de forma homogénea en plantillas sin interferir con el uso
-/// estándar de [`Markup`].
+/// Este tipo encapsula distintos orígenes de contenido HTML (texto plano, HTML sin escapar o
+/// fragmentos ya procesados) para renderizarlos de forma homogénea en plantillas, sin interferir
+/// con el uso estándar de [`Markup`].
 ///
 /// # Ejemplo
 ///
 /// ```rust
 /// use pagetop::prelude::*;
 ///
-/// let fragment = PrepareMarkup::Text(String::from("Hola <b>mundo</b>"));
+/// // Texto normal, se escapa automáticamente para evitar inyección de HTML.
+/// let fragment = PrepareMarkup::Escaped(String::from("Hola <b>mundo</b>"));
 /// assert_eq!(fragment.render().into_string(), "Hola &lt;b&gt;mundo&lt;/b&gt;");
 ///
-/// let raw_html = PrepareMarkup::Escaped(String::from("<b>negrita</b>"));
+/// // HTML literal, se inserta directamente, sin escapado adicional.
+/// let raw_html = PrepareMarkup::Raw(String::from("<b>negrita</b>"));
 /// assert_eq!(raw_html.render().into_string(), "<b>negrita</b>");
 ///
+/// // Fragmento ya preparado con la macro `html!`.
 /// let prepared = PrepareMarkup::With(html! {
 ///     h2 { "Título de ejemplo" }
 ///     p { "Este es un párrafo con contenido dinámico." }
@@ -60,14 +90,22 @@ use crate::AutoDefault;
 /// ```
 #[derive(AutoDefault)]
 pub enum PrepareMarkup {
-    /// No se genera contenido HTML (devuelve `html! {}`).
+    /// No se genera contenido HTML (equivale a `html! {}`).
     #[default]
     None,
-    /// Texto estático que se escapará automáticamente para no ser interpretado como HTML.
-    Text(String),
-    /// Contenido sin escapado adicional, útil para HTML generado externamente.
+    /// Texto plano que se **escapará automáticamente** para que no sea interpretado como HTML.
+    ///
+    /// Úsalo con textos que provengan de usuarios u otras fuentes externas para garantizar la
+    /// seguridad contra inyección de código.
     Escaped(String),
+    /// HTML literal que se inserta **sin escapado adicional**.
+    ///
+    /// Úsalo únicamente para contenido generado de forma confiable o controlada, ya que cualquier
+    /// etiqueta o script incluido será renderizado directamente en el documento.
+    Raw(String),
     /// Fragmento HTML ya preparado como [`Markup`], listo para insertarse directamente.
+    ///
+    /// Normalmente proviene de expresiones `html! { ... }`.
     With(Markup),
 }
 
@@ -76,8 +114,8 @@ impl PrepareMarkup {
     pub fn is_empty(&self) -> bool {
         match self {
             PrepareMarkup::None => true,
-            PrepareMarkup::Text(text) => text.is_empty(),
-            PrepareMarkup::Escaped(string) => string.is_empty(),
+            PrepareMarkup::Escaped(text) => text.is_empty(),
+            PrepareMarkup::Raw(string) => string.is_empty(),
             PrepareMarkup::With(markup) => markup.is_empty(),
         }
     }
@@ -88,8 +126,8 @@ impl Render for PrepareMarkup {
     fn render(&self) -> Markup {
         match self {
             PrepareMarkup::None => html! {},
-            PrepareMarkup::Text(text) => html! { (text) },
-            PrepareMarkup::Escaped(string) => html! { (PreEscaped(string)) },
+            PrepareMarkup::Escaped(text) => html! { (text) },
+            PrepareMarkup::Raw(string) => html! { (PreEscaped(string)) },
             PrepareMarkup::With(markup) => html! { (markup) },
         }
     }