Struct Node 

pub struct Node {
    pub node_type: Option<String>,
    pub attrs: Option<Map<String, Value>>,
    pub content: Option<Vec<Node>>,
    pub marks: Option<Vec<Mark>>,
    pub text: Option<String>,
    pub extra: Map<String, Value>,
}

A single Tiptap/ProseMirror node.

All structural fields are optional to faithfully distinguish “missing” from “empty” on roundtrip. Unknown top-level keys land in Node::extra.

Fields

node_type: Option<String>

Node type, e.g. "doc", "paragraph", "text".

attrs: Option<Map<String, Value>>

Node attributes.

content: Option<Vec<Node>>

Child nodes.

marks: Option<Vec<Mark>>

Marks applied to this node (typically text nodes).

text: Option<String>

Text payload (text nodes only).

extra: Map<String, Value>

Any unknown/extra top-level fields, preserved verbatim.

Implementations

impl Node

pub fn element(node_type: impl Into<String>) -> Node

Start an element node of node_type (no content/marks/attrs yet).

use tiptap_rusty_parser::Node;
let p = Node::element("paragraph")
    .with_attr("textAlign", "center")
    .with_text("hello");
assert_eq!(p.child_count(), 1);

pub fn text(text: impl Into<String>) -> Node

A text node with the given string.

pub fn text_with_marks( text: impl Into<String>, marks: impl IntoIterator<Item = Mark>, ) -> Node

A text node with text and the given marks.

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

Builder: set one attr (consuming).

pub fn with_child(self, node: Node) -> Self

Builder: add a child (consuming).

pub fn with_children(self, nodes: impl IntoIterator<Item = Node>) -> Self

Builder: add several children (consuming).

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

Builder: add a text child (consuming).

pub fn with_mark(self, mark: Mark) -> Self

Builder: add a mark (consuming).

impl Node

pub fn has_mark(&self, mark_type: &str) -> bool

True if a mark of mark_type is present.

pub fn get_mark(&self, mark_type: &str) -> Option<&Mark>

Reference to the first mark of mark_type.

pub fn add_mark(&mut self, mark: Mark) -> bool

Add mark if no mark of that type exists yet. Returns true if added.

pub fn remove_mark(&mut self, mark_type: &str) -> usize

Remove every mark of mark_type. Returns count removed.

pub fn toggle_mark(&mut self, mark: Mark) -> bool

Toggle a mark: remove if present, else add. Returns true if now present.

pub fn set_mark_attr( &mut self, mark_type: &str, key: impl Into<String>, value: impl Into<Value>, ) -> bool

Set an attr on the (first) mark of mark_type. Returns false if absent.

pub fn clear_marks(&mut self)

Drop all marks.

pub fn attr(&self, key: &str) -> Option<&Value>

Reference to attr key.

pub fn attrs_mut(&mut self) -> &mut Map<String, Value>

Mutable access to the attrs map, creating it if absent.

pub fn set_attr( &mut self, key: impl Into<String>, value: impl Into<Value>, ) -> Option<Value>

Set attr key, returning the previous value if any.

pub fn remove_attr(&mut self, key: &str) -> Option<Value>

Remove attr key, returning its value if present.

pub fn child_count(&self) -> usize

Number of direct children.

pub fn children(&self) -> &[Node]

Direct children slice (empty if none).

pub fn children_mut(&mut self) -> &mut Vec<Node>

Mutable access to children, creating the vec if absent.

pub fn child(&self, i: usize) -> Option<&Node>

Direct child at i.

pub fn child_mut(&mut self, i: usize) -> Option<&mut Node>

Mutable direct child at i.

pub fn push_child(&mut self, node: Node)

Append a child.

pub fn insert_child(&mut self, i: usize, node: Node)

Insert a child at i (clamped to len).

pub fn remove_child(&mut self, i: usize) -> Option<Node>

Remove and return the child at i.

pub fn replace_child(&mut self, i: usize, node: Node) -> Option<Node>

Replace the child at i, returning the old node.

pub fn clear_children(&mut self)

Remove all children.

pub fn retain_children(&mut self, pred: impl FnMut(&Node) -> bool)

Retain only children matching pred.

pub fn get_text(&self) -> Option<&str>

Text payload, if any.

pub fn set_text(&mut self, text: impl Into<String>)

Set text payload.

pub fn replace_all( &mut self, pred: impl FnMut(&Node) -> bool, f: impl FnMut(&mut Node), ) -> usize

Apply f to every node (incl. self) matching pred. Returns count.

impl Node

pub fn walk(&self, f: &mut impl FnMut(&Node))

Visit self and every descendant, pre-order.

use tiptap_rusty_parser::Document;
let doc = Document::from_json_str(r#"{"type":"doc","content":[{"type":"paragraph"}]}"#).unwrap();
let mut n = 0;
doc.root().walk(&mut |_| n += 1);
assert_eq!(n, 2);

pub fn walk_mut(&mut self, f: &mut impl FnMut(&mut Node))

Mutable pre-order visit of self and every descendant.

pub fn find(&self, pred: impl FnMut(&Node) -> bool) -> Option<&Node>

First node (incl. self) matching pred, pre-order.

pub fn find_mut(&mut self, pred: impl FnMut(&Node) -> bool) -> Option<&mut Node>

Mutable variant of Node::find.

pub fn find_all(&self, pred: impl FnMut(&Node) -> bool) -> Vec<&Node>

All nodes (incl. self) matching pred, pre-order.

pub fn find_all_mut( &mut self, pred: &mut impl FnMut(&Node) -> bool, ) -> Vec<&mut Node>

Mutable variant of Node::find_all. Collects matching &mut Node.

pub fn descendants(&self) -> Descendants<'_>

Lazy pre-order iterator over self and all descendants.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Default for Node

fn default() -> Node

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Node

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Node> for Document

fn from(root: Node) -> Self

Converts to this type from the input type.

impl PartialEq for Node

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

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 Node