Struct ElementNode 

pub struct ElementNode {
    pub tag_name: String,
    pub attributes: HashMap<String, String>,
    pub text_content: Option<String>,
    pub children: Vec<ElementNode>,
    pub index: Option<usize>,
    pub is_visible: bool,
    pub is_interactive: bool,
    pub bounding_box: Option<BoundingBox>,
}

Represents a DOM element node

Fields

tag_name: String

HTML tag name (e.g., “div”, “button”, “input”)

attributes: HashMap<String, String>

Element attributes (e.g., id, class, href, etc.)

text_content: Option<String>

Text content of the element

children: Vec<ElementNode>

Child elements

index: Option<usize>

Index assigned to this element (for interactive elements)

is_visible: bool

Whether the element is visible in the viewport

is_interactive: bool

Whether the element is interactive (clickable, input, etc.)

bounding_box: Option<BoundingBox>

Bounding box information (x, y, width, height)

Implementations

impl ElementNode

pub fn new(tag_name: impl Into<String>) -> Self

Create a new ElementNode

pub fn with_attributes(self, attributes: HashMap<String, String>) -> Self

Builder method: set attributes

pub fn with_text(self, text: impl Into<String>) -> Self

Builder method: set text content

pub fn with_children(self, children: Vec<ElementNode>) -> Self

Builder method: set children

pub fn with_index(self, index: usize) -> Self

Builder method: set index

pub fn with_visibility(self, visible: bool) -> Self

Builder method: set visibility

pub fn with_interactivity(self, interactive: bool) -> Self

Builder method: set interactivity

pub fn with_bounding_box(self, x: f64, y: f64, width: f64, height: f64) -> Self

Builder method: set bounding box

pub fn add_attribute( &mut self, key: impl Into<String>, value: impl Into<String>, )

Add a single attribute

pub fn add_child(&mut self, child: ElementNode)

Add a child element

pub fn get_attribute(&self, key: &str) -> Option<&String>

Get attribute value by key

pub fn has_class(&self, class_name: &str) -> bool

Check if element has a specific class

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

Get element ID

pub fn is_tag(&self, tag: &str) -> bool

Check if element is a specific tag

pub fn compute_interactivity(&mut self)

Determine if this element should be considered interactive

pub fn simplify(&mut self)

Simplify element by removing unnecessary children (like scripts, styles)

pub fn to_simple_string(&self) -> String

Convert to a simplified string representation

Trait Implementations

impl Clone for ElementNode

fn clone(&self) -> ElementNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ElementNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ElementNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ElementNode

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ElementNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ElementNode