eslint-plugin-code-style 1.8.1 → 1.8.3

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.8.3] - 2026-02-03
+
+### Fixed
+
+- **`class-naming-convention`** - Auto-fix now renames all references to the class (including instantiations like `new ClassName()` and type annotations), not just the class declaration
+
+---
+
+## [1.8.2] - 2026-02-03
+
+### Changed
+
+- **`multiline-if-conditions`** - Remove configurable `maxNestingLevel` option; nesting level is now fixed at 2 to prevent overly complex conditions. Nested groups with >maxOperands are formatted multiline inline (not extracted). Extraction only occurs when nesting exceeds 2 levels.
+- **`ternary-condition-multiline`** - Remove configurable `maxNestingLevel` option; nesting level is now fixed at 2 to prevent overly complex conditions. Nested groups with >maxOperands are formatted multiline inline (not extracted). Extraction only occurs when nesting exceeds 2 levels.
+- **`opening-brackets-same-line`** - Skip ternary condition tests and detect intentional multiline format to prevent rule conflicts
+- **`if-statement-format`** - Detect intentional multiline conditions to prevent collapsing formatted conditions
+
+### Documentation
+
+- Update both rules to show multiline inline formatting examples instead of extraction
+- Remove `maxNestingLevel` option from documentation (now fixed internally)
+
+---
+
 ## [1.8.1] - 2026-02-03
 
 ### Changed

package/README.md

@@ -1151,13 +1151,59 @@ if (isAuthenticated &&
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `maxOperands` | `integer` | `3` | Maximum operands to keep on single line |
+| `maxOperands` | `integer` | `3` | Maximum operands to keep on single line. Also applies to nested groups |
 
 ```javascript
 // Example: Allow up to 4 operands on single line
 "code-style/multiline-if-conditions": ["error", { maxOperands: 4 }]
 ```
 
+**Auto-formatting:** Nested groups with >maxOperands are formatted multiline inline:
+
+```javascript
+// ❌ Before (nested group has 4 operands)
+if ((a || b || c || d) && e) {}
+
+// ✅ After auto-fix — formats nested group multiline
+if ((
+    a
+    || b
+    || c
+    || d
+) && e) {}
+```
+
+**Double nesting:** Both levels expand when both exceed maxOperands:
+
+```javascript
+// ❌ Before (both parent and nested have 4 operands)
+if ((a || (c && d && a && b) || c || d) && e) {}
+
+// ✅ After auto-fix — both levels formatted multiline
+if ((
+    a
+    || (
+        c
+        && d
+        && a
+        && b
+    )
+    || c
+    || d
+) && e) {}
+```
+
+**Extraction:** Groups exceeding nesting level 2 are extracted to variables:
+
+```javascript
+// ❌ Before (level 3 nesting)
+if ((a && (b || (c && d))) || e) {}
+
+// ✅ After auto-fix — extracts deepest nested group
+const isCAndD = (c && d);
+if ((a && (b || isCAndD)) || e) {}
+```
+
 ---
 
 ### `no-empty-lines-in-switch-cases`
@@ -1217,6 +1263,9 @@ switch (status) {
 **What it does:** Formats ternary expressions based on condition operand count:
 - ≤maxOperands (default: 3): Always collapse to single line regardless of line length
 - \>maxOperands: Expand to multiline with each operand on its own line
+- Simple parenthesized nested ternaries (≤maxOperands) count as 1 operand and collapse
+- Complex nested ternaries (>maxOperands in their condition) are skipped for manual formatting
+- Nesting level is fixed at 2 to prevent overly complex conditions
 
 **Why use it:** Consistent formatting based on complexity, not line length. Simple conditions stay readable on one line; complex conditions get proper multiline formatting.
 
@@ -1224,13 +1273,16 @@ switch (status) {
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `maxOperands` | `integer` | `3` | Maximum condition operands to keep ternary on single line |
+| `maxOperands` | `integer` | `3` | Maximum condition operands to keep ternary on single line. Also applies to nested groups |
 
 ```javascript
 // ✅ Good — ≤3 operands always on single line
 const x = a && b && c ? "yes" : "no";
 const url = lang === "ar" ? `${apiEndpoints.exam.status}/${jobId}?lang=ar` : `${apiEndpoints.exam.status}/${jobId}`;
 
+// ✅ Good — parenthesized nested ternary counts as 1 operand
+const inputType = showToggle ? (showPassword ? "text" : "password") : type;
+
 // ✅ Good — >3 operands formatted multiline
 const style = variant === "ghost"
     || variant === "ghost-danger"
@@ -1239,6 +1291,19 @@ const style = variant === "ghost"
     ? "transparent"
     : "solid";
 
+// ✅ Good — nested group with >3 operands formatted multiline inline
+const result = (
+    a
+    || (
+        c
+        && d
+        && a
+        && b
+    )
+    || c
+    || d
+) && e ? "yes" : "no";
+
 // ❌ Bad — ≤3 operands split across lines
 const x = a && b && c
     ? "yes"
@@ -1248,6 +1313,19 @@ const x = a && b && c
 const style = variant === "ghost" || variant === "ghost-danger" || variant === "muted" || variant === "primary" ? "transparent" : "solid";
 ```
 
+**Auto-extraction:** Nested groups are auto-extracted to variables only when nesting depth exceeds 2 levels:
+
+```javascript
+// ❌ Before (level 3 nesting exceeds limit)
+const result = (a && (b || (c && d))) || e ? "yes" : "no";
+
+// ✅ After auto-fix — extracts deepest nested group
+const isCAndD = (c && d);
+const result = (a && (b || isCAndD)) || e ? "yes" : "no";
+```
+
+**Note:** When nested groups exceed `maxOperands` but stay within the 2-level nesting limit, they are formatted multiline inline (not extracted).
+
 <br />
 
 ## ⚡ Function Rules