reluxscript 0.1.4

Write AST transformations once. Compile to Babel, SWC, and beyond.
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

/// Test: Writer API
/// Tests: writer declaration, CodeBuilder, init/finish (pre/exit) hooks, read-only visitors

writer ReactToCSharp {

    // Metadata struct
    struct ClassInfo {
        name: Str,
        field_count: i32,
    }

    // Writer state
    struct State {
        builder: CodeBuilder,
        classes: Vec<ClassInfo>,
        indent_level: i32,
    }

    // Pre-hook (initialization) - using init() alias
    fn init() -> State {
        State {
            builder: CodeBuilder::new(),
            classes: vec![],
            indent_level: 0,
        }
    }

    // Helper to convert to Str type
    fn to_str(s: &Str) -> Str {
        s.clone()
    }

    // Helper to check component name
    fn is_component(name: &Str) -> bool {
        if name.is_empty() {
            return false;
        }
        let first = name.chars().next().unwrap();
        first.is_uppercase()
    }

    // Read-only visitor - note: &T not &mut T
    pub fn visit_function_declaration(node: &FunctionDeclaration) {
        let name = node.id.name.clone();

        if Self::is_component(&name) {
            // Use CodeBuilder methods
            self.state.builder.append("public class ");
            self.state.builder.append(&name);
            self.state.builder.append(" : ComponentBase");
            self.state.builder.newline();
            self.state.builder.append("{");
            self.state.builder.newline();
            self.state.builder.indent();

            // Track class - note: name needs to go through a Str-returning function
            let class_name = Self::to_str(&name);
            let info = ClassInfo {
                name: class_name,
                field_count: 0,
            };
            self.state.classes.push(info);

            // Visit children
            node.visit_children(self);

            // Close class
            self.state.builder.dedent();
            self.state.builder.append("}");
            self.state.builder.newline();
        }
    }

    pub fn visit_call_expression(node: &CallExpression) {
        // Check for useState
        if let Expression::Identifier(id) = &node.callee {
            if id.name == "useState" {
                self.state.builder.append("[Parameter]");
                self.state.builder.newline();
                self.state.builder.append("public object State { get; set; }");
                self.state.builder.newline();
            }
        }

        node.visit_children(self);
    }

    pub fn visit_jsx_element(node: &JSXElement) {
        self.state.builder.append("// Render: <");
        let tag = &node.opening_element.name;
        self.state.builder.append("element");
        self.state.builder.append(">");
        self.state.builder.newline();

        node.visit_children(self);
    }

    // Exit-hook (finalization) - using finish() alias
    pub fn finish(&self) -> Str {
        let mut output = CodeBuilder::new();

        // Add using statements
        output.append("using Microsoft.AspNetCore.Components;");
        output.newline();
        output.newline();

        // Add namespace
        output.append("namespace Generated");
        output.newline();
        output.append("{");
        output.newline();
        output.indent();

        // Add generated content
        output.append(&self.state.builder.to_string());

        // Close namespace
        output.dedent();
        output.append("}");
        output.newline();

        output.to_string()
    }
}