eslint-plugin-code-style 1.6.4 → 1.7.0

package/CHANGELOG.md

@@ -7,6 +7,59 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [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
+
+- **`component-props-destructure`** - Detect body destructuring patterns (e.g., `const { name } = data;`) even without type annotations
+- **`component-props-destructure`** - Add auto-fix for body destructuring: moves props to parameter and removes body declaration
+
+---
+
+## [1.6.5] - 2026-02-01
+
+### Added
+
+- **`function-object-destructure`** - Add auto-fix: replaces destructured usages with dot notation and removes declaration
+
+---
+
 ## [1.6.4] - 2026-02-01
 
 ### Enhanced
@@ -1011,6 +1064,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[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
 [1.6.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.1...v1.6.2

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,228 @@ 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) {
+                const declarationLine = sourceCode.lines[parent.loc.start.line - 1];
+                const beforeTernary = declarationLine.slice(0, node.loc.start.column);
+
+                prefixLength = beforeTernary.length - indent;
+            } else if (parent && parent.type === "AssignmentExpression" && parent.right === node) {
+                const assignmentLine = sourceCode.lines[parent.loc.start.line - 1];
+                const beforeTernary = assignmentLine.slice(0, node.loc.start.column);
+
+                prefixLength = beforeTernary.length - indent;
+            }
+
+            // Check if single line would fit
+            const totalLength = indent + prefixLength + singleLineText.length + 1;
+
+            if (totalLength <= maxLineLength) {
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, singleLineText),
+                    message: "Simple ternary should be on a single line",
+                    node,
+                });
+
+                return true;
+            }
+
+            return false;
+        };
 
-                if (isCorrectionNeeded) {
+        // 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;
+                }
+            }
+
+            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 +4221,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);
+
+                                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
@@ -12459,19 +12939,60 @@ const functionObjectDestructure = {
             }
         };
 
-        // Check for destructuring of data imports (not allowed)
+        // Find all references to a variable name in a scope (with parent tracking)
+        const findAllReferencesHandler = (scope, varName, declNode) => {
+            const references = [];
+
+            const visitNode = (n, parent) => {
+                if (!n || typeof n !== "object") return;
+
+                // Skip the declaration itself
+                if (n === declNode) return;
+
+                // Found a reference
+                if (n.type === "Identifier" && n.name === varName) {
+                    // Make sure it's not a property key or part of a member expression property
+                    const isMemberProp = parent && parent.type === "MemberExpression" && parent.property === n && !parent.computed;
+                    const isObjectKey = parent && parent.type === "Property" && parent.key === n && !parent.computed;
+                    const isShorthandValue = parent && parent.type === "Property" && parent.shorthand && parent.value === n;
+
+                    // Include shorthand properties as references (they use the variable)
+                    if (!isMemberProp && !isObjectKey) {
+                        references.push(n);
+                    }
+                }
+
+                for (const key of Object.keys(n)) {
+                    if (key === "parent" || key === "range" || key === "loc") continue;
+
+                    const child = n[key];
+
+                    if (Array.isArray(child)) {
+                        child.forEach((c) => visitNode(c, n));
+                    } else if (child && typeof child === "object" && child.type) {
+                        visitNode(child, n);
+                    }
+                }
+            };
+
+            visitNode(scope, null);
+
+            return references;
+        };
+
+        // Check for destructuring of module imports (not allowed)
         const checkVariableDeclarationHandler = (node) => {
             for (const decl of node.declarations) {
                 // Check for ObjectPattern destructuring
                 if (decl.id.type === "ObjectPattern" && decl.init) {
                     let sourceVarName = null;
 
-                    // Direct destructuring: const { x } = dataImport
+                    // Direct destructuring: const { x } = moduleImport
                     if (decl.init.type === "Identifier") {
                         sourceVarName = decl.init.name;
                     }
 
-                    // Nested destructuring: const { x } = dataImport.nested
+                    // Nested destructuring: const { x } = moduleImport.nested
                     if (decl.init.type === "MemberExpression") {
                         let obj = decl.init;
 
@@ -12485,14 +13006,76 @@ const functionObjectDestructure = {
                     }
 
                     if (sourceVarName && moduleImports.has(sourceVarName)) {
+                        // Get destructured properties with their local names
                         const destructuredProps = decl.id.properties
                             .filter((p) => p.type === "Property" && p.key && p.key.name)
-                            .map((p) => p.key.name);
+                            .map((p) => ({
+                                key: p.key.name,
+                                local: p.value && p.value.type === "Identifier" ? p.value.name : p.key.name,
+                            }));
 
                         const sourceText = sourceCode.getText(decl.init);
 
+                        // Find the containing function/program to search for references
+                        let scope = node.parent;
+
+                        while (scope && scope.type !== "BlockStatement" && scope.type !== "Program") {
+                            scope = scope.parent;
+                        }
+
                         context.report({
-                            message: `Do not destructure module imports. Use dot notation for searchability: "${sourceText}.${destructuredProps[0]}" instead of destructuring`,
+                            fix: scope
+                                ? (fixer) => {
+                                    const fixes = [];
+
+                                    // Replace all references with dot notation
+                                    destructuredProps.forEach(({ key, local }) => {
+                                        const refs = findAllReferencesHandler(scope, local, decl);
+
+                                        refs.forEach((ref) => {
+                                            fixes.push(fixer.replaceText(ref, `${sourceText}.${key}`));
+                                        });
+                                    });
+
+                                    // Remove the entire declaration statement
+                                    // If it's the only declaration in the statement, remove the whole statement
+                                    if (node.declarations.length === 1) {
+                                        // Find the full statement including newline
+                                        const tokenBefore = sourceCode.getTokenBefore(node);
+                                        const tokenAfter = sourceCode.getTokenAfter(node);
+                                        let start = node.range[0];
+                                        let end = node.range[1];
+
+                                        // Include leading whitespace/newline
+                                        if (tokenBefore) {
+                                            const textBetween = sourceCode.text.slice(tokenBefore.range[1], node.range[0]);
+                                            const newlineIndex = textBetween.lastIndexOf("\n");
+
+                                            if (newlineIndex !== -1) {
+                                                start = tokenBefore.range[1] + newlineIndex;
+                                            }
+                                        }
+
+                                        // Include trailing newline
+                                        if (tokenAfter) {
+                                            const textBetween = sourceCode.text.slice(node.range[1], tokenAfter.range[0]);
+                                            const newlineIndex = textBetween.indexOf("\n");
+
+                                            if (newlineIndex !== -1) {
+                                                end = node.range[1] + newlineIndex + 1;
+                                            }
+                                        }
+
+                                        fixes.push(fixer.removeRange([start, end]));
+                                    } else {
+                                        // Remove just this declarator
+                                        fixes.push(fixer.remove(decl));
+                                    }
+
+                                    return fixes;
+                                }
+                                : undefined,
+                            message: `Do not destructure module imports. Use dot notation for searchability: "${sourceText}.${destructuredProps[0].key}" instead of destructuring`,
                             node: decl.id,
                         });
                     }
@@ -13275,6 +13858,66 @@ const componentPropsDestructure = {
             return accesses;
         };
 
+        // Find body destructuring like: const { name } = data; or const { name, age } = data;
+        const findBodyDestructuringHandler = (body, paramName) => {
+            const results = [];
+
+            if (body.type !== "BlockStatement") return results;
+
+            for (const statement of body.body) {
+                if (statement.type === "VariableDeclaration") {
+                    for (const declarator of statement.declarations) {
+                        // Check if it's destructuring from the param: const { x } = paramName
+                        if (
+                            declarator.id.type === "ObjectPattern" &&
+                            declarator.init &&
+                            declarator.init.type === "Identifier" &&
+                            declarator.init.name === paramName
+                        ) {
+                            const props = [];
+
+                            for (const prop of declarator.id.properties) {
+                                if (prop.type === "Property" && prop.key.type === "Identifier") {
+                                    // Handle both { name } and { name: alias }
+                                    const keyName = prop.key.name;
+                                    const valueName = prop.value.type === "Identifier" ? prop.value.name : null;
+                                    const hasDefault = prop.value.type === "AssignmentPattern";
+                                    let defaultValue = null;
+
+                                    if (hasDefault && prop.value.right) {
+                                        defaultValue = sourceCode.getText(prop.value.right);
+                                    }
+
+                                    props.push({
+                                        default: defaultValue,
+                                        hasAlias: keyName !== valueName && !hasDefault,
+                                        key: keyName,
+                                        value: hasDefault ? prop.value.left.name : valueName,
+                                    });
+                                } else if (prop.type === "RestElement" && prop.argument.type === "Identifier") {
+                                    props.push({
+                                        isRest: true,
+                                        key: prop.argument.name,
+                                        value: prop.argument.name,
+                                    });
+                                }
+                            }
+
+                            results.push({
+                                declarator,
+                                props,
+                                statement,
+                                // Track if this is the only declarator in the statement
+                                statementHasOnlyThisDeclarator: statement.declarations.length === 1,
+                            });
+                        }
+                    }
+                }
+            }
+
+            return results;
+        };
+
         const checkComponentPropsHandler = (node) => {
             if (!isReactComponentHandler(node)) return;
 
@@ -13288,14 +13931,33 @@ const componentPropsDestructure = {
 
             if (firstParam.type === "Identifier") {
                 const paramName = firstParam.name;
+
+                // Find dot notation accesses: props.name
                 const accesses = findPropAccessesHandler(node.body, paramName);
-                const accessedProps = [...new Set(accesses.map((a) => a.property))];
 
-                // Check if param is used directly (not just via dot notation)
+                // Find body destructuring: const { name } = props
+                const bodyDestructures = findBodyDestructuringHandler(node.body, paramName);
+
+                // Collect all accessed props from dot notation
+                const dotNotationProps = [...new Set(accesses.map((a) => a.property))];
+
+                // Collect all props from body destructuring
+                const bodyDestructuredProps = [];
+
+                bodyDestructures.forEach((bd) => {
+                    bd.props.forEach((p) => {
+                        bodyDestructuredProps.push(p);
+                    });
+                });
+
+                // Check if param is used anywhere that we can't handle
                 const allRefs = [];
-                const countRefs = (n) => {
+                const countRefs = (n, skipNodes = []) => {
                     if (!n || typeof n !== "object") return;
 
+                    // Skip nodes we're already accounting for
+                    if (skipNodes.includes(n)) return;
+
                     if (n.type === "Identifier" && n.name === paramName) allRefs.push(n);
 
                     for (const key of Object.keys(n)) {
@@ -13303,23 +13965,58 @@ const componentPropsDestructure = {
 
                         const child = n[key];
 
-                        if (Array.isArray(child)) child.forEach(countRefs);
-                        else if (child && typeof child === "object" && child.type) countRefs(child);
+                        if (Array.isArray(child)) child.forEach((c) => countRefs(c, skipNodes));
+                        else if (child && typeof child === "object" && child.type) countRefs(child, skipNodes);
                     }
                 };
 
                 countRefs(node.body);
 
-                // Can only auto-fix if all references are covered by dot notation accesses
-                const canAutoFix = accessedProps.length > 0 && allRefs.length === accesses.length;
+                // Count expected refs: dot notation accesses + body destructuring init nodes
+                const expectedRefCount = accesses.length + bodyDestructures.length;
+
+                // Can auto-fix if:
+                // 1. We have either dot notation props OR body destructured props
+                // 2. All references to the param are accounted for
+                const hasSomeProps = dotNotationProps.length > 0 || bodyDestructuredProps.length > 0;
+                const canAutoFix = hasSomeProps && allRefs.length === expectedRefCount;
 
                 context.report({
                     fix: canAutoFix
                         ? (fixer) => {
                             const fixes = [];
 
-                            // Build destructured pattern, preserving type annotation if present
-                            const destructuredPattern = `{ ${accessedProps.join(", ")} }`;
+                            // Build the destructured props list for the parameter
+                            const allProps = [];
+
+                            // Add dot notation props (simple names)
+                            dotNotationProps.forEach((p) => {
+                                if (!allProps.some((ap) => ap.key === p)) {
+                                    allProps.push({ key: p, simple: true });
+                                }
+                            });
+
+                            // Add body destructured props (may have aliases, defaults, rest)
+                            bodyDestructuredProps.forEach((p) => {
+                                // Don't duplicate if already in dot notation
+                                if (!allProps.some((ap) => ap.key === p.key)) {
+                                    allProps.push(p);
+                                }
+                            });
+
+                            // Build the destructured pattern string
+                            const propStrings = allProps.map((p) => {
+                                if (p.isRest) return `...${p.key}`;
+
+                                if (p.simple) return p.key;
+
+                                if (p.default) return `${p.key} = ${p.default}`;
+
+                                if (p.hasAlias) return `${p.key}: ${p.value}`;
+
+                                return p.key;
+                            });
+                            const destructuredPattern = `{ ${propStrings.join(", ")} }`;
                             let replacement = destructuredPattern;
 
                             // Preserve TypeScript type annotation if present
@@ -13337,6 +14034,27 @@ const componentPropsDestructure = {
                                 fixes.push(fixer.replaceText(access.node, access.property));
                             });
 
+                            // Remove body destructuring statements
+                            bodyDestructures.forEach((bd) => {
+                                if (bd.statementHasOnlyThisDeclarator) {
+                                    // Remove the entire statement including newline
+                                    const statementStart = bd.statement.range[0];
+                                    let statementEnd = bd.statement.range[1];
+
+                                    // Try to also remove trailing newline/whitespace
+                                    const textAfter = sourceCode.getText().slice(statementEnd, statementEnd + 2);
+
+                                    if (textAfter.startsWith("\n")) statementEnd += 1;
+                                    else if (textAfter.startsWith("\r\n")) statementEnd += 2;
+
+                                    fixes.push(fixer.removeRange([statementStart, statementEnd]));
+                                } else {
+                                    // Only remove this declarator from a multi-declarator statement
+                                    // This is more complex - for now just remove the declarator text
+                                    fixes.push(fixer.remove(bd.declarator));
+                                }
+                            });
+
                             return fixes;
                         }
                         : undefined,
@@ -16456,12 +17174,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,
@@ -16518,6 +17240,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.4",
+    "version": "1.7.0",
     "description": "A custom ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects",
     "main": "index.js",
     "types": "index.d.ts",