oxc_transformer 0.131.0

A collection of JavaScript tools written in Rust.
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

mod options;
mod styled_components;
mod tagged_template_transform;

pub use options::PluginsOptions;
use oxc_ast::ast::*;
use oxc_traverse::Traverse;
pub use styled_components::StyledComponentsOptions;

use crate::{
    context::TraverseCtx,
    plugins::{
        styled_components::StyledComponents, tagged_template_transform::TaggedTemplateTransform,
    },
    state::TransformState,
};

pub struct Plugins<'a> {
    styled_components: Option<StyledComponents<'a>>,
    tagged_template_escape: Option<TaggedTemplateTransform>,
}

impl Plugins<'_> {
    pub fn new(options: PluginsOptions) -> Self {
        Self {
            styled_components: options.styled_components.map(StyledComponents::new),
            tagged_template_escape: if options.tagged_template_transform {
                Some(TaggedTemplateTransform::new())
            } else {
                None
            },
        }
    }
}

impl<'a> Traverse<'a, TransformState<'a>> for Plugins<'a> {
    fn enter_program(&mut self, node: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) {
        if let Some(styled_components) = &mut self.styled_components {
            styled_components.enter_program(node, ctx);
        }
    }

    fn enter_variable_declarator(
        &mut self,
        node: &mut VariableDeclarator<'a>,
        ctx: &mut TraverseCtx<'a>,
    ) {
        if let Some(styled_components) = &mut self.styled_components {
            styled_components.enter_variable_declarator(node, ctx);
        }
    }

    fn enter_expression(
        &mut self,
        node: &mut Expression<'a>,
        ctx: &mut oxc_traverse::TraverseCtx<'a, TransformState<'a>>,
    ) {
        if let Some(styled_components) = &mut self.styled_components {
            styled_components.enter_expression(node, ctx);
        }
        if let Some(tagged_template_escape) = &mut self.tagged_template_escape {
            tagged_template_escape.enter_expression(node, ctx);
        }
    }

    fn enter_call_expression(&mut self, node: &mut CallExpression<'a>, ctx: &mut TraverseCtx<'a>) {
        if let Some(styled_components) = &mut self.styled_components {
            styled_components.enter_call_expression(node, ctx);
        }
    }
}