Enum respo::RespoNode

pub enum RespoNode<T>where
    T: Debug + Clone,{
    Component(String, Vec<RespoEffect>, Box<RespoNode<T>>),
    Element {
        name: String,
        attrs: HashMap<String, String>,
        event: HashMap<String, RespoListenerFn<T>>,
        style: RespoStyle,
        children: Vec<(RespoIndexKey, RespoNode<T>)>,
    },
    Referenced(Rc<RespoNode<T>>),
}

an Element or a Component

Variants

Component(String, Vec<RespoEffect>, Box<RespoNode<T>>)

Element

Fields

name: String

tagName

attrs: HashMap<String, String>

event: HashMap<String, RespoListenerFn<T>>

style: RespoStyle

inlines styles, partially typed. there’s also a macro called static_styles for inserting CSS rules

children: Vec<(RespoIndexKey, RespoNode<T>)>

each child as a key like a string, by default generated from index, they are used in diffing, so it’s better to be distinct, although not required to be.

corresponding to DOM elements

Referenced(Rc<RespoNode<T>>)

Implementations

impl<T> RespoNode<T>where T: Debug + Clone,

pub fn new_tag(name: &str) -> Self

create an element node

pub fn new_component(name: &str, tree: RespoNode<T>) -> Self

create a new component

pub fn style(&mut self, more: RespoStyle) -> &mut Self

attach styles

element.style(RespoStyle::default().margin(10))

pub fn modify_style<U>(&mut self, builder: U) -> &mut Selfwhere U: Fn(&mut RespoStyle),

imparative way of updating style

element.modify_style(|s| {
  if data > 1 {
    s.color(CssColor::Red);
  }
});

pub fn attribute<U, V>(&mut self, property: U, value: V) -> &mut Selfwhere U: Into<String> + ToOwned, V: Display,

set an attribute on element

pub fn maybe_attribute<U, V>( &mut self, property: U, value: Option<V> ) -> &mut Selfwhere U: Into<String> + ToOwned, V: Display,

set an attribute on element, but using None indicates noting

pub fn on_click<U>(&mut self, handler: U) -> &mut Selfwhere U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

pub fn on_input<U>(&mut self, handler: U) -> &mut Selfwhere U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

pub fn on_keydown<U>(&mut self, handler: U) -> &mut Selfwhere U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

handle keydown event

pub fn on_focus<U>(&mut self, handler: U) -> &mut Selfwhere U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

handle focus event

pub fn on_change<U>(&mut self, handler: U) -> &mut Selfwhere U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

handle change event

pub fn on_named_event<U>(&mut self, name: &str, handler: U) -> &mut Selfwhere U: Fn(RespoEvent, DispatchFn<T>) -> Result<(), String> + 'static,

attach a listener by event name(only a small set of events are supported)

pub fn children<U>(&mut self, more: U) -> &mut Selfwhere U: IntoIterator<Item = RespoNode<T>>,

add children elements, index key are generated from index number

pub fn children_indexed<U>(&mut self, more: U) -> &mut Selfwhere U: IntoIterator<Item = (RespoIndexKey, RespoNode<T>)>,

add children elements, with index keys specified

pub fn effect<U, V>(&mut self, args: &[V], handler: U) -> &mut Selfwhere U: Fn(Vec<RespoEffectArg>, RespoEffectType, &Node) -> Result<(), String> + 'static, V: Serialize + Clone,

add an effect on component

pub fn stable_effect<U>(&mut self, handler: U) -> &mut Selfwhere U: Fn(Vec<RespoEffectArg>, RespoEffectType, &Node) -> Result<(), String> + 'static,

add an empty args effect on component, which does not update

pub fn effects<U>(&mut self, more: U) -> &mut Selfwhere U: IntoIterator<Item = RespoEffect>,

add a list of effects on component

pub fn class<U>(&mut self, name: U) -> &mut Selfwhere U: Into<String>,

attach a class name for adding styles

pub fn maybe_class<U>(&mut self, name: Option<U>) -> &mut Selfwhere U: Into<String>,

attach an optional class name for adding styles

pub fn toggle_class<U>(&mut self, name: U, on: bool) -> &mut Selfwhere U: Into<String>,

attach a class name, controlled by a boolean

pub fn class_list<U>(&mut self, names: &[U]) -> &mut Selfwhere U: Into<String> + Clone,

attach a list of class names for adding styles

pub fn inner_text<U>(&mut self, content: U) -> &mut Selfwhere U: Into<String>,

writes innerText

pub fn inner_html<U>(&mut self, content: U) -> &mut Selfwhere U: Into<String>,

writes innerHTML

pub fn value<U>(&mut self, content: U) -> &mut Selfwhere U: Into<String>,

writes value

pub fn share_with_ref(&self) -> Self

wrap with a Rc<RefCell<T>> to enable memory reuse and skipping in diff

Trait Implementations

impl<T> Clone for RespoNode<T>where T: Debug + Clone + Clone,

fn clone(&self) -> RespoNode<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RespoNode<T>where T: Debug + Clone + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Display for RespoNode<T>where T: Debug + Clone,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> From<RespoNode<T>> for Cirruwhere T: Debug + Clone,

fn from(value: RespoNode<T>) -> Self

Converts to this type from the input type.

impl<T> PartialEq<RespoNode<T>> for RespoNode<T>where T: Debug + Clone + PartialEq,

fn eq(&self, other: &RespoNode<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for RespoNode<T>where T: Debug + Clone + Eq,

impl<T> StructuralEq for RespoNode<T>where T: Debug + Clone,

impl<T> StructuralPartialEq for RespoNode<T>where T: Debug + Clone,