eslint-plugin-code-style 1.6.6 → 1.7.1

package/CHANGELOG.md

@@ -7,6 +7,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.7.1] - 2026-02-02
+
+### Fixed
+
+- **`no-empty-lines-in-function-params`** - Detect empty lines between destructured properties inside ObjectPattern params
+- **`component-props-inline-type`** - Handle TSIntersectionType (e.g., `ButtonHTMLAttributes & { prop: Type }`): check `&` position, opening brace position, and apply formatting rules to type literals within intersections
+- **`enum-type-enforcement`** - Fix argument passed to extractTypeInfoHandler for TSPropertySignature members (was passing `member`, now correctly passes `member.typeAnnotation`)
+- **`ternary-condition-multiline`** - Improve simple ternary prefix calculation to use actual declaration text instead of column positions; add check for `?` on same line as multiline condition end
+
+---
+
+## [1.7.0] - 2026-02-02
+
+**New Rules for Blocks, Classes & Enum Enforcement + Multiple Enhancements**
+
+**Version Range:** v1.6.1 → v1.7.0
+
+### Added
+
+**New Rules (3)**
+- `empty-line-after-block` - Require empty line between closing `}` of block statement and next statement 🔧
+- `class-naming-convention` - Enforce class declarations end with "Class" suffix 🔧
+- `enum-type-enforcement` - Enforce using enum values instead of string literals for typed variables (e.g., `ButtonVariantEnum.PRIMARY` instead of `"primary"`) 🔧
+
+### Enhanced
+
+- **`ternary-condition-multiline`** - Now also collapses simple ternaries to single line when they fit within max line length (default: 120 chars). Added `maxLineLength` option.
+- **`function-object-destructure`** - Add auto-fix (replaces destructured usages with dot notation), expand module paths (services, constants, config, api, utils, helpers, lib, apis, configs, utilities, routes)
+- **`function-params-per-line`** - Handle callbacks with mixed params (destructured + simple like `({ item }, index)`)
+- **`array-callback-destructure`** - Fix closing brace on same line as last property
+- **`simple-call-single-line`** - Skip callbacks with 2+ params to avoid conflicts
+- **`jsx-simple-element-one-line`**, **`jsx-children-on-new-line`**, **`jsx-element-child-new-line`** - Treat simple function calls (0-1 args) as simple expressions
+
+### Fixed
+
+- **`component-props-destructure`** - Detect body destructuring patterns even without type annotations, add auto-fix for body destructuring, preserve TypeScript type annotation when auto-fixing
+
+### Stats
+
+- Total Rules: 69 (was 66)
+- Auto-fixable: 63 rules 🔧
+- Report-only: 6 rules
+
+**Full Changelog:** [v1.6.1...v1.7.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.1...v1.7.0)
+
+---
+
 ## [1.6.6] - 2026-02-01
 
 ### Fixed
@@ -1028,6 +1075,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[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
+[1.6.6]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.5...v1.6.6
 [1.6.5]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.4...v1.6.5
 [1.6.4]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.3...v1.6.4
 [1.6.3]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.2...v1.6.3

package/README.md

@@ -19,7 +19,7 @@
 
 **A powerful ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects.**
 
-*66 rules (60 auto-fixable) to keep your codebase clean and consistent*
+*69 rules (63 auto-fixable) to keep your codebase clean and consistent*
 
 </div>
 
@@ -27,7 +27,7 @@
 
 ## 🎯 Why This Plugin?
 
-This plugin provides **66 custom rules** (60 auto-fixable) for code formatting. Built for **ESLint v9 flat configs**.
+This plugin provides **69 custom rules** (63 auto-fixable) for code formatting. Built for **ESLint v9 flat configs**.
 
 > **Note:** ESLint [deprecated 79 formatting rules](https://eslint.org/blog/2023/10/deprecating-formatting-rules/) in v8.53.0. Our recommended configs use `@stylistic/eslint-plugin` as the replacement for these deprecated rules.
 
@@ -36,7 +36,7 @@ This plugin provides **66 custom rules** (60 auto-fixable) for code formatting.
 - **Works alongside existing tools** — Complements ESLint's built-in rules and packages like eslint-plugin-react, eslint-plugin-import, etc
 - **Self-sufficient rules** — Each rule handles complete formatting independently
 - **Consistency at scale** — Reduces code-style differences between team members by enforcing uniform formatting across your projects
-- **Highly automated** — 60 of 66 rules support auto-fix with `eslint --fix`
+- **Highly automated** — 63 of 69 rules support auto-fix with `eslint --fix`
 
 When combined with ESLint's native rules and other popular plugins, this package helps create a complete code style solution that keeps your codebase clean and consistent.
 
@@ -60,7 +60,7 @@ We provide **ready-to-use ESLint flat configuration files** that combine `eslint
 
 ### 💡 Why Use These Configs?
 
-- **Complete Coverage** — Combines ESLint built-in rules, third-party plugins, and all 64 code-style rules
+- **Complete Coverage** — Combines ESLint built-in rules, third-party plugins, and all 69 code-style rules
 - **Ready-to-Use** — Copy the config file and start linting immediately
 - **Battle-Tested** — These configurations have been refined through real-world usage
 - **Fully Documented** — Each config includes detailed instructions and explanations
@@ -97,7 +97,7 @@ We provide **ready-to-use ESLint flat configuration files** that combine `eslint
 <td width="50%">
 
 ### 🔧 Auto-Fixable Rules
-**60 rules** support automatic fixing with `eslint --fix`. 6 rules are report-only (require manual changes).
+**63 rules** support automatic fixing with `eslint --fix`. 6 rules are report-only (require manual changes).
 
 </td>
 <td width="50%">
@@ -252,7 +252,7 @@ rules: {
 
 ## 📖 Rules Categories
 
-> **66 rules total** — 60 with auto-fix 🔧, 6 report-only. See detailed examples in [Rules Reference](#-rules-reference) below.
+> **69 rules total** — 63 with auto-fix 🔧, 6 report-only. See detailed examples in [Rules Reference](#-rules-reference) below.
 >
 > **Legend:** 🔧 Auto-fixable with `eslint --fix` • ⚙️ Customizable options
 
@@ -279,13 +279,16 @@ rules: {
 | **Component Rules** | |
 | `component-props-destructure` | Component props must be destructured `({ prop })` not received as `(props)` 🔧 |
 | `component-props-inline-type` | Inline type annotation `} : {` with matching props, proper spacing, commas, no interface reference 🔧 |
+| **Class Rules** | |
+| `class-naming-convention` | Class declarations must end with "Class" suffix (e.g., `ApiServiceClass`) 🔧 |
 | **Control Flow Rules** | |
 | `block-statement-newlines` | Newline after `{` and before `}` in if/for/while/function blocks 🔧 |
+| `empty-line-after-block` | Empty line required between closing `}` of block and next statement 🔧 |
 | `if-else-spacing` | Empty line between consecutive if blocks, no empty line between single-line if/else 🔧 |
 | `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` | Ternary conditions exceeding threshold get one operand per line (default: >3) 🔧 ⚙️ |
+| `ternary-condition-multiline` | Collapse simple ternaries to single line; expand complex conditions (>3 operands) to multiline 🔧 ⚙️ |
 | **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 🔧 |
@@ -330,6 +333,7 @@ rules: {
 | `member-expression-bracket-spacing` | No spaces inside brackets in computed member expressions: `arr[0]` not `arr[ 0 ]` 🔧 |
 | **TypeScript Rules** | |
 | `enum-format` | Enforce enum naming (PascalCase + Enum suffix), UPPER_CASE members, no empty lines, and trailing commas 🔧 |
+| `enum-type-enforcement` | Enforce using enum values instead of string literals for variables typed with `*Type` (e.g., use `ButtonVariantEnum.PRIMARY` not `"primary"`) 🔧 |
 | `interface-format` | Enforce interface naming (PascalCase + Interface suffix), camelCase properties, no empty lines, and trailing commas 🔧 |
 | `no-inline-type-definitions` | Inline union types in function params should be extracted to named types ⚙️ |
 | `type-annotation-spacing` | Enforce consistent spacing in type annotations: no space before colon/generic/array brackets, one space after colon 🔧 |
@@ -3066,7 +3070,7 @@ const UseAuth = () => {};          // hooks should be camelCase
 
 ## 🔧 Auto-fixing
 
-60 of 66 rules support auto-fixing. Run ESLint with the `--fix` flag:
+63 of 69 rules support auto-fixing. Run ESLint with the `--fix` flag:
 
 ```bash
 # Fix all files in src directory

package/index.d.ts

@@ -13,11 +13,14 @@ export type RuleNames =
     | "code-style/arrow-function-simplify"
     | "code-style/assignment-value-same-line"
     | "code-style/block-statement-newlines"
+    | "code-style/class-naming-convention"
     | "code-style/comment-format"
     | "code-style/component-props-destructure"
     | "code-style/react-code-order"
     | "code-style/component-props-inline-type"
     | "code-style/curried-arrow-same-line"
+    | "code-style/empty-line-after-block"
+    | "code-style/enum-type-enforcement"
     | "code-style/export-format"
     | "code-style/function-arguments-format"
     | "code-style/function-call-spacing"
@@ -101,11 +104,14 @@ interface PluginRules {
     "arrow-function-simplify": Rule.RuleModule;
     "assignment-value-same-line": Rule.RuleModule;
     "block-statement-newlines": Rule.RuleModule;
+    "class-naming-convention": Rule.RuleModule;
     "comment-format": Rule.RuleModule;
     "component-props-destructure": Rule.RuleModule;
     "react-code-order": Rule.RuleModule;
     "component-props-inline-type": Rule.RuleModule;
     "curried-arrow-same-line": Rule.RuleModule;
+    "empty-line-after-block": Rule.RuleModule;
+    "enum-type-enforcement": Rule.RuleModule;
     "export-format": Rule.RuleModule;
     "function-arguments-format": Rule.RuleModule;
     "function-call-spacing": Rule.RuleModule;

package/index.js

@@ -3890,6 +3890,7 @@ 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) => {
@@ -3984,115 +3985,240 @@ const ternaryConditionMultiline = {
             return false;
         };
 
-        return {
-            ConditionalExpression(node) {
-                const { test } = node;
+        // Check if the test is a simple condition (not a complex logical expression)
+        const isSimpleConditionHandler = (test) => {
+            if (test.type === "Identifier") return true;
 
-                // Only handle ternaries with logical expression conditions
-                if (test.type !== "LogicalExpression") return;
+            if (test.type === "MemberExpression") return true;
 
-                const operands = collectOperandsHandler(test);
-                const testStartLine = test.loc.start.line;
-                const testEndLine = test.loc.end.line;
-                const isMultiLine = testStartLine !== testEndLine;
+            if (test.type === "UnaryExpression") return true;
 
-                // ≤maxOperands operands: keep on single line
-                if (operands.length <= maxOperands) {
-                    const firstOperandStartLine = operands[0].loc.start.line;
-                    const allOperandsStartOnSameLine = operands.every(
-                        (op) => op.loc.start.line === firstOperandStartLine,
-                    );
+            if (test.type === "BinaryExpression") return true;
 
-                    const hasSplitBinaryExpression = operands.some(
-                        (op) => isBinaryExpressionSplitHandler(op),
-                    );
+            if (test.type === "CallExpression") return true;
 
-                    if (!allOperandsStartOnSameLine || hasSplitBinaryExpression) {
-                        context.report({
-                            fix: (fixer) => {
-                                const buildSameLineHandler = (n) => {
-                                    if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
-                                        const leftText = buildSameLineHandler(n.left);
-                                        const rightText = buildSameLineHandler(n.right);
+            // Logical expression with ≤maxOperands is still simple
+            if (test.type === "LogicalExpression") {
+                return collectOperandsHandler(test).length <= maxOperands;
+            }
 
-                                        return `${leftText} ${n.operator} ${rightText}`;
-                                    }
+            return false;
+        };
 
-                                    if (n.type === "BinaryExpression" && isBinaryExpressionSplitHandler(n)) {
-                                        return buildBinaryExpressionSingleLineHandler(n);
-                                    }
+        // Get the full ternary as single line text
+        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();
 
-                                    return getSourceTextWithGroupsHandler(n);
-                                };
+            return `${testText} ? ${consequentText} : ${alternateText}`;
+        };
 
-                                return fixer.replaceText(test, buildSameLineHandler(test));
-                            },
-                            message: `Ternary conditions with ≤${maxOperands} operands should be single line`,
-                            node: test,
-                        });
-                    }
+        // Get the indentation level for the line
+        const getLineIndentHandler = (node) => {
+            const lineText = sourceCode.lines[node.loc.start.line - 1];
 
-                    return;
-                }
+            return lineText.match(/^\s*/)[0].length;
+        };
 
-                // More than maxOperands: each on its own line
-                let isCorrectionNeeded = !isMultiLine;
+        // Check if branches have complex objects (should stay multiline)
+        const hasComplexObjectHandler = (n) => {
+            if (n.type === "ObjectExpression" && n.properties.length >= 2) return true;
 
-                if (isMultiLine) {
-                    for (let i = 0; i < operands.length - 1; i += 1) {
-                        if (operands[i].loc.end.line === operands[i + 1].loc.start.line) {
-                            isCorrectionNeeded = true;
-                            break;
-                        }
-                    }
+            if (n.type === "ArrayExpression" && n.elements.length >= 3) return true;
 
-                    // Check if any operator is at end of line (should be at beginning)
-                    if (!isCorrectionNeeded && hasOperatorAtEndOfLineHandler(test)) {
-                        isCorrectionNeeded = true;
-                    }
-                }
+            return false;
+        };
+
+        // Handle simple ternaries - collapse to single line if they fit
+        const handleSimpleTernaryHandler = (node) => {
+            // Skip if already on single line
+            if (node.loc.start.line === node.loc.end.line) return false;
+
+            // Skip nested ternaries
+            if (node.consequent.type === "ConditionalExpression" || node.alternate.type === "ConditionalExpression") {
+                return false;
+            }
+
+            // Skip if branches have complex objects
+            if (hasComplexObjectHandler(node.consequent) || hasComplexObjectHandler(node.alternate)) {
+                return false;
+            }
+
+            // 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 = ")
+            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 + " = "
+            }
+
+            // Check if single line would fit
+            const totalLength = indent + prefixLength + singleLineText.length + 1;
 
-                if (isCorrectionNeeded) {
+            if (totalLength <= maxLineLength) {
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, singleLineText),
+                    message: "Simple ternary should be on a single line",
+                    node,
+                });
+
+                return true;
+            }
+
+            return false;
+        };
+
+        // Handle complex logical expressions - format multiline
+        const handleComplexLogicalTernaryHandler = (node) => {
+            const { test } = node;
+            const operands = collectOperandsHandler(test);
+            const testStartLine = test.loc.start.line;
+            const testEndLine = test.loc.end.line;
+            const isMultiLine = testStartLine !== testEndLine;
+
+            // ≤maxOperands operands: keep condition on single line
+            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),
+                );
+
+                if (!allOperandsStartOnSameLine || hasSplitBinaryExpression) {
                     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];
-                            const conditionIndent = baseIndent + "    ";
-                            const branchIndent = baseIndent + "        ";
-
-                            const buildMultilineHandler = (n) => {
+                            const buildSameLineHandler = (n) => {
                                 if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
-                                    const leftText = buildMultilineHandler(n.left);
-                                    const rightText = buildMultilineHandler(n.right);
+                                    const leftText = buildSameLineHandler(n.left);
+                                    const rightText = buildSameLineHandler(n.right);
 
-                                    return `${leftText}\n${conditionIndent}${n.operator} ${rightText}`;
+                                    return `${leftText} ${n.operator} ${rightText}`;
+                                }
+
+                                if (n.type === "BinaryExpression" && isBinaryExpressionSplitHandler(n)) {
+                                    return buildBinaryExpressionSingleLineHandler(n);
                                 }
 
                                 return getSourceTextWithGroupsHandler(n);
                             };
 
-                            const consequentText = sourceCode.getText(node.consequent);
-                            const alternateText = sourceCode.getText(node.alternate);
-
-                            const newText = `\n${conditionIndent}${buildMultilineHandler(test)}\n${branchIndent}? ${consequentText}\n${branchIndent}: ${alternateText}`;
-
-                            return fixer.replaceText(node, newText);
+                            return fixer.replaceText(test, buildSameLineHandler(test));
                         },
-                        message: `Ternary conditions with more than ${maxOperands} operands should be multiline, with each operand on its own line`,
+                        message: `Ternary conditions with ≤${maxOperands} operands should be single line`,
                         node: test,
                     });
                 }
+
+                return;
+            }
+
+            // More than maxOperands: each on its own line
+            let isCorrectionNeeded = !isMultiLine;
+
+            if (isMultiLine) {
+                for (let i = 0; i < operands.length - 1; i += 1) {
+                    if (operands[i].loc.end.line === operands[i + 1].loc.start.line) {
+                        isCorrectionNeeded = true;
+                        break;
+                    }
+                }
+
+                // Check if any operator is at end of line (should be at beginning)
+                if (!isCorrectionNeeded && hasOperatorAtEndOfLineHandler(test)) {
+                    isCorrectionNeeded = true;
+                }
+
+                // Check if ? is on same line as end of multiline condition (BAD - should be on its own line)
+                if (!isCorrectionNeeded) {
+                    const questionToken = sourceCode.getTokenAfter(test, (t) => t.value === "?");
+
+                    if (questionToken && questionToken.loc.start.line === test.loc.end.line) {
+                        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];
+                        const conditionIndent = baseIndent + "    ";
+                        const branchIndent = baseIndent + "        ";
+
+                        const buildMultilineHandler = (n) => {
+                            if (n.type === "LogicalExpression" && !isParenthesizedHandler(n)) {
+                                const leftText = buildMultilineHandler(n.left);
+                                const rightText = buildMultilineHandler(n.right);
+
+                                return `${leftText}\n${conditionIndent}${n.operator} ${rightText}`;
+                            }
+
+                            return getSourceTextWithGroupsHandler(n);
+                        };
+
+                        const consequentText = sourceCode.getText(node.consequent);
+                        const alternateText = sourceCode.getText(node.alternate);
+
+                        const newText = `\n${conditionIndent}${buildMultilineHandler(test)}\n${branchIndent}? ${consequentText}\n${branchIndent}: ${alternateText}`;
+
+                        return fixer.replaceText(node, newText);
+                    },
+                    message: `Ternary conditions with more than ${maxOperands} operands should be multiline, with each operand on its own line`,
+                    node: test,
+                });
+            }
+        };
+
+        return {
+            ConditionalExpression(node) {
+                const { test } = node;
+
+                // First, try to collapse simple ternaries to single line
+                if (isSimpleConditionHandler(test)) {
+                    if (handleSimpleTernaryHandler(node)) return;
+                }
+
+                // For complex logical expressions, handle multiline formatting
+                if (test.type === "LogicalExpression") {
+                    handleComplexLogicalTernaryHandler(node);
+                }
             },
         };
     },
     meta: {
-        docs: { description: "Enforce multiline formatting for ternary expressions with complex conditions" },
+        docs: { description: "Enforce consistent ternary formatting: collapse simple ternaries to single line, expand complex conditions 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)",
@@ -4107,6 +4233,372 @@ const ternaryConditionMultiline = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Empty Line After Block
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Require an empty line between a closing brace `}` of a block
+ *   statement (if, try, for, while, etc.) and the next statement,
+ *   unless the next statement is part of the same construct (else, catch, finally).
+ *
+ * ✓ Good:
+ *   if (condition) {
+ *       doSomething();
+ *   }
+ *
+ *   const x = 1;
+ *
+ * ✗ Bad:
+ *   if (condition) {
+ *       doSomething();
+ *   }
+ *   const x = 1;
+ */
+const emptyLineAfterBlock = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        // Check if a node is a block-containing statement
+        const isBlockStatementHandler = (node) => {
+            const blockTypes = [
+                "IfStatement",
+                "ForStatement",
+                "ForInStatement",
+                "ForOfStatement",
+                "WhileStatement",
+                "DoWhileStatement",
+                "TryStatement",
+                "SwitchStatement",
+                "WithStatement",
+            ];
+
+            return blockTypes.includes(node.type);
+        };
+
+        // Get the actual end line of a statement (including else, catch, finally)
+        const getStatementEndLineHandler = (node) => {
+            if (node.type === "IfStatement" && node.alternate) {
+                return getStatementEndLineHandler(node.alternate);
+            }
+
+            if (node.type === "TryStatement") {
+                if (node.finalizer) return node.finalizer.loc.end.line;
+
+                if (node.handler) return node.handler.loc.end.line;
+            }
+
+            return node.loc.end.line;
+        };
+
+        return {
+            "BlockStatement:exit"(node) {
+                const parent = node.parent;
+
+                // Only check for block-containing statements
+                if (!parent || !isBlockStatementHandler(parent)) return;
+
+                // Skip if this block is followed by else, catch, or finally
+                if (parent.type === "IfStatement" && parent.consequent === node && parent.alternate) {
+                    return;
+                }
+
+                if (parent.type === "TryStatement" && (parent.block === node || parent.handler?.body === node) && (parent.handler || parent.finalizer)) {
+                    if (parent.block === node && (parent.handler || parent.finalizer)) return;
+
+                    if (parent.handler?.body === node && parent.finalizer) return;
+                }
+
+                // Get the parent's container (the block that contains the parent statement)
+                const grandparent = parent.parent;
+
+                if (!grandparent || grandparent.type !== "BlockStatement") return;
+
+                // Find the index of the parent statement in the grandparent's body
+                const stmtIndex = grandparent.body.indexOf(parent);
+
+                if (stmtIndex === -1 || stmtIndex === grandparent.body.length - 1) return;
+
+                // Get the next statement
+                const nextStmt = grandparent.body[stmtIndex + 1];
+
+                // Get the actual end of the current statement
+                const currentEndLine = getStatementEndLineHandler(parent);
+                const nextStartLine = nextStmt.loc.start.line;
+
+                // Check if there's an empty line between them
+                if (nextStartLine - currentEndLine < 2) {
+                    context.report({
+                        fix: (fixer) => {
+                            const endToken = sourceCode.getLastToken(parent);
+
+                            return fixer.insertTextAfter(endToken, "\n");
+                        },
+                        message: "Expected empty line after block statement",
+                        node: nextStmt,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Require empty line between block statement closing brace and next statement" },
+        fixable: "whitespace",
+        schema: [],
+        type: "layout",
+    },
+};
+
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Class Naming Convention
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforce that class declarations must end with "Class" suffix.
+ *   This distinguishes class definitions from other PascalCase names
+ *   like React components or type definitions.
+ *
+ * ✓ Good:
+ *   class ApiServiceClass { ... }
+ *   class UserRepositoryClass { ... }
+ *
+ * ✗ Bad:
+ *   class ApiService { ... }
+ *   class UserRepository { ... }
+ */
+const classNamingConvention = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        return {
+            ClassDeclaration(node) {
+                if (!node.id || !node.id.name) return;
+
+                const className = node.id.name;
+
+                if (!className.endsWith("Class")) {
+                    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)];
+
+                            if (variable && variable.references) {
+                                variable.references.forEach((ref) => {
+                                    if (ref.identifier !== node.id) {
+                                        fixes.push(fixer.replaceText(ref.identifier, newName));
+                                    }
+                                });
+                            }
+
+                            return fixes;
+                        },
+                        message: `Class name "${className}" should end with "Class" suffix`,
+                        node: node.id,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce class names end with 'Class' suffix" },
+        fixable: "code",
+        schema: [],
+        type: "suggestion",
+    },
+};
+
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Enum Type Enforcement
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   When a variable/parameter has a type like "ButtonVariantType",
+ *   enforce using the corresponding enum "ButtonVariantEnum.VALUE"
+ *   instead of string literals like "primary" or "ghost".
+ *
+ *   The rule detects:
+ *   - Default values in destructuring: `variant = "primary"` → `variant = ButtonVariantEnum.PRIMARY`
+ *   - Comparisons: `variant === "ghost"` → `variant === ButtonVariantEnum.GHOST`
+ *   - Object property values matching the type
+ *
+ * ✓ Good:
+ *   const Button = ({ variant = ButtonVariantEnum.PRIMARY }: { variant?: ButtonVariantType }) => ...
+ *   if (variant === ButtonVariantEnum.GHOST) { ... }
+ *
+ * ✗ Bad:
+ *   const Button = ({ variant = "primary" }: { variant?: ButtonVariantType }) => ...
+ *   if (variant === "ghost") { ... }
+ */
+const enumTypeEnforcement = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        // Map to track variables with Type annotations and their corresponding Enum
+        // e.g., "variant" -> { typeName: "ButtonVariantType", enumName: "ButtonVariantEnum" }
+        const typeAnnotatedVars = new Map();
+
+        // Convert type name to enum name: ButtonVariantType -> ButtonVariantEnum
+        const getEnumNameFromTypeHandler = (typeName) => {
+            if (typeName.endsWith("Type")) {
+                return typeName.slice(0, -4) + "Enum";
+            }
+
+            return null;
+        };
+
+        // Convert string literal to enum member: "primary" -> "PRIMARY", "ghost-danger" -> "GHOST_DANGER"
+        const toEnumMemberHandler = (str) => str.toUpperCase().replace(/-/g, "_");
+
+        // Check if a type annotation references a Type that has a corresponding Enum
+        const extractTypeInfoHandler = (typeAnnotation) => {
+            if (!typeAnnotation) return null;
+
+            const annotation = typeAnnotation.typeAnnotation;
+
+            if (!annotation) return null;
+
+            // Handle direct type reference: : ButtonVariantType
+            if (annotation.type === "TSTypeReference" && annotation.typeName?.type === "Identifier") {
+                const typeName = annotation.typeName.name;
+
+                if (typeName.endsWith("Type")) {
+                    return {
+                        enumName: getEnumNameFromTypeHandler(typeName),
+                        typeName,
+                    };
+                }
+            }
+
+            return null;
+        };
+
+        // Track type-annotated parameters in function/component definitions
+        const trackTypedParamsHandler = (params) => {
+            params.forEach((param) => {
+                // Handle destructured params: ({ variant }: { variant?: ButtonVariantType })
+                if (param.type === "ObjectPattern" && param.typeAnnotation) {
+                    const annotation = param.typeAnnotation.typeAnnotation;
+
+                    if (annotation && annotation.type === "TSTypeLiteral") {
+                        annotation.members.forEach((member) => {
+                            if (member.type === "TSPropertySignature" && member.key?.type === "Identifier") {
+                                const propName = member.key.name;
+                                const typeInfo = extractTypeInfoHandler(member.typeAnnotation);
+
+                                if (typeInfo) {
+                                    typeAnnotatedVars.set(propName, typeInfo);
+                                }
+                            }
+                        });
+                    }
+                }
+
+                // Handle simple typed param: (variant: ButtonVariantType)
+                if (param.type === "Identifier" && param.typeAnnotation) {
+                    const typeInfo = extractTypeInfoHandler(param);
+
+                    if (typeInfo) {
+                        typeAnnotatedVars.set(param.name, typeInfo);
+                    }
+                }
+            });
+        };
+
+        return {
+            // Track function parameters
+            "ArrowFunctionExpression, FunctionDeclaration, FunctionExpression"(node) {
+                trackTypedParamsHandler(node.params);
+            },
+
+            // Check default values in destructuring patterns
+            AssignmentPattern(node) {
+                // Pattern like: variant = "primary"
+                if (node.left.type !== "Identifier") return;
+
+                const varName = node.left.name;
+                const typeInfo = typeAnnotatedVars.get(varName);
+
+                if (!typeInfo) return;
+
+                // Check if the default is a string literal
+                if (node.right.type === "Literal" && typeof node.right.value === "string") {
+                    const stringValue = node.right.value;
+                    const enumMember = toEnumMemberHandler(stringValue);
+                    const replacement = `${typeInfo.enumName}.${enumMember}`;
+
+                    context.report({
+                        fix: (fixer) => fixer.replaceText(node.right, replacement),
+                        message: `Use "${replacement}" instead of string literal "${stringValue}"`,
+                        node: node.right,
+                    });
+                }
+            },
+
+            // Check comparisons: variant === "ghost"
+            BinaryExpression(node) {
+                if (node.operator !== "===" && node.operator !== "!==") return;
+
+                let varNode = null;
+                let literalNode = null;
+
+                if (node.left.type === "Identifier" && node.right.type === "Literal") {
+                    varNode = node.left;
+                    literalNode = node.right;
+                } else if (node.right.type === "Identifier" && node.left.type === "Literal") {
+                    varNode = node.right;
+                    literalNode = node.left;
+                }
+
+                if (!varNode || !literalNode) return;
+
+                if (typeof literalNode.value !== "string") return;
+
+                const typeInfo = typeAnnotatedVars.get(varNode.name);
+
+                if (!typeInfo) return;
+
+                const stringValue = literalNode.value;
+                const enumMember = toEnumMemberHandler(stringValue);
+                const replacement = `${typeInfo.enumName}.${enumMember}`;
+
+                context.report({
+                    fix: (fixer) => fixer.replaceText(literalNode, replacement),
+                    message: `Use "${replacement}" instead of string literal "${stringValue}"`,
+                    node: literalNode,
+                });
+            },
+
+            // Clear tracked vars when exiting function scope
+            "ArrowFunctionExpression:exit"() {
+                typeAnnotatedVars.clear();
+            },
+
+            "FunctionDeclaration:exit"() {
+                typeAnnotatedVars.clear();
+            },
+
+            "FunctionExpression:exit"() {
+                typeAnnotatedVars.clear();
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce using enum values instead of string literals for typed variables" },
+        fixable: "code",
+        schema: [],
+        type: "suggestion",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: Absolute Imports Only
@@ -9085,6 +9577,29 @@ const noEmptyLinesInFunctionParams = {
                     });
                 }
             }
+
+            // Check inside ObjectPattern params for empty lines between destructured props
+            params.forEach((param) => {
+                if (param.type === "ObjectPattern" && param.properties.length > 1) {
+                    for (let i = 0; i < param.properties.length - 1; i += 1) {
+                        const current = param.properties[i];
+                        const next = param.properties[i + 1];
+
+                        if (next.loc.start.line - current.loc.end.line > 1) {
+                            const commaToken = sourceCode.getTokenAfter(current, (t) => t.value === ",");
+
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [commaToken.range[1], next.range[0]],
+                                    "\n" + " ".repeat(next.loc.start.column),
+                                ),
+                                message: "No empty lines between destructured properties",
+                                node: next,
+                            });
+                        }
+                    }
+                }
+            });
         };
 
         return {
@@ -13747,6 +14262,161 @@ const componentPropsInlineType = {
                 }
             }
 
+            // Handle intersection types: ButtonHTMLAttributes<HTMLButtonElement> & { prop: Type }
+            if (typeAnnotation.type === "TSIntersectionType" && isComponent) {
+                const types = typeAnnotation.types;
+
+                // Check & operators are on same line as previous type
+                for (let i = 0; i < types.length - 1; i += 1) {
+                    const currentType = types[i];
+                    const nextType = types[i + 1];
+
+                    const ampersandToken = sourceCode.getTokenAfter(currentType, (t) => t.value === "&");
+
+                    if (ampersandToken && ampersandToken.loc.start.line !== currentType.loc.end.line) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [currentType.range[1], ampersandToken.range[1]],
+                                " &",
+                            ),
+                            message: "\"&\" must be on same line as previous type",
+                            node: ampersandToken,
+                        });
+                    }
+
+                    // { should be on same line as &
+                    if (nextType.type === "TSTypeLiteral" && ampersandToken) {
+                        const openBrace = sourceCode.getFirstToken(nextType);
+
+                        if (openBrace && openBrace.loc.start.line !== ampersandToken.loc.end.line) {
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [ampersandToken.range[1], openBrace.range[0]],
+                                    " ",
+                                ),
+                                message: "Opening brace must be on same line as \"&\"",
+                                node: openBrace,
+                            });
+                        }
+                    }
+                }
+
+                // Find TSTypeLiteral in the intersection and apply formatting rules
+                const typeLiteral = types.find((t) => t.type === "TSTypeLiteral");
+
+                if (typeLiteral) {
+                    const members = typeLiteral.members;
+
+                    // Get the base indentation from the component declaration
+                    const componentLine = sourceCode.lines[node.loc.start.line - 1];
+                    const baseIndent = componentLine.match(/^\s*/)[0];
+                    const propIndent = baseIndent + "    ";
+
+                    // Get opening and closing brace tokens
+                    const openBraceToken = sourceCode.getFirstToken(typeLiteral);
+                    const closeBraceToken = sourceCode.getLastToken(typeLiteral);
+
+                    // For multiple members, first member should be on new line after opening brace
+                    if (members.length > 1 && members[0]) {
+                        const firstMember = members[0];
+
+                        if (firstMember.loc.start.line === openBraceToken.loc.end.line) {
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [openBraceToken.range[1], firstMember.range[0]],
+                                    "\n" + propIndent,
+                                ),
+                                message: "First props type property must be on a new line when there are multiple properties",
+                                node: firstMember,
+                            });
+                        }
+                    }
+
+                    // Check closing brace position - should be on its own line for multiple members
+                    if (members.length > 1 && closeBraceToken) {
+                        const lastMember = members[members.length - 1];
+
+                        if (closeBraceToken.loc.start.line === lastMember.loc.end.line) {
+                            context.report({
+                                fix: (fixer) => fixer.replaceTextRange(
+                                    [lastMember.range[1], closeBraceToken.range[0]],
+                                    "\n" + baseIndent,
+                                ),
+                                message: "Closing brace must be on its own line when there are multiple properties",
+                                node: closeBraceToken,
+                            });
+                        }
+                    }
+
+                    // Check each member for formatting
+                    members.forEach((member, index) => {
+                        const memberText = sourceCode.getText(member);
+
+                        // Check property ends with comma, not semicolon
+                        if (memberText.trimEnd().endsWith(";")) {
+                            context.report({
+                                fix: (fixer) => {
+                                    const lastChar = memberText.lastIndexOf(";");
+                                    const absolutePos = member.range[0] + lastChar;
+
+                                    return fixer.replaceTextRange([absolutePos, absolutePos + 1], ",");
+                                },
+                                message: "Props type properties must end with comma (,) not semicolon (;)",
+                                node: member,
+                            });
+                        }
+
+                        // If more than one member, check each is on its own line
+                        if (members.length > 1 && index > 0) {
+                            const prevMember = members[index - 1];
+
+                            if (member.loc.start.line === prevMember.loc.end.line) {
+                                context.report({
+                                    fix: (fixer) => {
+                                        let commaToken = sourceCode.getTokenAfter(prevMember);
+
+                                        while (commaToken && commaToken.value !== "," && commaToken.range[0] < member.range[0]) {
+                                            commaToken = sourceCode.getTokenAfter(commaToken);
+                                        }
+
+                                        const insertPoint = commaToken && commaToken.value === "," ? commaToken.range[1] : prevMember.range[1];
+
+                                        return fixer.replaceTextRange(
+                                            [insertPoint, member.range[0]],
+                                            "\n" + propIndent,
+                                        );
+                                    },
+                                    message: "Each props type property must be on its own line when there are multiple properties",
+                                    node: member,
+                                });
+                            }
+
+                            // Check for empty lines between properties
+                            if (member.loc.start.line - prevMember.loc.end.line > 1) {
+                                context.report({
+                                    fix: (fixer) => {
+                                        const textBetween = sourceCode.getText().slice(
+                                            prevMember.range[1],
+                                            member.range[0],
+                                        );
+                                        const newText = textBetween.replace(/\n\s*\n/g, "\n");
+
+                                        return fixer.replaceTextRange(
+                                            [prevMember.range[1], member.range[0]],
+                                            newText,
+                                        );
+                                    },
+                                    message: "No empty lines allowed between props type properties",
+                                    node: member,
+                                });
+                            }
+                        }
+                    });
+                }
+
+                return;
+            }
+
             // Check if type is a reference (TSTypeReference) instead of inline (TSTypeLiteral)
             // Only enforce inline types for React components - regular functions can use interface/type references
             if (typeAnnotation.type === "TSTypeReference") {
@@ -16694,12 +17364,16 @@ export default {
 
         // Control flow rules
         "block-statement-newlines": blockStatementNewlines,
+        "empty-line-after-block": emptyLineAfterBlock,
         "if-else-spacing": ifElseSpacing,
         "if-statement-format": ifStatementFormat,
         "multiline-if-conditions": multilineIfConditions,
         "no-empty-lines-in-switch-cases": noEmptyLinesInSwitchCases,
         "ternary-condition-multiline": ternaryConditionMultiline,
 
+        // Class rules
+        "class-naming-convention": classNamingConvention,
+
         // Function rules
         "function-call-spacing": functionCallSpacing,
         "function-declaration-style": functionDeclarationStyle,
@@ -16756,6 +17430,9 @@ export default {
         "type-format": typeFormat,
         "typescript-definition-location": typescriptDefinitionLocation,
 
+        // Type/Enum rules
+        "enum-type-enforcement": enumTypeEnforcement,
+
         // Variable rules
         "variable-naming-convention": variableNamingConvention,
     },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-code-style",
-    "version": "1.6.6",
+    "version": "1.7.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",