textlane-core 0.6.0

Textlane's core: unist, mdast, hast and nlcst trees, the file and the plugin contract its crates share
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use serde_json::Value;

use crate::actions::hast::deserialize::deserialize_data;
use crate::actions::position::deserialize::deserialize_position;
use crate::models::data::Data;
use crate::models::error::Error;
use crate::models::mdx::{MdxJsxAttribute, MdxJsxAttributeValue};
use crate::{Allocator, ArenaVec};

/// Read a JSX element's `name`; a missing or null one makes a fragment.
pub(crate) fn read_mdx_jsx_name<'a>(
    value: &Value,
    alloc: &'a Allocator,
) -> Option<&'a str> {
    value
        .get("name")
        .and_then(Value::as_str)
        .map(|name| &*alloc.alloc_str(name))
}

/// Read a JSX element's `attributes`, an empty list when missing.
pub(crate) fn read_mdx_jsx_attributes<'a>(
    value: &Value,
    alloc: &'a Allocator,
    depth: usize,
) -> Result<ArenaVec<'a, MdxJsxAttribute<'a>>, Error> {
    let mut attributes = ArenaVec::new_in(alloc);
    for item in value
        .get("attributes")
        .and_then(Value::as_array)
        .into_iter()
        .flatten()
    {
        let position = deserialize_position(item, alloc)?;
        let data = read_data(item, alloc, depth)?;
        let read_str = |item: &Value| -> &'a str {
            alloc.alloc_str(item.get("value").and_then(Value::as_str).unwrap_or(""))
        };
        let attribute = match item.get("type").and_then(Value::as_str) {
            Some("mdxJsxExpressionAttribute") => MdxJsxAttribute::Expression {
                value: read_str(item),
                position,
                data,
            },
            Some("mdxJsxAttribute") => MdxJsxAttribute::Attribute {
                name: alloc
                    .alloc_str(item.get("name").and_then(Value::as_str).unwrap_or("")),
                value: match item.get("value") {
                    Some(Value::String(value)) => {
                        Some(MdxJsxAttributeValue::Literal(alloc.alloc_str(value)))
                    }
                    Some(expression @ Value::Object(_)) => {
                        Some(MdxJsxAttributeValue::Expression {
                            value: read_str(expression),
                            data: read_data(expression, alloc, depth)?,
                        })
                    }
                    _ => None,
                },
                position,
                data,
            },
            _ => {
                return Err(Error::new(
                    "invalid-tree",
                    format!("not a JSX attribute: {item}"),
                ));
            }
        };
        attributes.push(attribute);
    }
    Ok(attributes)
}

/// Read the `value` of an MDX expression or ESM node, empty when missing.
pub(crate) fn read_mdx_value<'a>(value: &Value, alloc: &'a Allocator) -> &'a str {
    alloc.alloc_str(value.get("value").and_then(Value::as_str).unwrap_or(""))
}

fn read_data<'a>(
    value: &Value,
    alloc: &'a Allocator,
    depth: usize,
) -> Result<Option<&'a Data<'a>>, Error> {
    match value.get("data") {
        Some(data) => Ok(Some(&*alloc.alloc(deserialize_data(
            data,
            alloc,
            depth + 2,
        )?))),
        None => Ok(None),
    }
}