eslint-plugin-code-style 1.7.3 → 1.7.6

package/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.7.6] - 2026-02-02
+
+### Changed
+
+- **`ternary-condition-multiline`** - Now depends only on operand count, not line length:
+  - ≤maxOperands (default: 3): Always collapse to single line regardless of line length
+  - \>maxOperands: Format multiline with each operand on its own line
+  - Removed `maxLineLength` option (no longer used)
+  - This aligns behavior with `multiline-if-conditions` rule
+
+---
+
+## [1.7.5] - 2026-02-02
+
+### Fixed
+
+- **`ternary-condition-multiline`** - For ≤3 operands, always collapse to single line when `?` is on different line than condition end (enforces `condition ? value : value` format for simple ternaries)
+- **`no-empty-lines-in-function-params`** - Add detection for empty lines in TSTypeLiteral (type annotation objects like `{ prop: Type }` in intersection types)
+
+---
+
+## [1.7.4] - 2026-02-02
+
+### Fixed
+
+- **`no-empty-lines-in-function-params`** - Fix bug that deleted TypeScript type annotations when fixing empty lines in destructured params; now uses `getTokenAfter` instead of `getLastToken` to find closing brace
+- **`no-inline-type-definitions`** - Change threshold comparison from `>` to `>=` so 2-member unions are now flagged (with default `maxUnionMembers: 2`)
+- **`ternary-condition-multiline`** - Fix multiline formatting for >3 operands: first operand stays on same line as property key, `?` and `:` each on their own lines; fix circular fix bug for ≤3 operands case
+
+---
+
 ## [1.7.3] - 2026-02-02
 
 ### Fixed
@@ -1107,6 +1138,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.7.6]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.5...v1.7.6
+[1.7.5]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.4...v1.7.5
+[1.7.4]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.3...v1.7.4
+[1.7.3]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.2...v1.7.3
 [1.7.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.1...v1.7.2
 [1.7.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.0...v1.7.1
 [1.7.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.6...v1.7.0

package/README.md

@@ -295,7 +295,7 @@ rules: {
 | `if-statement-format` | `{` on same line as `if`/`else if`, `else` on same line as `}`, proper spacing 🔧 |
 | `multiline-if-conditions` | Conditions exceeding threshold get one operand per line with proper indentation (default: >3) 🔧 ⚙️ |
 | `no-empty-lines-in-switch-cases` | No empty line after `case X:` before code, no empty lines between cases 🔧 |
-| `ternary-condition-multiline` | Collapse simple ternaries to single line; expand complex conditions (>3 operands) to multiline 🔧 ⚙️ |
+| `ternary-condition-multiline` | ≤maxOperands always single line; >maxOperands multiline (based on operand count, not line length) 🔧 ⚙️ |
 | **Function Rules** | |
 | `function-call-spacing` | No space between function name and `(`: `fn()` not `fn ()` 🔧 |
 | `function-declaration-style` | Auto-fix for `func-style`: converts function declarations to arrow expressions 🔧 |
@@ -1211,24 +1211,24 @@ switch (status) {
 
 ### `ternary-condition-multiline`
 
-**What it does:** Enforces consistent ternary formatting:
-- Simple ternaries (≤3 operands in condition) collapse to single line if they fit
-- Complex ternaries (>3 operands) expand to multiline with each operand on its own line
+**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
 
-**Why use it:** Long ternary conditions on a single line are hard to read. Breaking complex conditions into multiple lines makes them scannable.
+**Why use it:** Consistent formatting based on complexity, not line length. Simple conditions stay readable on one line; complex conditions get proper multiline formatting.
 
 **Options:**
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `maxOperands` | `integer` | `3` | Maximum operands to keep on single line |
-| `maxLineLength` | `integer` | `120` | Maximum line length for single-line ternaries |
+| `maxOperands` | `integer` | `3` | Maximum condition operands to keep ternary on single line |
 
 ```javascript
-// ✅ Good — simple condition on single line
+// ✅ 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 — complex condition multiline (>3 operands)
+// ✅ Good — >3 operands formatted multiline
 const style = variant === "ghost"
     || variant === "ghost-danger"
     || variant === "muted"
@@ -1236,7 +1236,12 @@ const style = variant === "ghost"
     ? "transparent"
     : "solid";
 
-// ❌ Bad — complex condition crammed on one line
+// ❌ Bad — ≤3 operands split across lines
+const x = a && b && c
+    ? "yes"
+    : "no";
+
+// ❌ Bad — >3 operands crammed on one line
 const style = variant === "ghost" || variant === "ghost-danger" || variant === "muted" || variant === "primary" ? "transparent" : "solid";
 ```
 

package/index.js

@@ -3868,21 +3868,31 @@ const multilineIfConditions = {
  * ───────────────────────────────────────────────────────────────
  *
  * Description:
- *   When a ternary condition has multiple operands (>3), format
- *   each operand on its own line for readability.
+ *   Formats ternary expressions based on condition operand count:
+ *   - ≤maxOperands (default: 3): Always collapse to single line
+ *   - >maxOperands: Format multiline with each operand on its own line
  *
- * ✓ Good:
+ * Options:
+ *   { maxOperands: 3 } - Maximum operands to keep on single line (default: 3)
+ *
+ * ✓ Good (≤3 operands - single line):
  *   const x = a && b && c ? "yes" : "no";
+ *   const url = lang === "ar" ? "/ar/path" : "/en/path";
  *
- *   const x =
- *       variant === "ghost"
+ * ✓ Good (>3 operands - multiline):
+ *   const x = variant === "ghost"
  *       || variant === "ghost-danger"
  *       || variant === "muted"
  *       || variant === "primary"
- *           ? "value1"
- *           : "value2";
+ *       ? "value1"
+ *       : "value2";
  *
- * ✗ Bad:
+ * ✗ Bad (≤3 operands split across lines):
+ *   const x = a && b && c
+ *       ? "yes"
+ *       : "no";
+ *
+ * ✗ Bad (>3 operands on single line):
  *   const x = variant === "ghost" || variant === "ghost-danger" || variant === "muted" || variant === "primary" ? "value1" : "value2";
  */
 const ternaryConditionMultiline = {
@@ -3890,7 +3900,6 @@ const ternaryConditionMultiline = {
         const sourceCode = context.sourceCode || context.getSourceCode();
         const options = context.options[0] || {};
         const maxOperands = options.maxOperands ?? 3;
-        const maxLineLength = options.maxLineLength ?? 120;
 
         // Check if node is wrapped in parentheses
         const isParenthesizedHandler = (node) => {
@@ -4048,7 +4057,7 @@ const ternaryConditionMultiline = {
             return false;
         };
 
-        // Handle simple ternaries - collapse to single line if they fit
+        // Handle simple ternaries (≤maxOperands) - always collapse to single line
         const handleSimpleTernaryHandler = (node) => {
             const isOnSingleLine = node.loc.start.line === node.loc.end.line;
             const hasOperatorOnOwnLine = isOperatorOnOwnLineHandler(node);
@@ -4068,46 +4077,15 @@ const ternaryConditionMultiline = {
 
             // Calculate what the single line would look like
             const singleLineText = getTernarySingleLineHandler(node);
-            const indent = getLineIndentHandler(node);
-
-            // Check if the parent needs prefix text (like "const x = " or "key: ")
-            let prefixLength = 0;
-            const parent = node.parent;
-
-            if (parent && parent.type === "VariableDeclarator" && parent.init === node) {
-                // Calculate prefix based on parent's start line (where "const x = " is)
-                const varDecl = parent.parent;
-                const declKeyword = varDecl ? sourceCode.getFirstToken(varDecl).value : "const";
-                const varName = parent.id.name || sourceCode.getText(parent.id);
-
-                // Prefix is "const varName = " or similar
-                prefixLength = declKeyword.length + 1 + varName.length + 3; // keyword + space + name + " = "
-            } else if (parent && parent.type === "AssignmentExpression" && parent.right === node) {
-                // Calculate prefix based on left side of assignment
-                const leftText = sourceCode.getText(parent.left);
-
-                prefixLength = leftText.length + 3; // left + " = "
-            } else if (parent && parent.type === "Property" && parent.value === node) {
-                // Object property: key: ternary
-                const keyText = sourceCode.getText(parent.key);
-
-                prefixLength = keyText.length + 2; // key + ": "
-            }
-
-            // Check if single line would fit
-            const totalLength = indent + prefixLength + singleLineText.length + 1;
-
-            if (totalLength <= maxLineLength) {
-                context.report({
-                    fix: (fixer) => fixer.replaceText(node, singleLineText),
-                    message: "Simple ternary should be on a single line",
-                    node,
-                });
 
-                return true;
-            }
+            // For ≤maxOperands conditions, always collapse to single line regardless of length
+            context.report({
+                fix: (fixer) => fixer.replaceText(node, singleLineText),
+                message: `Ternary with ≤${maxOperands} operands should be on a single line`,
+                node,
+            });
 
-            return false;
+            return true;
         };
 
         // Handle complex logical expressions - format multiline
@@ -4118,100 +4096,41 @@ const ternaryConditionMultiline = {
             const testEndLine = test.loc.end.line;
             const isMultiLine = testStartLine !== testEndLine;
 
-            // ≤maxOperands operands: keep condition on single line, and try to collapse whole ternary
+            // ≤maxOperands operands: always collapse to single line (regardless of line length)
             if (operands.length <= maxOperands) {
-                const firstOperandStartLine = operands[0].loc.start.line;
-                const allOperandsStartOnSameLine = operands.every(
-                    (op) => op.loc.start.line === firstOperandStartLine,
-                );
-
-                const hasSplitBinaryExpression = operands.some(
-                    (op) => isBinaryExpressionSplitHandler(op),
-                );
-
-                // Check if ? or : is on its own line without its value
-                const hasOperatorOnOwnLine = isOperatorOnOwnLineHandler(node);
-
-                // Check if ternary is multiline (could be collapsed)
-                const isTernaryMultiline = node.loc.start.line !== node.loc.end.line;
-
-                // Helper to build single line condition
-                const buildSameLineHandler = (n) => {
-                    if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
-                        const leftText = buildSameLineHandler(n.left);
-                        const rightText = buildSameLineHandler(n.right);
-
-                        return `${leftText} ${n.operator} ${rightText}`;
-                    }
-
-                    if (n.type === "BinaryExpression" && isBinaryExpressionSplitHandler(n)) {
-                        return buildBinaryExpressionSingleLineHandler(n);
-                    }
-
-                    return getSourceTextWithGroupsHandler(n);
-                };
-
-                // Check if whole ternary can fit on one line
-                const singleLineText = getTernarySingleLineHandler(node);
-                const indent = getLineIndentHandler(node);
-
-                // Calculate prefix length for context
-                let prefixLength = 0;
-                const parent = node.parent;
-
-                if (parent && parent.type === "VariableDeclarator" && parent.init === node) {
-                    const varDecl = parent.parent;
-                    const declKeyword = varDecl ? sourceCode.getFirstToken(varDecl).value : "const";
-                    const varName = parent.id.name || sourceCode.getText(parent.id);
-
-                    prefixLength = declKeyword.length + 1 + varName.length + 3;
-                } else if (parent && parent.type === "AssignmentExpression" && parent.right === node) {
-                    const leftText = sourceCode.getText(parent.left);
-
-                    prefixLength = leftText.length + 3;
-                } else if (parent && parent.type === "Property" && parent.value === node) {
-                    const keyText = sourceCode.getText(parent.key);
-
-                    prefixLength = keyText.length + 2;
-                }
-
-                const totalLength = indent + prefixLength + singleLineText.length + 1;
-                const canFitOnOneLine = totalLength <= maxLineLength;
-
                 // Skip if branches have complex objects
                 const hasComplexBranches = hasComplexObjectHandler(node.consequent) || hasComplexObjectHandler(node.alternate);
 
                 // Skip nested ternaries
                 const hasNestedTernary = node.consequent.type === "ConditionalExpression" || node.alternate.type === "ConditionalExpression";
 
-                // Determine if we need to fix anything
-                const needsConditionFix = !allOperandsStartOnSameLine || hasSplitBinaryExpression;
-                const needsTernaryCollapse = isTernaryMultiline && canFitOnOneLine && !hasComplexBranches && !hasNestedTernary;
-                const needsOperatorFix = hasOperatorOnOwnLine;
+                if (hasComplexBranches || hasNestedTernary) {
+                    return;
+                }
 
-                if (needsConditionFix || needsTernaryCollapse || needsOperatorFix) {
-                    // If whole ternary can fit on one line, collapse it
-                    if (canFitOnOneLine && !hasComplexBranches && !hasNestedTernary) {
-                        context.report({
-                            fix: (fixer) => fixer.replaceText(node, singleLineText),
-                            message: `Ternary with ≤${maxOperands} operands should be on single line when it fits`,
-                            node,
-                        });
-                    } else if (needsConditionFix) {
-                        // Otherwise just fix the condition to be on single line
-                        context.report({
-                            fix: (fixer) => fixer.replaceText(test, buildSameLineHandler(test)),
-                            message: `Ternary conditions with ≤${maxOperands} operands should be single line`,
-                            node: test,
-                        });
-                    }
+                // Check if already properly formatted (single line)
+                const isOnSingleLine = node.loc.start.line === node.loc.end.line;
+                const hasOperatorOnOwnLine = isOperatorOnOwnLineHandler(node);
+
+                if (isOnSingleLine && !hasOperatorOnOwnLine) {
+                    return;
                 }
 
+                // Collapse to single line
+                const singleLineText = getTernarySingleLineHandler(node);
+
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, singleLineText),
+                    message: `Ternary with ≤${maxOperands} operands should be on a single line`,
+                    node,
+                });
+
                 return;
             }
 
             // More than maxOperands: each on its own line
             let isCorrectionNeeded = !isMultiLine;
+            const parent = node.parent;
 
             if (isMultiLine) {
                 for (let i = 0; i < operands.length - 1; i += 1) {
@@ -4257,14 +4176,57 @@ const ternaryConditionMultiline = {
                 if (!isCorrectionNeeded && isOperatorOnOwnLineHandler(node)) {
                     isCorrectionNeeded = true;
                 }
+
+                // Check if : is on same line as ? (both should be on their own lines for multiline)
+                if (!isCorrectionNeeded) {
+                    const questionToken = sourceCode.getTokenAfter(test, (t) => t.value === "?");
+                    const colonToken = sourceCode.getTokenAfter(node.consequent, (t) => t.value === ":");
+
+                    if (questionToken && colonToken && questionToken.loc.start.line === colonToken.loc.start.line) {
+                        isCorrectionNeeded = true;
+                    }
+                }
+
+                // Check if first operand is not on same line as parent property key
+                if (!isCorrectionNeeded && parent && parent.type === "Property" && parent.value === node) {
+                    const keyEndLine = parent.key.loc.end.line;
+                    const firstOperandLine = operands[0].loc.start.line;
+
+                    if (firstOperandLine !== keyEndLine) {
+                        isCorrectionNeeded = true;
+                    }
+                }
             }
 
             if (isCorrectionNeeded) {
                 context.report({
                     fix: (fixer) => {
-                        // Get the indentation based on where the ternary starts
-                        const lineText = sourceCode.lines[node.loc.start.line - 1];
-                        const baseIndent = lineText.match(/^\s*/)[0];
+                        // Get proper base indent
+                        let baseIndent;
+                        let includePropertyKey = false;
+                        let propertyKeyText = "";
+
+                        // Check if parent is Property and value starts on different line
+                        if (parent && parent.type === "Property" && parent.value === node) {
+                            const keyEndLine = parent.key.loc.end.line;
+                            const firstOperandLine = operands[0].loc.start.line;
+
+                            if (firstOperandLine !== keyEndLine) {
+                                // Need to include property key in fix
+                                includePropertyKey = true;
+                                propertyKeyText = sourceCode.getText(parent.key) + ": ";
+                                const propertyLineText = sourceCode.lines[parent.loc.start.line - 1];
+
+                                baseIndent = propertyLineText.match(/^\s*/)[0];
+                            }
+                        }
+
+                        if (!baseIndent) {
+                            const lineText = sourceCode.lines[node.loc.start.line - 1];
+
+                            baseIndent = lineText.match(/^\s*/)[0];
+                        }
+
                         const conditionIndent = baseIndent + "    ";
 
                         const buildMultilineHandler = (n) => {
@@ -4281,9 +4243,17 @@ const ternaryConditionMultiline = {
                         const consequentText = sourceCode.getText(node.consequent);
                         const alternateText = sourceCode.getText(node.alternate);
 
-                        // No leading newline - keep first operand on same line as whatever precedes it
-                        // Use conditionIndent for ? and : to align with || operators
-                        const newText = `${buildMultilineHandler(test)}\n${conditionIndent}? ${consequentText}\n${conditionIndent}: ${alternateText}`;
+                        // Build multiline with ? and : each on their own lines
+                        const conditionPart = buildMultilineHandler(test);
+                        const newText = `${conditionPart}\n${conditionIndent}? ${consequentText}\n${conditionIndent}: ${alternateText}`;
+
+                        if (includePropertyKey) {
+                            // Replace the entire property value including fixing the key position
+                            return fixer.replaceTextRange(
+                                [parent.key.range[0], node.range[1]],
+                                `${propertyKeyText}${newText}`,
+                            );
+                        }
 
                         return fixer.replaceText(node, newText);
                     },
@@ -4310,21 +4280,15 @@ const ternaryConditionMultiline = {
         };
     },
     meta: {
-        docs: { description: "Enforce consistent ternary formatting: collapse simple ternaries to single line, expand complex conditions to multiline" },
+        docs: { description: "Enforce consistent ternary formatting based on condition operand count: ≤maxOperands collapses to single line, >maxOperands expands to multiline" },
         fixable: "code",
         schema: [
             {
                 additionalProperties: false,
                 properties: {
-                    maxLineLength: {
-                        default: 120,
-                        description: "Maximum line length for single-line ternaries (default: 120)",
-                        minimum: 80,
-                        type: "integer",
-                    },
                     maxOperands: {
                         default: 3,
-                        description: "Maximum operands to keep on single line (default: 3)",
+                        description: "Maximum condition operands to keep ternary on single line (default: 3). Ternaries with more operands are formatted multiline.",
                         minimum: 1,
                         type: "integer",
                     },
@@ -9747,10 +9711,10 @@ const noEmptyLinesInFunctionParams = {
                         }
                     }
 
-                    // Find the closing brace of ObjectPattern
-                    const closeBrace = sourceCode.getLastToken(param);
+                    // Find the closing brace of ObjectPattern (first } after last prop, not last token which could be from type annotation)
+                    const closeBrace = sourceCode.getTokenAfter(lastProp, (t) => t.value === "}");
 
-                    if (closeBrace && closeBrace.value === "}") {
+                    if (closeBrace) {
                         // Check for empty line before closing brace
                         if (closeBrace.loc.start.line - lastProp.loc.end.line > 1) {
                             context.report({
@@ -9788,14 +9752,74 @@ const noEmptyLinesInFunctionParams = {
             });
         };
 
+        // Check TSTypeLiteral for empty lines (type annotation objects like { prop: Type })
+        const checkTypeLiteralHandler = (node) => {
+            if (!node.members || node.members.length === 0) return;
+
+            const firstMember = node.members[0];
+            const lastMember = node.members[node.members.length - 1];
+
+            // Find opening brace
+            const openBrace = sourceCode.getFirstToken(node);
+
+            if (openBrace && openBrace.value === "{") {
+                // Check for empty line after opening brace
+                if (firstMember.loc.start.line - openBrace.loc.end.line > 1) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [openBrace.range[1], firstMember.range[0]],
+                            "\n" + " ".repeat(firstMember.loc.start.column),
+                        ),
+                        message: "No empty line after opening brace in type definition",
+                        node: firstMember,
+                    });
+                }
+            }
+
+            // Find closing brace
+            const closeBrace = sourceCode.getLastToken(node);
+
+            if (closeBrace && closeBrace.value === "}") {
+                // Check for empty line before closing brace
+                if (closeBrace.loc.start.line - lastMember.loc.end.line > 1) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [lastMember.range[1], closeBrace.range[0]],
+                            "\n" + " ".repeat(closeBrace.loc.start.column),
+                        ),
+                        message: "No empty line before closing brace in type definition",
+                        node: lastMember,
+                    });
+                }
+            }
+
+            // Check for empty lines between members
+            for (let i = 0; i < node.members.length - 1; i += 1) {
+                const current = node.members[i];
+                const next = node.members[i + 1];
+
+                if (next.loc.start.line - current.loc.end.line > 1) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [current.range[1], next.range[0]],
+                            "\n" + " ".repeat(next.loc.start.column),
+                        ),
+                        message: "No empty lines between type members",
+                        node: next,
+                    });
+                }
+            }
+        };
+
         return {
             ArrowFunctionExpression: checkFunctionHandler,
             FunctionDeclaration: checkFunctionHandler,
             FunctionExpression: checkFunctionHandler,
+            TSTypeLiteral: checkTypeLiteralHandler,
         };
     },
     meta: {
-        docs: { description: "Disallow empty lines in function parameters" },
+        docs: { description: "Disallow empty lines in function parameters and type definitions" },
         fixable: "whitespace",
         schema: [],
         type: "layout",
@@ -14993,7 +15017,7 @@ const noInlineTypeDefinitions = {
                 const memberCount = countUnionMembersHandler(typeNode);
                 const typeText = sourceCode.getText(typeNode);
 
-                if (memberCount > maxUnionMembers || typeText.length > maxLength) {
+                if (memberCount >= maxUnionMembers || typeText.length > maxLength) {
                     context.report({
                         message: `Inline union type with ${memberCount} members is too complex. Extract to a named type in a types file.`,
                         node: typeNode,
@@ -15023,7 +15047,7 @@ const noInlineTypeDefinitions = {
                             const memberCount = countUnionMembersHandler(propType);
                             const typeText = sourceCode.getText(propType);
 
-                            if (memberCount > maxUnionMembers || typeText.length > maxLength) {
+                            if (memberCount >= maxUnionMembers || typeText.length > maxLength) {
                                 context.report({
                                     message: `Property "${propName}" has inline union type with ${memberCount} members. Extract to a named type in a types file.`,
                                     node: propType,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.7.3",
+    "version": "1.7.6",
     "description": "A custom ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects",
     "main": "index.js",
     "types": "index.d.ts",