pagetop 0.5.0

Un entorno de desarrollo para crear soluciones web modulares, extensibles y configurables.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use crate::prelude::*;

use super::FnActionTransformMarkup;

/// 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 [`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
    }

    /// 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> 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(),
            weight: 0,
        }
    }

    /// 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
    }

    /// 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 encadenando el [`Markup`] entre cada una.
    #[inline]
    pub(crate) fn dispatch(component: &C, cx: &Context, markup: Markup) -> Markup {
        let mut output = markup;

        // Primero despacha las acciones para el tipo de componente.
        dispatch_actions(
            &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);
            },
        );

        // 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>(), Some(UniqueId::of::<C>()), Some(id)),
                |action: &Self| {
                    let taken = std::mem::replace(&mut output, html! {});
                    output = (action.f)(component, cx, taken);
                },
            );
        }

        output
    }
}