compo-macros 0.1.3

Compo is a general-purpose declarative and reactive component framework designed for single-threaded asynchronous execution, offering high performance and safety guarantees. Suitable for GUI scenarios or other similar non-GUI component systems.
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

#[path = "macros.rs"]
#[macro_use]
mod macros;
mod recurse;
mod stmt;

use {
    crate::utils::to_camel, proc_macro::TokenStream, recurse::handle_block_recursively,
    std::collections::HashMap,
};

pub(super) fn handle_block(
    stream: TokenStream,
    var_bindings: &mut Vec<TokenStream>,
    component_name: &str,
) -> (TokenStream, Vec<TokenStream>, Vec<TokenStream>) {
    let mut has_attr = false;
    let mut attrs = Vec::new();
    let mut field_defines = Vec::new();
    let mut field_initializers = Vec::new();
    let mut stmts = Vec::new();
    let mut component_name_index = 0;
    let mut refer_to_component = HashMap::new();

    let error = handle_block_recursively(
        &stream,
        &mut has_attr,
        &mut attrs,
        var_bindings,
        &mut field_defines,
        &mut field_initializers,
        &mut component_name_index,
        &mut stmts,
        &mut refer_to_component,
    );
    if !error.is_empty() {
        return (error, Default::default(), Default::default());
    }
    let var_bindings = var_bindings
        .iter()
        .map(|i| i.to_string())
        .collect::<String>();
    let stmts = stmts.iter().map(|i| format!("{} ", i)).collect::<String>();

    (
        ts!(
            "{{\nlet Some(this) = this.upgrade() else {{\neprintln!(\"{} dropped.\");\nreturn;\n}};\n{}\n{}\n}}",
            to_camel(&component_name),
            var_bindings,
            stmts
        ),
        field_defines,
        field_initializers,
    )
}