vize_relief 0.42.0

Relief - The sculptured AST surface for Vize Vue templates
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
126
127
128
129
130
131

//! Control flow AST node types.
//!
//! Contains if (v-if/v-else-if/v-else), for (v-for),
//! and text call node definitions.

use vize_carton::{Box, Bump, Vec};

use super::{
    codegen::{CacheExpression, CallExpression, ConditionalExpression, VNodeCall},
    core::{NodeType, SourceLocation},
    elements::PropNode,
    expressions::{CompoundExpressionNode, ExpressionNode, SimpleExpressionNode},
    nodes::TemplateChildNode,
};

/// If node (v-if)
#[derive(Debug)]
pub struct IfNode<'a> {
    pub branches: Vec<'a, IfBranchNode<'a>>,
    pub loc: SourceLocation,
    pub codegen_node: Option<IfCodegenNode<'a>>,
}

impl<'a> IfNode<'a> {
    pub fn new(allocator: &'a Bump, loc: SourceLocation) -> Self {
        Self {
            branches: Vec::new_in(allocator),
            loc,
            codegen_node: None,
        }
    }

    pub fn node_type(&self) -> NodeType {
        NodeType::If
    }
}

/// If codegen node type
#[derive(Debug)]
pub enum IfCodegenNode<'a> {
    Conditional(Box<'a, ConditionalExpression<'a>>),
    Cache(Box<'a, CacheExpression<'a>>),
}

/// If branch node (v-if, v-else-if, v-else)
#[derive(Debug)]
pub struct IfBranchNode<'a> {
    pub condition: Option<ExpressionNode<'a>>,
    pub children: Vec<'a, TemplateChildNode<'a>>,
    pub user_key: Option<PropNode<'a>>,
    pub is_template_if: bool,
    pub loc: SourceLocation,
}

impl<'a> IfBranchNode<'a> {
    pub fn new(
        allocator: &'a Bump,
        condition: Option<ExpressionNode<'a>>,
        loc: SourceLocation,
    ) -> Self {
        Self {
            condition,
            children: Vec::new_in(allocator),
            user_key: None,
            is_template_if: false,
            loc,
        }
    }

    pub fn node_type(&self) -> NodeType {
        NodeType::IfBranch
    }
}

/// For node (v-for)
#[derive(Debug)]
pub struct ForNode<'a> {
    pub source: ExpressionNode<'a>,
    pub value_alias: Option<ExpressionNode<'a>>,
    pub key_alias: Option<ExpressionNode<'a>>,
    pub object_index_alias: Option<ExpressionNode<'a>>,
    pub parse_result: ForParseResult<'a>,
    pub children: Vec<'a, TemplateChildNode<'a>>,
    pub loc: SourceLocation,
    pub codegen_node: Option<Box<'a, VNodeCall<'a>>>,
}

impl<'a> ForNode<'a> {
    pub fn node_type(&self) -> NodeType {
        NodeType::For
    }
}

/// Parsed result for v-for expression
#[derive(Debug)]
pub struct ForParseResult<'a> {
    pub source: ExpressionNode<'a>,
    pub value: Option<ExpressionNode<'a>>,
    pub key: Option<ExpressionNode<'a>>,
    pub index: Option<ExpressionNode<'a>>,
    pub finalized: bool,
}

/// Text call node
#[derive(Debug)]
pub struct TextCallNode<'a> {
    pub content: TextCallContent<'a>,
    pub loc: SourceLocation,
    pub codegen_node: Option<TextCallCodegenNode<'a>>,
}

impl<'a> TextCallNode<'a> {
    pub fn node_type(&self) -> NodeType {
        NodeType::TextCall
    }
}

/// Text call content
#[derive(Debug)]
pub enum TextCallContent<'a> {
    Text(Box<'a, super::elements::TextNode>),
    Interpolation(Box<'a, super::elements::InterpolationNode<'a>>),
    Compound(Box<'a, CompoundExpressionNode<'a>>),
}

/// Text call codegen node
#[derive(Debug)]
pub enum TextCallCodegenNode<'a> {
    Call(Box<'a, CallExpression<'a>>),
    Simple(Box<'a, SimpleExpressionNode<'a>>),
}