feat: add enhanced useBraces modes, structural indentation, and nextControlFlowPosition fixes

This fork adds several enhancements to formatting control and fixes bugs in control flow positioning:

New Features:
- Enhanced useBraces modes: whenFormattedMultiLine and onlyNeeded for finer control over brace usage
- Structural indentation mode for conditional expressions (ternary operators) that avoids deep nesting
- forceParentheses option to control when wrapping parentheses are added around expressions
- Helper functions (single_non_empty_stmt, push_always_true_condition) to optimize iterator usage

Bug Fixes:
- Fixed NextLineExceptAfterBrace hanging with try-catch-finally statements
- Fixed NextLineExceptAfterBrace for do-while statements to properly track block braces
- Fixed useBraces:whenNeeded to keep braces for function and variable declarations (strict mode requirement)
- Fixed multiple-statement blocks incorrectly returning false for brace requirements

Configuration Changes:
- Version bumped to 0.95.11+sf.2
- Made plugin URLs configurable via Cargo.toml metadata
- Uses version ranges for dependencies instead of exact pinning

Test Coverage:
- Added comprehensive test coverage for empty statements, dangling else, and control flow positioning
- Added regression tests for empty blocks and NextLineExceptAfterBrace behavior
- 671 tests passing

Performance Improvements:
- Eliminated Vec allocations in get_force_braces and brace-checking helpers
- Optimized to only create conditions when NextLineExceptAfterBrace is actually used
- Extracted common iterator patterns to reduce code duplication

Author: steffen-heil-secforge

Cargo.lock

@@ -1,14 +1,18 @@
 [package]
 name = "dprint-plugin-typescript"
-version = "0.95.11"
+version = "0.95.11+sf.2"
 authors = ["David Sherret <dsherret@gmail.com>"]
 edition = "2021"
-homepage = "https://github.com/dprint/dprint-plugin-typescript"
+homepage = "https://github.com/secforge/dprint-plugin-typescript"
 keywords = ["formatting", "formatter", "typescript", "javascript"]
 license = "MIT"
-repository = "https://github.com/dprint/dprint-plugin-typescript"
+repository = "https://github.com/secforge/dprint-plugin-typescript"
 description = "TypeScript and JavaScript code formatter."
 
+[package.metadata]
+dprint_update_url = "https://github.com/secforge/dprint-plugin-typescript/releases/latest/download/latest.json"
+dprint_schema_url_template = "https://github.com/secforge/dprint-plugin-typescript/releases/download/{VERSION}/schema.json"
+
 [lib]
 crate-type = ["lib", "cdylib"]
 
@@ -29,6 +33,9 @@ name = "specs"
 path = "tests/spec_test.rs"
 harness = false
 
+[build-dependencies]
+toml = "0.9"
+
 [dependencies]
 anyhow = "1.0.64"
 capacity_builder = "0.5.0"
@@ -47,4 +54,3 @@ malva = "0.11.2"
 markup_fmt = "0.19.0"
 pretty_assertions = "1.3.0"
 serde_json = { version = "1.0" }
-

Cargo.toml

@@ -0,0 +1,24 @@
+fn main() {
+    // Read Cargo.toml and extract custom metadata
+    let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+    let cargo_toml = std::fs::read_to_string(format!("{}/Cargo.toml", manifest))
+        .expect("Failed to read Cargo.toml");
+
+    // Parse TOML to get metadata
+    let toml: toml::Table = cargo_toml.parse().expect("Failed to parse Cargo.toml");
+
+    if let Some(package) = toml.get("package") {
+        if let Some(metadata) = package.get("metadata") {
+            if let Some(update_url) = metadata.get("dprint_update_url") {
+                if let Some(url_str) = update_url.as_str() {
+                    println!("cargo:rustc-env=DPRINT_UPDATE_URL={}", url_str);
+                }
+            }
+            if let Some(schema_url_template) = metadata.get("dprint_schema_url_template") {
+                if let Some(url_str) = schema_url_template.as_str() {
+                    println!("cargo:rustc-env=DPRINT_SCHEMA_URL_TEMPLATE={}", url_str);
+                }
+            }
+        }
+    }
+}

build.rs

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://plugins.dprint.dev/dprint/dprint-plugin-typescript/0.0.0/schema.json",
+  "$id": "https://github.com/secforge/dprint-plugin-typescript/releases/download/0.95.11+sf.2/schema.json",
   "type": "object",
   "definitions": {
     "useTabs": {
@@ -151,6 +151,24 @@
       }, {
         "const": "preferNone",
         "description": "Forces no braces when the header is one line and body is one line. Otherwise forces braces."
+      }, {
+        "const": "whenNeeded",
+        "description": "Uses braces when needed for clarity or safety, avoiding them when the statement is simple and unambiguous."
+      }, {
+        "const": "whenFormattedMultiLine",
+        "description": "Uses braces when the formatted code spans multiple lines, removing them for single-line statements."
+      }]
+    },
+    "ternaryIndentStyle": {
+      "description": "How ternary conditional expressions should be indented.",
+      "type": "string",
+      "default": "align",
+      "oneOf": [{
+        "const": "align",
+        "description": "Align the ? and : operators under the condition."
+      }, {
+        "const": "structural",
+        "description": "Use structural indentation for the ternary expression."
       }]
     },
     "bracePosition": {
@@ -199,6 +217,9 @@
       }, {
         "const": "nextLine",
         "description": "Forces the next control flow to be on the next line."
+      }, {
+        "const": "nextLineExceptAfterBrace",
+        "description": "Forces the next control flow to be on the next line, except when preceded by a brace."
       }]
     },
     "trailingCommas": {
@@ -1181,6 +1202,14 @@
     "conditionalExpression.operatorPosition": {
       "$ref": "#/definitions/operatorPosition"
     },
+    "conditionalExpression.indentStyle": {
+      "$ref": "#/definitions/ternaryIndentStyle"
+    },
+    "expressionStatement.forceParentheses": {
+      "description": "Whether to force parentheses around expression statements.",
+      "type": "boolean",
+      "default": true
+    },
     "conditionalType.operatorPosition": {
       "$ref": "#/definitions/operatorPosition"
     },

deployment/schema.json

@@ -822,6 +822,10 @@ impl ConfigurationBuilder {
     self.insert("conditionalExpression.operatorPosition", value.to_string().into())
   }
 
+  pub fn conditional_expression_indent_style(&mut self, value: TernaryIndentStyle) -> &mut Self {
+    self.insert("conditionalExpression.indentStyle", value.to_string().into())
+  }
+
   pub fn conditional_type_operator_position(&mut self, value: OperatorPosition) -> &mut Self {
     self.insert("conditionalType.operatorPosition", value.to_string().into())
   }
@@ -1077,6 +1081,10 @@ impl ConfigurationBuilder {
     self.insert("whileStatement.spaceAround", value.into())
   }
 
+  pub fn expression_statement_force_parentheses(&mut self, value: bool) -> &mut Self {
+    self.insert("expressionStatement.forceParentheses", value.into())
+  }
+
   #[cfg(test)]
   pub(super) fn get_inner_config(&self) -> ConfigKeyMap {
     self.config.clone()

src/configuration/builder.rs

@@ -202,6 +202,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     /* operator position */
     binary_expression_operator_position: get_value(&mut config, "binaryExpression.operatorPosition", operator_position, &mut diagnostics),
     conditional_expression_operator_position: get_value(&mut config, "conditionalExpression.operatorPosition", operator_position, &mut diagnostics),
+    conditional_expression_indent_style: get_value(&mut config, "conditionalExpression.indentStyle", TernaryIndentStyle::Align, &mut diagnostics),
     conditional_type_operator_position: get_value(&mut config, "conditionalType.operatorPosition", operator_position, &mut diagnostics),
     /* single body position */
     if_statement_single_body_position: get_value(&mut config, "ifStatement.singleBodyPosition", single_body_position, &mut diagnostics),
@@ -333,6 +334,7 @@ pub fn resolve_config(config: ConfigKeyMap, global_config: &GlobalConfiguration)
     switch_statement_space_around: get_value(&mut config, "switchStatement.spaceAround", space_around, &mut diagnostics),
     tuple_type_space_around: get_value(&mut config, "tupleType.spaceAround", space_around, &mut diagnostics),
     while_statement_space_around: get_value(&mut config, "whileStatement.spaceAround", space_around, &mut diagnostics),
+    expression_statement_force_parentheses: get_value(&mut config, "expressionStatement.forceParentheses", true, &mut diagnostics),
   };
 
   diagnostics.extend(get_unknown_property_diagnostics(config));

src/configuration/resolve_config.rs

@@ -119,9 +119,11 @@ pub enum NextControlFlowPosition {
   SameLine,
   /// Forces the next control flow to be on the next line.
   NextLine,
+  /// Forces the next control flow to be on the next line except when it appears after a closing brace.
+  NextLineExceptAfterBrace,
 }
 
-generate_str_to_from![NextControlFlowPosition, [Maintain, "maintain"], [SameLine, "sameLine"], [NextLine, "nextLine"]];
+generate_str_to_from![NextControlFlowPosition, [Maintain, "maintain"], [SameLine, "sameLine"], [NextLine, "nextLine"], [NextLineExceptAfterBrace, "nextLineExceptAfterBrace"]];
 
 /// Where to place the operator for expressions that span multiple lines.
 #[derive(Debug, Clone, PartialEq, Copy, Serialize, Deserialize)]
@@ -137,6 +139,19 @@ pub enum OperatorPosition {
 
 generate_str_to_from![OperatorPosition, [Maintain, "maintain"], [SameLine, "sameLine"], [NextLine, "nextLine"]];
 
+/// How to indent ternary expression branches.
+#[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TernaryIndentStyle {
+  /// Align all ternary branches at the same indentation level (original behavior).
+  Align,
+  /// Add structural indentation for nested ternary branches.
+  Structural,
+}
+
+generate_str_to_from![TernaryIndentStyle, [Align, "align"], [Structural, "structural"]];
+
+
 /// Where to place a node that could be on the same line or next line.
 #[derive(Clone, PartialEq, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -163,14 +178,20 @@ pub enum UseBraces {
   Always,
   /// Forces no braces when the header is one line and body is one line. Otherwise forces braces.
   PreferNone,
+  /// Only uses braces when syntactically required (empty blocks, declarations, multiple statements).
+  WhenNeeded,
+  /// Uses braces when the formatted body spans multiple lines.
+  WhenFormattedMultiLine,
 }
 
 generate_str_to_from![
   UseBraces,
   [Maintain, "maintain"],
   [WhenNotSingleLine, "whenNotSingleLine"],
   [Always, "always"],
-  [PreferNone, "preferNone"]
+  [PreferNone, "preferNone"],
+  [WhenNeeded, "whenNeeded"],
+  [WhenFormattedMultiLine, "whenFormattedMultiLine"]
 ];
 
 /// Whether to use parentheses around a single parameter in an arrow function.
@@ -466,6 +487,8 @@ pub struct Configuration {
   pub binary_expression_operator_position: OperatorPosition,
   #[serde(rename = "conditionalExpression.operatorPosition")]
   pub conditional_expression_operator_position: OperatorPosition,
+  #[serde(rename = "conditionalExpression.indentStyle")]
+  pub conditional_expression_indent_style: TernaryIndentStyle,
   #[serde(rename = "conditionalType.operatorPosition")]
   pub conditional_type_operator_position: OperatorPosition,
   /* single body position */
@@ -662,4 +685,7 @@ pub struct Configuration {
   pub tuple_type_space_around: bool,
   #[serde(rename = "whileStatement.spaceAround")]
   pub while_statement_space_around: bool,
+  /* expression parentheses */
+  #[serde(rename = "expressionStatement.forceParentheses")]
+  pub expression_statement_force_parentheses: bool,
 }