dprint-plugin-typescript 0.11.0

TypeScript formatter for dprint.
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use std::collections::HashMap;
use dprint_core::configuration::{resolve_global_config, NewLineKind};
use super::configuration::*;

#[test]
fn check_all_values_set() {
    let mut config = ConfigurationBuilder::new();
    config.new_line_kind(NewLineKind::Auto)
        .line_width(80)
        .use_tabs(false)
        .indent_width(4)
        /* common */
        .quote_style(QuoteStyle::AlwaysDouble)
        .semi_colons(SemiColons::Prefer)
        .brace_position(BracePosition::NextLine)
        .next_control_flow_position(NextControlFlowPosition::SameLine)
        .operator_position(OperatorPosition::SameLine)
        .single_body_position(SingleBodyPosition::SameLine)
        .trailing_commas(TrailingCommas::Never)
        .use_braces(UseBraces::WhenNotSingleLine)
        .prefer_hanging(false)
        /* use parentheses */
        .arrow_function_use_parentheses(UseParentheses::Maintain)
        /* brace position*/
        .arrow_function_brace_position(BracePosition::NextLine)
        .class_declaration_brace_position(BracePosition::NextLine)
        .class_expression_brace_position(BracePosition::NextLine)
        .constructor_brace_position(BracePosition::NextLine)
        .do_while_statement_brace_position(BracePosition::NextLine)
        .enum_declaration_brace_position(BracePosition::NextLine)
        .for_statement_brace_position(BracePosition::NextLine)
        .for_in_statement_brace_position(BracePosition::NextLine)
        .for_of_statement_brace_position(BracePosition::NextLine)
        .get_accessor_brace_position(BracePosition::NextLine)
        .if_statement_brace_position(BracePosition::NextLine)
        .interface_declaration_brace_position(BracePosition::NextLine)
        .function_declaration_brace_position(BracePosition::NextLine)
        .function_expression_brace_position(BracePosition::NextLine)
        .method_brace_position(BracePosition::NextLine)
        .module_declaration_brace_position(BracePosition::NextLine)
        .set_accessor_brace_position(BracePosition::NextLine)
        .switch_case_brace_position(BracePosition::NextLine)
        .switch_statement_brace_position(BracePosition::NextLine)
        .try_statement_brace_position(BracePosition::NextLine)
        .while_statement_brace_position(BracePosition::NextLine)
        /* prefer hanging */
        .arguments_prefer_hanging(true)
        .array_expression_prefer_hanging(true)
        .array_pattern_prefer_hanging(true)
        .do_while_statement_prefer_hanging(true)
        .export_declaration_prefer_hanging(true)
        .extends_clause_prefer_hanging(true)
        .for_in_statement_prefer_hanging(true)
        .for_of_statement_prefer_hanging(true)
        .for_statement_prefer_hanging(true)
        .if_statement_prefer_hanging(true)
        .implements_clause_prefer_hanging(true)
        .import_declaration_prefer_hanging(true)
        .object_expression_prefer_hanging(true)
        .object_pattern_prefer_hanging(true)
        .parameters_prefer_hanging(true)
        .sequence_expression_prefer_hanging(true)
        .switch_statement_prefer_hanging(true)
        .tuple_type_prefer_hanging(true)
        .type_literal_prefer_hanging(true)
        .type_parameter_declaration_prefer_hanging(true)
        .union_and_intersection_type_prefer_hanging(true)
        .variable_statement_prefer_hanging(true)
        .while_statement_prefer_hanging(true)
        /* member spacing */
        .enum_declaration_member_spacing(MemberSpacing::Maintain)
        /* next control flow position */
        .if_statement_next_control_flow_position(NextControlFlowPosition::SameLine)
        .try_statement_next_control_flow_position(NextControlFlowPosition::SameLine)
        /* operator position */
        .binary_expression_operator_position(OperatorPosition::SameLine)
        .conditional_expression_operator_position(OperatorPosition::SameLine)
        /* single body position */
        .if_statement_single_body_position(SingleBodyPosition::SameLine)
        .for_statement_single_body_position(SingleBodyPosition::SameLine)
        .for_in_statement_single_body_position(SingleBodyPosition::SameLine)
        .for_of_statement_single_body_position(SingleBodyPosition::SameLine)
        .while_statement_single_body_position(SingleBodyPosition::SameLine)
        /* trailing commas */
        .arguments_trailing_commas(TrailingCommas::Never)
        .parameters_trailing_commas(TrailingCommas::Never)
        .array_expression_trailing_commas(TrailingCommas::Never)
        .array_pattern_trailing_commas(TrailingCommas::Never)
        .enum_declaration_trailing_commas(TrailingCommas::Never)
        .import_declaration_trailing_commas(TrailingCommas::Never)
        .export_declaration_trailing_commas(TrailingCommas::Never)
        .object_expression_trailing_commas(TrailingCommas::Never)
        .object_pattern_trailing_commas(TrailingCommas::Never)
        .type_parameter_declaration_trailing_commas(TrailingCommas::Never)
        .tuple_type_trailing_commas(TrailingCommas::Never)
        /* use braces */
        .if_statement_use_braces(UseBraces::Always)
        .for_statement_use_braces(UseBraces::Always)
        .for_in_statement_use_braces(UseBraces::Always)
        .for_of_statement_use_braces(UseBraces::Always)
        .while_statement_use_braces(UseBraces::Always)
        /* prefer single line */
        .arguments_prefer_single_line(false)
        .conditional_expression_prefer_single_line(false)
        .parameters_prefer_single_line(false)
        /* space settings */
        .binary_expression_space_surrounding_bitwise_and_arithmetic_operator(true)
        .comment_line_force_space_after_slashes(false)
        .construct_signature_space_after_new_keyword(true)
        .constructor_space_before_parentheses(true)
        .constructor_type_space_after_new_keyword(true)
        .do_while_statement_space_after_while_keyword(true)
        .export_declaration_space_surrounding_named_exports(true)
        .for_statement_space_after_for_keyword(true)
        .for_statement_space_after_semi_colons(true)
        .for_in_statement_space_after_for_keyword(true)
        .for_of_statement_space_after_for_keyword(true)
        .function_declaration_space_before_parentheses(true)
        .function_expression_space_before_parentheses(true)
        .function_expression_space_after_function_keyword(true)
        .get_accessor_space_before_parentheses(true)
        .if_statement_space_after_if_keyword(true)
        .import_declaration_space_surrounding_named_imports(true)
        .jsx_expression_container_space_surrounding_expression(true)
        .method_space_before_parentheses(true)
        .set_accessor_space_before_parentheses(true)
        .tagged_template_space_before_literal(false)
        .type_annotation_space_before_colon(true)
        .type_assertion_space_before_expression(true)
        .while_statement_space_after_while_keyword(true);

    let inner_config = config.get_inner_config();
    assert_eq!(inner_config.len(), 111);
    let diagnostics = resolve_config(&inner_config, &resolve_global_config(&HashMap::new()).config).diagnostics;
    assert_eq!(diagnostics.len(), 0);
}

#[test]
fn handle_global_config() {
    let mut global_config = HashMap::new();
    global_config.insert(String::from("lineWidth"), String::from("80"));
    global_config.insert(String::from("indentWidth"), String::from("8"));
    global_config.insert(String::from("newLineKind"), String::from("crlf"));
    global_config.insert(String::from("useTabs"), String::from("true"));
    let global_config = resolve_global_config(&global_config).config;
    let mut config_builder = ConfigurationBuilder::new();
    let config = config_builder.global_config(global_config).build();
    assert_eq!(config.line_width, 80);
    assert_eq!(config.indent_width, 8);
    assert_eq!(config.new_line_kind == NewLineKind::CarriageReturnLineFeed, true);
    assert_eq!(config.use_tabs, true);
}

#[test]
fn handle_deno_config() {
    let mut config = HashMap::new();
    config.insert(String::from("deno"), String::from("true"));
    let global_config = resolve_global_config(&HashMap::new()).config;
    let result = resolve_config(&config, &global_config);
    let expected_config = ConfigurationBuilder::new().deno().build();
    // todo: test that both objects equal each other
    assert_eq!(result.config.indent_width, expected_config.indent_width);
    assert_eq!(result.config.line_width, expected_config.line_width);
    assert_eq!(result.diagnostics.len(), 0);
}

#[test]
fn handle_deno_config_with_overwrites() {
    let mut config = HashMap::new();
    config.insert(String::from("deno"), String::from("true"));
    config.insert(String::from("indentWidth"), String::from("8"));
    let global_config = resolve_global_config(&HashMap::new()).config;
    let result = resolve_config(&config, &global_config);
    let expected_config = ConfigurationBuilder::new().deno().build();
    assert_eq!(result.config.indent_width, 8);
    assert_eq!(result.config.line_width, expected_config.line_width);
    assert_eq!(result.diagnostics.len(), 0);
}