Enum VirtualNode 

pub enum VirtualNode {
    Element {
        tag: Tag,
        attributes: Vec<AttributeEntry>,
        children: Vec<VirtualNode>,
        key: Option<String>,
    },
    Text(TextNode),
    Fragment(Vec<VirtualNode>),
    Dynamic(DynamicNode),
    Empty,
}

Represents a node in the virtual DOM tree.

The core enum representing elements, text, fragments, and empty nodes.

Variants

Element

An element node with a tag, attributes, and children.

Fields

tag: Tag

The tag type of this element.

attributes: Vec<AttributeEntry>

The attributes attached to this element.

children: Vec<VirtualNode>

The child nodes.

key: Option<String>

An optional key for diffing.

Text(TextNode)

A text node.

Fragment(Vec<VirtualNode>)

A fragment of multiple nodes without a wrapper element.

Dynamic(DynamicNode)

A dynamic node that re-renders based on signal changes.

Empty

An empty placeholder node.

Implementations

impl VirtualNode

Implementation of virtual node construction and property extraction.

pub fn needs_patch(old: &VirtualNode, new: &VirtualNode) -> bool

Determines whether the DOM needs to be patched when transitioning from old to new.

Unlike PartialEq, this method treats two Dynamic variants as different so that the renderer always re-evaluates dynamic subtrees. This is essential for route-based match expressions where different pages may occupy the same DynamicNode slot.

Arguments

• &VirtualNode - The old virtual node.
• &VirtualNode - The new virtual node.

Returns

• bool - true if the DOM needs to be patched.

pub fn get_element_node(tag_name: &str) -> Self

Creates a new element node with the given tag name.

Arguments

• &str - The tag name for the element.

Returns

• Self - A new element virtual node.

pub fn get_text_node(content: &str) -> Self

Creates a new text node with the given content.

Arguments

• &str - The text content.

Returns

• Self - A new text virtual node.

pub fn with_attribute(self, name: &str, value: AttributeValue) -> Self

Adds an attribute to this node if it is an element.

Arguments

• &str - The attribute name.
• AttributeValue - The attribute value.

Returns

• Self - This node with the attribute added.

pub fn with_child(self, child: VirtualNode) -> Self

Adds a child node to this node if it is an element.

Arguments

• VirtualNode - The child node to add.

Returns

• Self - This node with the child added.

pub fn is_component(&self) -> bool

Returns true if this node is a component node.

Returns

• bool - true if this is a component node.

pub fn tag_name(&self) -> Option<String>

Returns the tag name if this is an element or component node.

Returns

• Option<String> - The tag name, or None if not an element node.

pub fn try_get_prop(&self, name: &Attribute) -> Option<String>

Extracts a string property from this node if it is an element with the named attribute.

Arguments

• &Attribute - The attribute to look up.

Returns

• Option<String> - The attribute value as a string, or None if not found.

pub fn try_get_signal_prop(&self, name: &Attribute) -> Option<Signal<String>>

Extracts a signal property from this node if it is an element with the named attribute.

Returns the raw Signal<String> so components can reactively read the current value and subscribe to future changes, rather than receiving a snapshot string.

Arguments

• &Attribute - The attribute to look up.

Returns

• Option<Signal<String>> - The signal if found, or None.

pub fn get_children(&self) -> Vec<VirtualNode>

Extracts children from this node if it is an element.

Returns

• Vec<VirtualNode> - The children, or an empty vec if not an element.

pub fn try_get_text(&self) -> Option<String>

Extracts text content from this node.

Returns

• Option<String> - The text content, or None if not a text node.

pub fn try_get_event( &self, name: &NativeEventName, ) -> Option<NativeEventHandler>

Extracts an event handler from this node if it is an element with the named event attribute.

Arguments

• &NativeEventName - The event name to look up.

Returns

• Option<NativeEventHandler> - The event handler if found, or None.

pub fn try_get_callback(&self, name: &str) -> Option<NativeEventHandler>

Extracts an event handler from this node by a custom attribute name.

Arguments

• &str - The custom attribute name to look up.

Returns

• Option<NativeEventHandler> - The event handler if found, or None.

Trait Implementations

impl AsNode for &VirtualNode

Converts a VirtualNode reference into an owned node.

fn as_node(&self) -> Option<VirtualNode>

Clones this virtual node reference into an owned Option<VirtualNode>.

Returns

• Option<VirtualNode> - Always Some with the cloned node.

impl AsNode for VirtualNode

Converts a VirtualNode reference into an owned node.

fn as_node(&self) -> Option<VirtualNode>

Clones this virtual node into an owned Option<VirtualNode>.

Returns

• Option<VirtualNode> - Always Some with the cloned node.

impl Clone for VirtualNode

fn clone(&self) -> VirtualNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for VirtualNode

fn default() -> VirtualNode

Returns the “default value” for a type.

impl IntoNode for VirtualNode

Converts a VirtualNode into itself via IntoNode.

fn into_node(self) -> VirtualNode

Returns this virtual node as-is.

Returns

• VirtualNode - This same virtual node.

impl PartialEq for VirtualNode

Visual equality comparison for virtual DOM nodes.

Used by DynamicNode re-rendering to skip unnecessary DOM patches when the rendered output has not changed. Event attributes are always considered equal because re-binding event listeners is handled separately by the handler registry and does not affect visual output. Dynamic nodes manage their own subtree re-rendering, so two Dynamic variants are always considered equal — the inner renderer handles patching when the dynamic content actually changes.

fn eq(&self, other: &Self) -> bool

Compares two virtual nodes for visual equality.

Arguments

• &Self - The first virtual node.
• &Self - The second virtual node.

Returns

• bool - true if the virtual nodes are visually equal.

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

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