Struct ExtensionBlock 

pub struct ExtensionBlock {
    pub namespace: String,
    pub block_type: String,
    pub id: Option<String>,
    pub attributes: Value,
    pub children: Vec<Block>,
    pub fallback: Option<Box<Block>>,
}

An extension block for unsupported or unknown block types.

When parsing a document with extension blocks (e.g., “forms:textInput”), this struct preserves the raw data so it can be:

• Passed through unchanged when saving
• Rendered using fallback content
• Processed by extension-aware applications

Fields

namespace: String

The extension namespace (e.g., “forms”, “semantic”, “collaboration”).

block_type: String

The block type within the namespace (e.g., “textInput”, “citation”).

id: Option<String>

Optional unique identifier.

attributes: Value

Raw attributes from the original block.

This preserves all extension-specific properties without interpretation.

children: Vec<Block>

Child blocks (if the extension is a container).

fallback: Option<Box<Block>>

Fallback content for renderers that don’t support this extension.

Implementations

impl ExtensionBlock

pub fn new(namespace: impl Into<String>, block_type: impl Into<String>) -> Self

Create a new extension block.

pub fn parse_type(type_str: &str) -> Option<(&str, &str)>

Parse an extension type string like “forms:textInput” into (namespace, block_type).

Returns None if the type doesn’t contain a colon.

pub fn full_type(&self) -> String

Get the full type string (e.g., “forms:textInput”).

pub fn is_namespace(&self, namespace: &str) -> bool

Check if this extension is from a specific namespace.

pub fn is_type(&self, namespace: &str, block_type: &str) -> bool

Check if this is a specific extension type.

pub fn with_id(self, id: impl Into<String>) -> Self

Set the block ID.

pub fn with_attributes(self, attributes: Value) -> Self

Set the attributes.

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

Set the children.

pub fn with_fallback(self, fallback: Block) -> Self

Set fallback content.

pub fn fallback_content(&self) -> Option<&Block>

Get the fallback content, if any.

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

Get an attribute value by key.

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

Get a string attribute.

pub fn get_string_array_attribute(&self, key: &str) -> Option<Vec<&str>>

Get an array-of-strings attribute.

pub fn get_bool_attribute(&self, key: &str) -> Option<bool>

Get a boolean attribute.

pub fn get_i64_attribute(&self, key: &str) -> Option<i64>

Get an integer attribute.

pub fn as_form_field(&self) -> Option<FormField>

Try to convert this extension block to a specific form field type.

Returns None if this is not a forms extension or conversion fails.

Trait Implementations

impl Clone for ExtensionBlock

fn clone(&self) -> ExtensionBlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExtensionBlock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExtensionBlock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExtensionBlock

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

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 ExtensionBlock