ox_content_renderer 2.72.0

Markdown renderer for Ox Content
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use compact_str::CompactString;

use super::{
    parser::{HtmlAttribute, HtmlElement},
    shared, FrameworkComponentIsland,
};

pub(super) fn render_root(children: &[String]) -> String {
    let mut output = String::with_capacity(36 + children.iter().map(String::len).sum::<usize>());
    output.push_str("h('div', { class: 'ox-content' }");
    push_children(&mut output, children);
    output.push(')');
    output
}

pub(super) fn render_element(element: &HtmlElement, children: &[String]) -> String {
    let props = render_props(&element.attributes);
    let mut output = String::with_capacity(
        8 + element.tag_name.len() + props.len() + children.iter().map(String::len).sum::<usize>(),
    );
    output.push_str("h(");
    shared::push_js_string_literal(&mut output, &element.tag_name);
    output.push_str(", ");
    output.push_str(&props);
    push_children(&mut output, children);
    output.push(')');
    output
}

pub(super) fn render_island(island: &FrameworkComponentIsland) -> String {
    let props = shared::render_json_object_literal(&island.props);
    let content_len = island.content.as_ref().map_or(0, |content| content.len() + 4);
    let mut output = String::with_capacity(5 + island.name.len() + props.len() + content_len);
    output.push_str("h(");
    output.push_str(&island.name);
    output.push_str(", ");
    output.push_str(&props);
    if let Some(content) = &island.content {
        output.push_str(", ");
        shared::push_js_string_literal(&mut output, content);
    }
    output.push(')');
    output
}

pub(super) fn render_function_module(expression: &str) -> String {
    let mut output = String::with_capacity(68 + expression.len());
    output.push_str("import { h } from 'vue';\n\n");
    output.push_str("export function renderMarkdownContent() {\n  return ");
    output.push_str(expression);
    output.push_str(";\n}\n");
    output
}

pub(super) fn component_module(expression: &str) -> String {
    let mut output = String::with_capacity(138 + expression.len());
    output.push_str("import { defineComponent, h } from 'vue';\n\n");
    output.push_str("export default defineComponent({\n");
    output.push_str("  name: 'MarkdownContent',\n");
    output.push_str("  setup() {\n");
    output.push_str("    return () => ");
    output.push_str(expression);
    output.push_str(";\n");
    output.push_str("  },\n");
    output.push_str("});\n");
    output
}

pub(super) fn inner_html_component_module(html: &str) -> String {
    let mut output = String::with_capacity(188 + html.len());
    output.push_str("import { defineComponent, h } from 'vue';\n\n");
    output.push_str("const rawHtml = ");
    shared::push_raw_html_js_string_literal(&mut output, html);
    output.push_str(";\n\n");
    output.push_str("export default defineComponent({\n");
    output.push_str("  name: 'MarkdownContent',\n");
    output.push_str("  setup() {\n");
    output.push_str("    return () => h('div', { class: 'ox-content', innerHTML: rawHtml });\n");
    output.push_str("  },\n");
    output.push_str("});\n");
    output
}

fn push_children(output: &mut String, children: &[String]) {
    match children {
        [] => {}
        [child] => {
            output.push_str(", ");
            output.push_str(child);
        }
        _ => {
            output.push_str(", [");
            for (index, child) in children.iter().enumerate() {
                if index > 0 {
                    output.push_str(", ");
                }
                output.push_str(child);
            }
            output.push(']');
        }
    }
}

fn render_props(attributes: &[HtmlAttribute]) -> String {
    let mut output = String::with_capacity(attributes.len().saturating_mul(24).max(4));
    let mut has_entries = false;
    for attribute in attributes {
        let prop_name = to_prop_name(&attribute.name);
        if shared::should_skip_property(prop_name.as_str()) {
            continue;
        }
        shared::push_object_entry_key(&mut output, &mut has_entries, prop_name.as_str());
        shared::push_attribute_value(&mut output, attribute.value.as_deref());
    }
    shared::finish_object_literal(&mut output, has_entries);
    output
}

fn to_prop_name(name: &str) -> CompactString {
    match name {
        "className" => CompactString::const_new("class"),
        "htmlFor" => CompactString::const_new("for"),
        _ => shared::to_data_or_aria_attribute_name(name),
    }
}