surplus 0.3.0

Core library for the Surplus JSX compiler
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::cell::Cell;

use oxc::{
	allocator::{Box, CloneIn, Vec},
	ast::ast::{
		Argument, ArrayExpression, CallExpression, Expression, IdentifierName, IdentifierReference,
		JSXChild, JSXText, StaticMemberExpression, StringLiteral,
	},
	span::Atom,
};
use oxc_traverse::TraverseCtx;

use crate::{
	constants::{CREATE_TEXT_NODE, DOCUMENT},
	decode_html_entities,
	element::SurplusChildType,
};

impl<'a> super::SurplusTraverser<'a> {
	pub fn inner_exit_jsx_child(&mut self, node: &mut JSXChild<'a>, ctx: &mut TraverseCtx<'a>) {
		match node {
			JSXChild::Element(e) => {
				let child = self
					.element_stack
					.pop()
					.expect("surplus element stack underflow");

				// Removing leading/trailing whitespace from child elements
				self.element_stack
					.last_mut()
					.unwrap()
					.child_exprs
					.push(SurplusChildType::Normal(child.into_surplus_comp(
						e.span,
						ctx,
						self.s_ref,
						self.allocator,
					)));
			}
			JSXChild::Fragment(e) => {
				let child = self
					.element_stack
					.pop()
					.expect("surplus element stack underflow");
				self.element_stack
					.last_mut()
					.unwrap()
					.child_exprs
					.push(SurplusChildType::Normal(Expression::ArrayExpression(
						ctx.alloc(ArrayExpression {
							span: e.span,
							elements: Vec::from_iter_in(
								child.child_exprs.into_iter().map(|e| e.unwrap().into()),
								self.allocator,
							),
							trailing_comma: None,
						}),
					)));
			}
			JSXChild::Text(text) => {
				// Skip any empty text nodes.
				if text.value.is_empty() {
					return;
				}

				// Handle case of multiple spaces in text nodes.
				let is_whitespace = if text.value.chars().all(char::is_whitespace) {
					// If we've already serviced a whitespace text node,
					// we don't need to add another one.
					if self
						.element_stack
						.last_mut()
						.unwrap()
						.child_exprs
						.last()
						.is_none_or(SurplusChildType::is_whitespace)
					{
						return;
					}

					*text = Box::new_in(
						JSXText {
							span: text.span,
							value: Atom::new_const(" "),
							raw: None,
						},
						self.allocator,
					);
					true
				} else {
					false
				};

				let expr = Expression::CallExpression(ctx.alloc(CallExpression {
					span: text.span,
					callee: Expression::StaticMemberExpression(ctx.alloc(StaticMemberExpression {
						span: text.span,
						object: Expression::Identifier(ctx.alloc(IdentifierReference {
							span: text.span,
							name: Atom::new_const(DOCUMENT),
							reference_id: Cell::new(None),
						})),
						property: IdentifierName {
							span: text.span,
							name: Atom::new_const(CREATE_TEXT_NODE),
						},
						optional: false,
					})),
					type_arguments: None,
					arguments: Vec::from_array_in(
						[Argument::StringLiteral(ctx.alloc(StringLiteral {
							span: text.span,
							value: decode_html_entities(self.allocator, text.value),
							raw: None,
							lossy: false,
						}))],
						self.allocator,
					),
					optional: false,
					pure: false,
				}));

				self.element_stack.last_mut().unwrap().child_exprs.push(
					if is_whitespace {
						SurplusChildType::Whitespace(expr)
					} else {
						SurplusChildType::Normal(expr)
					},
				);
			}
			JSXChild::ExpressionContainer(expr) => {
				let expr_sexpr = self.s_expression(
					ctx,
					expr.span,
					expr.expression.clone_in(self.allocator).into_expression(),
				);

				self.element_stack
					.last_mut()
					.unwrap()
					.child_exprs
					.push(SurplusChildType::Normal(expr_sexpr));
			}
			JSXChild::Spread(_expr) => {
				todo!("JSXChild::Spread");
			}
		}
	}
}