Enum VirtualNode 

pub enum VirtualNode<Dom>
where
    Dom: RealDom,
{
    Element(VirtualElement<Dom>),
    Text(VirtualText),
}

When building your views you’ll typically use the html! macro to generate VirtualNode’s.

html! { <div> <span></span> </div> } really generates a VirtualNode with one child (span).

Later, on the client side, you’ll use the diff and patch modules to update the real DOM with your latest tree of virtual nodes (virtual dom).

Or on the server side you’ll just call .to_string() on your root virtual node in order to recursively render the node and all of its children.

Examples

use virtual_node::VirtualNode;
let div = VirtualNode::<()>::new_element("div");
assert_eq!(div.to_string(), "<div></div>");

Variants

Element(VirtualElement<Dom>)

An element node (node type ELEMENT_NODE).

Text(VirtualText)

A text node (node type TEXT_NODE).

Note: This wraps a VText instead of a plain String in order to enable custom methods like create_text_node() on the wrapped type.

Implementations

impl<Handle> VirtualNode<Handle>

where Handle: RealDom,

pub fn children_recursive<'a>(&'a self) -> Vec<&'a VirtualNode<Handle>>

Get a vector of all of the VirtualNode children / grandchildren / etc of your virtual_node.

Children are visited recursively depth first.

Examples

let component = html! {
 <div>
   <span> {"Hi!"} </span>
   <em> {"There!!"} </em>
   <div> {"My Friend"} </div>
 </div>
};

let children = component.children_recursive();

assert_eq!(children[2].tag(), "em");

impl<Dom> VirtualNode<Dom>

where Dom: RealDom,

pub fn new_element<S>(tag: S) -> VirtualNode<Dom>

where S: Into<String>,

Create a new virtual element node with a given tag.

These get patched into the DOM using document.createElement

let _div = VirtualNode::<()>::new_element("div");

pub fn new_text<S>(text: S) -> VirtualNode<Dom>

where S: Into<String>,

Create a new virtual text node with the given text.

These get patched into the DOM using document.createTextNode

let _text = VirtualNode::<()>::new_text("My text node");

pub fn as_elem(&self) -> Option<&VirtualElement<Dom>>

Return a VirtualElement reference, if this is an Element variant.

pub fn as_elem_mut(&mut self) -> Option<&mut VirtualElement<Dom>>

Return a mutable VirtualElement reference, if this is an Element variant.

pub fn as_text(&self) -> Option<&VirtualText>

Return a VirtualText reference, if this is an Text variant.

pub fn as_text_mut(&mut self) -> Option<&mut VirtualText>

Return a mutable VText reference, if this is an Text variant.

pub fn map_real_dom<New>( self, convert_event: &dyn Fn(EventHandler<Dom>) -> EventHandler<New>, ) -> VirtualNode<New>

where New: RealDom,

Convert this VirtualNode<DomA> into a VirtualNode<DomB>.

pub fn insert_space_before_text(&mut self)

Used by html-macro to insert space before text that is inside of a block that came after an open tag.

html! {

{world}

}

So that we end up with

world

when we’re finished parsing.

pub fn insert_space_after_text(&mut self)

Used by html-macro to insert space after braced text if we know that the next block is another block or a closing tag.

html! {

{Hello} {world}

} ->

Hello world

html! {

{Hello}

} ->

Hello

So that we end up with

Hello world

when we’re finished parsing.

impl VirtualNode<Window>

pub fn create_dom_node( &self, events: &mut VirtualEvents<Window>, ) -> (Node, VirtualEventNode)

Create and return a web_sys::Node along with its events.

Trait Implementations

impl<Dom> Debug for VirtualNode<Dom>

where Dom: RealDom,

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

Formats the value using the given formatter.

impl<Dom> Display for VirtualNode<Dom>

where Dom: RealDom,

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

Formats the value using the given formatter.

impl<V, Dom> From<&V> for VirtualNode<Dom>

where Dom: RealDom, V: View<Dom>,

fn from(v: &V) -> VirtualNode<Dom>

Converts to this type from the input type.

impl<Dom> From<&str> for VirtualNode<Dom>

where Dom: RealDom,

fn from(other: &str) -> VirtualNode<Dom>

Converts to this type from the input type.

impl<Dom> From<String> for VirtualNode<Dom>

where Dom: RealDom,

fn from(other: String) -> VirtualNode<Dom>

Converts to this type from the input type.

impl<Dom> From<VirtualElement<Dom>> for VirtualNode<Dom>

where Dom: RealDom,

fn from(other: VirtualElement<Dom>) -> VirtualNode<Dom>

Converts to this type from the input type.

impl<Handle> From<VirtualNode<Handle>> for IterableNodes<Handle>

where Handle: RealDom,

fn from(other: VirtualNode<Handle>) -> IterableNodes<Handle>

Converts to this type from the input type.

impl<Dom> From<VirtualText> for VirtualNode<Dom>

where Dom: RealDom,

fn from(other: VirtualText) -> VirtualNode<Dom>

Converts to this type from the input type.

impl<Dom> Into<IntoIter<VirtualNode<Dom>>> for VirtualNode<Dom>

where Dom: RealDom,

fn into(self) -> IntoIter<VirtualNode<Dom>>

Converts this type into the (usually inferred) input type.

impl<Dom> IntoIterator for VirtualNode<Dom>

where Dom: RealDom,

type Item = VirtualNode<Dom>

The type of the elements being iterated over.

type IntoIter = IntoIter<VirtualNode<Dom>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <VirtualNode<Dom> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Dom> PartialEq for VirtualNode<Dom>

where Dom: RealDom,

fn eq(&self, other: &VirtualNode<Dom>) -> bool

Equality operator ==.

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

Inequality operator !=.