Struct AriaNode 

pub struct AriaNode {

    pub role: String,
    pub name: String,
    pub index: Option<usize>,
    pub children: Vec<AriaChild>,
    pub props: HashMap<String, String>,
    pub box_info: BoxInfo,
    pub checked: Option<AriaChecked>,
    pub disabled: Option<bool>,
    pub expanded: Option<bool>,
    pub level: Option<u32>,
    pub pressed: Option<AriaPressed>,
    pub selected: Option<bool>,
    pub active: Option<bool>,
}

Represents an ARIA node in the accessibility tree Based on Playwright’s AriaNode structure

Fields

role: String

ARIA role (e.g., “button”, “link”, “textbox”, “generic”, “iframe”, “fragment”)

name: String

Accessible name of the element

index: Option<usize>

Index of the element in the interactive elements array

children: Vec<AriaChild>

Child nodes (can be AriaNode or text strings)

props: HashMap<String, String>

ARIA properties specific to this element (e.g., url, placeholder)

box_info: BoxInfo

Box information (visibility, cursor)

checked: Option<AriaChecked>

Whether element is checked (for checkboxes, radios, etc.)

disabled: Option<bool>

Whether element is disabled

expanded: Option<bool>

Whether element is expanded (for expandable elements)

level: Option<u32>

Heading/list level

pressed: Option<AriaPressed>

Whether button is pressed

selected: Option<bool>

Whether element is selected

active: Option<bool>

Whether element is currently active/focused

Implementations

impl AriaNode

pub fn new(role: impl Into<String>, name: impl Into<String>) -> Self

Create a new AriaNode with minimal fields

pub fn fragment() -> Self

Create a fragment node (root container)

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

Builder: set index

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

Builder: add a child node

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

Builder: add multiple children

pub fn with_prop(self, key: impl Into<String>, value: impl Into<String>) -> Self

Builder: add a property

pub fn with_box(self, visible: bool, cursor: Option<String>) -> Self

Builder: set box info

pub fn with_checked(self, checked: bool) -> Self

Builder: set checked state

pub fn with_disabled(self, disabled: bool) -> Self

Builder: set disabled state

pub fn with_expanded(self, expanded: bool) -> Self

Builder: set expanded state

pub fn with_level(self, level: u32) -> Self

Builder: set level

pub fn is_interactive(&self) -> bool

Check if this node is interactive (has an index and is visible)

pub fn has_pointer_cursor(&self) -> bool

Check if this node has pointer cursor

pub fn is_container(&self) -> bool

Check if this is a fragment or iframe

pub fn get_text_content(&self) -> String

Get all text content (concatenate all text children recursively)

pub fn count_nodes(&self) -> usize

Count total nodes in subtree

pub fn find_by_index(&self, index: usize) -> Option<&AriaNode>

Find node by index (depth-first search)

pub fn find_by_index_mut(&mut self, index: usize) -> Option<&mut AriaNode>

Find node by index (mutable)

pub fn count_interactive(&self) -> usize

Count interactive elements in subtree (elements with indices)

pub fn aria_equals(&self, other: &AriaNode) -> bool

Check if two nodes are equal (for diffing) Based on Playwright’s ariaNodesEqual

Trait Implementations

impl Clone for AriaNode

fn clone(&self) -> AriaNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AriaNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AriaNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AriaNode

fn eq(&self, other: &AriaNode) -> 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 AriaNode

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 AriaNode