quasiquodo 0.3.0

Compile-time TypeScript quasi-quoting
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

use quasiquodo::ts_quote;
use swc_ecma_ast::*;
use swc_ecma_codegen::to_code;

// MARK: `ClassMember` output kind

#[test]
fn test_class_member_property() {
    let member: ClassMember = ts_quote!("name: string;" as ClassMember);
    assert_eq!(to_code(&member), "name: string;");
}

#[test]
fn test_class_member_method() {
    let member: ClassMember = ts_quote!("async get(): Promise<void> {}" as ClassMember);
    assert_eq!(to_code(&member), "async get(): Promise<void> {}");
}

// MARK: Method parameter splicing

#[test]
fn test_method_params_vec_splice() {
    let params: Vec<Param> = vec![ts_quote!("id: string" as Param)];
    let member: ClassMember = ts_quote!(
        "async get(#{Params}): Promise<void> {}" as ClassMember,
        Params: Vec<Param> = params,
    );
    assert_eq!(to_code(&member), "async get(id: string): Promise<void> {}");
}

// MARK: Constructor parameter splicing

#[test]
fn test_constructor_params_vec_splice() {
    let params: Vec<ParamOrTsParamProp> = vec![ts_quote!("x: string" as ParamOrTsParamProp)];
    let member: ClassMember = ts_quote!(
        "constructor(#{Params}) {}" as ClassMember,
        Params: Vec<ParamOrTsParamProp> = params,
    );
    assert_eq!(to_code(&member), "constructor(x: string){}");
}

#[test]
fn test_constructor_fixed_plus_vec_splice() {
    let rest: Vec<ParamOrTsParamProp> = vec![ts_quote!("y: number" as ParamOrTsParamProp)];
    let member: ClassMember = ts_quote!(
        "constructor(x: string, #{Rest}) {}" as ClassMember,
        Rest: Vec<ParamOrTsParamProp> = rest,
    );
    assert_eq!(to_code(&member), "constructor(x: string, y: number){}");
}

#[test]
fn test_single_param_or_ts_param_prop_substitution() {
    let my_param: ParamOrTsParamProp = ts_quote!("x: string" as ParamOrTsParamProp);
    let member: ClassMember = ts_quote!(
        "constructor(#{p}) {}" as ClassMember,
        p: ParamOrTsParamProp = my_param,
    );
    assert_eq!(to_code(&member), "constructor(x: string){}");
}

// MARK: `ParamOrTsParamProp` output kind

#[test]
fn test_param_or_ts_param_prop_output() {
    let p: ParamOrTsParamProp = ts_quote!("x: string" as ParamOrTsParamProp);
    assert_eq!(to_code(&p), "x: string");
}

#[test]
fn test_param_or_ts_param_prop_with_variable() {
    let my_name: Ident = ts_quote!("x" as Ident);
    let my_ty: TsType = ts_quote!("number" as TsType);
    let p: ParamOrTsParamProp = ts_quote!(
        "#{name}: #{ty}" as ParamOrTsParamProp,
        name: Ident = my_name,
        ty: TsType = my_ty,
    );
    assert_eq!(to_code(&p), "x: number");
}