dia_core 0.1.0

core elements of dia
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

use swc_common::DUMMY_SP;
use swc_ecma_ast::*;

pub fn ident(name: &str) -> Ident {
    Ident::new(name.into(), DUMMY_SP)
}

pub fn var_name(name: &str) -> PropName {
    PropName::Ident(ident(name))
}

pub fn const_declare(ident: Ident, value: Box<Expr>) -> Decl {
    let declaration = VarDeclarator {
        span: DUMMY_SP,
        name: Pat::Ident(BindingIdent {
            id: ident,
            type_ann: None,
        }),
        init: Some(value),
        definite: false,
    };
    Decl::Var(Box::new(VarDecl {
        span: DUMMY_SP,
        kind: VarDeclKind::Const,
        declare: false,
        decls: vec![declaration],
    }))
}

pub fn expr_arrow_cb(body: Box<Expr>) -> Box<Expr> {
    Box::new(Expr::Arrow(ArrowExpr {
        span: DUMMY_SP,
        is_async: false,
        is_generator: false,
        params: vec![],
        body: Box::new(BlockStmtOrExpr::Expr(body)),
        type_params: None,
        return_type: None,
    }))
}

pub fn string(value: &str) -> Box<Expr> {
    Box::new(Expr::Lit(Lit::Str(Str {
        span: DUMMY_SP,
        value: value.into(),
        raw: None,
    })))
}

pub fn array(exprs: Vec<Box<Expr>>) -> Box<Expr> {
    let elems = exprs
        .into_iter()
        .map(|expr| Some(ExprOrSpread { spread: None, expr }))
        .collect();

    Box::new(Expr::Array(ArrayLit {
        span: DUMMY_SP,
        elems,
    }))
}

pub fn object(key_value_pairs: Vec<KeyValueProp>) -> Box<Expr> {
    let props = key_value_pairs
        .into_iter()
        .map(|prop| PropOrSpread::Prop(Box::new(Prop::KeyValue(prop))))
        .collect();

    Box::new(Expr::Object(ObjectLit {
        span: DUMMY_SP,
        props,
    }))
}

pub fn export(decl: Decl) -> ModuleItem {
    ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
        span: DUMMY_SP,
        decl,
    }))
}

pub fn satisfies(expr: Box<Expr>, type_ann: Box<TsType>) -> Box<Expr> {
    Box::new(Expr::TsSatisfies(TsSatisfiesExpr {
        span: DUMMY_SP,
        expr,
        type_ann,
    }))
}

pub fn as_const(expr: Box<Expr>) -> Box<Expr> {
    Box::new(Expr::TsConstAssertion(TsConstAssertion {
        span: DUMMY_SP,
        expr,
    }))
}

pub fn paren(expr: Box<Expr>) -> Box<Expr> {
    Box::new(Expr::Paren(ParenExpr {
        span: DUMMY_SP,
        expr,
    }))
}

pub fn ts_type_ref(name: &str) -> Box<TsType> {
    Box::new(TsType::TsTypeRef(TsTypeRef {
        span: DUMMY_SP,
        type_name: TsEntityName::Ident(ident(name)),
        type_params: None,
    }))
}