manuelcillero/pagetop
manuelcillero/pagetop
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

✨ Completa la API de temas con setup_component!

Browse source 
Elimina `action::theme` fusionando sus responsabilidades en
`action::component`. Renombra `AlterMarkup` a `TransformMarkup` y
`FnActionAlterMarkup` a `FnActionTransformMarkup`. Simplifica
`ActionKey` y mueve los tipos de función al módulo de componente.
This commit is contained in:
Manuel Cillero 2026-03-23 15:52:06 +01:00 • committed by Manuel Cillero
parent afd98e2c03
commit f1d3218a68
18 changed files with 178 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/base/action.rs
View file

@ -1,31 +1,5 @@
//! Acciones predefinidas para alterar el funcionamiento interno de PageTop.
use crate::prelude::*;
/// Tipo de función para manipular componentes y su contexto de renderizado.
///
/// Se usa en acciones definidas en [`action::component`] y [`action::theme`] para alterar el
/// comportamiento de los componentes.
///
/// Recibe referencias mutables (`&mut`) del componente `component` y del contexto `cx`.
pub type FnActionWithComponent<C> = fn(component: &mut C, cx: &mut Context);
/// Tipo de función para modificar el [`Markup`] generado por un componente.
///
/// Se usa en [`action::component::AlterMarkup`] para permitir a las extensiones modificar el HTML
/// final producido por el renderizado de un componente. La edición trabaja a nivel de texto: el
/// [`Markup`] recibido expone su contenido como [`String`], lo que permite aplicar búsquedas,
/// sustituciones, concatenaciones y cualquier otra primitiva de trabajo con cadenas.
///
/// La función recibe referencias mutables del componente `component` y del contexto `cx`, y toma
/// posesión del `markup` producido hasta ese momento. Devuelve el nuevo [`Markup`] modificado, que
/// se encadena como entrada para la siguiente acción registrada, si la hay.
pub type FnActionAlterMarkup<C> = fn(component: &mut C, cx: &mut Context, markup: Markup) -> Markup;
// **< Acciones por tipo >**************************************************************************
pub mod component;
pub mod theme;
pub mod page;

27
src/base/action/component.rs
View file

@ -1,10 +1,33 @@
//! Acciones que operan sobre componentes.
use pagetop::prelude::*;
/// Tipo de función para manipular componentes y su contexto de renderizado.
///
/// Se usa en [`action::component::BeforeRender`] y [`action::component::AfterRender`] para alterar
/// el comportamiento predefinido de los componentes.
///
/// Recibe referencias mutables (`&mut`) del componente `component` y del contexto `cx`.
pub type FnActionWithComponent<C> = fn(component: &mut C, cx: &mut Context);
/// Tipo de función para alterar el [`Markup`] generado por un componente.
///
/// Se usa en [`action::component::TransformMarkup`] para permitir a las extensiones alterar el HTML
/// final producido por el renderizado de un componente. La edición trabaja a nivel de texto: el
/// [`Markup`] recibido expone su contenido como [`String`], lo que permite aplicar búsquedas,
/// sustituciones, concatenaciones y cualquier otra primitiva de trabajo con cadenas.
///
/// La función recibe una referencia inmutable al componente `component` (el renderizado ya ha
/// concluido, solo se necesita leer su estado), una referencia mutable al contexto `cx`, y toma
/// posesión del `markup` producido hasta ese momento. Devuelve el nuevo [`Markup`] transformado,
/// que se encadena como entrada para la siguiente acción registrada, si la hay.
pub type FnActionTransformMarkup<C> = fn(component: &C, cx: &mut Context, markup: Markup) -> Markup;
mod before_render_component;
pub use before_render_component::*;
mod after_render_component;
pub use after_render_component::*;
mod alter_markup_component;
pub use alter_markup_component::*;
mod transform_markup_component;
pub use transform_markup_component::*;

16
src/base/action/component/after_render_component.rs
View file

@ -1,6 +1,6 @@
use crate::prelude::*;
use crate::base::action::FnActionWithComponent;
use super::FnActionWithComponent;
/// Ejecuta [`FnActionWithComponent`] después de renderizar un componente.
pub struct AfterRender<C: Component> {
@ -57,24 +57,14 @@ impl<C: Component> AfterRender<C> {
pub(crate) fn dispatch(component: &mut C, cx: &mut Context) {
// Primero despacha las acciones para el tipo de componente.
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
None,
Some(UniqueId::of::<C>()),
None,
),
&ActionKey::new(UniqueId::of::<Self>(), Some(UniqueId::of::<C>()), None),
|action: &Self| (action.f)(component, cx),
);
// Y luego despacha las acciones para el tipo de componente con un identificador dado.
if let Some(id) = component.id() {
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
None,
Some(UniqueId::of::<C>()),
Some(id),
),
&ActionKey::new(UniqueId::of::<Self>(), Some(UniqueId::of::<C>()), Some(id)),
|action: &Self| (action.f)(component, cx),
);
}

16
src/base/action/component/before_render_component.rs
View file

@ -1,6 +1,6 @@
use crate::prelude::*;
use crate::base::action::FnActionWithComponent;
use super::FnActionWithComponent;
/// Ejecuta [`FnActionWithComponent`] antes de renderizar el componente.
pub struct BeforeRender<C: Component> {
@ -57,24 +57,14 @@ impl<C: Component> BeforeRender<C> {
pub(crate) fn dispatch(component: &mut C, cx: &mut Context) {
// Primero despacha las acciones para el tipo de componente.
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
None,
Some(UniqueId::of::<C>()),
None,
),
&ActionKey::new(UniqueId::of::<Self>(), Some(UniqueId::of::<C>()), None),
|action: &Self| (action.f)(component, cx),
);
// Y luego despacha las aciones para el tipo de componente con un identificador dado.
if let Some(id) = component.id() {
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
None,
Some(UniqueId::of::<C>()),
Some(id),
),
&ActionKey::new(UniqueId::of::<Self>(), Some(UniqueId::of::<C>()), Some(id)),
|action: &Self| (action.f)(component, cx),
);
}

41
src/base/action/component/alter_markup_component.rs → src/base/action/component/transform_markup_component.rs
View file

@ -1,18 +1,17 @@
use crate::prelude::*;
use crate::base::action::FnActionAlterMarkup;
use crate::html::html;
use super::FnActionTransformMarkup;
/// Ejecuta [`FnActionAlterMarkup`] para modificar el renderizado de un componente.
pub struct AlterMarkup<C: Component> {
f: FnActionAlterMarkup<C>,
/// Ejecuta [`FnActionTransformMarkup`] para alterar el renderizado de componentes.
pub struct TransformMarkup<C: Component> {
f: FnActionTransformMarkup<C>,
referer_type_id: Option<UniqueId>,
referer_id: AttrId,
weight: Weight,
}
/// Filtro para despachar [`FnActionAlterMarkup`] sobre el renderizado de un componente `C`.
impl<C: Component> ActionDispatcher for AlterMarkup<C> {
/// Filtro para despachar [`FnActionTransformMarkup`] sobre el renderizado de un componente `C`.
impl<C: Component> ActionDispatcher for TransformMarkup<C> {
/// Devuelve el identificador de tipo ([`UniqueId`]) del componente `C`.
fn referer_type_id(&self) -> Option<UniqueId> {
self.referer_type_id
@ -29,10 +28,10 @@ impl<C: Component> ActionDispatcher for AlterMarkup<C> {
}
}
impl<C: Component> AlterMarkup<C> {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionAlterMarkup`].
pub fn new(f: FnActionAlterMarkup<C>) -> Self {
AlterMarkup {
impl<C: Component> TransformMarkup<C> {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionTransformMarkup`].
pub fn new(f: FnActionTransformMarkup<C>) -> Self {
TransformMarkup {
f,
referer_type_id: Some(UniqueId::of::<C>()),
referer_id: AttrId::default(),
@ -40,8 +39,8 @@ impl<C: Component> AlterMarkup<C> {
}
}
/// Afina el registro para ejecutar la acción [`FnActionAlterMarkup`] sólo para el componente
/// `C` con identificador `id`.
/// Afina el registro para ejecutar la acción [`FnActionTransformMarkup`] 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_id(id);
self
@ -55,17 +54,12 @@ impl<C: Component> AlterMarkup<C> {
/// Despacha las acciones encadenando el [`Markup`] entre cada una.
#[inline]
pub(crate) fn dispatch(component: &mut C, cx: &mut Context, markup: Markup) -> Markup {
pub(crate) fn dispatch(component: &C, cx: &mut Context, markup: Markup) -> Markup {
let mut output = markup;
// Primero despacha las acciones para el tipo de componente.
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
None,
Some(UniqueId::of::<C>()),
None,
),
&ActionKey::new(UniqueId::of::<Self>(), Some(UniqueId::of::<C>()), None),
|action: &Self| {
let taken = std::mem::replace(&mut output, html! {});
output = (action.f)(component, cx, taken);
@ -75,12 +69,7 @@ impl<C: Component> AlterMarkup<C> {
// Y luego despacha las acciones para el tipo de componente con un identificador dado.
if let Some(id) = component.id() {
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
None,
Some(UniqueId::of::<C>()),
Some(id),
),
&ActionKey::new(UniqueId::of::<Self>(), Some(UniqueId::of::<C>()), Some(id)),
|action: &Self| {
let taken = std::mem::replace(&mut output, html! {});
output = (action.f)(component, cx, taken);

4
src/base/action/page/after_render_body.rs
View file

@ -1,6 +1,6 @@
use crate::prelude::*;
use crate::base::action::page::FnActionWithPage;
use super::FnActionWithPage;
/// Ejecuta [`FnActionWithPage`](crate::base::action::page::FnActionWithPage) después de renderizar
/// el cuerpo de la página.
@ -39,7 +39,7 @@ impl AfterRenderBody {
#[allow(clippy::inline_always)]
pub(crate) fn dispatch(page: &mut Page) {
dispatch_actions(
&ActionKey::new(UniqueId::of::<Self>(), None, None, None),
&ActionKey::new(UniqueId::of::<Self>(), None, None),
|action: &Self| (action.f)(page),
);
}

4
src/base/action/page/before_render_body.rs
View file

@ -1,6 +1,6 @@
use crate::prelude::*;
use crate::base::action::page::FnActionWithPage;
use super::FnActionWithPage;
/// Ejecuta [`FnActionWithPage`](crate::base::action::page::FnActionWithPage) antes de renderizar
/// el cuerpo de la página.
@ -39,7 +39,7 @@ impl BeforeRenderBody {
#[allow(clippy::inline_always)]
pub(crate) fn dispatch(page: &mut Page) {
dispatch_actions(
&ActionKey::new(UniqueId::of::<Self>(), None, None, None),
&ActionKey::new(UniqueId::of::<Self>(), None, None),
|action: &Self| (action.f)(page),
);
}

7
src/base/action/theme.rs
View file

@ -1,7 +0,0 @@
//! Acciones lanzadas desde los temas.
mod before_render_component;
pub use before_render_component::*;
mod after_render_component;
pub use after_render_component::*;

50
src/base/action/theme/after_render_component.rs
View file

@ -1,50 +0,0 @@
use crate::prelude::*;
use crate::base::action::FnActionWithComponent;
/// Ejecuta [`FnActionWithComponent`] después de que un tema renderice el componente.
pub struct AfterRender<C: Component> {
f: FnActionWithComponent<C>,
theme_type_id: Option<UniqueId>,
referer_type_id: Option<UniqueId>,
}
/// Filtro para despachar [`FnActionWithComponent`] después de que un tema renderice el componente
/// `C`.
impl<C: Component> ActionDispatcher for AfterRender<C> {
/// Devuelve el identificador de tipo ([`UniqueId`]) del tema.
fn theme_type_id(&self) -> Option<UniqueId> {
self.theme_type_id
}
/// Devuelve el identificador de tipo ([`UniqueId`]) del componente `C`.
fn referer_type_id(&self) -> Option<UniqueId> {
self.referer_type_id
}
}
impl<C: Component> AfterRender<C> {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionWithComponent`] para un
/// tema dado.
pub fn new(theme: ThemeRef, f: FnActionWithComponent<C>) -> Self {
AfterRender {
f,
theme_type_id: Some(theme.type_id()),
referer_type_id: Some(UniqueId::of::<C>()),
}
}
/// Despacha las acciones.
#[inline]
pub(crate) fn dispatch(component: &mut C, cx: &mut Context) {
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
Some(cx.theme().type_id()),
Some(UniqueId::of::<C>()),
None,
),
|action: &Self| (action.f)(component, cx),
);
}
}

50
src/base/action/theme/before_render_component.rs
View file

@ -1,50 +0,0 @@
use crate::prelude::*;
use crate::base::action::FnActionWithComponent;
/// Ejecuta [`FnActionWithComponent`] antes de que un tema renderice el componente.
pub struct BeforeRender<C: Component> {
f: FnActionWithComponent<C>,
theme_type_id: Option<UniqueId>,
referer_type_id: Option<UniqueId>,
}
/// Filtro para despachar [`FnActionWithComponent`] antes de que un tema renderice el componente
/// `C`.
impl<C: Component> ActionDispatcher for BeforeRender<C> {
/// Devuelve el identificador de tipo ([`UniqueId`]) del tema.
fn theme_type_id(&self) -> Option<UniqueId> {
self.theme_type_id
}
/// Devuelve el identificador de tipo ([`UniqueId`]) del componente `C`.
fn referer_type_id(&self) -> Option<UniqueId> {
self.referer_type_id
}
}
impl<C: Component> BeforeRender<C> {
/// Permite [registrar](Extension::actions) una nueva acción [`FnActionWithComponent`] para un
/// tema dado.
pub fn new(theme: ThemeRef, f: FnActionWithComponent<C>) -> Self {
BeforeRender {
f,
theme_type_id: Some(theme.type_id()),
referer_type_id: Some(UniqueId::of::<C>()),
}
}
/// Despacha las acciones.
#[inline]
pub(crate) fn dispatch(component: &mut C, cx: &mut Context) {
dispatch_actions(
&ActionKey::new(
UniqueId::of::<Self>(),
Some(cx.theme().type_id()),
Some(UniqueId::of::<C>()),
None,
),
|action: &Self| (action.f)(component, cx),
);
}
}