eslint-plugin-code-style 1.8.1 → 1.8.3

package/index.js

@@ -3258,8 +3258,15 @@ const ifStatementFormat = {
             }
 
             // LogicalExpression - collapse if it's short enough to fit on one line
-            // "Short enough" means under 80 characters for the condition itself
+            // BUT skip if it has intentional multiline formatting (operator at start of line)
             if (testNode.type === "LogicalExpression") {
+                // Check for intentional multiline format (operator at start of line after newline)
+                // This pattern indicates multiline-if-conditions has intentionally formatted it
+                if (/\n\s*(\|\||&&)/.test(testText)) {
+                    return false; // Intentionally multilined, don't collapse
+                }
+
+                // "Short enough" means under 80 characters for the condition itself
                 const conditionLength = testText.replace(/\s+/g, " ").trim().length;
 
                 return conditionLength <= 80;
@@ -3518,26 +3525,36 @@ const ifElseSpacing = {
  * Description:
  *   When an if statement has multiple conditions that span
  *   multiple lines, each condition should be on its own line.
+ *   Nested groups with >maxOperands are formatted multiline inline.
+ *   Groups exceeding nesting level 2 are extracted to variables.
  *
  * Options:
  *   { maxOperands: 3 } - Maximum operands on single line (default: 3)
  *
- * ✓ Good:
- *   if (
- *       conditionA &&
- *       conditionB &&
- *       conditionC
- *   ) {}
- *
- * ✗ Bad:
- *   if (conditionA &&
- *       conditionB && conditionC) {}
+ * ✓ Good (nested group with >3 operands - multiline inline):
+ *   if ((
+ *       a
+ *       || b
+ *       || c
+ *       || d
+ *   ) && e) {}
+ *
+ * ✓ Good (≤2 nesting level):
+ *   if ((a && b) || c) {}                    // Level 1
+ *   if ((a && (b || c)) || d) {}             // Level 2
+ *
+ * ✗ Bad (>2 nesting level - auto-fixed by extraction):
+ *   if ((a && (b || (c && d))) || e) {}
+ *   // Fixed to:
+ *   // const isCAndD = (c && d);
+ *   // if ((a && (b || isCAndD)) || e) {}
  */
 const multilineIfConditions = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
         const options = context.options[0] || {};
         const maxOperands = options.maxOperands !== undefined ? options.maxOperands : 3;
+        const maxNestingLevel = 2; // Fixed at 2 - not configurable to avoid overly complex conditions
 
         const isParenthesizedHandler = (node) => {
             const tokenBefore = sourceCode.getTokenBefore(node);
@@ -3598,6 +3615,138 @@ const multilineIfConditions = {
             return operands;
         };
 
+        // Calculate max nesting depth of parenthesized groups in a logical expression
+        // Level 0: a && b (no groups)
+        // Level 1: (a && b) || c (one group at top)
+        // Level 2: (a && (b || c)) || d (group inside group)
+        const getNestingDepthHandler = (node, currentDepth = 0) => {
+            if (node.type !== "LogicalExpression") return currentDepth;
+
+            let maxDepth = currentDepth;
+
+            // Check left side
+            if (node.left.type === "LogicalExpression") {
+                const leftDepth = isParenthesizedHandler(node.left)
+                    ? getNestingDepthHandler(node.left, currentDepth + 1)
+                    : getNestingDepthHandler(node.left, currentDepth);
+                maxDepth = Math.max(maxDepth, leftDepth);
+            }
+
+            // Check right side
+            if (node.right.type === "LogicalExpression") {
+                const rightDepth = isParenthesizedHandler(node.right)
+                    ? getNestingDepthHandler(node.right, currentDepth + 1)
+                    : getNestingDepthHandler(node.right, currentDepth);
+                maxDepth = Math.max(maxDepth, rightDepth);
+            }
+
+            return maxDepth;
+        };
+
+        // Find the deepest nested parenthesized group that exceeds maxNestingLevel
+        const findDeepNestedGroupHandler = (node, currentDepth = 0, parentInfo = null) => {
+            if (node.type !== "LogicalExpression") return null;
+
+            let deepestGroup = null;
+
+            // Check left side
+            if (node.left.type === "LogicalExpression") {
+                const leftIsParen = isParenthesizedHandler(node.left);
+                const newDepth = leftIsParen ? currentDepth + 1 : currentDepth;
+
+                if (leftIsParen && newDepth > maxNestingLevel) {
+                    // This group exceeds max nesting
+                    deepestGroup = {
+                        node: node.left,
+                        depth: newDepth,
+                        parent: node,
+                        side: "left",
+                    };
+                }
+
+                // Recurse to find even deeper
+                const deeper = findDeepNestedGroupHandler(node.left, newDepth, { node, side: "left" });
+                if (deeper && (!deepestGroup || deeper.depth > deepestGroup.depth)) {
+                    deepestGroup = deeper;
+                }
+            }
+
+            // Check right side
+            if (node.right.type === "LogicalExpression") {
+                const rightIsParen = isParenthesizedHandler(node.right);
+                const newDepth = rightIsParen ? currentDepth + 1 : currentDepth;
+
+                if (rightIsParen && newDepth > maxNestingLevel) {
+                    // This group exceeds max nesting
+                    const rightGroup = {
+                        node: node.right,
+                        depth: newDepth,
+                        parent: node,
+                        side: "right",
+                    };
+                    if (!deepestGroup || rightGroup.depth > deepestGroup.depth) {
+                        deepestGroup = rightGroup;
+                    }
+                }
+
+                // Recurse to find even deeper
+                const deeper = findDeepNestedGroupHandler(node.right, newDepth, { node, side: "right" });
+                if (deeper && (!deepestGroup || deeper.depth > deepestGroup.depth)) {
+                    deepestGroup = deeper;
+                }
+            }
+
+            return deepestGroup;
+        };
+
+        // Count operands inside a group, ignoring the outer parentheses of the group itself
+        // This is used to count operands INSIDE a parenthesized group
+        const countOperandsInsideGroupHandler = (node) => {
+            if (node.type !== "LogicalExpression") return 1;
+
+            let count = 0;
+            const countHelperHandler = (n) => {
+                if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                    countHelperHandler(n.left);
+                    countHelperHandler(n.right);
+                } else {
+                    count += 1;
+                }
+            };
+
+            // Start by recursing into children directly (ignoring outer parens)
+            countHelperHandler(node.left);
+            countHelperHandler(node.right);
+
+            return count;
+        };
+
+        // Find a nested parenthesized group that has >maxOperands operands
+        // Returns the first such group found (for extraction to variable)
+        const findNestedGroupExceedingMaxOperandsHandler = (node) => {
+            if (node.type !== "LogicalExpression") return null;
+
+            // Check if this node is a parenthesized group with >maxOperands
+            if (isParenthesizedHandler(node)) {
+                const insideCount = countOperandsInsideGroupHandler(node);
+                if (insideCount > maxOperands) {
+                    return node;
+                }
+            }
+
+            // Recursively check children
+            if (node.left.type === "LogicalExpression") {
+                const found = findNestedGroupExceedingMaxOperandsHandler(node.left);
+                if (found) return found;
+            }
+            if (node.right.type === "LogicalExpression") {
+                const found = findNestedGroupExceedingMaxOperandsHandler(node.right);
+                if (found) return found;
+            }
+
+            return null;
+        };
+
         const checkIfStatementHandler = (node) => {
             const { test } = node;
 
@@ -3609,6 +3758,81 @@ const multilineIfConditions = {
 
             if (!openParen || !closeParen) return;
 
+            // Check for excessive nesting depth
+            const nestingDepth = getNestingDepthHandler(test);
+
+            if (nestingDepth > maxNestingLevel) {
+                const deepGroup = findDeepNestedGroupHandler(test);
+
+                if (deepGroup) {
+                    const groupText = getSourceTextWithGroupsHandler(deepGroup.node);
+
+                    // Generate a more descriptive variable name based on condition structure
+                    const getConditionNameHandler = (n) => {
+                        if (n.type === "LogicalExpression") {
+                            const leftName = getConditionNameHandler(n.left);
+                            const rightName = getConditionNameHandler(n.right);
+                            const opName = n.operator === "&&" ? "And" : "Or";
+
+                            return `${leftName}${opName}${rightName}`;
+                        }
+                        if (n.type === "Identifier") {
+                            return n.name.charAt(0).toUpperCase() + n.name.slice(1);
+                        }
+                        if (n.type === "BinaryExpression" || n.type === "CallExpression" || n.type === "MemberExpression") {
+                            return "Expr";
+                        }
+
+                        return "Cond";
+                    };
+
+                    // Generate unique variable name
+                    let varName = `is${getConditionNameHandler(deepGroup.node)}`;
+                    // Limit length and sanitize
+                    if (varName.length > 30) {
+                        varName = "isNestedCondition";
+                    }
+
+                    context.report({
+                        fix: (fixer) => {
+                            const fixes = [];
+
+                            // Get the line before the if statement for inserting the variable
+                            const ifLine = node.loc.start.line;
+                            const lineStart = sourceCode.getIndexFromLoc({ line: ifLine, column: 0 });
+                            const lineText = sourceCode.lines[ifLine - 1];
+                            const indent = lineText.match(/^\s*/)[0];
+
+                            // Insert variable declaration before the if statement
+                            fixes.push(fixer.insertTextBeforeRange(
+                                [lineStart, lineStart],
+                                `const ${varName} = ${groupText};\n${indent}`,
+                            ));
+
+                            // Replace the nested group with the variable name in the condition
+                            // We need to replace including the parentheses around the group
+                            const tokenBefore = sourceCode.getTokenBefore(deepGroup.node);
+                            const tokenAfter = sourceCode.getTokenAfter(deepGroup.node);
+
+                            if (tokenBefore && tokenAfter && tokenBefore.value === "(" && tokenAfter.value === ")") {
+                                fixes.push(fixer.replaceTextRange(
+                                    [tokenBefore.range[0], tokenAfter.range[1]],
+                                    varName,
+                                ));
+                            } else {
+                                fixes.push(fixer.replaceText(deepGroup.node, varName));
+                            }
+
+                            return fixes;
+                        },
+                        message: `Condition nesting depth (${nestingDepth}) exceeds maximum (${maxNestingLevel}). Extract deeply nested condition to a variable.`,
+                        node: deepGroup.node,
+                    });
+
+                    return; // Don't process other rules for this statement
+                }
+            }
+
             const isMultiLine = openParen.loc.start.line !== closeParen.loc.end.line;
 
             // Check if a BinaryExpression is split across lines (left/operator/right not on same line)
@@ -3639,8 +3863,146 @@ const multilineIfConditions = {
                 return sourceCode.getText(n);
             };
 
-            // maxOperands or fewer operands: keep on single line (operand starts on same line)
+            // Check if any nested parenthesized group has >maxOperands - format multiline inline
+            const nestedGroupExceeding = findNestedGroupExceedingMaxOperandsHandler(test);
+            if (nestedGroupExceeding) {
+                // Get indentation for formatting
+                const lineText = sourceCode.lines[node.loc.start.line - 1];
+                const parenIndent = lineText.match(/^\s*/)[0];
+                const contentIndent = parenIndent + "    ";
+
+                // Build multiline text for operands inside a nested group
+                // isOuterGroup=true means we're at the target group itself (ignore its own parentheses)
+                // Also recursively expands any inner nested groups with >maxOperands
+                const buildNestedMultilineHandler = (n, isOuterGroup = false, currentIndent = contentIndent) => {
+                    if (n.type === "LogicalExpression" && (isOuterGroup || !isParenthesizedHandler(n))) {
+                        const leftText = buildNestedMultilineHandler(n.left, false, currentIndent);
+                        const rightText = buildNestedMultilineHandler(n.right, false, currentIndent);
+
+                        return `${leftText}\n${currentIndent}${n.operator} ${rightText}`;
+                    }
+
+                    // Check if this is a parenthesized group with >maxOperands - also expand it
+                    if (n.type === "LogicalExpression" && isParenthesizedHandler(n)) {
+                        const innerCount = countOperandsInsideGroupHandler(n);
+                        if (innerCount > maxOperands) {
+                            const innerIndent = currentIndent + "    ";
+                            const buildInner = (inner) => {
+                                if (inner.type === "LogicalExpression" && !isParenthesizedHandler(inner)) {
+                                    const l = buildInner(inner.left);
+                                    const r = buildInner(inner.right);
+
+                                    return `${l}\n${innerIndent}${inner.operator} ${r}`;
+                                }
+
+                                return getSourceTextWithGroupsHandler(inner);
+                            };
+
+                            const innerLeft = buildInner(n.left);
+                            const innerRight = buildInner(n.right);
+
+                            return `(\n${innerIndent}${innerLeft}\n${innerIndent}${n.operator} ${innerRight}\n${currentIndent})`;
+                        }
+                    }
+
+                    return getSourceTextWithGroupsHandler(n);
+                };
+
+                // Build the full condition with nested group formatted multiline
+                const buildFullConditionHandler = (n, targetNode) => {
+                    if (n === targetNode) {
+                        // This is the nested group - format it multiline
+                        // Pass true to ignore outer parentheses check
+                        const nestedText = buildNestedMultilineHandler(n, true);
+
+                        return `(\n${contentIndent}${nestedText}\n${parenIndent})`;
+                    }
+
+                    if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                        const leftText = buildFullConditionHandler(n.left, targetNode);
+                        const rightText = buildFullConditionHandler(n.right, targetNode);
+
+                        return `${leftText} ${n.operator} ${rightText}`;
+                    }
+
+                    if (n.type === "LogicalExpression" && isParenthesizedHandler(n)) {
+                        // Check if this contains the target
+                        const containsTargetHandler = (node, target) => {
+                            if (node === target) return true;
+                            if (node.type === "LogicalExpression") {
+                                return containsTargetHandler(node.left, target) || containsTargetHandler(node.right, target);
+                            }
+
+                            return false;
+                        };
+
+                        if (containsTargetHandler(n, targetNode)) {
+                            const innerText = buildFullConditionHandler(n, targetNode);
+
+                            return `(${innerText})`;
+                        }
+                    }
+
+                    return getSourceTextWithGroupsHandler(n);
+                };
+
+                // Check if already correctly formatted
+                // Collect operands INSIDE the nested group (not treating the group itself as 1 operand)
+                const collectInsideGroupHandler = (node) => {
+                    const operands = [];
+                    const collectHelper = (n) => {
+                        if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                            collectHelper(n.left);
+                            collectHelper(n.right);
+                        } else {
+                            operands.push(n);
+                        }
+                    };
+
+                    // Start from children directly, ignoring outer parentheses
+                    if (node.type === "LogicalExpression") {
+                        collectHelper(node.left);
+                        collectHelper(node.right);
+                    }
+
+                    return operands;
+                };
+
+                const nestedOperands = collectInsideGroupHandler(nestedGroupExceeding);
+                const allOnDifferentLines = nestedOperands.every((op, i) => {
+                    if (i === 0) return true;
+
+                    return op.loc.start.line !== nestedOperands[i - 1].loc.start.line;
+                });
+
+                if (!allOnDifferentLines) {
+                    context.report({
+                        fix: (fixer) => {
+                            const newCondition = buildFullConditionHandler(test, nestedGroupExceeding);
+
+                            // Replace just the content between if statement's parens
+                            return fixer.replaceTextRange(
+                                [openParen.range[1], closeParen.range[0]],
+                                newCondition,
+                            );
+                        },
+                        message: `Nested condition with >${maxOperands} operands should be formatted multiline`,
+                        node: nestedGroupExceeding,
+                    });
+
+                    return;
+                }
+            }
+
+            // maxOperands or fewer operands: keep on single line
+            // BUT skip if any nested group has >maxOperands (already expanded or needs expansion)
             if (operands.length <= maxOperands) {
+                // Check if any nested parenthesized group has >maxOperands (should stay multiline)
+                const hasExpandedNestedGroup = findNestedGroupExceedingMaxOperandsHandler(test);
+                if (hasExpandedNestedGroup) {
+                    return; // Don't collapse - nested group needs multiline
+                }
+
                 // Check if all operands START on the same line
                 const firstOperandStartLine = operands[0].loc.start.line;
                 const allOperandsStartOnSameLine = operands.every(
@@ -3738,13 +4100,39 @@ const multilineIfConditions = {
                         const lineText = sourceCode.lines[node.loc.start.line - 1];
                         const parenIndent = lineText.match(/^\s*/)[0];
                         const indent = parenIndent + "    ";
+                        const nestedIndent = indent + "    ";
 
-                        const buildMultilineHandler = (n) => {
+                        // Build multiline, also expanding nested groups with >maxOperands
+                        const buildMultilineHandler = (n, currentIndent) => {
                             if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
-                                const leftText = buildMultilineHandler(n.left);
-                                const rightText = buildMultilineHandler(n.right);
+                                const leftText = buildMultilineHandler(n.left, currentIndent);
+                                const rightText = buildMultilineHandler(n.right, currentIndent);
 
-                                return `${leftText}\n${indent}${n.operator} ${rightText}`;
+                                return `${leftText}\n${currentIndent}${n.operator} ${rightText}`;
+                            }
+
+                            // Check if this is a parenthesized group with >maxOperands - expand it too
+                            if (n.type === "LogicalExpression" && isParenthesizedHandler(n)) {
+                                const innerCount = countOperandsInsideGroupHandler(n);
+                                if (innerCount > maxOperands) {
+                                    // Expand this nested group
+                                    const innerIndent = currentIndent + "    ";
+                                    const buildInnerHandler = (inner) => {
+                                        if (inner.type === "LogicalExpression" && !isParenthesizedHandler(inner)) {
+                                            const l = buildInnerHandler(inner.left);
+                                            const r = buildInnerHandler(inner.right);
+
+                                            return `${l}\n${innerIndent}${inner.operator} ${r}`;
+                                        }
+
+                                        return getSourceTextWithGroupsHandler(inner);
+                                    };
+
+                                    const innerLeft = buildInnerHandler(n.left);
+                                    const innerRight = buildInnerHandler(n.right);
+
+                                    return `(\n${innerIndent}${innerLeft}\n${innerIndent}${n.operator} ${innerRight}\n${currentIndent})`;
+                                }
                             }
 
                             return getSourceTextWithGroupsHandler(n);
@@ -3752,7 +4140,7 @@ const multilineIfConditions = {
 
                         return fixer.replaceTextRange(
                             [openParen.range[0], closeParen.range[1]],
-                            `(\n${indent}${buildMultilineHandler(test)}\n${parenIndent})`,
+                            `(\n${indent}${buildMultilineHandler(test, indent)}\n${parenIndent})`,
                         );
                     },
                     message: `If conditions with more than ${maxOperands} operands should be multiline, with each operand on its own line`,
@@ -3804,8 +4192,12 @@ const multilineIfConditions = {
                 return sourceCode.getText(n);
             };
 
-            // maxOperands or fewer operands: keep on single line (operand starts on same line)
-            if (operands.length <= maxOperands) {
+            // Check if any nested parenthesized group has >maxOperands
+            // For properties, if nested group exceeds, skip single-line formatting (let multiline handle it)
+            const nestedGroupExceeding = findNestedGroupExceedingMaxOperandsHandler(value);
+
+            // maxOperands or fewer operands AND no nested group exceeds maxOperands: keep on single line
+            if (operands.length <= maxOperands && !nestedGroupExceeding) {
                 // Check if all operands START on the same line
                 const firstOperandStartLine = operands[0].loc.start.line;
                 const allOperandsStartOnSameLine = operands.every(
@@ -3899,7 +4291,7 @@ const multilineIfConditions = {
                 properties: {
                     maxOperands: {
                         default: 3,
-                        description: "Maximum operands to keep on single line (default: 3)",
+                        description: "Maximum operands to keep on single line (default: 3). Also applies to nested groups.",
                         minimum: 1,
                         type: "integer",
                     },
@@ -3920,6 +4312,10 @@ const multilineIfConditions = {
  *   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
+ *   - Simple parenthesized nested ternaries (≤maxOperands) count as 1 operand
+ *   - Complex nested ternaries (>maxOperands) are skipped (format manually)
+ *   - Nested groups with >maxOperands are formatted multiline inline
+ *   - Groups exceeding nesting level 2 are extracted to variables
  *
  * Options:
  *   { maxOperands: 3 } - Maximum operands to keep on single line (default: 3)
@@ -3927,6 +4323,7 @@ const multilineIfConditions = {
  * ✓ Good (≤3 operands - single line):
  *   const x = a && b && c ? "yes" : "no";
  *   const url = lang === "ar" ? "/ar/path" : "/en/path";
+ *   const inputType = showToggle ? (showPwd ? "text" : "password") : type;
  *
  * ✓ Good (>3 operands - multiline):
  *   const x = variant === "ghost"
@@ -3949,6 +4346,7 @@ const ternaryConditionMultiline = {
         const sourceCode = context.sourceCode || context.getSourceCode();
         const options = context.options[0] || {};
         const maxOperands = options.maxOperands ?? 3;
+        const maxNestingLevel = 2; // Fixed at 2 - not configurable to avoid overly complex conditions
 
         // Check if node is wrapped in parentheses
         const isParenthesizedHandler = (node) => {
@@ -3995,6 +4393,157 @@ const ternaryConditionMultiline = {
             return operands;
         };
 
+        // Calculate max nesting depth of parenthesized groups in a logical expression
+        // Level 0: a && b (no groups)
+        // Level 1: (a && b) || c (one group at top)
+        // Level 2: (a && (b || c)) || d (group inside group)
+        const getNestingDepthHandler = (node, currentDepth = 0) => {
+            if (node.type !== "LogicalExpression") return currentDepth;
+
+            let maxDepth = currentDepth;
+
+            // Check left side
+            if (node.left.type === "LogicalExpression") {
+                const leftDepth = isParenthesizedHandler(node.left)
+                    ? getNestingDepthHandler(node.left, currentDepth + 1)
+                    : getNestingDepthHandler(node.left, currentDepth);
+                maxDepth = Math.max(maxDepth, leftDepth);
+            }
+
+            // Check right side
+            if (node.right.type === "LogicalExpression") {
+                const rightDepth = isParenthesizedHandler(node.right)
+                    ? getNestingDepthHandler(node.right, currentDepth + 1)
+                    : getNestingDepthHandler(node.right, currentDepth);
+                maxDepth = Math.max(maxDepth, rightDepth);
+            }
+
+            return maxDepth;
+        };
+
+        // Find the deepest nested parenthesized group that exceeds maxNestingLevel
+        const findDeepNestedGroupHandler = (node, currentDepth = 0) => {
+            if (node.type !== "LogicalExpression") return null;
+
+            let deepestGroup = null;
+
+            // Check left side
+            if (node.left.type === "LogicalExpression") {
+                const leftIsParen = isParenthesizedHandler(node.left);
+                const newDepth = leftIsParen ? currentDepth + 1 : currentDepth;
+
+                if (leftIsParen && newDepth > maxNestingLevel) {
+                    // This group exceeds max nesting
+                    deepestGroup = {
+                        node: node.left,
+                        depth: newDepth,
+                        parent: node,
+                        side: "left",
+                    };
+                }
+
+                // Recurse to find even deeper
+                const deeper = findDeepNestedGroupHandler(node.left, newDepth);
+                if (deeper && (!deepestGroup || deeper.depth > deepestGroup.depth)) {
+                    deepestGroup = deeper;
+                }
+            }
+
+            // Check right side
+            if (node.right.type === "LogicalExpression") {
+                const rightIsParen = isParenthesizedHandler(node.right);
+                const newDepth = rightIsParen ? currentDepth + 1 : currentDepth;
+
+                if (rightIsParen && newDepth > maxNestingLevel) {
+                    // This group exceeds max nesting
+                    const rightGroup = {
+                        node: node.right,
+                        depth: newDepth,
+                        parent: node,
+                        side: "right",
+                    };
+                    if (!deepestGroup || rightGroup.depth > deepestGroup.depth) {
+                        deepestGroup = rightGroup;
+                    }
+                }
+
+                // Recurse to find even deeper
+                const deeper = findDeepNestedGroupHandler(node.right, newDepth);
+                if (deeper && (!deepestGroup || deeper.depth > deepestGroup.depth)) {
+                    deepestGroup = deeper;
+                }
+            }
+
+            return deepestGroup;
+        };
+
+        // Generate descriptive variable name based on condition structure
+        const getConditionNameHandler = (n) => {
+            if (n.type === "LogicalExpression") {
+                const leftName = getConditionNameHandler(n.left);
+                const rightName = getConditionNameHandler(n.right);
+                const opName = n.operator === "&&" ? "And" : "Or";
+
+                return `${leftName}${opName}${rightName}`;
+            }
+            if (n.type === "Identifier") {
+                return n.name.charAt(0).toUpperCase() + n.name.slice(1);
+            }
+            if (n.type === "BinaryExpression" || n.type === "CallExpression" || n.type === "MemberExpression") {
+                return "Expr";
+            }
+
+            return "Cond";
+        };
+
+        // Count operands inside a group, ignoring the outer parentheses of the group itself
+        // This is used to count operands INSIDE a parenthesized group
+        const countOperandsInsideGroupHandler = (node) => {
+            if (node.type !== "LogicalExpression") return 1;
+
+            let count = 0;
+            const countHelperHandler = (n) => {
+                if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                    countHelperHandler(n.left);
+                    countHelperHandler(n.right);
+                } else {
+                    count += 1;
+                }
+            };
+
+            // Start by recursing into children directly (ignoring outer parens)
+            countHelperHandler(node.left);
+            countHelperHandler(node.right);
+
+            return count;
+        };
+
+        // Find a nested parenthesized group that has >maxOperands operands
+        // Returns the first such group found (for extraction to variable)
+        const findNestedGroupExceedingMaxOperandsHandler = (node) => {
+            if (node.type !== "LogicalExpression") return null;
+
+            // Check if this node is a parenthesized group with >maxOperands
+            if (isParenthesizedHandler(node)) {
+                const insideCount = countOperandsInsideGroupHandler(node);
+                if (insideCount > maxOperands) {
+                    return node;
+                }
+            }
+
+            // Recursively check children
+            if (node.left.type === "LogicalExpression") {
+                const found = findNestedGroupExceedingMaxOperandsHandler(node.left);
+                if (found) return found;
+            }
+            if (node.right.type === "LogicalExpression") {
+                const found = findNestedGroupExceedingMaxOperandsHandler(node.right);
+                if (found) return found;
+            }
+
+            return null;
+        };
+
         // Check if a BinaryExpression is split across lines
         const isBinaryExpressionSplitHandler = (n) => {
             if (n.type !== "BinaryExpression") return false;
@@ -4056,18 +4605,22 @@ const ternaryConditionMultiline = {
             if (test.type === "CallExpression") return true;
 
             // Logical expression with ≤maxOperands is still simple
+            // BUT if any nested group has >maxOperands, it's not simple
             if (test.type === "LogicalExpression") {
-                return collectOperandsHandler(test).length <= maxOperands;
+                const operandCount = collectOperandsHandler(test).length;
+                const nestedGroupExceeding = findNestedGroupExceedingMaxOperandsHandler(test);
+                return operandCount <= maxOperands && !nestedGroupExceeding;
             }
 
             return false;
         };
 
-        // Get the full ternary as single line text
+        // Get the full ternary as single line text (preserving parentheses around nested ternaries)
         const getTernarySingleLineHandler = (node) => {
             const testText = sourceCode.getText(node.test).replace(/\s+/g, " ").trim();
-            const consequentText = sourceCode.getText(node.consequent).replace(/\s+/g, " ").trim();
-            const alternateText = sourceCode.getText(node.alternate).replace(/\s+/g, " ").trim();
+            // Use getSourceTextWithGroupsHandler to preserve parentheses around nested expressions
+            const consequentText = getSourceTextWithGroupsHandler(node.consequent).replace(/\s+/g, " ").trim();
+            const alternateText = getSourceTextWithGroupsHandler(node.alternate).replace(/\s+/g, " ").trim();
 
             return `${testText} ? ${consequentText} : ${alternateText}`;
         };
@@ -4088,6 +4641,21 @@ const ternaryConditionMultiline = {
             return false;
         };
 
+        // Check if a nested ternary has complex condition (>maxOperands)
+        const hasComplexNestedTernaryHandler = (node) => {
+            const checkBranch = (branch) => {
+                if (branch.type === "ConditionalExpression" && isParenthesizedHandler(branch)) {
+                    const nestedOperands = collectOperandsHandler(branch.test);
+
+                    return nestedOperands.length > maxOperands;
+                }
+
+                return false;
+            };
+
+            return checkBranch(node.consequent) || checkBranch(node.alternate);
+        };
+
         // Check if ? or : is on its own line without its value
         const isOperatorOnOwnLineHandler = (node) => {
             const questionToken = sourceCode.getTokenAfter(node.test, (t) => t.value === "?");
@@ -4106,16 +4674,16 @@ const ternaryConditionMultiline = {
             return false;
         };
 
-        // Handle simple ternaries (≤maxOperands) - always collapse to single line
+        // Handle simple ternaries (≤maxOperands) - collapse or format with complex nested
         const handleSimpleTernaryHandler = (node) => {
             const isOnSingleLine = node.loc.start.line === node.loc.end.line;
             const hasOperatorOnOwnLine = isOperatorOnOwnLineHandler(node);
 
-            // Skip if already on single line and no formatting issues
-            if (isOnSingleLine && !hasOperatorOnOwnLine) return false;
+            // Skip unparenthesized nested ternaries (parenthesized ones count as 1 operand)
+            const hasUnparenthesizedNestedTernary = (node.consequent.type === "ConditionalExpression" && !isParenthesizedHandler(node.consequent))
+                || (node.alternate.type === "ConditionalExpression" && !isParenthesizedHandler(node.alternate));
 
-            // Skip nested ternaries
-            if (node.consequent.type === "ConditionalExpression" || node.alternate.type === "ConditionalExpression") {
+            if (hasUnparenthesizedNestedTernary) {
                 return false;
             }
 
@@ -4124,6 +4692,15 @@ const ternaryConditionMultiline = {
                 return false;
             }
 
+            // Skip parenthesized nested ternaries with complex condition (>maxOperands)
+            // These should be formatted manually or stay as-is
+            if (hasComplexNestedTernaryHandler(node)) {
+                return false;
+            }
+
+            // Skip if already on single line and no formatting issues
+            if (isOnSingleLine && !hasOperatorOnOwnLine) return false;
+
             // Calculate what the single line would look like
             const singleLineText = getTernarySingleLineHandler(node);
 
@@ -4145,15 +4722,159 @@ const ternaryConditionMultiline = {
             const testEndLine = test.loc.end.line;
             const isMultiLine = testStartLine !== testEndLine;
 
-            // ≤maxOperands operands: always collapse to single line (regardless of line length)
+            // Check if any nested parenthesized group has >maxOperands - format multiline inline
+            const nestedGroupExceeding = findNestedGroupExceedingMaxOperandsHandler(test);
+            if (nestedGroupExceeding) {
+                // Get indentation for formatting
+                const parent = node.parent;
+                let parenIndent = "";
+
+                if (parent && parent.loc) {
+                    const parentLineText = sourceCode.lines[parent.loc.start.line - 1];
+                    parenIndent = parentLineText.match(/^\s*/)[0];
+                }
+
+                const contentIndent = parenIndent + "    ";
+
+                // Build multiline text for operands inside a nested group
+                // isOuterGroup=true means we're at the target group itself (ignore its own parentheses)
+                // Also recursively expands any inner nested groups with >maxOperands
+                const buildNestedMultilineHandler = (n, isOuterGroup = false, currentIndent = contentIndent) => {
+                    if (n.type === "LogicalExpression" && (isOuterGroup || !isParenthesizedHandler(n))) {
+                        const leftText = buildNestedMultilineHandler(n.left, false, currentIndent);
+                        const rightText = buildNestedMultilineHandler(n.right, false, currentIndent);
+
+                        return `${leftText}\n${currentIndent}${n.operator} ${rightText}`;
+                    }
+
+                    // Check if this is a parenthesized group with >maxOperands - also expand it
+                    if (n.type === "LogicalExpression" && isParenthesizedHandler(n)) {
+                        const innerCount = countOperandsInsideGroupHandler(n);
+                        if (innerCount > maxOperands) {
+                            const innerIndent = currentIndent + "    ";
+                            const buildInner = (inner) => {
+                                if (inner.type === "LogicalExpression" && !isParenthesizedHandler(inner)) {
+                                    const l = buildInner(inner.left);
+                                    const r = buildInner(inner.right);
+
+                                    return `${l}\n${innerIndent}${inner.operator} ${r}`;
+                                }
+
+                                return getSourceTextWithGroupsHandler(inner);
+                            };
+
+                            const innerLeft = buildInner(n.left);
+                            const innerRight = buildInner(n.right);
+
+                            return `(\n${innerIndent}${innerLeft}\n${innerIndent}${n.operator} ${innerRight}\n${currentIndent})`;
+                        }
+                    }
+
+                    return getSourceTextWithGroupsHandler(n);
+                };
+
+                // Build the full condition with nested group formatted multiline
+                const buildFullConditionHandler = (n, targetNode) => {
+                    if (n === targetNode) {
+                        // This is the nested group - format it multiline
+                        // Pass true to ignore outer parentheses check
+                        const nestedText = buildNestedMultilineHandler(n, true);
+
+                        return `(\n${contentIndent}${nestedText}\n${parenIndent})`;
+                    }
+
+                    if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                        const leftText = buildFullConditionHandler(n.left, targetNode);
+                        const rightText = buildFullConditionHandler(n.right, targetNode);
+
+                        return `${leftText} ${n.operator} ${rightText}`;
+                    }
+
+                    if (n.type === "LogicalExpression" && isParenthesizedHandler(n)) {
+                        // Check if this contains the target
+                        const containsTargetHandler = (node, target) => {
+                            if (node === target) return true;
+                            if (node.type === "LogicalExpression") {
+                                return containsTargetHandler(node.left, target) || containsTargetHandler(node.right, target);
+                            }
+
+                            return false;
+                        };
+
+                        if (containsTargetHandler(n, targetNode)) {
+                            const innerText = buildFullConditionHandler(n, targetNode);
+
+                            return `(${innerText})`;
+                        }
+                    }
+
+                    return getSourceTextWithGroupsHandler(n);
+                };
+
+                // Check if already correctly formatted
+                // Collect operands INSIDE the nested group (not treating the group itself as 1 operand)
+                const collectInsideGroupHandler = (node) => {
+                    const operands = [];
+                    const collectHelper = (n) => {
+                        if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                            collectHelper(n.left);
+                            collectHelper(n.right);
+                        } else {
+                            operands.push(n);
+                        }
+                    };
+
+                    // Start from children directly, ignoring outer parentheses
+                    if (node.type === "LogicalExpression") {
+                        collectHelper(node.left);
+                        collectHelper(node.right);
+                    }
+
+                    return operands;
+                };
+
+                const nestedOperands = collectInsideGroupHandler(nestedGroupExceeding);
+                const allOnDifferentLines = nestedOperands.every((op, i) => {
+                    if (i === 0) return true;
+
+                    return op.loc.start.line !== nestedOperands[i - 1].loc.start.line;
+                });
+
+                if (!allOnDifferentLines) {
+                    const newCondition = buildFullConditionHandler(test, nestedGroupExceeding);
+
+                    // Get consequent and alternate text
+                    const consequentText = getSourceTextWithGroupsHandler(node.consequent).replace(/\s+/g, " ").trim();
+                    const alternateText = getSourceTextWithGroupsHandler(node.alternate).replace(/\s+/g, " ").trim();
+
+                    context.report({
+                        fix: (fixer) => fixer.replaceText(node, `${newCondition} ? ${consequentText} : ${alternateText}`),
+                        message: `Nested condition with >${maxOperands} operands should be formatted multiline`,
+                        node: nestedGroupExceeding,
+                    });
+
+                    return;
+                }
+            }
+
+            // ≤maxOperands operands: collapse to single line
+            // BUT skip if any nested group has >maxOperands (already expanded or needs expansion)
             if (operands.length <= maxOperands) {
+                // Check if any nested parenthesized group has >maxOperands (should stay multiline)
+                const hasExpandedNestedGroup = findNestedGroupExceedingMaxOperandsHandler(test);
+                if (hasExpandedNestedGroup) {
+                    return; // Don't collapse - nested group needs multiline
+                }
+
                 // 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";
+                // Skip unparenthesized nested ternaries (parenthesized ones count as 1 operand)
+                const hasUnparenthesizedNestedTernary = (node.consequent.type === "ConditionalExpression" && !isParenthesizedHandler(node.consequent))
+                    || (node.alternate.type === "ConditionalExpression" && !isParenthesizedHandler(node.alternate));
 
-                if (hasComplexBranches || hasNestedTernary) {
+                // Skip parenthesized nested ternaries with complex condition (>maxOperands)
+                if (hasComplexBranches || hasUnparenthesizedNestedTernary || hasComplexNestedTernaryHandler(node)) {
                     return;
                 }
 
@@ -4312,10 +5033,99 @@ const ternaryConditionMultiline = {
             }
         };
 
+        // Check if this ternary is a nested ternary inside another ternary's branch
+        const isNestedInTernaryBranchHandler = (node) => {
+            let parent = node.parent;
+
+            // Walk up through parentheses
+            while (parent && parent.type === "ParenthesizedExpression") {
+                parent = parent.parent;
+            }
+
+            // Check if parent is a ternary and this node is in consequent or alternate
+            if (parent && parent.type === "ConditionalExpression") {
+                return parent.consequent === node || parent.alternate === node
+                    || (node.parent.type === "ParenthesizedExpression"
+                        && (parent.consequent === node.parent || parent.alternate === node.parent));
+            }
+
+            return false;
+        };
+
         return {
             ConditionalExpression(node) {
                 const { test } = node;
 
+                // Skip nested ternaries that are inside another ternary's branch
+                // They will be formatted by their parent ternary
+                if (isNestedInTernaryBranchHandler(node)) {
+                    return;
+                }
+
+                // Check for excessive nesting depth in the condition
+                if (test.type === "LogicalExpression") {
+                    const nestingDepth = getNestingDepthHandler(test);
+
+                    if (nestingDepth > maxNestingLevel) {
+                        const deepGroup = findDeepNestedGroupHandler(test);
+
+                        if (deepGroup) {
+                            const groupText = getSourceTextWithGroupsHandler(deepGroup.node);
+
+                            // Generate unique variable name
+                            let varName = `is${getConditionNameHandler(deepGroup.node)}`;
+                            // Limit length and sanitize
+                            if (varName.length > 30) {
+                                varName = "isNestedCondition";
+                            }
+
+                            context.report({
+                                fix: (fixer) => {
+                                    const fixes = [];
+
+                                    // Get the line before the ternary statement for inserting the variable
+                                    // Find the statement that contains this ternary
+                                    let statementNode = node;
+                                    while (statementNode.parent && statementNode.parent.type !== "Program" && statementNode.parent.type !== "BlockStatement") {
+                                        statementNode = statementNode.parent;
+                                    }
+
+                                    const ternaryLine = statementNode.loc.start.line;
+                                    const lineStart = sourceCode.getIndexFromLoc({ line: ternaryLine, column: 0 });
+                                    const lineText = sourceCode.lines[ternaryLine - 1];
+                                    const indent = lineText.match(/^\s*/)[0];
+
+                                    // Insert variable declaration before the statement containing the ternary
+                                    fixes.push(fixer.insertTextBeforeRange(
+                                        [lineStart, lineStart],
+                                        `const ${varName} = ${groupText};\n${indent}`,
+                                    ));
+
+                                    // Replace the nested group with the variable name in the condition
+                                    // We need to replace including the parentheses around the group
+                                    const tokenBefore = sourceCode.getTokenBefore(deepGroup.node);
+                                    const tokenAfter = sourceCode.getTokenAfter(deepGroup.node);
+
+                                    if (tokenBefore && tokenAfter && tokenBefore.value === "(" && tokenAfter.value === ")") {
+                                        fixes.push(fixer.replaceTextRange(
+                                            [tokenBefore.range[0], tokenAfter.range[1]],
+                                            varName,
+                                        ));
+                                    } else {
+                                        fixes.push(fixer.replaceText(deepGroup.node, varName));
+                                    }
+
+                                    return fixes;
+                                },
+                                message: `Ternary condition nesting depth (${nestingDepth}) exceeds maximum (${maxNestingLevel}). Extract deeply nested condition to a variable.`,
+                                node: deepGroup.node,
+                            });
+
+                            return; // Don't process other rules for this statement
+                        }
+                    }
+                }
+
                 // First, try to collapse simple ternaries to single line
                 if (isSimpleConditionHandler(test)) {
                     if (handleSimpleTernaryHandler(node)) return;
@@ -4337,7 +5147,7 @@ const ternaryConditionMultiline = {
                 properties: {
                     maxOperands: {
                         default: 3,
-                        description: "Maximum condition operands to keep ternary on single line (default: 3). Ternaries with more operands are formatted multiline.",
+                        description: "Maximum condition operands to keep ternary on single line (default: 3). Also applies to nested groups.",
                         minimum: 1,
                         type: "integer",
                     },
@@ -4495,6 +5305,40 @@ const classNamingConvention = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
+        // Store classes that need renaming and their references
+        const classesToRename = new Map();
+
+        // Collect all Identifier nodes that might be class references
+        const collectReferencesHandler = (programNode, className) => {
+            const references = [];
+
+            const visitHandler = (node) => {
+                if (!node || typeof node !== "object") return;
+
+                // Found a matching Identifier
+                if (node.type === "Identifier" && node.name === className) {
+                    references.push(node);
+                }
+
+                // Recursively visit children
+                for (const key in node) {
+                    if (key === "parent" || key === "range" || key === "loc") continue;
+
+                    const child = node[key];
+
+                    if (Array.isArray(child)) {
+                        child.forEach((c) => visitHandler(c));
+                    } else if (child && typeof child === "object" && child.type) {
+                        visitHandler(child);
+                    }
+                }
+            };
+
+            visitHandler(programNode);
+
+            return references;
+        };
+
         return {
             ClassDeclaration(node) {
                 if (!node.id || !node.id.name) return;
@@ -4502,31 +5346,33 @@ const classNamingConvention = {
                 const className = node.id.name;
 
                 if (!className.endsWith("Class")) {
+                    classesToRename.set(className, {
+                        classIdNode: node.id,
+                        newName: `${className}Class`,
+                    });
+                }
+            },
+
+            "Program:exit"(programNode) {
+                // Process all classes that need renaming
+                classesToRename.forEach(({ classIdNode, newName }, className) => {
+                    // Find all references to this class in the entire program
+                    const allReferences = collectReferencesHandler(programNode, className);
+
                     context.report({
                         fix: (fixer) => {
-                            const newName = `${className}Class`;
-
-                            // Find all references to this class and rename them
-                            const scope = context.sourceCode.getScope
-                                ? context.sourceCode.getScope(node)
-                                : context.getScope();
-                            const variable = scope.set.get(className);
-                            const fixes = [fixer.replaceText(node.id, newName)];
+                            const fixes = [];
 
-                            if (variable && variable.references) {
-                                variable.references.forEach((ref) => {
-                                    if (ref.identifier !== node.id) {
-                                        fixes.push(fixer.replaceText(ref.identifier, newName));
-                                    }
-                                });
-                            }
+                            allReferences.forEach((ref) => {
+                                fixes.push(fixer.replaceText(ref, newName));
+                            });
 
                             return fixes;
                         },
                         message: `Class name "${className}" should end with "Class" suffix`,
-                        node: node.id,
+                        node: classIdNode,
                     });
-                }
+                });
             },
         };
     },
@@ -11889,6 +12735,7 @@ const openingBracketsSameLine = {
 
                 // Check if a condition expression is split incorrectly across lines
                 // (operator and operands should be on the same line)
+                // BUT skip if it's intentionally formatted multiline (operator at start of line pattern)
                 const checkConditionSplitHandler = (conditionNode) => {
                     // Handle LogicalExpression (&&, ||) and BinaryExpression (===, !==, etc.)
                     if (conditionNode.type !== "LogicalExpression" && conditionNode.type !== "BinaryExpression") {
@@ -11899,19 +12746,31 @@ const openingBracketsSameLine = {
 
                     // Check if this expression spans multiple lines
                     if (conditionNode.loc.start.line !== conditionNode.loc.end.line) {
-                        // For BinaryExpression, always collapse if split
-                        // For LogicalExpression, check if operator is on different line
+                        // Check if this is intentionally formatted multiline
+                        // (pattern: operator at start of line, e.g., multiline-if-conditions format)
                         const condOperator = sourceCode.getTokenAfter(
                             left,
                             (t) => ["&&", "||", "===", "!==", "==", "!=", ">", "<", ">=", "<="].includes(t.value),
                         );
 
                         if (condOperator) {
+                            // Check for intentional multiline format: operator at start of line with proper indentation
+                            // This pattern indicates multiline-if-conditions has formatted it this way
+                            const textBetween = sourceCode.text.slice(left.range[1], condOperator.range[0]);
+                            const hasNewlineBeforeOperator = textBetween.includes("\n");
+                            const operatorIsAtLineStart = hasNewlineBeforeOperator
+                                && /\n\s*$/.test(textBetween);
+
+                            // Skip collapsing if operator is intentionally at the start of a line
+                            if (operatorIsAtLineStart) {
+                                return false;
+                            }
+
                             const leftEndLine = left.loc.end.line;
                             const operatorLine = condOperator.loc.start.line;
                             const rightStartLine = right.loc.start.line;
 
-                            // Bad: operator or operands on different lines
+                            // Bad: operator or operands on different lines (not intentional format)
                             if (leftEndLine !== operatorLine || operatorLine !== rightStartLine) {
                                 const tokenBefore = sourceCode.getTokenBefore(conditionNode);
                                 const tokenAfter = sourceCode.getTokenAfter(conditionNode);
@@ -12282,6 +13141,9 @@ const openingBracketsSameLine = {
             // Skip if this is the test of an IfStatement - those are handled by multiline-if-conditions
             if (node.parent && node.parent.type === "IfStatement" && node.parent.test === node) return;
 
+            // Skip if this is the test of a ConditionalExpression (ternary) - those are handled by ternary-condition-multiline
+            if (node.parent && node.parent.type === "ConditionalExpression" && node.parent.test === node) return;
+
             // Check if operands are valid for same-line formatting
             const isValidOperand = (n) => n.type === "CallExpression"
                 || n.type === "LogicalExpression"
@@ -12319,6 +13181,14 @@ const openingBracketsSameLine = {
                 // Correct: ) || canDoHandler(  (all on same line)
                 // Wrong: ) ||\n    canDoHandler(  or  )\n    || canDoHandler(
                 if (leftEndLine !== operatorLine || operatorLine !== rightStartLine) {
+                    // Check for intentional multiline format (operator at start of line)
+                    // This indicates multiline-if-conditions or ternary-condition-multiline has formatted it this way
+                    const textBetween = sourceCode.text.slice(left.range[1], operatorToken.range[0]);
+                    const operatorIsAtLineStart = textBetween.includes("\n") && /\n\s*$/.test(textBetween);
+
+                    // Skip if intentionally formatted with operator at start of line
+                    if (operatorIsAtLineStart) return;
+
                     // Get the end of left operand (might end with closing paren)
                     const leftEndToken = sourceCode.getLastToken(left);