🚚 Renombra ThemeRegion por DefaultRegions

extensions/pagetop-aliner/src/lib.rs

@@ -82,13 +82,13 @@ async fn homepage(request: HttpRequest) -> ResultPage<Markup, ErrorPage> {
 
 use pagetop::prelude::*;
 
-/// El tema usa las mismas regiones predefinidas por [`ThemeRegion`].
+/// El tema usa las mismas regiones predefinidas por [`DefaultRegions`].
-pub type AlinerRegion = ThemeRegion;
+pub type AlinerRegions = DefaultRegions;
 
 /// Implementa el tema para usar en pruebas que muestran el esquema de páginas HTML.
 ///
 /// Tema mínimo ideal para **pruebas y demos** que renderiza el **esqueleto HTML** con las mismas
-/// regiones básicas definidas por [`ThemeRegion`]. No pretende ser un tema para producción, está
+/// regiones básicas definidas por [`DefaultRegions`]. No pretende ser un tema para producción, está
 /// pensado para:
 ///
 /// - Verificar integración de componentes y composiciones (*layouts*) sin estilos complejos.

extensions/pagetop-bootsier/src/lib.rs

@@ -101,8 +101,8 @@ pub mod prelude {
     pub use crate::theme::*;
 }
 
-/// El tema usa las mismas regiones predefinidas por [`ThemeRegion`].
+/// El tema usa las mismas regiones predefinidas por [`DefaultRegions`].
-pub type BootsierRegion = ThemeRegion;
+pub type BootsierRegions = DefaultRegions;
 
 /// Implementa el tema.
 pub struct Bootsier;

src/base/action/component.rs

@@ -1,8 +1,5 @@
 //! Acciones que operan sobre componentes.
 
-mod is_renderable;
-pub use is_renderable::*;
-
 mod before_render_component;
 pub use before_render_component::*;
 

src/base/action/component/is_renderable.rs

@@ -1,96 +0,0 @@
-use crate::prelude::*;
-
-/// Tipo de función para determinar si un componente se renderiza o no.
-///
-/// Se usa en la acción [`IsRenderable`] para controlar dinámicamente la visibilidad del componente
-/// `component` según el contexto `cx`. El componente **no se renderiza** en cuanto una de las
-/// funciones devuelva `false`.
-pub type FnIsRenderable<C> = fn(component: &C, cx: &Context) -> bool;
-
-/// Con la función [`FnIsRenderable`] se puede decidir si se renderiza o no un componente.
-pub struct IsRenderable<C: Component> {
-    f: FnIsRenderable<C>,
-    referer_type_id: Option<UniqueId>,
-    referer_id: AttrId,
-    weight: Weight,
-}
-
-/// Filtro para despachar [`FnIsRenderable`] para decidir si se renderiza o no un componente `C`.
-impl<C: Component> ActionDispatcher for IsRenderable<C> {
-    /// Devuelve el identificador de tipo ([`UniqueId`]) del componente `C`.
-    fn referer_type_id(&self) -> Option<UniqueId> {
-        self.referer_type_id
-    }
-
-    /// Devuelve el identificador del componente.
-    fn referer_id(&self) -> Option<String> {
-        self.referer_id.get()
-    }
-
-    /// Devuelve el peso para definir el orden de ejecución.
-    fn weight(&self) -> Weight {
-        self.weight
-    }
-}
-
-impl<C: Component> IsRenderable<C> {
-    /// Permite [registrar](Extension::actions) una nueva acción [`FnIsRenderable`].
-    pub fn new(f: FnIsRenderable<C>) -> Self {
-        IsRenderable {
-            f,
-            referer_type_id: Some(UniqueId::of::<C>()),
-            referer_id: AttrId::default(),
-            weight: 0,
-        }
-    }
-
-    /// Afina el registro para ejecutar la acción [`FnIsRenderable`] sólo para el componente `C`
-    /// con identificador `id`.
-    pub fn filter_by_referer_id(mut self, id: impl AsRef<str>) -> Self {
-        self.referer_id.alter_value(id);
-        self
-    }
-
-    /// Opcional. Acciones con pesos más bajos se aplican antes. Se pueden usar valores negativos.
-    pub fn with_weight(mut self, value: Weight) -> Self {
-        self.weight = value;
-        self
-    }
-
-    // Despacha las acciones. Se detiene en cuanto una [`FnIsRenderable`] devuelve `false`.
-    #[inline]
-    pub(crate) fn dispatch(component: &C, cx: &mut Context) -> bool {
-        let mut renderable = true;
-        dispatch_actions(
-            &ActionKey::new(
-                UniqueId::of::<Self>(),
-                None,
-                Some(UniqueId::of::<C>()),
-                None,
-            ),
-            |action: &Self| {
-                if renderable && !(action.f)(component, cx) {
-                    renderable = false;
-                }
-            },
-        );
-        if renderable {
-            if let Some(id) = component.id() {
-                dispatch_actions(
-                    &ActionKey::new(
-                        UniqueId::of::<Self>(),
-                        None,
-                        Some(UniqueId::of::<C>()),
-                        Some(id),
-                    ),
-                    |action: &Self| {
-                        if renderable && !(action.f)(component, cx) {
-                            renderable = false;
-                        }
-                    },
-                );
-            }
-        }
-        renderable
-    }
-}

src/base/theme.rs

@@ -1,4 +1,4 @@
 //! Temas básicos soportados por PageTop.
 
 mod basic;
-pub use basic::{Basic, BasicRegion};
+pub use basic::{Basic, BasicRegions};

src/base/theme/basic.rs

@@ -1,8 +1,8 @@
 /// Es el tema básico que incluye PageTop por defecto.
 use crate::prelude::*;
 
-/// El tema básico usa las mismas regiones predefinidas por [`ThemeRegion`].
+/// El tema básico usa las mismas regiones predefinidas por [`DefaultRegions`].
-pub type BasicRegion = ThemeRegion;
+pub type BasicRegions = DefaultRegions;
 
 /// Tema básico por defecto que extiende el funcionamiento predeterminado de [`Theme`].
 pub struct Basic;

src/core/component.rs

@@ -11,6 +11,59 @@ pub use children::{Typed, TypedOp};
 mod context;
 pub use context::{Context, ContextError, ContextOp, Contextual};
 
+/// Alias de función (*callback*) para **determinar si un componente se renderiza o no**.
+///
+/// Puede usarse para permitir que una instancia concreta de un tipo de componente dado decida
+/// dinámicamente durante el proceso de renderizado ([`Component::is_renderable()`]) si se renderiza
+/// o no.
+///
+/// # Ejemplo
+///
+/// ```rust
+/// # use pagetop::prelude::*;
+/// #[derive(AutoDefault)]
+/// struct SampleComponent {
+///     renderable: Option<FnIsRenderable>,
+/// }
+///
+/// impl Component for SampleComponent {
+///     fn new() -> Self {
+///         Self::default()
+///     }
+///
+///     fn is_renderable(&self, cx: &mut Context) -> bool {
+///         // Si hay callback, se usa; en caso contrario, se renderiza por defecto.
+///         self.renderable.map_or(true, |f| f(cx))
+///     }
+///
+///     fn prepare_component(&self, _cx: &mut Context) -> PrepareMarkup {
+///         PrepareMarkup::Escaped("Visible component".into())
+///     }
+/// }
+///
+/// impl SampleComponent {
+///     /// Asigna una función que decidirá si el componente se renderiza o no.
+///     #[builder_fn]
+///     pub fn with_renderable(mut self, f: Option<FnIsRenderable>) -> Self {
+///         self.renderable = f;
+///         self
+///     }
+/// }
+///
+/// fn sample() {
+///     let mut cx = Context::default().with_param("user_logged_in", true);
+///
+///     // Se instancia un componente que sólo se renderiza si `user_logged_in` es `true`.
+///     let mut component = SampleComponent::new().with_renderable(Some(|cx: &Context| {
+///         cx.param::<bool>("user_logged_in").copied().unwrap_or(false)
+///     }));
+///
+///     // Aquí simplemente se comprueba que compila y se puede invocar.
+///     let _markup = component.render(&mut cx);
+/// }
+/// ```
+pub type FnIsRenderable = fn(cx: &Context) -> bool;
+
 /// Alias de función (*callback*) para **resolver una URL** según el contexto de renderizado.
 ///
 /// Se usa para generar enlaces dinámicos en función del contexto (petición, idioma, etc.). Debe

src/core/component/definition.rs

@@ -45,6 +45,20 @@ pub trait Component: AnyInfo + ComponentRender + Send + Sync {
         None
     }
 
+    /// Indica si el componente es renderizable.
+    ///
+    /// Por defecto, todos los componentes son renderizables (`true`). Sin embargo, este método
+    /// puede sobrescribirse para decidir dinámicamente si los componentes de este tipo se
+    /// renderizan o no en función del contexto de renderizado.
+    ///
+    /// También puede usarse junto con un alias de función como
+    /// ([`FnIsRenderable`](crate::core::component::FnIsRenderable)) para permitir que instancias
+    /// concretas del componente decidan si se renderizan o no.
+    #[allow(unused_variables)]
+    fn is_renderable(&self, cx: &mut Context) -> bool {
+        true
+    }
+
     /// Configura el componente justo antes de preparar el renderizado.
     ///
     /// Este método puede sobrescribirse para modificar la estructura interna del componente o el
@@ -72,30 +86,30 @@ pub trait Component: AnyInfo + ComponentRender + Send + Sync {
 
 /// Implementa [`render()`](ComponentRender::render) para todos los componentes.
 ///
-/// Y para cada componente ejecuta la siguiente secuencia:
+/// El proceso de renderizado de cada componente sigue esta secuencia:
 ///
-/// 1. Despacha [`action::component::IsRenderable`](crate::base::action::component::IsRenderable)
+/// 1. Ejecuta [`is_renderable()`](Component::is_renderable) para ver si puede renderizarse en el
-///    para ver si se puede renderizar. Si no es así, devuelve un [`Markup`] vacío.
+///    contexto actual. Si no es así, devuelve un [`Markup`] vacío.
 /// 2. Ejecuta [`setup_before_prepare()`](Component::setup_before_prepare) para que el componente
 ///    pueda ajustar su estructura interna o modificar el contexto.
 /// 3. Despacha [`action::theme::BeforeRender<C>`](crate::base::action::theme::BeforeRender) para
-///    que el tema pueda hacer ajustes en el componente o el contexto.
+///    permitir que el tema realice ajustes previos.
 /// 4. Despacha [`action::component::BeforeRender<C>`](crate::base::action::component::BeforeRender)
-///    para que otras extensiones puedan hacer ajustes.
+///    para que otras extensiones puedan también hacer ajustes previos.
 /// 5. **Prepara el renderizado del componente**:
 ///    - Despacha [`action::theme::PrepareRender<C>`](crate::base::action::theme::PrepareRender)
-///      para permitir al tema preparar un renderizado diferente al predefinido.
+///      para permitir al tema generar un renderizado alternativo.
-///    - Si no es así, ejecuta [`prepare_component()`](Component::prepare_component) para preparar
+///    - Si el tema no lo modifica, llama a [`prepare_component()`](Component::prepare_component)
-///      el renderizado predefinido del componente.
+///      para obtener el renderizado por defecto del componente.
 /// 6. Despacha [`action::theme::AfterRender<C>`](crate::base::action::theme::AfterRender) para
-///    que el tema pueda hacer sus últimos ajustes.
+///    que el tema pueda aplicar ajustes finales.
 /// 7. Despacha [`action::component::AfterRender<C>`](crate::base::action::component::AfterRender)
 ///    para que otras extensiones puedan hacer sus últimos ajustes.
-/// 8. Finalmente devuelve un [`Markup`] del renderizado preparado en el paso 5.
+/// 8. Devuelve el [`Markup`] generado en el paso 5.
 impl<C: Component> ComponentRender for C {
     fn render(&mut self, cx: &mut Context) -> Markup {
         // Si no es renderizable, devuelve un bloque HTML vacío.
-        if !action::component::IsRenderable::dispatch(self, cx) {
+        if !self.is_renderable(cx) {
             return html! {};
         }
 

src/core/theme.rs

@@ -9,13 +9,14 @@
 //! tipografías, espaciados y cualquier otro detalle visual o de comportamiento (como animaciones,
 //! scripts de interfaz, etc.).
 //!
-//! Los temas son extensiones que implementan [`Extension`](crate::core::extension::Extension); por
+//! Los temas son extensiones que implementan [`Extension`](crate::core::extension::Extension), por
-//! lo que se instancian, declaran sus dependencias y se inician igual que el resto de extensiones;
+//! lo que se instancian, declaran dependencias y se inician igual que cualquier otra extensión.
-//! pero serán temas si además implementan [`theme()`](crate::core::extension::Extension::theme) y
+//! También deben implementar [`Theme`] y sobrescribir el método
-//! [`Theme`].
+//! [`Extension::theme()`](crate::core::extension::Extension::theme) para que PageTop pueda
+//! registrarlos como temas
 
 mod definition;
-pub use definition::{Theme, ThemePage, ThemeRef, ThemeRegion};
+pub use definition::{Theme, ThemePage, ThemeRef, DefaultRegions};
 
 mod regions;
 pub(crate) use regions::{ChildrenInRegions, REGION_CONTENT};

src/core/theme/definition.rs

@@ -4,7 +4,7 @@ use crate::core::theme::{Region, RegionRef, REGION_CONTENT};
 use crate::html::{html, Markup, StyleSheet};
 use crate::locale::L10n;
 use crate::response::page::Page;
-use crate::{global, join};
+use crate::{global, join, AutoDefault};
 
 use std::sync::LazyLock;
 
@@ -14,16 +14,17 @@ use std::sync::LazyLock;
 /// implementen [`Theme`] y, a su vez, [`Extension`].
 pub type ThemeRef = &'static dyn Theme;
 
-/// Conjunto de regiones que los temas pueden exponer para el renderizado.
+/// Conjunto de regiones predefinidas que los temas pueden exponer para el renderizado.
 ///
-/// `ThemeRegion` define un conjunto de regiones predefinidas para estructurar un documento HTML.
+/// `DefaultRegions` define un conjunto de regiones predefinidas para estructurar un documento HTML.
 /// Proporciona **identificadores estables** (vía [`Region::key()`]) y **etiquetas localizables**
 /// (vía [`Region::label()`]) a las regiones donde se añadirán los componentes.
 ///
 /// Se usa por defecto en [`Theme::page_regions()`](crate::core::theme::Theme::page_regions) y sus
 /// variantes representan el conjunto mínimo recomendado para cualquier tema. Sin embargo, cada tema
 /// podría exponer su propio conjunto de regiones.
-pub enum ThemeRegion {
+#[derive(AutoDefault)]
+pub enum DefaultRegions {
     /// Cabecera de la página.
     ///
     /// Clave: `"header"`. Suele contener *branding*, navegación principal o avisos globales.
@@ -32,6 +33,7 @@ pub enum ThemeRegion {
     /// Contenido principal de la página (**obligatoria**).
     ///
     /// Clave: `"content"`. Es el destino por defecto para insertar componentes a nivel de página.
+    #[default]
     Content,
 
     /// Pie de página.
@@ -40,12 +42,12 @@ pub enum ThemeRegion {
     Footer,
 }
 
-impl Region for ThemeRegion {
+impl Region for DefaultRegions {
     fn key(&self) -> &str {
         match self {
-            ThemeRegion::Header => "header",
+            Self::Header => "header",
-            ThemeRegion::Content => REGION_CONTENT,
+            Self::Content => REGION_CONTENT,
-            ThemeRegion::Footer => "footer",
+            Self::Footer => "footer",
         }
     }
 
@@ -60,16 +62,17 @@ impl Region for ThemeRegion {
 /// implementa automáticamente para cualquier tipo que implemente [`Theme`], por lo que normalmente
 /// no requiere implementación explícita.
 ///
-/// Si un tema **sobrescribe** uno o más de estos métodos de [`Theme`]:
+/// Si un tema **sobrescribe** uno o más de los siguientes métodos de [`Theme`]:
 ///
 /// - [`render_page_region()`](Theme::render_page_region),
 /// - [`render_page_head()`](Theme::render_page_head), o
 /// - [`render_page_body()`](Theme::render_page_body);
 ///
-/// es posible volver al comportamiento por defecto usando FQS (*Fully Qualified Syntax*):
+/// puede volver al comportamiento por defecto con una llamada FQS (*Fully Qualified Syntax*) a:
 ///
-/// - `<Self as ThemePage>::render_body(self, page, self.page_regions())`
+/// - `<Self as ThemePage>::render_region(self, page, region)`,
-/// - `<Self as ThemePage>::render_head(self, page)`
+/// - `<Self as ThemePage>::render_body(self, page, self.page_regions())`, o
+/// - `<Self as ThemePage>::render_head(self, page)`.
 pub trait ThemePage {
     /// Renderiza el **contenedor** de una región concreta del `<body>` de la página.
     ///
@@ -206,9 +209,9 @@ pub trait Theme: Extension + ThemePage + Send + Sync {
     /// fn page_regions(&self) -> &'static [RegionRef] {
     ///     static REGIONS: LazyLock<[RegionRef; 4]> = LazyLock::new(|| {
     ///         [
-    ///             &ThemeRegion::Header,
+    ///             &DefaultRegions::Header,
-    ///             &ThemeRegion::Content,
+    ///             &DefaultRegions::Content,
-    ///             &ThemeRegion::Footer,
+    ///             &DefaultRegions::Footer,
     ///         ]
     ///     });
     ///     &*REGIONS
@@ -217,9 +220,9 @@ pub trait Theme: Extension + ThemePage + Send + Sync {
     fn page_regions(&self) -> &'static [RegionRef] {
         static REGIONS: LazyLock<[RegionRef; 3]> = LazyLock::new(|| {
             [
-                &ThemeRegion::Header,
+                &DefaultRegions::Header,
-                &ThemeRegion::Content,
+                &DefaultRegions::Content,
-                &ThemeRegion::Footer,
+                &DefaultRegions::Footer,
             ]
         });
         &*REGIONS

src/core/theme/regions.rs

@@ -31,25 +31,25 @@ pub const REGION_CONTENT: &str = "content";
 ///   `aria-label` o en descripciones semánticas del contenedor).
 ///
 /// Las implementaciones típicas son *enumeraciones estáticas* declaradas por cada tema (ver como
-/// ejemplo [`ThemeRegion`](crate::core::theme::ThemeRegion)), de modo que las claves y etiquetas
+/// ejemplo [`DefaultRegions`](crate::core::theme::DefaultRegions)), de modo que las claves y
-/// permanecen inmutables y fácilmente referenciables.
+/// etiquetas permanecen inmutables y fácilmente referenciables.
 ///
 /// # Ejemplo
 ///
 /// ```rust
 /// # use pagetop::prelude::*;
-/// pub enum MyThemeRegion {
+/// pub enum MyThemeRegions {
 ///     Header,
 ///     Content,
 ///     Footer,
 /// }
 ///
-/// impl Region for MyThemeRegion {
+/// impl Region for MyThemeRegions {
 ///     fn key(&self) -> &str {
 ///         match self {
-///             MyThemeRegion::Header => "header",
+///             Self::Header => "header",
-///             MyThemeRegion::Content => "content",
+///             Self::Content => "content",
-///             MyThemeRegion::Footer => "footer",
+///             Self::Footer => "footer",
 ///         }
 ///     }
 ///
@@ -111,7 +111,7 @@ impl ChildrenInRegions {
     }
 }
 
-/// Punto de acceso para añadir componentes a regiones globales o específicas de un tema.
+/// Permite añadir componentes a regiones globales o específicas de un tema.
 ///
 /// Según la variante, se pueden añadir componentes ([`add()`](Self::add)) que permanecerán
 /// disponibles durante toda la ejecución.

src/html.rs

@@ -104,11 +104,11 @@ pub use unit::UnitValue;
 /// # use pagetop::prelude::*;
 /// // Texto normal, se escapa automáticamente para evitar inyección de HTML.
 /// let fragment = PrepareMarkup::Escaped("Hola <b>mundo</b>".to_string());
-/// assert_eq!(fragment.render().into_string(), "Hola &lt;b&gt;mundo&lt;/b&gt;");
+/// assert_eq!(fragment.into_string(), "Hola &lt;b&gt;mundo&lt;/b&gt;");
 ///
 /// // HTML literal, se inserta directamente, sin escapado adicional.
 /// let raw_html = PrepareMarkup::Raw("<b>negrita</b>".to_string());
-/// assert_eq!(raw_html.render().into_string(), "<b>negrita</b>");
+/// assert_eq!(raw_html.into_string(), "<b>negrita</b>");
 ///
 /// // Fragmento ya preparado con la macro `html!`.
 /// let prepared = PrepareMarkup::With(html! {
@@ -116,11 +116,11 @@ pub use unit::UnitValue;
 ///     p { "Este es un párrafo con contenido dinámico." }
 /// });
 /// assert_eq!(
-///     prepared.render().into_string(),
+///     prepared.into_string(),
 ///     "<h2>Título de ejemplo</h2><p>Este es un párrafo con contenido dinámico.</p>"
 /// );
 /// ```
-#[derive(AutoDefault)]
+#[derive(AutoDefault, Clone)]
 pub enum PrepareMarkup {
     /// No se genera contenido HTML (equivale a `html! {}`).
     #[default]
@@ -152,8 +152,13 @@ impl PrepareMarkup {
         }
     }
 
-    /// Integra el renderizado fácilmente en la macro [`html!`].
+    /// Convierte el contenido en una cadena HTML renderizada. Usar sólo para pruebas o depuración.
-    pub fn render(&self) -> Markup {
+    pub fn into_string(&self) -> String {
+        self.render().into_string()
+    }
+
+    // Integra el renderizado fácilmente en la macro [`html!`].
+    pub(crate) fn render(&self) -> Markup {
         match self {
             PrepareMarkup::None => html! {},
             PrepareMarkup::Escaped(text) => html! { (text) },

tests/component_html.rs

@@ -2,32 +2,28 @@ use pagetop::prelude::*;
 
 #[pagetop::test]
 async fn component_html_renders_static_markup() {
-    let component = Html::with(|_| {
+    let mut component = Html::with(|_| {
         html! {
             p { "Test" }
         }
     });
 
-    let markup = component
+    let markup = component.render(&mut Context::default());
-        .prepare_component(&mut Context::new(None))
-        .render();
-
     assert_eq!(markup.0, "<p>Test</p>");
 }
 
 #[pagetop::test]
 async fn component_html_renders_using_context_param() {
-    let mut cx = Context::new(None).with_param("username", "Alice".to_string());
+    let mut cx = Context::default().with_param("username", "Alice".to_string());
 
-    let component = Html::with(|cx| {
+    let mut component = Html::with(|cx| {
         let name = cx.param::<String>("username").cloned().unwrap_or_default();
         html! {
             span { (name) }
         }
     });
 
-    let markup = component.prepare_component(&mut cx).render();
+    let markup = component.render(&mut cx);
-
     assert_eq!(markup.0, "<span>Alice</span>");
 }
 
@@ -37,21 +33,15 @@ async fn component_html_allows_replacing_render_function() {
 
     component.alter_fn(|_| html! { div { "Modified" } });
 
-    let markup = component
+    let markup = component.render(&mut Context::default());
-        .prepare_component(&mut Context::new(None))
-        .render();
-
     assert_eq!(markup.0, "<div>Modified</div>");
 }
 
 #[pagetop::test]
 async fn component_html_default_renders_empty_markup() {
-    let component = Html::default();
+    let mut component = Html::default();
-
-    let markup = component
-        .prepare_component(&mut Context::new(None))
-        .render();
 
+    let markup = component.render(&mut Context::default());
     assert_eq!(markup.0, "");
 }
 
@@ -60,7 +50,7 @@ async fn component_html_can_access_http_method() {
     let req = service::test::TestRequest::with_uri("/").to_http_request();
     let mut cx = Context::new(Some(req));
 
-    let component = Html::with(|cx| {
+    let mut component = Html::with(|cx| {
         let method = cx
             .request()
             .map(|r| r.method().to_string())
@@ -68,7 +58,6 @@ async fn component_html_can_access_http_method() {
         html! { span { (method) } }
     });
 
-    let markup = component.prepare_component(&mut cx).render();
+    let markup = component.render(&mut cx);
-
     assert_eq!(markup.0, "<span>GET</span>");
 }

tests/component_poweredby.rs

@@ -4,8 +4,8 @@ use pagetop::prelude::*;
 async fn poweredby_default_shows_only_pagetop_recognition() {
     let _app = service::test::init_service(Application::new().test()).await;
 
-    let p = PoweredBy::default();
+    let mut p = PoweredBy::default();
-    let html = render_component(&p);
+    let html = p.render(&mut Context::default());
 
     // Debe mostrar el bloque de reconocimiento a PageTop.
     assert!(html.as_str().contains("poweredby__pagetop"));
@@ -18,8 +18,8 @@ async fn poweredby_default_shows_only_pagetop_recognition() {
 async fn poweredby_new_includes_current_year_and_app_name() {
     let _app = service::test::init_service(Application::new().test()).await;
 
-    let p = PoweredBy::new();
+    let mut p = PoweredBy::new();
-    let html = render_component(&p);
+    let html = p.render(&mut Context::default());
 
     let year = Utc::now().format("%Y").to_string();
     assert!(
@@ -43,8 +43,8 @@ async fn poweredby_with_copyright_overrides_text() {
     let _app = service::test::init_service(Application::new().test()).await;
 
     let custom = "2001 © FooBar Inc.";
-    let p = PoweredBy::default().with_copyright(Some(custom));
+    let mut p = PoweredBy::default().with_copyright(Some(custom));
-    let html = render_component(&p);
+    let html = p.render(&mut Context::default());
 
     assert!(html.as_str().contains(custom));
     assert!(html.as_str().contains("poweredby__copyright"));
@@ -54,8 +54,8 @@ async fn poweredby_with_copyright_overrides_text() {
 async fn poweredby_with_copyright_none_hides_text() {
     let _app = service::test::init_service(Application::new().test()).await;
 
-    let p = PoweredBy::new().with_copyright(None::<String>);
+    let mut p = PoweredBy::new().with_copyright(None::<String>);
-    let html = render_component(&p);
+    let html = p.render(&mut Context::default());
 
     assert!(!html.as_str().contains("poweredby__copyright"));
     // El reconocimiento a PageTop siempre debe aparecer.
@@ -66,8 +66,8 @@ async fn poweredby_with_copyright_none_hides_text() {
 async fn poweredby_link_points_to_crates_io() {
     let _app = service::test::init_service(Application::new().test()).await;
 
-    let p = PoweredBy::default();
+    let mut p = PoweredBy::default();
-    let html = render_component(&p);
+    let html = p.render(&mut Context::default());
 
     assert!(
         html.as_str().contains("https://pagetop.cillero.es"),
@@ -89,11 +89,3 @@ async fn poweredby_getter_reflects_internal_state() {
     assert!(c1.contains(&Utc::now().format("%Y").to_string()));
     assert!(c1.contains(&global::SETTINGS.app.name));
 }
-
-// **< HELPERS >************************************************************************************
-
-fn render_component<C: Component>(c: &C) -> Markup {
-    let mut cx = Context::default();
-    let pm = c.prepare_component(&mut cx);
-    pm.render()
-}

tests/html_pm.rs

@@ -1,70 +1,69 @@
 use pagetop::prelude::*;
 
-#[pagetop::test]
+/// Componente mínimo para probar `PrepareMarkup` pasando por el ciclo real
-async fn prepare_markup_render_none_is_empty_string() {
+/// de renderizado de componentes (`ComponentRender`).
-    assert_eq!(PrepareMarkup::None.render().as_str(), "");
+#[derive(AutoDefault)]
+struct TestPrepareComponent {
+    pm: PrepareMarkup,
+}
+
+impl Component for TestPrepareComponent {
+    fn new() -> Self {
+        Self {
+            pm: PrepareMarkup::None,
+        }
+    }
+
+    fn prepare_component(&self, _cx: &mut Context) -> PrepareMarkup {
+        self.pm.clone()
+    }
+}
+
+impl TestPrepareComponent {
+    fn render_pm(pm: PrepareMarkup) -> String {
+        let mut c = TestPrepareComponent { pm };
+        c.render(&mut Context::default()).into_string()
+    }
 }
 
 #[pagetop::test]
-async fn prepare_markup_render_escaped_escapes_html_and_ampersands() {
+async fn prepare_markup_none_is_empty_string() {
+    assert_eq!(PrepareMarkup::None.into_string(), "");
+}
+
+#[pagetop::test]
+async fn prepare_markup_escaped_escapes_html_and_ampersands() {
     let pm = PrepareMarkup::Escaped("<b>& \" ' </b>".to_string());
-    assert_eq!(pm.render().as_str(), "&lt;b&gt;&amp; &quot; ' &lt;/b&gt;");
+    assert_eq!(pm.into_string(), "&lt;b&gt;&amp; &quot; ' &lt;/b&gt;");
 }
 
 #[pagetop::test]
-async fn prepare_markup_render_raw_is_inserted_verbatim() {
+async fn prepare_markup_raw_is_inserted_verbatim() {
     let pm = PrepareMarkup::Raw("<b>bold</b><script>1<2</script>".to_string());
-    assert_eq!(pm.render().as_str(), "<b>bold</b><script>1<2</script>");
+    assert_eq!(pm.into_string(), "<b>bold</b><script>1<2</script>");
 }
 
 #[pagetop::test]
-async fn prepare_markup_render_with_keeps_structure() {
+async fn prepare_markup_with_keeps_structure() {
     let pm = PrepareMarkup::With(html! {
         h2 { "Sample title" }
         p  { "This is a paragraph." }
     });
     assert_eq!(
-        pm.render().as_str(),
+        pm.into_string(),
         "<h2>Sample title</h2><p>This is a paragraph.</p>"
     );
 }
 
-#[pagetop::test]
-async fn prepare_markup_does_not_double_escape_when_wrapped_in_html_macro() {
-    // Escaped: dentro de `html!` no debe volver a escaparse.
-    let escaped = PrepareMarkup::Escaped("<i>x</i>".into());
-    let wrapped_escaped = html! { div { (escaped.render()) } };
-    assert_eq!(
-        wrapped_escaped.into_string(),
-        "<div>&lt;i&gt;x&lt;/i&gt;</div>"
-    );
-
-    // Raw: tampoco debe escaparse al integrarlo.
-    let raw = PrepareMarkup::Raw("<i>x</i>".into());
-    let wrapped_raw = html! { div { (raw.render()) } };
-    assert_eq!(wrapped_raw.into_string(), "<div><i>x</i></div>");
-
-    // With: debe incrustar el Markup tal cual.
-    let with = PrepareMarkup::With(html! { span.title { "ok" } });
-    let wrapped_with = html! { div { (with.render()) } };
-    assert_eq!(
-        wrapped_with.into_string(),
-        "<div><span class=\"title\">ok</span></div>"
-    );
-}
-
 #[pagetop::test]
 async fn prepare_markup_unicode_is_preserved() {
     // Texto con acentos y emojis debe conservarse (salvo el escape HTML de signos).
     let esc = PrepareMarkup::Escaped("Hello, tomorrow coffee ☕ & donuts!".into());
-    assert_eq!(
+    assert_eq!(esc.into_string(), "Hello, tomorrow coffee ☕ &amp; donuts!");
-        esc.render().as_str(),
-        "Hello, tomorrow coffee ☕ &amp; donuts!"
-    );
 
     // Raw debe pasar íntegro.
     let raw = PrepareMarkup::Raw("Title — section © 2025".into());
-    assert_eq!(raw.render().as_str(), "Title — section © 2025");
+    assert_eq!(raw.into_string(), "Title — section © 2025");
 }
 
 #[pagetop::test]
@@ -88,7 +87,36 @@ async fn prepare_markup_is_empty_semantics() {
 }
 
 #[pagetop::test]
-async fn prepare_markup_equivalence_between_render_and_inline_in_html_macro() {
+async fn prepare_markup_does_not_double_escape_when_markup_is_reinjected_in_html_macro() {
+    let mut cx = Context::default();
+
+    // Escaped: dentro de `html!` no debe volver a escaparse.
+    let mut comp = TestPrepareComponent {
+        pm: PrepareMarkup::Escaped("<i>x</i>".into()),
+    };
+    let markup = comp.render(&mut cx); // Markup
+    let wrapped_escaped = html! { div { (markup) } }.into_string();
+    assert_eq!(wrapped_escaped, "<div>&lt;i&gt;x&lt;/i&gt;</div>");
+
+    // Raw: tampoco debe escaparse al integrarlo.
+    let mut comp = TestPrepareComponent {
+        pm: PrepareMarkup::Raw("<i>x</i>".into()),
+    };
+    let markup = comp.render(&mut cx);
+    let wrapped_raw = html! { div { (markup) } }.into_string();
+    assert_eq!(wrapped_raw, "<div><i>x</i></div>");
+
+    // With: debe incrustar el Markup tal cual.
+    let mut comp = TestPrepareComponent {
+        pm: PrepareMarkup::With(html! { span.title { "ok" } }),
+    };
+    let markup = comp.render(&mut cx);
+    let wrapped_with = html! { div { (markup) } }.into_string();
+    assert_eq!(wrapped_with, "<div><span class=\"title\">ok</span></div>");
+}
+
+#[pagetop::test]
+async fn prepare_markup_equivalence_between_component_render_and_markup_reinjected_in_html_macro() {
     let cases = [
         PrepareMarkup::None,
         PrepareMarkup::Escaped("<b>x</b>".into()),
@@ -97,12 +125,20 @@ async fn prepare_markup_equivalence_between_render_and_inline_in_html_macro() {
     ];
 
     for pm in cases {
-        let rendered = pm.render();
+        // Vía 1: renderizamos y obtenemos directamente el String.
-        let in_macro = html! { (rendered) }.into_string();
+        let via_component = TestPrepareComponent::render_pm(pm.clone());
+
+        // Vía 2: renderizamos, reinyectamos el Markup en `html!` y volvemos a obtener String.
+        let via_macro = {
+            let mut cx = Context::default();
+            let mut comp = TestPrepareComponent { pm };
+            let markup = comp.render(&mut cx);
+            html! { (markup) }.into_string()
+        };
+
         assert_eq!(
-            rendered.as_str(),
+            via_component, via_macro,
-            in_macro,
+            "The output of component render and (Markup) inside html! must match"
-            "The output of Render and (pm) inside html! must match"
         );
     }
 }