Enum NodeType 

#[non_exhaustive]
pub enum NodeType {
    Blockquote,
    Code,
    Comment,
    Document,
    Em,
    Error,
    Fence,
    Hardbreak,
    Heading,
    Hr,
    Image,
    Inline,
    Item,
    Link,
    List,
    Node,
    Paragraph,
    S,
    Softbreak,
    Strong,
    Table,
    Tag,
    Tbody,
    Td,
    Text,
    Th,
    Thead,
    Tr,
}

What kind of node this is.

Upstream’s NodeType is a union of string literals in types.ts, and the spellings here are those strings exactly, because a schema is looked up by them: a host writing nodes: { fence: ... } is naming this enum.

#[non_exhaustive] because Markdoc gained node types across its 0.5.x line. Matching exhaustively on it in a host would turn each new one into a breaking release of this crate.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Blockquote

> quoted.

Code

Inline code, `x`.

Comment

An HTML comment, when comments are enabled.

Document

The root of a parsed document.

Em

*emphasis*.

Error

A tag whose internals did not parse. Carries the failure in Node::errors.

Fence

A fenced code block.

Hardbreak

A line break written as two trailing spaces or a backslash.

Heading

# heading.

Hr

A thematic break.

Image

![alt](src).

Inline

The inline content of a block.

Not a Markdoc construct: it is the seam markdown-it puts between a block and its inline children, and this port keeps it because the annotation rules depend on it. An annotation is applied to the node that owns the inline run, so # Title {% #id %} sets id on the heading rather than on the text beside it, and an annotation with no inline run above it is the no-inline-annotations error.

Item

A list item.

Link

[text](href).

List

An ordered or unordered list.

Node

The default, and what a host-constructed node is unless it says otherwise.

Paragraph

A paragraph.

S

~~strikethrough~~.

Softbreak

A newline inside a block.

Strong

**strong**.

Table

A table.

Tag

A Markdoc tag. The tag name is in Node::tag.

Tbody

A table body.

Td

A table body cell.

Text

A run of literal text. Its content is the content attribute, which may hold a Value::Variable rather than a string.

Th

A table header cell.

Thead

A table header.

Tr

A table row.

Implementations

impl NodeType

pub const ALL: [NodeType; 28]

Every node type, in the order as_str lists them.

For a host that reads node names from text and wants to say what it expected: the “expected one of” in its error is this list, joined. One list here rather than a copy per host, because a copy is a second list to keep in step with the enum. A variant added to the enum fails as_str to compile until it gains an arm, and this sits beside it; the test pins that every entry round-trips through as_str and from_name and that none repeats, not that none is missing, so add to both.

pub const fn as_str(self) -> &'static str

Upstream’s spelling, which is the key a schema is registered under.

pub fn from_name(name: &str) -> Option<NodeType>

The node type upstream spells name, or None.

The inverse of NodeType::as_str. A host keys its nodes schema map by these strings – upstream’s config is a JavaScript object literal, and anything read from a file or a manifest arrives as text – so the mapping has to run in both directions. Returning Option rather than defaulting to NodeType::Node is the point: a misspelled key is a schema that silently never applies, which is the hardest kind of schema bug to see.

Trait Implementations

impl Clone for NodeType

fn clone(&self) -> NodeType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for NodeType

impl Debug for NodeType

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

Formats the value using the given formatter.

impl Default for NodeType

fn default() -> NodeType

Returns the “default value” for a type.

impl Display for NodeType

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

Formats the value using the given formatter.

impl Eq for NodeType

impl Hash for NodeType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for NodeType

fn cmp(&self, other: &NodeType) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for NodeType

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for NodeType

fn partial_cmp(&self, other: &NodeType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for NodeType