eslint-plugin-code-style 1.9.7 → 1.10.1

package/CHANGELOG.md

@@ -7,6 +7,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.10.1] - 2026-02-03
+
+**Bug Fix: logical-expression-multiline rule improvements**
+
+**Version Range:** v1.10.0 → v1.10.1
+
+### Fixed
+
+- **`logical-expression-multiline`** - Add collapse to single line for simple expressions (≤3 operands)
+- **`logical-expression-multiline`** - Skip collapsing when any operand is multiline (e.g., JSX elements)
+
+**Full Changelog:** [v1.10.0...v1.10.1](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.10.0...v1.10.1)
+
+---
+
+## [1.10.0] - 2026-02-03
+
+**New Rule: logical-expression-multiline + Enhanced no-hardcoded-strings**
+
+**Version Range:** v1.9.1 → v1.10.0
+
+### Added
+
+**New Rules (1)**
+
+- **`logical-expression-multiline`** - Enforce multiline formatting for logical expressions with more than maxOperands (default: 3) 🔧
+  - Handles variable declarations: `const err = a || b || c || d || e;`
+  - Handles return statements, assignments, and other contexts
+  - Skips if/ternary conditions (handled by other rules)
+  - Auto-fixes to put each operand on its own line with operator at start
+
+### Enhanced
+
+- **`no-hardcoded-strings`** - Major improvements:
+  - Remove single-word string length limitations (now detects all single-word hardcoded strings)
+  - Add validation strings: `empty`, `invalid`, `missing`, `optional`, `required`, `valid`
+  - Add auth state strings: `anonymous`, `authenticated`, `authed`, `authorized`, `denied`, `forbidden`, etc.
+  - Add more status strings: `done`, `finished`, `inprogress`, `queued`, `ready`, `running`, etc.
+  - Skip UI component patterns in JSX attributes: `variant="ghost"`, `size="md"`, etc.
+  - Skip Tailwind CSS class strings: `"px-5 py-3 w-full"`, `"hover:bg-primary"`, etc.
+  - Make technical patterns stricter to avoid false negatives
+
+### Fixed
+
+- **`no-hardcoded-strings`** - Fix detection of strings inside exported components
+- **`no-hardcoded-strings`** - Fix Tailwind detection being too broad (now requires actual Tailwind syntax)
+
+### Stats
+
+- Total Rules: 72 (was 71)
+- Auto-fixable: 65 rules 🔧 (was 64)
+- Report-only: 7 rules
+
+**Full Changelog:** [v1.9.1...v1.10.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.1...v1.10.0)
+
+---
+
 ## [1.9.7] - 2026-02-03
 
 ### Fixed
@@ -1337,6 +1394,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.10.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.10.0...v1.10.1
+[1.10.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.7...v1.10.0
 [1.9.7]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.6...v1.9.7
 [1.9.6]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.5...v1.9.6
 [1.9.5]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.4...v1.9.5

package/index.d.ts

@@ -50,6 +50,7 @@ export type RuleNames =
     | "code-style/jsx-simple-element-one-line"
     | "code-style/jsx-string-value-trim"
     | "code-style/jsx-ternary-format"
+    | "code-style/logical-expression-multiline"
     | "code-style/member-expression-bracket-spacing"
     | "code-style/module-index-exports"
     | "code-style/multiline-if-conditions"
@@ -143,6 +144,7 @@ interface PluginRules {
     "jsx-simple-element-one-line": Rule.RuleModule;
     "jsx-string-value-trim": Rule.RuleModule;
     "jsx-ternary-format": Rule.RuleModule;
+    "logical-expression-multiline": Rule.RuleModule;
     "member-expression-bracket-spacing": Rule.RuleModule;
     "module-index-exports": Rule.RuleModule;
     "multiline-if-conditions": Rule.RuleModule;

package/index.js

@@ -5208,6 +5208,205 @@ const ternaryConditionMultiline = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Logical Expression Multiline
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforce multiline formatting for logical expressions with more
+ *   than maxOperands. This applies to variable declarations, return
+ *   statements, assignment expressions, and other contexts.
+ *
+ * Options:
+ *   { maxOperands: 3 } - Maximum operands on single line (default: 3)
+ *
+ * ✓ Good:
+ *   const err = data.error
+ *       || data.message
+ *       || data.status
+ *       || data.fallback;
+ *
+ * ✗ Bad:
+ *   const err = data.error || data.message || data.status || data.fallback;
+ */
+const logicalExpressionMultiline = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const options = context.options[0] || {};
+        const maxOperands = options.maxOperands !== undefined ? options.maxOperands : 3;
+
+        // Check if node is wrapped in parentheses
+        const isParenthesizedHandler = (node) => {
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            const tokenAfter = sourceCode.getTokenAfter(node);
+
+            if (!tokenBefore || !tokenAfter) return false;
+
+            return tokenBefore.value === "(" && tokenAfter.value === ")";
+        };
+
+        // Collect all operands from a logical expression (flattening non-parenthesized ones)
+        const collectOperandsHandler = (node) => {
+            const operands = [];
+
+            const collectHelperHandler = (n) => {
+                if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                    collectHelperHandler(n.left);
+                    collectHelperHandler(n.right);
+                } else {
+                    operands.push(n);
+                }
+            };
+
+            collectHelperHandler(node);
+
+            return operands;
+        };
+
+        // Get the operator between two operands
+        const getOperatorHandler = (leftNode, rightNode) => {
+            const tokens = sourceCode.getTokensBetween(leftNode, rightNode);
+            const opToken = tokens.find((t) => t.value === "||" || t.value === "&&" || t.value === "??" || t.value === "|" || t.value === "&");
+
+            return opToken ? opToken.value : "||";
+        };
+
+        // Check if the expression is already multiline
+        const isMultilineHandler = (node) => node.loc.start.line !== node.loc.end.line;
+
+        // Check if we're inside an if condition or ternary test (handled by other rules)
+        const isInIfOrTernaryHandler = (node) => {
+            let current = node.parent;
+
+            while (current) {
+                if (current.type === "IfStatement" && current.test === node) return true;
+
+                if (current.type === "ConditionalExpression" && current.test === node) return true;
+
+                // Stop if we hit a statement or declaration boundary
+                if (current.type.includes("Statement") || current.type.includes("Declaration")) return false;
+
+                current = current.parent;
+            }
+
+            return false;
+        };
+
+        // Handle logical expression
+        const checkLogicalExpressionHandler = (node) => {
+            // Only process top-level logical expressions (not nested ones)
+            if (node.parent.type === "LogicalExpression" && !isParenthesizedHandler(node)) return;
+
+            // Skip if this is in an if condition or ternary test (handled by other rules)
+            if (isInIfOrTernaryHandler(node)) return;
+
+            // Collect all operands
+            const operands = collectOperandsHandler(node);
+
+            // Case 1: Simple expression (≤maxOperands) that's multiline → collapse to single line
+            if (operands.length <= maxOperands) {
+                if (isMultilineHandler(node)) {
+                    // Skip if any operand is itself multiline (e.g., JSX elements, function calls)
+                    const hasMultilineOperand = operands.some((op) => op.loc.start.line !== op.loc.end.line);
+
+                    if (hasMultilineOperand) return;
+
+                    context.report({
+                        fix(fixer) {
+                            // Build single line: operand1 op operand2 op operand3
+                            const parts = [sourceCode.getText(operands[0])];
+
+                            for (let i = 1; i < operands.length; i++) {
+                                const operator = getOperatorHandler(operands[i - 1], operands[i]);
+                                parts.push(` ${operator} ${sourceCode.getText(operands[i])}`);
+                            }
+
+                            return fixer.replaceText(node, parts.join(""));
+                        },
+                        message: `Logical expression with ${operands.length} operands should be on a single line (max for multiline: ${maxOperands})`,
+                        node,
+                    });
+                }
+
+                return;
+            }
+
+            // Case 2: Complex expression (>maxOperands) → enforce multiline
+            // Check if already properly multiline
+            if (isMultilineHandler(node)) {
+                // Check if each operand is on its own line
+                let allOnOwnLines = true;
+
+                for (let i = 1; i < operands.length; i++) {
+                    if (operands[i].loc.start.line === operands[i - 1].loc.end.line) {
+                        allOnOwnLines = false;
+                        break;
+                    }
+                }
+
+                if (allOnOwnLines) return;
+            }
+
+            // Report and fix
+            context.report({
+                fix(fixer) {
+                    // Build the formatted expression
+                    const firstOperandText = sourceCode.getText(operands[0]);
+
+                    // Get the line containing the first operand
+                    const firstToken = sourceCode.getFirstToken(operands[0]);
+                    const lineStart = sourceCode.text.lastIndexOf("\n", firstToken.range[0]) + 1;
+                    const lineContent = sourceCode.text.slice(lineStart, firstToken.range[0]);
+
+                    // Extract only the whitespace indentation from the line
+                    const indentMatch = lineContent.match(/^(\s*)/);
+                    const baseIndent = indentMatch ? indentMatch[1] : "";
+
+                    // Build each line: first operand, then operator + operand for each subsequent
+                    const lines = [firstOperandText];
+
+                    for (let i = 1; i < operands.length; i++) {
+                        const operator = getOperatorHandler(operands[i - 1], operands[i]);
+                        const operandText = sourceCode.getText(operands[i]);
+                        lines.push(`${baseIndent}    ${operator} ${operandText}`);
+                    }
+
+                    // Get the full range of the expression
+                    const fullText = lines.join("\n");
+
+                    return fixer.replaceText(node, fullText);
+                },
+                message: `Logical expression with ${operands.length} operands should be on multiple lines (max: ${maxOperands})`,
+                node,
+            });
+        };
+
+        return {
+            LogicalExpression: checkLogicalExpressionHandler,
+        };
+    },
+    meta: {
+        docs: { description: "Enforce single line for ≤maxOperands, multiline for >maxOperands logical expressions" },
+        fixable: "code",
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    maxOperands: {
+                        default: 3,
+                        description: "Maximum operands to keep on single line (default: 3)",
+                        minimum: 1,
+                        type: "integer",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "layout",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: Empty Line After Block
@@ -19918,6 +20117,7 @@ export default {
         "empty-line-after-block": emptyLineAfterBlock,
         "if-else-spacing": ifElseSpacing,
         "if-statement-format": ifStatementFormat,
+        "logical-expression-multiline": logicalExpressionMultiline,
         "multiline-if-conditions": multilineIfConditions,
         "no-empty-lines-in-switch-cases": noEmptyLinesInSwitchCases,
         "ternary-condition-multiline": ternaryConditionMultiline,

package/package.json

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