eslint-plugin-code-style 1.8.4 → 1.9.2

package/CHANGELOG.md

@@ -7,6 +7,70 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.9.2] - 2026-02-03
+
+### Enhanced
+
+- **`no-hardcoded-strings`** - Now detects special strings that should be enums:
+  - HTTP status codes (2xx, 4xx, 5xx like "200", "404", "500")
+  - HTTP methods ("GET", "POST", "PUT", "DELETE", etc.)
+  - Role/permission names ("admin", "user", "moderator", etc.)
+  - Environment names ("production", "development", "staging", etc.)
+  - Log levels ("debug", "info", "warn", "error", etc.)
+  - Status strings ("active", "pending", "approved", "rejected", etc.)
+  - Priority levels ("high", "medium", "low", "critical", etc.)
+  - All above → import from `@/enums` or `@/data`
+  - Regular strings → import from `@/data or @/strings or @/constants or @/@constants or @/@strings`
+
+### Fixed
+
+- **`no-hardcoded-strings`** - Fixed bug where `isInConstantsObjectHandler` incorrectly matched camelCase variable names due to case-insensitive regex flag
+
+---
+
+## [1.9.1] - 2026-02-03
+
+### Enhanced
+
+- **`no-hardcoded-strings`** - Initial special string detection:
+  - HTTP status codes (4xx, 5xx)
+  - Role/permission names
+
+---
+
+## [1.9.0] - 2026-02-03
+
+**New Rule: class-method-definition-format + Enhanced Spacing Rules**
+
+**Version Range:** v1.8.1 → v1.9.0
+
+### Added
+
+**New Rules (1)**
+- **`class-method-definition-format`** - Enforce consistent spacing in class and method definitions 🔧
+  - Space before opening brace `{` in class declarations
+  - No space between method name and opening parenthesis `(`
+  - Space before opening brace `{` in method definitions
+  - Opening brace must be on same line as class/method signature
+
+### Enhanced
+
+- **`function-call-spacing`** - Now also handles:
+  - `new` expressions (`new Class ()` → `new Class()`)
+  - Generic type calls (`get <Type>()` → `get<Type>()`)
+- **`member-expression-bracket-spacing`** - Now also handles:
+  - TypeScript indexed access types (`Type ["prop"]` → `Type["prop"]`)
+
+### Stats
+
+- Total Rules: 71 (was 70)
+- Auto-fixable: 64 rules 🔧 (was 63)
+- Report-only: 7 rules
+
+**Full Changelog:** [v1.8.1...v1.9.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.8.1...v1.9.0)
+
+---
+
 ## [1.8.4] - 2026-02-03
 
 ### Documentation
@@ -54,7 +118,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 **New Rule: no-hardcoded-strings**
 
-**Version Range:** v1.6.1 → v1.8.0
+**Version Range:** v1.7.1 → v1.8.0
 
 ### Added
 
@@ -76,7 +140,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Auto-fixable: 63 rules 🔧
 - Report-only: 7 rules (was 6)
 
-**Full Changelog:** [v1.6.1...v1.8.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.6.1...v1.8.0)
+**Full Changelog:** [v1.7.1...v1.8.0](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.7.1...v1.8.0)
 
 ---
 
@@ -1211,6 +1275,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.9.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.1...v1.9.2
+[1.9.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.0...v1.9.1
+[1.9.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.8.4...v1.9.0
 [1.8.4]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.8.3...v1.8.4
 [1.8.3]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.8.2...v1.8.3
 [1.8.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.8.1...v1.8.2

package/README.md

@@ -19,7 +19,7 @@
 
 **A powerful ESLint plugin for enforcing consistent code formatting and style rules in React/JSX projects.**
 
-*70 rules (63 auto-fixable) to keep your codebase clean and consistent*
+*71 rules (64 auto-fixable) to keep your codebase clean and consistent*
 
 </div>
 
@@ -27,7 +27,7 @@
 
 ## 🎯 Why This Plugin?
 
-This plugin provides **70 custom rules** (63 auto-fixable) for code formatting. Built for **ESLint v9 flat configs**.
+This plugin provides **71 custom rules** (64 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 **70 custom rules** (63 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** — 63 of 70 rules support auto-fix with `eslint --fix`
+- **Highly automated** — 64 of 71 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.
 
@@ -97,7 +97,7 @@ We provide **ready-to-use ESLint flat configuration files** that combine `eslint
 <td width="50%">
 
 ### 🔧 Auto-Fixable Rules
-**63 rules** support automatic fixing with `eslint --fix`. 6 rules are report-only (require manual changes).
+**64 rules** support automatic fixing with `eslint --fix`. 6 rules are report-only (require manual changes).
 
 </td>
 <td width="50%">
@@ -190,6 +190,7 @@ rules: {
     "code-style/arrow-function-simplify": "error",
     "code-style/assignment-value-same-line": "error",
     "code-style/block-statement-newlines": "error",
+    "code-style/class-method-definition-format": "error",
     "code-style/class-naming-convention": "error",
     "code-style/classname-dynamic-at-end": "error",
     "code-style/classname-multiline": "error",
@@ -260,7 +261,7 @@ rules: {
 
 ## 📖 Rules Categories
 
-> **70 rules total** — 63 with auto-fix 🔧, 7 report-only. See detailed examples in [Rules Reference](#-rules-reference) below.
+> **71 rules total** — 64 with auto-fix 🔧, 7 report-only. See detailed examples in [Rules Reference](#-rules-reference) below.
 >
 > **Legend:** 🔧 Auto-fixable with `eslint --fix` • ⚙️ Customizable options
 
@@ -288,6 +289,7 @@ 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-method-definition-format` | Consistent spacing in class/method definitions: space before `{`, no space before `(` 🔧 |
 | `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 🔧 |
@@ -893,6 +895,60 @@ dispatch(
 
 ## 🏛️ Class Rules
 
+### `class-method-definition-format`
+
+**What it does:** Enforces consistent spacing in class and method definitions:
+- Space before opening brace `{` in class declarations
+- No space between method name and opening parenthesis `(`
+- Space before opening brace `{` in method definitions
+- Opening brace must be on same line as class/method signature
+
+**Why use it:** Consistent formatting makes code more readable and prevents common spacing inconsistencies in class definitions.
+
+```javascript
+// ✅ Good — proper spacing in class and methods
+class ApiServiceClass {
+    getDataHandler(): string {
+        return "data";
+    }
+
+    async fetchUserHandler(id: string): Promise<User> {
+        return await this.fetch(id);
+    }
+}
+
+// ❌ Bad — missing space before { in class
+class ApiServiceClass{
+    getDataHandler(): string {
+        return "data";
+    }
+}
+
+// ❌ Bad — space between method name and (
+class ApiServiceClass {
+    getDataHandler (): string {
+        return "data";
+    }
+}
+
+// ❌ Bad — missing space before { in method
+class ApiServiceClass {
+    getDataHandler(): string{
+        return "data";
+    }
+}
+
+// ❌ Bad — opening brace on different line
+class ApiServiceClass {
+    getDataHandler(): string
+    {
+        return "data";
+    }
+}
+```
+
+---
+
 ### `class-naming-convention`
 
 **What it does:** Enforces that class declarations must end with "Class" suffix. This distinguishes class definitions from other PascalCase names like React components or type definitions.
@@ -3367,10 +3423,19 @@ const YetAnotherBad = ({ title }) => {
 
 ### `no-hardcoded-strings`
 
-**What it does:** Enforces that user-facing strings should be imported from constants/strings modules rather than hardcoded inline. This promotes maintainability, consistency, and enables easier internationalization.
+**What it does:** Enforces that user-facing strings should be imported from constants/strings/data modules rather than hardcoded inline. This promotes maintainability, consistency, and enables easier internationalization.
 
 **Why use it:** Hardcoded strings scattered throughout your codebase are hard to maintain, translate, and keep consistent. Centralizing strings in constants makes them easy to find, update, and potentially translate.
 
+**Special detection (should be imported from `@/enums` or `@/data`):**
+- **HTTP status codes** — 2xx, 4xx, 5xx like "200", "404", "500"
+- **HTTP methods** — "GET", "POST", "PUT", "DELETE", "PATCH", etc.
+- **Role/permission names** — "admin", "user", "moderator", "editor", etc.
+- **Environment names** — "production", "development", "staging", "test", etc.
+- **Log levels** — "debug", "info", "warn", "error", "fatal", etc.
+- **Status strings** — "active", "pending", "approved", "rejected", "completed", etc.
+- **Priority levels** — "high", "medium", "low", "critical", "urgent", etc.
+
 **Options:**
 
 | Option | Type | Default | Description |
@@ -3387,8 +3452,9 @@ const YetAnotherBad = ({ title }) => {
 // ✅ Good — strings imported from constants
 import { BUTTON_LABEL, ERROR_MESSAGE, welcomeText } from "@/constants";
 import { FORM_LABELS } from "@/strings";
+import { HttpStatus, UserRole } from "@/enums";
 
-const Component = () => (
+const ComponentHandler = () => (
     <div>
         <button>{BUTTON_LABEL}</button>
         <span>{ERROR_MESSAGE}</span>
@@ -3396,7 +3462,11 @@ const Component = () => (
     </div>
 );
 
-const getMessage = () => ERROR_MESSAGE;
+const getMessageHandler = () => ERROR_MESSAGE;
+
+// ✅ Good — using enums for status codes and roles
+if (status === HttpStatus.NOT_FOUND) { ... }
+if (role === UserRole.ADMIN) { ... }
 
 // ✅ Good — technical strings are allowed
 <input type="text" className="input-field" />
@@ -3409,6 +3479,10 @@ const size = "100px";
 <span>Something went wrong</span>
 const message = "Welcome to the application";
 return "User not found";
+
+// ❌ Bad — hardcoded status codes and roles
+if (status === "404") { ... }
+if (role === "admin") { ... }
 ```
 
 **Configuration example:**
@@ -3421,10 +3495,14 @@ return "User not found";
 }]
 ```
 
-**Valid import paths for constants:**
-- `@/constants` or `@/@constants`
+**Valid import paths for strings:**
+- `@/data`
 - `@/strings` or `@/@strings`
-- `@/data/constants` or `@/data/strings`
+- `@/constants` or `@/@constants`
+
+**Valid import paths for enums (status codes, roles):**
+- `@/enums`
+- `@/data`
 
 ---
 
@@ -3463,7 +3541,7 @@ const UseAuth = () => {};          // hooks should be camelCase
 
 ## 🔧 Auto-fixing
 
-63 of 70 rules support auto-fixing. Run ESLint with the `--fix` flag:
+64 of 71 rules support auto-fixing. Run ESLint with the `--fix` flag:
 
 ```bash
 # Fix all files in src directory

package/index.d.ts

@@ -13,6 +13,7 @@ export type RuleNames =
     | "code-style/arrow-function-simplify"
     | "code-style/assignment-value-same-line"
     | "code-style/block-statement-newlines"
+    | "code-style/class-method-definition-format"
     | "code-style/class-naming-convention"
     | "code-style/comment-format"
     | "code-style/component-props-destructure"
@@ -105,6 +106,7 @@ interface PluginRules {
     "arrow-function-simplify": Rule.RuleModule;
     "assignment-value-same-line": Rule.RuleModule;
     "block-statement-newlines": Rule.RuleModule;
+    "class-method-definition-format": Rule.RuleModule;
     "class-naming-convention": Rule.RuleModule;
     "comment-format": Rule.RuleModule;
     "component-props-destructure": Rule.RuleModule;

package/index.js

@@ -1850,31 +1850,80 @@ const functionCallSpacing = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
-        return {
-            CallExpression(node) {
-                const { callee } = node;
+        const checkCallSpacingHandler = (node, callee) => {
+            // Get the last token of the callee (function name or member expression)
+            const calleeLastToken = sourceCode.getLastToken(callee);
 
-                // Get the last token of the callee (function name or member expression)
-                const calleeLastToken = sourceCode.getLastToken(callee);
+            // For calls with type arguments (generics), check space before <
+            // e.g., axiosClient.get <Type>() should be axiosClient.get<Type>()
+            if (node.typeArguments || node.typeParameters) {
+                const typeArgs = node.typeArguments || node.typeParameters;
+                const openAngle = sourceCode.getFirstToken(typeArgs);
 
-                // Get the opening parenthesis
-                const openParen = sourceCode.getTokenAfter(callee);
+                if (openAngle && openAngle.value === "<") {
+                    const textBeforeAngle = sourceCode.text.slice(calleeLastToken.range[1], openAngle.range[0]);
 
-                if (!openParen || openParen.value !== "(") return;
+                    if (/\s/.test(textBeforeAngle)) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [calleeLastToken.range[1], openAngle.range[0]],
+                                "",
+                            ),
+                            message: "No space between function name and generic type arguments",
+                            node: openAngle,
+                        });
+                    }
+                }
 
-                // Check if there's space between callee and opening paren
-                const textBetween = sourceCode.text.slice(calleeLastToken.range[1], openParen.range[0]);
+                // Also check space between closing > and opening (
+                const closeAngle = sourceCode.getLastToken(typeArgs);
+                const openParen = sourceCode.getTokenAfter(typeArgs);
 
-                if (textBetween.length > 0) {
-                    context.report({
-                        fix: (fixer) => fixer.replaceTextRange(
-                            [calleeLastToken.range[1], openParen.range[0]],
-                            "",
-                        ),
-                        message: "No space between function name and opening parenthesis",
-                        node: openParen,
-                    });
+                if (openParen && openParen.value === "(") {
+                    const textBetween = sourceCode.text.slice(closeAngle.range[1], openParen.range[0]);
+
+                    if (/\s/.test(textBetween)) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [closeAngle.range[1], openParen.range[0]],
+                                "",
+                            ),
+                            message: "No space between generic type arguments and opening parenthesis",
+                            node: openParen,
+                        });
+                    }
                 }
+
+                return;
+            }
+
+            // Get the opening parenthesis
+            const openParen = sourceCode.getTokenAfter(callee);
+
+            if (!openParen || openParen.value !== "(") return;
+
+            // Check if there's space between callee and opening paren
+            const textBetween = sourceCode.text.slice(calleeLastToken.range[1], openParen.range[0]);
+
+            if (textBetween.length > 0) {
+                context.report({
+                    fix: (fixer) => fixer.replaceTextRange(
+                        [calleeLastToken.range[1], openParen.range[0]],
+                        "",
+                    ),
+                    message: "No space between function name and opening parenthesis",
+                    node: openParen,
+                });
+            }
+        };
+
+        return {
+            CallExpression(node) {
+                checkCallSpacingHandler(node, node.callee);
+            },
+
+            NewExpression(node) {
+                checkCallSpacingHandler(node, node.callee);
             },
         };
     },
@@ -5384,6 +5433,180 @@ const classNamingConvention = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Class/Method Definition Format
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforce consistent spacing in class and method definitions:
+ *   - Space before opening brace { in class declarations
+ *   - No space between method name and opening parenthesis (
+ *   - Space before opening brace { in method definitions
+ *   - Opening brace must be on same line as method signature
+ *
+ * ✓ Good:
+ *   class ApiServiceClass {
+ *       getDataHandler(): string {
+ *           return "data";
+ *       }
+ *       async fetchUserHandler(id: string): Promise<User> {
+ *           return await fetch(id);
+ *       }
+ *   }
+ *
+ * ✗ Bad:
+ *   class ApiServiceClass{  // Missing space before {
+ *   class ApiServiceClass
+ *   {  // Opening brace on different line
+ *       getDataHandler (): string {  // Space before (
+ *       getDataHandler(): string{  // Missing space before {
+ *       getDataHandler(): string
+ *       {  // Opening brace on different line
+ */
+const classMethodDefinitionFormat = {
+    create(context) {
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        return {
+            ClassDeclaration(node) {
+                const classBody = node.body;
+
+                if (!classBody) return;
+
+                // Find the opening brace of the class body
+                const openBrace = sourceCode.getFirstToken(classBody);
+
+                if (!openBrace || openBrace.value !== "{") return;
+
+                // Get the token before the opening brace (class name or extends clause)
+                const tokenBefore = sourceCode.getTokenBefore(openBrace);
+
+                if (!tokenBefore) return;
+
+                // Check if opening brace is on same line as class declaration
+                if (tokenBefore.loc.end.line !== openBrace.loc.start.line) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [tokenBefore.range[1], openBrace.range[0]],
+                            " ",
+                        ),
+                        message: "Opening brace should be on the same line as class declaration",
+                        node: openBrace,
+                    });
+
+                    return;
+                }
+
+                // Check for space before opening brace
+                const textBetween = sourceCode.text.slice(tokenBefore.range[1], openBrace.range[0]);
+
+                if (textBetween !== " ") {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [tokenBefore.range[1], openBrace.range[0]],
+                            " ",
+                        ),
+                        message: "Expected single space before opening brace in class declaration",
+                        node: openBrace,
+                    });
+                }
+            },
+
+            MethodDefinition(node) {
+                const methodKey = node.key;
+                const methodValue = node.value;
+
+                if (!methodKey || !methodValue) return;
+
+                // Check for space between method name and opening parenthesis
+                // For computed properties, we need to get the ] token
+                const keyLastToken = node.computed
+                    ? sourceCode.getTokenAfter(methodKey, { filter: (t) => t.value === "]" })
+                    : sourceCode.getLastToken(methodKey);
+
+                if (!keyLastToken) return;
+
+                // Find the opening parenthesis of the parameters
+                let openParen = sourceCode.getTokenAfter(keyLastToken);
+
+                // Skip over async, static, get, set keywords and * for generators
+                while (openParen && openParen.value !== "(") {
+                    openParen = sourceCode.getTokenAfter(openParen);
+                }
+
+                if (!openParen || openParen.value !== "(") return;
+
+                // Get the token immediately before the opening paren (method name or modifier)
+                const tokenBeforeParen = sourceCode.getTokenBefore(openParen);
+
+                if (tokenBeforeParen) {
+                    const textBeforeParen = sourceCode.text.slice(tokenBeforeParen.range[1], openParen.range[0]);
+
+                    if (/\s/.test(textBeforeParen)) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceTextRange(
+                                [tokenBeforeParen.range[1], openParen.range[0]],
+                                "",
+                            ),
+                            message: "No space between method name and opening parenthesis",
+                            node: openParen,
+                        });
+                    }
+                }
+
+                // Check for space before opening brace and brace on same line
+                const functionBody = methodValue.body;
+
+                if (!functionBody || functionBody.type !== "BlockStatement") return;
+
+                const openBrace = sourceCode.getFirstToken(functionBody);
+
+                if (!openBrace || openBrace.value !== "{") return;
+
+                // Get the token before the opening brace (return type annotation or closing paren)
+                const tokenBeforeBrace = sourceCode.getTokenBefore(openBrace);
+
+                if (!tokenBeforeBrace) return;
+
+                // Check if opening brace is on same line
+                if (tokenBeforeBrace.loc.end.line !== openBrace.loc.start.line) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [tokenBeforeBrace.range[1], openBrace.range[0]],
+                            " ",
+                        ),
+                        message: "Opening brace should be on the same line as method signature",
+                        node: openBrace,
+                    });
+
+                    return;
+                }
+
+                // Check for space before opening brace
+                const textBeforeBrace = sourceCode.text.slice(tokenBeforeBrace.range[1], openBrace.range[0]);
+
+                if (textBeforeBrace !== " ") {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange(
+                            [tokenBeforeBrace.range[1], openBrace.range[0]],
+                            " ",
+                        ),
+                        message: "Expected single space before opening brace in method definition",
+                        node: openBrace,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce consistent spacing in class and method definitions" },
+        fixable: "whitespace",
+        schema: [],
+        type: "layout",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: Enum Type Enforcement
@@ -9921,44 +10144,71 @@ const memberExpressionBracketSpacing = {
     create(context) {
         const sourceCode = context.sourceCode || context.getSourceCode();
 
-        return {
-            MemberExpression(node) {
-                // Only check computed member expressions (bracket notation)
-                if (!node.computed) return;
+        const checkBracketSpacingHandler = (node, objectPart, indexPart) => {
+            const openBracket = sourceCode.getTokenBefore(indexPart);
+            const closeBracket = sourceCode.getTokenAfter(indexPart);
 
-                const openBracket = sourceCode.getTokenBefore(node.property);
-                const closeBracket = sourceCode.getTokenAfter(node.property);
+            if (!openBracket || openBracket.value !== "[") return;
+            if (!closeBracket || closeBracket.value !== "]") return;
 
-                if (!openBracket || openBracket.value !== "[") return;
-                if (!closeBracket || closeBracket.value !== "]") return;
+            // Check for space before [ (between object and bracket)
+            const objectLastToken = sourceCode.getLastToken(objectPart);
 
-                // Check for space after [
-                const textAfterOpen = sourceCode.text.slice(openBracket.range[1], node.property.range[0]);
+            if (objectLastToken) {
+                const textBeforeOpen = sourceCode.text.slice(objectLastToken.range[1], openBracket.range[0]);
 
-                if (textAfterOpen.includes(" ") || textAfterOpen.includes("\n")) {
+                if (/\s/.test(textBeforeOpen)) {
                     context.report({
                         fix: (fixer) => fixer.replaceTextRange(
-                            [openBracket.range[1], node.property.range[0]],
+                            [objectLastToken.range[1], openBracket.range[0]],
                             "",
                         ),
-                        message: "No space after opening bracket in member expression",
+                        message: "No space before opening bracket in member expression",
                         node: openBracket,
                     });
                 }
+            }
 
-                // Check for space before ]
-                const textBeforeClose = sourceCode.text.slice(node.property.range[1], closeBracket.range[0]);
+            // Check for space after [
+            const textAfterOpen = sourceCode.text.slice(openBracket.range[1], indexPart.range[0]);
 
-                if (textBeforeClose.includes(" ") || textBeforeClose.includes("\n")) {
-                    context.report({
-                        fix: (fixer) => fixer.replaceTextRange(
-                            [node.property.range[1], closeBracket.range[0]],
-                            "",
-                        ),
-                        message: "No space before closing bracket in member expression",
-                        node: closeBracket,
-                    });
-                }
+            if (textAfterOpen.includes(" ") || textAfterOpen.includes("\n")) {
+                context.report({
+                    fix: (fixer) => fixer.replaceTextRange(
+                        [openBracket.range[1], indexPart.range[0]],
+                        "",
+                    ),
+                    message: "No space after opening bracket in member expression",
+                    node: openBracket,
+                });
+            }
+
+            // Check for space before ]
+            const textBeforeClose = sourceCode.text.slice(indexPart.range[1], closeBracket.range[0]);
+
+            if (textBeforeClose.includes(" ") || textBeforeClose.includes("\n")) {
+                context.report({
+                    fix: (fixer) => fixer.replaceTextRange(
+                        [indexPart.range[1], closeBracket.range[0]],
+                        "",
+                    ),
+                    message: "No space before closing bracket in member expression",
+                    node: closeBracket,
+                });
+            }
+        };
+
+        return {
+            MemberExpression(node) {
+                // Only check computed member expressions (bracket notation)
+                if (!node.computed) return;
+
+                checkBracketSpacingHandler(node, node.object, node.property);
+            },
+
+            // Handle TypeScript indexed access types: Type["prop"]
+            TSIndexedAccessType(node) {
+                checkBracketSpacingHandler(node, node.objectType, node.indexType);
             },
         };
     },
@@ -13572,10 +13822,30 @@ const stringPropertySpacing = {
  *
  * Description:
  *   Enforces that user-facing strings should be imported from
- *   constants/strings modules rather than hardcoded inline.
+ *   constants/strings/data modules rather than hardcoded inline.
  *   This promotes maintainability, consistency, and enables
  *   easier internationalization.
  *
+ *   The rule also detects special strings that should be enums:
+ *   - HTTP status codes (2xx, 4xx, 5xx like "200", "404", "500")
+ *   - HTTP methods ("GET", "POST", "PUT", "DELETE", etc.)
+ *   - Role/permission names ("admin", "user", "moderator", etc.)
+ *   - Environment names ("production", "development", "staging", etc.)
+ *   - Log levels ("debug", "info", "warn", "error", etc.)
+ *   - Status strings ("active", "pending", "approved", "rejected", etc.)
+ *   - Priority levels ("high", "medium", "low", "critical", etc.)
+ *
+ * Valid import sources for strings:
+ *   - @/data
+ *   - @/strings
+ *   - @/constants
+ *   - @/@strings
+ *   - @/@constants
+ *
+ * Valid import sources for enums:
+ *   - @/enums
+ *   - @/data
+ *
  * Options:
  *   { ignoreAttributes: ["className", "id", ...] } - JSX attributes to ignore (replaces defaults)
  *   { extraIgnoreAttributes: ["tooltip", ...] } - Additional JSX attributes to ignore (extends defaults)
@@ -13584,16 +13854,21 @@ const stringPropertySpacing = {
  * ✓ Good:
  *   import { BUTTON_LABEL, ERROR_MESSAGE } from "@/constants";
  *   import { welcomeText } from "@/strings";
+ *   import { HttpStatus, UserRole } from "@/enums";
  *
  *   <button>{BUTTON_LABEL}</button>
  *   <span>{ERROR_MESSAGE}</span>
  *   const message = welcomeText;
+ *   if (status === HttpStatus.NOT_FOUND) { ... }
+ *   if (role === UserRole.ADMIN) { ... }
  *
  * ✗ Bad:
  *   <button>Submit</button>
  *   <span>Something went wrong</span>
  *   const message = "Welcome to the app";
  *   return "User not found";
+ *   if (status === "404") { ... }      // HTTP status code
+ *   if (role === "admin") { ... }      // Role name
  */
 const noHardcodedStrings = {
     create(context) {
@@ -13786,8 +14061,6 @@ const noHardcodedStrings = {
             /^[A-Z][A-Z0-9_]*$/,
             // Common technical strings
             /^(true|false|null|undefined|NaN|Infinity)$/,
-            // HTTP methods
-            /^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE)$/,
             // Content types
             /^application\//,
             // Environment variables pattern
@@ -13816,16 +14089,181 @@ const noHardcodedStrings = {
 
         const allIgnorePatterns = [...technicalPatterns, ...extraIgnorePatterns];
 
-        // Check if a string matches any ignore pattern
-        const shouldIgnoreStringHandler = (str) => allIgnorePatterns.some((pattern) => pattern.test(str));
+        // HTTP status codes that should NOT be hardcoded (2xx, 4xx, and 5xx)
+        const httpStatusCodePattern = /^[245]\d{2}$/;
+
+        // Common role/permission names that should be imported from enums/data
+        const rolePermissionNames = new Set([
+            "admin",
+            "administrator",
+            "editor",
+            "guest",
+            "manager",
+            "member",
+            "moderator",
+            "operator",
+            "owner",
+            "reviewer",
+            "subscriber",
+            "superadmin",
+            "supervisor",
+            "user",
+            "viewer",
+        ]);
+
+        // HTTP methods that should be imported from enums/data
+        const httpMethods = new Set([
+            "CONNECT",
+            "DELETE",
+            "GET",
+            "HEAD",
+            "OPTIONS",
+            "PATCH",
+            "POST",
+            "PUT",
+            "TRACE",
+        ]);
+
+        // Environment names that should be imported from enums/data
+        const environmentNames = new Set([
+            "dev",
+            "development",
+            "local",
+            "prod",
+            "production",
+            "qa",
+            "sandbox",
+            "staging",
+            "test",
+            "testing",
+            "uat",
+        ]);
+
+        // Log levels that should be imported from enums/data
+        const logLevels = new Set([
+            "debug",
+            "error",
+            "fatal",
+            "info",
+            "log",
+            "trace",
+            "warn",
+            "warning",
+        ]);
 
-        // Check if we're inside a constants/strings file
+        // Status/state strings that should be imported from enums/data
+        const statusStrings = new Set([
+            "accepted",
+            "active",
+            "approved",
+            "archived",
+            "blocked",
+            "cancelled",
+            "closed",
+            "completed",
+            "declined",
+            "deleted",
+            "disabled",
+            "draft",
+            "enabled",
+            "expired",
+            "failed",
+            "inactive",
+            "open",
+            "paused",
+            "pending",
+            "processing",
+            "published",
+            "rejected",
+            "resolved",
+            "scheduled",
+            "submitted",
+            "success",
+            "suspended",
+            "verified",
+        ]);
+
+        // Priority levels that should be imported from enums/data
+        const priorityLevels = new Set([
+            "critical",
+            "high",
+            "highest",
+            "low",
+            "lowest",
+            "medium",
+            "normal",
+            "urgent",
+        ]);
+
+        // Check functions for each category
+        const isHttpStatusCodeHandler = (str) => httpStatusCodePattern.test(str);
+        const isRoleNameHandler = (str) => rolePermissionNames.has(str.toLowerCase());
+        const isHttpMethodHandler = (str) => httpMethods.has(str.toUpperCase());
+        const isEnvironmentNameHandler = (str) => environmentNames.has(str.toLowerCase());
+        const isLogLevelHandler = (str) => logLevels.has(str.toLowerCase());
+        const isStatusStringHandler = (str) => statusStrings.has(str.toLowerCase());
+        const isPriorityLevelHandler = (str) => priorityLevels.has(str.toLowerCase());
+
+        // Check if string should be flagged even if it matches technical patterns
+        const isFlaggedSpecialStringHandler = (str) => isHttpStatusCodeHandler(str)
+            || isRoleNameHandler(str)
+            || isHttpMethodHandler(str)
+            || isEnvironmentNameHandler(str)
+            || isLogLevelHandler(str)
+            || isStatusStringHandler(str)
+            || isPriorityLevelHandler(str);
+
+        // Get descriptive error message based on string type
+        const getErrorMessageHandler = (str, context = "") => {
+            const truncatedStr = str.length > 30 ? `${str.substring(0, 30)}...` : str;
+            const contextPart = context ? ` in ${context}` : "";
+
+            if (isHttpStatusCodeHandler(str)) {
+                return `Hardcoded HTTP status code "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            if (isRoleNameHandler(str)) {
+                return `Hardcoded role/permission "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            if (isHttpMethodHandler(str)) {
+                return `Hardcoded HTTP method "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            if (isEnvironmentNameHandler(str)) {
+                return `Hardcoded environment name "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            if (isLogLevelHandler(str)) {
+                return `Hardcoded log level "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            if (isStatusStringHandler(str)) {
+                return `Hardcoded status "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            if (isPriorityLevelHandler(str)) {
+                return `Hardcoded priority level "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
+            }
+
+            return `Hardcoded string "${truncatedStr}"${contextPart} should be imported from @/data or @/strings or @/constants or @/@constants or @/@strings`;
+        };
+
+        // Check if a string matches any ignore pattern (but not if it's a flagged special string)
+        const shouldIgnoreStringHandler = (str) => {
+            // Always flag HTTP status codes and role names
+            if (isFlaggedSpecialStringHandler(str)) return false;
+
+            return allIgnorePatterns.some((pattern) => pattern.test(str));
+        };
+
+        // Check if we're inside a constants/strings/data/enums file
         const isConstantsFileHandler = () => {
             const filename = context.filename || context.getFilename();
             const normalizedPath = filename.replace(/\\/g, "/").toLowerCase();
 
-            // Check if file is in constants/strings folders
-            return /\/(constants|strings|@constants|@strings)(\/|\.)/i.test(normalizedPath)
+            // Check if file is in constants/strings/data/enums folders
+            return /\/(constants|strings|@constants|@strings|data|@data|enums|@enums)(\/|\.)/i.test(normalizedPath)
                 || /\/data\/(constants|strings)/i.test(normalizedPath);
         };
 
@@ -13838,8 +14276,8 @@ const noHardcodedStrings = {
 
             if (typeof importPath !== "string") return;
 
-            // Check if import is from constants/strings
-            const isFromConstants = /@?\/?(@?constants|@?strings|data\/constants|data\/strings)/i
+            // Check if import is from constants/strings/data/enums
+            const isFromConstants = /@?\/?(@?constants|@?strings|@?data|@?enums|data\/constants|data\/strings)/i
                 .test(importPath);
 
             if (isFromConstants) {
@@ -13931,9 +14369,17 @@ const noHardcodedStrings = {
                 if (current.type === "VariableDeclarator") {
                     const varName = current.id && current.id.name;
 
-                    // Check if variable name suggests it's a constants object
-                    if (varName && /^[A-Z][A-Z0-9_]*$|CONSTANTS?|STRINGS?|MESSAGES?|LABELS?|TEXTS?/i.test(varName)) {
-                        return true;
+                    if (varName) {
+                        // Check for SCREAMING_SNAKE_CASE (e.g., MY_CONSTANT, API_URL)
+                        if (/^[A-Z][A-Z0-9_]*$/.test(varName)) {
+                            return true;
+                        }
+
+                        // Check for exact keywords or keywords at word boundaries (not in Handler names)
+                        // Match: MESSAGES, Messages, userMessages, but NOT longMessageHandler
+                        if (/^(constants?|strings?|messages?|labels?|texts?|data)$/i.test(varName)) {
+                            return true;
+                        }
                     }
                 }
 
@@ -13960,13 +14406,18 @@ const noHardcodedStrings = {
             JSXText(node) {
                 const text = node.value.trim();
 
-                if (!text || shouldIgnoreStringHandler(text)) return;
+                if (!text) return;
+
+                // Check if it's a flagged special string (status code, role name)
+                const isSpecialString = isFlaggedSpecialStringHandler(text);
 
-                // Check if it looks like user-facing text (contains letters and spaces)
-                if (!/[a-zA-Z]/.test(text)) return;
+                if (!isSpecialString && shouldIgnoreStringHandler(text)) return;
+
+                // Check if it looks like user-facing text (contains letters) - skip for special strings
+                if (!isSpecialString && !/[a-zA-Z]/.test(text)) return;
 
                 context.report({
-                    message: `Hardcoded string "${text.substring(0, 30)}${text.length > 30 ? "..." : ""}" should be imported from constants/strings module`,
+                    message: getErrorMessageHandler(text, "JSX"),
                     node,
                 });
             },
@@ -13982,13 +14433,16 @@ const noHardcodedStrings = {
                 if (expression.type === "Literal" && typeof expression.value === "string") {
                     const str = expression.value;
 
-                    if (shouldIgnoreStringHandler(str)) return;
+                    // Check if it's a flagged special string (status code, role name)
+                    const isSpecialString = isFlaggedSpecialStringHandler(str);
+
+                    if (!isSpecialString && shouldIgnoreStringHandler(str)) return;
 
-                    // Check if it looks like user-facing text
-                    if (!/[a-zA-Z]/.test(str)) return;
+                    // Check if it looks like user-facing text - skip for special strings
+                    if (!isSpecialString && !/[a-zA-Z]/.test(str)) return;
 
                     context.report({
-                        message: `Hardcoded string "${str.substring(0, 30)}${str.length > 30 ? "..." : ""}" should be imported from constants/strings module`,
+                        message: getErrorMessageHandler(str, "JSX expression"),
                         node: expression,
                     });
                 }
@@ -13998,16 +14452,19 @@ const noHardcodedStrings = {
                     expression.quasis.forEach((quasi) => {
                         const str = quasi.value.cooked || quasi.value.raw;
 
-                        if (shouldIgnoreStringHandler(str)) return;
+                        // Check if it's a flagged special string (status code, role name)
+                        const isSpecialString = isFlaggedSpecialStringHandler(str);
 
-                        // Check if it contains user-facing text (more than just variable placeholders)
-                        if (!/[a-zA-Z]{2,}/.test(str)) return;
+                        if (!isSpecialString && shouldIgnoreStringHandler(str)) return;
+
+                        // Check if it contains user-facing text - skip for special strings
+                        if (!isSpecialString && !/[a-zA-Z]{2,}/.test(str)) return;
 
                         // Skip if it looks like a path or URL pattern
                         if (/^[/.]|https?:\/\//.test(str)) return;
 
                         context.report({
-                            message: `Hardcoded string in template literal "${str.substring(0, 30)}${str.length > 30 ? "..." : ""}" should be imported from constants/strings module`,
+                            message: getErrorMessageHandler(str, "template literal"),
                             node: quasi,
                         });
                     });
@@ -14034,15 +14491,19 @@ const noHardcodedStrings = {
                 if (node.value.type === "Literal" && typeof node.value.value === "string") {
                     const str = node.value.value;
 
-                    if (shouldIgnoreStringHandler(str)) return;
+                    // Check if it's a flagged special string (status code, role name)
+                    const isSpecialString = isFlaggedSpecialStringHandler(str);
+
+                    if (!isSpecialString && shouldIgnoreStringHandler(str)) return;
 
-                    // Check if it looks like user-facing text (contains letters and multiple words or is long)
-                    if (!/[a-zA-Z]/.test(str)) return;
+                    // Check if it looks like user-facing text - skip for special strings
+                    if (!isSpecialString && !/[a-zA-Z]/.test(str)) return;
 
-                    if (str.split(/\s+/).length < 2 && str.length < 10) return;
+                    // Require multiple words or reasonable length for non-special strings
+                    if (!isSpecialString && str.split(/\s+/).length < 2 && str.length < 10) return;
 
                     context.report({
-                        message: `Hardcoded string "${str.substring(0, 30)}${str.length > 30 ? "..." : ""}" in attribute "${attrName}" should be imported from constants/strings module`,
+                        message: getErrorMessageHandler(str, `attribute "${attrName}"`),
                         node: node.value,
                     });
                 }
@@ -14057,14 +14518,18 @@ const noHardcodedStrings = {
                     if (expression.type === "Literal" && typeof expression.value === "string") {
                         const str = expression.value;
 
-                        if (shouldIgnoreStringHandler(str)) return;
+                        // Check if it's a flagged special string (status code, role name)
+                        const isSpecialString = isFlaggedSpecialStringHandler(str);
 
-                        if (!/[a-zA-Z]/.test(str)) return;
+                        if (!isSpecialString && shouldIgnoreStringHandler(str)) return;
 
-                        if (str.split(/\s+/).length < 2 && str.length < 10) return;
+                        if (!isSpecialString && !/[a-zA-Z]/.test(str)) return;
+
+                        // Require multiple words or reasonable length for non-special strings
+                        if (!isSpecialString && str.split(/\s+/).length < 2 && str.length < 10) return;
 
                         context.report({
-                            message: `Hardcoded string "${str.substring(0, 30)}${str.length > 30 ? "..." : ""}" in attribute "${attrName}" should be imported from constants/strings module`,
+                            message: getErrorMessageHandler(str, `attribute "${attrName}"`),
                             node: expression,
                         });
                     }
@@ -14078,8 +14543,11 @@ const noHardcodedStrings = {
 
                 const str = node.value;
 
-                // Skip if it matches ignore patterns
-                if (shouldIgnoreStringHandler(str)) return;
+                // Check if it's a flagged special string (status code, role name)
+                const isSpecialString = isFlaggedSpecialStringHandler(str);
+
+                // Skip if it matches ignore patterns (but not special strings)
+                if (!isSpecialString && shouldIgnoreStringHandler(str)) return;
 
                 // Skip if not in relevant context
                 if (!isInRelevantContextHandler(node)) return;
@@ -14096,14 +14564,14 @@ const noHardcodedStrings = {
                 // Skip object property keys
                 if (node.parent.type === "Property" && node.parent.key === node) return;
 
-                // Skip if it doesn't look like user-facing text
-                if (!/[a-zA-Z]/.test(str)) return;
+                // Skip if it doesn't look like user-facing text - but not for special strings
+                if (!isSpecialString && !/[a-zA-Z]/.test(str)) return;
 
-                // Require at least 2 words or be reasonably long to be considered user-facing
-                if (str.split(/\s+/).length < 2 && str.length < 15) return;
+                // Require at least 2 words or be reasonably long - but not for special strings
+                if (!isSpecialString && str.split(/\s+/).length < 2 && str.length < 15) return;
 
                 context.report({
-                    message: `Hardcoded string "${str.substring(0, 30)}${str.length > 30 ? "..." : ""}" should be imported from constants/strings module`,
+                    message: getErrorMessageHandler(str),
                     node,
                 });
             },
@@ -14123,10 +14591,13 @@ const noHardcodedStrings = {
                 node.quasis.forEach((quasi) => {
                     const str = quasi.value.cooked || quasi.value.raw;
 
-                    if (shouldIgnoreStringHandler(str)) return;
+                    // Check if it's a flagged special string (status code, role name)
+                    const isSpecialString = isFlaggedSpecialStringHandler(str);
+
+                    if (!isSpecialString && shouldIgnoreStringHandler(str)) return;
 
-                    // Check if it contains substantial user-facing text
-                    if (!/[a-zA-Z]{3,}/.test(str)) return;
+                    // Check if it contains substantial user-facing text - but not for special strings
+                    if (!isSpecialString && !/[a-zA-Z]{3,}/.test(str)) return;
 
                     // Skip if it looks like a path, URL, or query
                     if (/^[/.]|^https?:\/\/|^[?&]/.test(str)) return;
@@ -14135,7 +14606,7 @@ const noHardcodedStrings = {
                     if (node.expressions.length > node.quasis.length) return;
 
                     context.report({
-                        message: `Hardcoded string in template literal "${str.substring(0, 30)}${str.length > 30 ? "..." : ""}" should be imported from constants/strings module`,
+                        message: getErrorMessageHandler(str, "template literal"),
                         node: quasi,
                     });
                 });
@@ -19291,6 +19762,7 @@ export default {
         "ternary-condition-multiline": ternaryConditionMultiline,
 
         // Class rules
+        "class-method-definition-format": classMethodDefinitionFormat,
         "class-naming-convention": classNamingConvention,
 
         // Function rules

package/package.json

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