wip

Author: todor-a

deployment/schema.json

@@ -284,14 +284,17 @@
     },
     "forceMultiLineSpecifiers": {
       "description": "If code import/export specifiers should be forced to be on multiple lines.",
-      "type": "boolean",
-      "default": false,
+      "type": "string",
+      "default": "never",
       "oneOf": [{
-        "const": true,
+        "const": "always",
         "description": ""
       }, {
-        "const": false,
+        "const": "never",
         "description": ""
+      }, {
+        "const": "onlyWhenMultiple",
+        "description": "Force multiple lines only if importing more than one thing."
       }]
     },
     "sortOrder": {

src/configuration/builder.rs

@@ -759,12 +759,12 @@ impl ConfigurationBuilder {
 
   /* force multi line specifiers */
 
-  pub fn export_declaration_force_multi_line(&mut self, value: bool) -> &mut Self {
-    self.insert("exportDeclaration.forceMultiLine", value.into())
+  pub fn export_declaration_force_multi_line(&mut self, value: ForceMultiLine) -> &mut Self {
+    self.insert("exportDeclaration.forceMultiLine", value.to_string().into())
   }
 
-  pub fn import_declaration_force_multi_line(&mut self, value: bool) -> &mut Self {
-    self.insert("importDeclaration.forceMultiLine", value.into())
+  pub fn import_declaration_force_multi_line(&mut self, value: ForceMultiLine) -> &mut Self {
+    self.insert("importDeclaration.forceMultiLine", value.to_string().into())
   }
 
   /* member spacing */
@@ -1220,8 +1220,8 @@ mod tests {
       .export_declaration_force_single_line(true)
       .import_declaration_force_single_line(true)
       /* force multi line specifiers */
-      .export_declaration_force_multi_line(true)
-      .import_declaration_force_multi_line(true)
+      .export_declaration_force_multi_line(ForceMultiLine::Never)
+      .import_declaration_force_multi_line(ForceMultiLine::Never)
       /* space settings */
       .binary_expression_space_surrounding_bitwise_and_arithmetic_operator(true)
       .comment_line_force_space_after_slashes(false)

src/configuration/resolve_config.rs

@@ -254,8 +254,8 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     import_declaration_force_single_line: get_value(&mut config, "importDeclaration.forceSingleLine", false, &mut diagnostics),
     export_declaration_force_single_line: get_value(&mut config, "exportDeclaration.forceSingleLine", false, &mut diagnostics),
     /* force multi line specifiers */
-    import_declaration_force_multi_line: get_value(&mut config, "importDeclaration.forceMultiLine", false, &mut diagnostics),
-    export_declaration_force_multi_line: get_value(&mut config, "exportDeclaration.forceMultiLine", false, &mut diagnostics),
+    import_declaration_force_multi_line: get_value(&mut config, "importDeclaration.forceMultiLine", ForceMultiLine::Never, &mut diagnostics),
+    export_declaration_force_multi_line: get_value(&mut config, "exportDeclaration.forceMultiLine", ForceMultiLine::Never, &mut diagnostics),
     /* space settings */
     binary_expression_space_surrounding_bitwise_and_arithmetic_operator: get_value(
       &mut config,

src/configuration/types.rs

@@ -57,6 +57,20 @@ pub enum TrailingCommas {
 
 generate_str_to_from![TrailingCommas, [Always, "always"], [Never, "never"], [OnlyMultiLine, "onlyMultiLine"]];
 
+/// Force multilines possibilities.
+#[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ForceMultiLine {
+  /// Multiline imports/exports should not be forced.
+  Never,
+  /// Always force multiline imports/exports.
+  Always,
+  /// Mulitline imports/exports should be forced only when importing/exporting multiple items.
+  OnlyWhenMultiple,
+}
+
+generate_str_to_from![ForceMultiLine, [Always, "always"], [Never, "never"], [OnlyWhenMultiple, "onlyWhenMultiple"]];
+
 /// Where to place the opening brace.
 #[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -541,9 +555,9 @@ pub struct Configuration {
   pub export_declaration_force_single_line: bool,
   /* force multi line specifiers */
   #[serde(rename = "exportDeclaration.forceMultiLine")]
-  pub export_declaration_force_multi_line: bool,
+  pub export_declaration_force_multi_line: ForceMultiLine,
   #[serde(rename = "importDeclaration.forceMultiLine")]
-  pub import_declaration_force_multi_line: bool,
+  pub import_declaration_force_multi_line: ForceMultiLine,
 
   /* use space separator */
   #[serde(rename = "binaryExpression.spaceSurroundingBitwiseAndArithmeticOperator")]

src/generation/generate.rs

@@ -1033,10 +1033,15 @@ fn gen_export_named_decl<'a>(node: &NamedExport<'a>, context: &mut Context<'a>)
   }
 
   let force_single_line = context.config.export_declaration_force_single_line && !contains_line_or_multiline_comment(node.into(), context.program);
+
+  let force_multi_line = !force_single_line
+    && ((context.config.export_declaration_force_multi_line == ForceMultiLine::Always)
+      || (named_exports.len() > 1 && context.config.export_declaration_force_multi_line == ForceMultiLine::OnlyWhenMultiple));
+
   let should_single_line = force_single_line
     || (default_export.is_none()
       && namespace_export.is_none()
-      && (named_exports.len() <= 1 && !context.config.export_declaration_force_multi_line)
+      && !force_multi_line
       && node.start_line_fast(context.program) == node.end_line_fast(context.program));
 
   // generate
@@ -1218,10 +1223,14 @@ fn gen_import_decl<'a>(node: &ImportDecl<'a>, context: &mut Context<'a>) -> Prin
   }
 
   let force_single_line = context.config.import_declaration_force_single_line && !contains_line_or_multiline_comment(node.into(), context.program);
+  let force_multi_line = !force_single_line
+    && ((context.config.import_declaration_force_multi_line == ForceMultiLine::Always)
+      || (named_imports.len() > 1 && context.config.import_declaration_force_multi_line == ForceMultiLine::OnlyWhenMultiple));
+
   let should_single_line = force_single_line
     || (default_import.is_none()
       && namespace_import.is_none()
-      && (named_imports.len() <= 1 && !context.config.import_declaration_force_multi_line)
+      && !force_multi_line
       && node.start_line_fast(context.program) == node.end_line_fast(context.program));
   let has_named_imports = !named_imports.is_empty() || {
     let from_keyword = context.token_finder.get_previous_token_if_from_keyword(node.src);
@@ -1467,7 +1476,7 @@ struct GenNamedImportOrExportSpecifierOptions<'a> {
   parent: Node<'a>,
   specifiers: Vec<Node<'a>>,
   force_single_line: bool,
-  force_multi_line_specifiers: bool,
+  force_multi_line_specifiers: ForceMultiLine,
 }
 
 fn gen_named_import_or_export_specifiers<'a>(opts: GenNamedImportOrExportSpecifierOptions<'a>, context: &mut Context<'a>) -> PrintItems {
@@ -1487,6 +1496,14 @@ fn gen_named_import_or_export_specifiers<'a>(opts: GenNamedImportOrExportSpecifi
     context,
   );
 
+  fn get_force_multiline(parent_decl: Node, context: &Context) -> ForceMultiLine {
+    match parent_decl {
+      Node::NamedExport(_) => context.config.export_declaration_force_multi_line,
+      Node::ImportDecl(_) => context.config.import_declaration_force_multi_line,
+      _ => unreachable!(),
+    }
+  }
+
   fn get_trailing_commas(parent_decl: Node, context: &Context) -> TrailingCommas {
     match parent_decl {
       Node::NamedExport(_) => context.config.export_declaration_trailing_commas,

…xportDeclaration_ForceMultiLine_True.txt …ortDeclaration_ForceMultiLine_Always.txttests/specs/declarations/export/ExportDeclaration_ForceMultiLine_True.txt renamed to tests/specs/declarations/export/ExportDeclaration_ForceMultiLine_Always.txt tests/specs/declarations/export/ExportDeclaration_ForceMultiLine_True.txt renamed to tests/specs/declarations/export/ExportDeclaration_ForceMultiLine_Always.txt

@@ -1,4 +1,4 @@
-~~ exportDeclaration.forceMultiLine: true, lineWidth: 40 ~~
+~~ exportDeclaration.forceMultiLine: always, lineWidth: 40 ~~
 == should always add a new line between exports ==
 export { testing, a, b, c, d, e } from "./test.ts";
 export { testing, a, b, c, d, e // test

…ort/ImportDeclaration_ForceMultiLine.txt …ortDeclaration_ForceMultiLine_Always.txttests/specs/declarations/import/ImportDeclaration_ForceMultiLine.txt renamed to tests/specs/declarations/import/ImportDeclaration_ForceMultiLine_Always.txt tests/specs/declarations/import/ImportDeclaration_ForceMultiLine.txt renamed to tests/specs/declarations/import/ImportDeclaration_ForceMultiLine_Always.txt

@@ -1,4 +1,4 @@
-~~ importDeclaration.forceMultiLine: true, lineWidth: 40 ~~
+~~ importDeclaration.forceMultiLine: always, lineWidth: 40 ~~
 == should always add a new line between ==
 import { testing, a, b, c, d, e } from "./test.ts";
 import { testing, a, b, c, d, e // test

tests/specs/declarations/import/ImportDeclaration_ForceMultiLine_Never.txt

@@ -0,0 +1,6 @@
+~~ importDeclaration.forceMultiLine: never, lineWidth: 40 ~~
+== should never add a new line between ==
+import { a, b } from "./test.ts";
+
+[expect]
+import { a, b } from "./test.ts";

tests/specs/declarations/import/ImportDeclaration_ForceMultiLine_OnlyWhenMultiple.txt

@@ -0,0 +1,16 @@
+~~ importDeclaration.forceMultiLine: onlyWhenMultiple, lineWidth: 40 ~~
+== should break imports when more than one ==
+import { a, b } from "./test.ts";
+
+[expect]
+import {
+    a,
+    b,
+} from "./test.ts";
+
+== should not break single-line imports ==
+import { a } from "./test.ts";
+
+
+[expect]
+import {a,} from "./test.ts";

tests/specs/declarations/import/NamedImports_PreferHanging_True.txt

@@ -13,7 +13,7 @@ import { test1, test2, test3 as something } from "test";
 import { test1, test2,
     test3 as something } from "test";
 
-== should break up on `as` when really long on the same line ==
+== should break up on `as` when really long on the same line (only) ==
 import { loooooooooooooooooooooooooooooooooooong as alias, test } from "test";
 
 [expect]