eslint-plugin-code-style 1.9.1 → 1.9.3

package/CHANGELOG.md

@@ -7,15 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
-## [1.9.1] - 2026-02-03
+## [1.9.3] - 2026-02-03
+
+### Enhanced
+
+- **`no-hardcoded-strings`** - Remove single-word string length limitations and add more special cases:
+  - Removed length restrictions (now detects all single-word hardcoded strings)
+  - Added validation strings: `empty`, `invalid`, `missing`, `optional`, `required`, `valid`
+  - Added auth state strings: `anonymous`, `authenticated`, `authed`, `authorized`, `denied`, `forbidden`, `granted`, `locked`, `loggedin`, `loggedout`, `revoked`, `unauthenticated`, `unauthorized`, `unlocked`, `unverified`, `verified`
+  - Added more status strings: `done`, `finished`, `inprogress`, `queued`, `ready`, `running`, `started`, `stopped`, `successful`, `waiting`
+  - Made technical patterns stricter to avoid false negatives (camelCase requires uppercase in middle, snake_case requires underscore, kebab-case requires hyphen)
+
+---
+
+## [1.9.2] - 2026-02-03
 
 ### Enhanced
 
-- **`no-hardcoded-strings`** - Now detects additional hardcoded values:
-  - HTTP status codes (4xx, 5xx like "404", "422", "500") with descriptive error message
-  - Role/permission names ("admin", "user", "moderator", etc.) with descriptive error message
-  - Added `@/data` as preferred import source for enums/objects
-  - Improved error messages to mention all valid import sources
+- **`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
 
@@ -23,6 +41,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [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**
@@ -1260,6 +1288,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.9.3]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.9.2...v1.9.3
+[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

package/README.md

@@ -3427,9 +3427,14 @@ const YetAnotherBad = ({ title }) => {
 
 **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:**
-- **HTTP status codes** (4xx, 5xx like "404", "500") — should be imported from `@/data` as enums/objects
-- **Role/permission names** ("admin", "user", "moderator", etc.) — should be imported from `@/data` as enums/objects
+**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:**
 
@@ -3447,7 +3452,7 @@ 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 "@/data";
+import { HttpStatus, UserRole } from "@/enums";
 
 const ComponentHandler = () => (
     <div>
@@ -3490,11 +3495,14 @@ if (role === "admin") { ... }
 }]
 ```
 
-**Valid import paths for constants:**
-- `@/data` (preferred for enums/objects like HttpStatus, UserRole)
-- `@/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`
 
 ---
 

package/index.js

@@ -13826,17 +13826,26 @@ const stringPropertySpacing = {
  *   This promotes maintainability, consistency, and enables
  *   easier internationalization.
  *
- *   The rule also detects:
- *   - HTTP status codes (4xx, 5xx) that should be imported from @/data or enums
- *   - Role/permission names (admin, user, moderator, etc.) that should be from @/data
- *
- * Valid import sources:
- *   - @/data (enums, objects)
+ *   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)
@@ -13845,7 +13854,7 @@ const stringPropertySpacing = {
  * ✓ Good:
  *   import { BUTTON_LABEL, ERROR_MESSAGE } from "@/constants";
  *   import { welcomeText } from "@/strings";
- *   import { HttpStatus, UserRole } from "@/data";
+ *   import { HttpStatus, UserRole } from "@/enums";
  *
  *   <button>{BUTTON_LABEL}</button>
  *   <span>{ERROR_MESSAGE}</span>
@@ -14046,22 +14055,21 @@ const noHardcodedStrings = {
             /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/,
             // Time formats
             /^\d{1,2}:\d{2}(:\d{2})?(\s?(AM|PM|am|pm))?$/,
-            // JSON keys (camelCase, snake_case, SCREAMING_SNAKE_CASE)
-            /^[a-z][a-zA-Z0-9]*$/,
-            /^[a-z][a-z0-9_]*$/,
-            /^[A-Z][A-Z0-9_]*$/,
+            // JSON keys - require actual naming convention markers (underscore/uppercase in middle)
+            // camelCase: must have uppercase letter in middle (e.g., userId, firstName)
+            /^[a-z]+[A-Z][a-zA-Z0-9]*$/,
+            // snake_case: must have underscore (e.g., user_id, first_name)
+            /^[a-z][a-z0-9]*_[a-z0-9_]*$/,
+            // SCREAMING_SNAKE_CASE: must have underscore (e.g., MAX_VALUE, API_URL)
+            /^[A-Z][A-Z0-9]*_[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
-            /^[A-Z][A-Z0-9_]*$/,
             // Query parameters
             /^[a-z][a-zA-Z0-9_]*=/,
-            // CSS property-like
-            /^[a-z]+(-[a-z]+)*$/,
+            // CSS property-like (kebab-case): must have hyphen (e.g., font-size, background-color)
+            /^[a-z]+-[a-z]+(-[a-z]+)*$/,
             // Numbers with separators
             /^[\d,._]+$/,
             // Semantic version
@@ -14082,10 +14090,10 @@ const noHardcodedStrings = {
 
         const allIgnorePatterns = [...technicalPatterns, ...extraIgnorePatterns];
 
-        // HTTP status codes that should NOT be hardcoded (4xx and 5xx error codes)
-        const httpStatusCodePattern = /^[45]\d{2}$/;
+        // 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 data/enums
+        // Common role/permission names that should be imported from enums/data
         const rolePermissionNames = new Set([
             "admin",
             "administrator",
@@ -14104,14 +14112,152 @@ const noHardcodedStrings = {
             "viewer",
         ]);
 
-        // Check if string looks like an HTTP status code
-        const isHttpStatusCodeHandler = (str) => httpStatusCodePattern.test(str);
+        // 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",
+        ]);
+
+        // 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",
+            "done",
+            "draft",
+            "enabled",
+            "expired",
+            "failed",
+            "finished",
+            "inactive",
+            "inprogress",
+            "open",
+            "paused",
+            "pending",
+            "processing",
+            "published",
+            "queued",
+            "ready",
+            "rejected",
+            "resolved",
+            "running",
+            "scheduled",
+            "started",
+            "stopped",
+            "submitted",
+            "success",
+            "successful",
+            "suspended",
+            "verified",
+            "waiting",
+        ]);
+
+        // Validation/form strings that should be imported from enums/data
+        const validationStrings = new Set([
+            "empty",
+            "invalid",
+            "missing",
+            "optional",
+            "required",
+            "valid",
+        ]);
+
+        // Auth/permission state strings that should be imported from enums/data
+        const authStrings = new Set([
+            "anonymous",
+            "authenticated",
+            "authed",
+            "authorized",
+            "denied",
+            "expired",
+            "forbidden",
+            "granted",
+            "locked",
+            "loggedin",
+            "loggedout",
+            "revoked",
+            "unauthenticated",
+            "unauthorized",
+            "unlocked",
+            "unverified",
+            "verified",
+        ]);
+
+        // Priority levels that should be imported from enums/data
+        const priorityLevels = new Set([
+            "critical",
+            "high",
+            "highest",
+            "low",
+            "lowest",
+            "medium",
+            "normal",
+            "urgent",
+        ]);
 
-        // Check if string is a role/permission name
+        // 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());
+        const isValidationStringHandler = (str) => validationStrings.has(str.toLowerCase());
+        const isAuthStringHandler = (str) => authStrings.has(str.toLowerCase());
 
         // Check if string should be flagged even if it matches technical patterns
-        const isFlaggedSpecialStringHandler = (str) => isHttpStatusCodeHandler(str) || isRoleNameHandler(str);
+        const isFlaggedSpecialStringHandler = (str) => isHttpStatusCodeHandler(str)
+            || isRoleNameHandler(str)
+            || isHttpMethodHandler(str)
+            || isEnvironmentNameHandler(str)
+            || isLogLevelHandler(str)
+            || isStatusStringHandler(str)
+            || isPriorityLevelHandler(str)
+            || isValidationStringHandler(str)
+            || isAuthStringHandler(str);
 
         // Get descriptive error message based on string type
         const getErrorMessageHandler = (str, context = "") => {
@@ -14119,14 +14265,42 @@ const noHardcodedStrings = {
             const contextPart = context ? ` in ${context}` : "";
 
             if (isHttpStatusCodeHandler(str)) {
-                return `Hardcoded HTTP status code "${truncatedStr}"${contextPart} should be imported from @/data (enum/object) or @/constants`;
+                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 @/data (enum/object) or @/constants`;
+                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`;
+            }
+
+            if (isValidationStringHandler(str)) {
+                return `Hardcoded validation string "${truncatedStr}"${contextPart} should be imported from @/enums or @/data`;
             }
 
-            return `Hardcoded string "${truncatedStr}"${contextPart} should be imported from @/data, @/strings, @/constants, or constants module`;
+            if (isAuthStringHandler(str)) {
+                return `Hardcoded auth state "${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)
@@ -14137,13 +14311,13 @@ const noHardcodedStrings = {
             return allIgnorePatterns.some((pattern) => pattern.test(str));
         };
 
-        // Check if we're inside a constants/strings/data file
+        // 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/data folders
-            return /\/(constants|strings|@constants|@strings|data|@data)(\/|\.)/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);
         };
 
@@ -14156,8 +14330,8 @@ const noHardcodedStrings = {
 
             if (typeof importPath !== "string") return;
 
-            // Check if import is from constants/strings/data
-            const isFromConstants = /@?\/?(@?constants|@?strings|@?data|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) {
@@ -14255,8 +14429,9 @@ const noHardcodedStrings = {
                             return true;
                         }
 
-                        // Check for keywords that suggest constants (case-insensitive)
-                        if (/CONSTANTS?|STRINGS?|MESSAGES?|LABELS?|TEXTS?|DATA$/i.test(varName)) {
+                        // 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;
                         }
                     }
@@ -14378,9 +14553,6 @@ const noHardcodedStrings = {
                     // Check if it looks like user-facing text - skip for special strings
                     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: getErrorMessageHandler(str, `attribute "${attrName}"`),
                         node: node.value,
@@ -14404,9 +14576,6 @@ const noHardcodedStrings = {
 
                         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: getErrorMessageHandler(str, `attribute "${attrName}"`),
                             node: expression,
@@ -14446,9 +14615,6 @@ const noHardcodedStrings = {
                 // 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 - but not for special strings
-                if (!isSpecialString && str.split(/\s+/).length < 2 && str.length < 15) return;
-
                 context.report({
                     message: getErrorMessageHandler(str),
                     node,

package/package.json

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