Struct FlatNode 

#[non_exhaustive]
pub struct FlatNode {

    pub id: NodeId,
    pub parent: Option<NodeId>,
    pub first_child: Option<NodeId>,
    pub next_sibling: Option<NodeId>,
    pub span: Range<usize>,
    pub content_span: Option<Range<usize>>,
    pub level: Option<u32>,
    pub kind: String,
    pub text: Option<String>,
    pub destination: Option<String>,
    pub head: Option<bool>,
    pub alignment: Option<Alignment>,
    pub name: Option<String>,
    pub directive_form: Option<DirectiveForm>,
    pub attrs: Vec<(String, Option<String>)>,
}

One node of an Editor::nodes snapshot — the flat AST arena as owned Rust data (the JSON-free read path). id indexes the snapshot; parent, first_child, and next_sibling link the tree (None where absent). text is the node’s primary payload (a str’s bytes, a code_block’s body, …) and destination a link/image target, each None when the kind carries no such payload. #[non_exhaustive]: a snapshot node is something twig hands you, never something you build, so it gains a field whenever a node kind’s payload is surfaced (as head/alignment were for tables). Sealing construction here keeps every future addition a minor release instead of a major one.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: NodeId

parent: Option<NodeId>

first_child: Option<NodeId>

next_sibling: Option<NodeId>

span: Range<usize>

content_span: Option<Range<usize>>

level: Option<u32>

A heading’s level; None for every other kind.

kind: String

text: Option<String>

destination: Option<String>

head: Option<bool>

Whether a row/cell belongs to the table head; None for every other kind.

alignment: Option<Alignment>

A cell’s column alignment; None for every other kind. The delimiter row (|:--|--:|) that spells the alignment out is consumed by the parser and has no node of its own, so this is the only way to recover it. Alignment::Default is a real, unspecified alignment (a bare ---) — distinct from the None a non-cell node reports.

name: Option<String>

The name a kind carries in its own payload rather than in kind: a generic element’s tag ("picture", "source", …) or a directive’s type ("note", "embed", "vis", …, no leading colons). None for every semantic kind, whose identity is kind alone. With this an html_elements parse’s <picture>/<source> are distinguishable — both report kind == "element" — and so are a ::embed and a ::toc, both of which report kind == "directive".

directive_form: Option<DirectiveForm>

Which of the three surface forms a directive was written in; None for every other kind. Pairs with name: the name says which directive, this says how it was written, and a renderer needs both — the same type is a span inline (DirectiveForm::Text), a standalone block with no body (DirectiveForm::Leaf), and a wrapper around blocks (DirectiveForm::Container).

attrs: Vec<(String, Option<String>)>

The node’s {...} / HTML attributes as (key, value) pairs in source order (empty when it has none). A bare attribute (HTML disabled, or a <source media=…> used as a flag) has a None value.

Trait Implementations

impl Clone for FlatNode

fn clone(&self) -> FlatNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FlatNode

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

Formats the value using the given formatter.

impl Eq for FlatNode

impl PartialEq for FlatNode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FlatNode