eslint-plugin-code-style 1.17.0 → 1.17.2

package/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.17.2] - 2026-02-09
+
+**Fix: CamelCase Naming Auto-Fix & Prefix Enforcement**
+
+**Version Range:** v1.17.1 → v1.17.2
+
+### Fixed
+
+- **`folder-based-naming-convention`** - Fix camelCase naming enforcement for constants, data, reducers, services, and strings folders
+  - Auto-fix missing suffix: `common` → `commonConstants` on save (all camelCase folders)
+  - Near-match prefix enforcement: `routeConstants` → `routesConstants` when file is `routes.ts`
+  - Multi-export files with unrelated prefixes (e.g., `buttonTypeData` in `data/app.ts`) are not flagged
+
+**Full Changelog:** [v1.17.1...v1.17.2](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.17.1...v1.17.2)
+
+---
+
+## [1.17.1] - 2026-02-09
+
+**Fix: Index File Behavior in Wrapped Folders**
+
+**Version Range:** v1.17.0 → v1.17.1
+
+### Fixed
+
+- **`index-exports-only`** - Enforce dual index file behavior for wrapped folder structure
+  - Root module index (`views/index.ts`) → barrel only (re-exports)
+  - Subfolder index (`views/assessment/index.tsx`) → must contain component code, not just re-exports
+  - Only one barrel per module — subfolder index files that simulate a barrel are flagged
+- **`no-redundant-folder-suffix`** - Detect file name matching parent folder name (e.g., `assessment/assessment.tsx` → use `assessment/index.tsx`)
+
+**Full Changelog:** [v1.17.0...v1.17.1](https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.17.0...v1.17.1)
+
+---
+
 ## [1.17.0] - 2026-02-09
 
 **New Rule + Enhancements to Naming & Import Rules**
@@ -1806,6 +1841,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+[1.17.2]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.17.1...v1.17.2
+[1.17.1]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.17.0...v1.17.1
 [1.17.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.16.0...v1.17.0
 [1.16.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.15.0...v1.16.0
 [1.15.0]: https://github.com/Mohamed-Elhawary/eslint-plugin-code-style/compare/v1.14.4...v1.15.0

package/index.js

@@ -8022,23 +8022,37 @@ const indexExportsOnly = {
 
         if (!isIndexFile) return {};
 
-        // Helper to check if a node is an import or export statement
-        const isImportOrExportHandler = (node) => {
+        // Determine if this is a subfolder index inside a module folder
+        // e.g., views/assessment/index.tsx (depth >= 2 from module folder) = subfolder index
+        // vs views/index.ts (depth == 1 from module folder) = root barrel
+        const moduleFolders = [
+            "actions", "apis", "assets", "atoms", "components", "config", "configs",
+            "constants", "contexts", "data", "enums", "helpers", "hooks", "interfaces",
+            "layouts", "lib", "middlewares", "pages", "providers", "reducers", "redux",
+            "requests", "routes", "schemas", "services", "store", "strings", "styles",
+            "theme", "themes", "thunks", "types", "ui", "utils", "utilities", "views",
+        ];
+        const parts = normalizedFilename.split("/");
+        const indexPos = parts.length - 1;
+        let isSubfolderIndex = false;
+
+        for (let i = 0; i < indexPos; i++) {
+            if (moduleFolders.includes(parts[i])) {
+                if (indexPos - i >= 2) isSubfolderIndex = true;
+
+                break;
+            }
+        }
+
+        // Helper to check if a node is an import or re-export (no inline declarations)
+        const isImportOrReexportHandler = (node) => {
             const { type } = node;
 
-            // Import statements
             if (type === "ImportDeclaration") return true;
 
-            // Export statements (named, default, all)
-            if (type === "ExportNamedDeclaration") {
-                // Only allow re-exports (export { x } from "./module" or export { x })
-                // If it has a declaration, it's defining something (not allowed)
-                return !node.declaration;
-            }
+            if (type === "ExportNamedDeclaration") return !node.declaration;
 
             if (type === "ExportDefaultDeclaration") {
-                // Allow export default <identifier> (re-exporting)
-                // Disallow export default function/class/object (defining something)
                 return node.declaration && node.declaration.type === "Identifier";
             }
 
@@ -8047,6 +8061,21 @@ const indexExportsOnly = {
             return false;
         };
 
+        // Helper to check if a node contains actual code (declarations, logic)
+        const hasCodeDeclarationHandler = (node) => {
+            const { type } = node;
+
+            if (type === "VariableDeclaration" || type === "FunctionDeclaration" || type === "ClassDeclaration") return true;
+
+            if (type === "ExportNamedDeclaration" && node.declaration) return true;
+
+            if (type === "ExportDefaultDeclaration") {
+                return node.declaration && node.declaration.type !== "Identifier";
+            }
+
+            return false;
+        };
+
         // Get a friendly description of what the disallowed node is
         const getNodeDescriptionHandler = (node) => {
             switch (node.type) {
@@ -8063,9 +8092,7 @@ const indexExportsOnly = {
                 case "ClassDeclaration":
                     return "Class declaration";
                 case "ExportNamedDeclaration":
-                    if (node.declaration) {
-                        return getNodeDescriptionHandler(node.declaration);
-                    }
+                    if (node.declaration) return getNodeDescriptionHandler(node.declaration);
 
                     return "Export with inline declaration";
                 case "ExportDefaultDeclaration":
@@ -8077,8 +8104,28 @@ const indexExportsOnly = {
 
         return {
             Program(programNode) {
+                if (isSubfolderIndex) {
+                    // Subfolder index (e.g., views/assessment/index.tsx):
+                    // Must contain component code — must NOT be a barrel (re-exports only)
+                    // Only one barrel per module (the root index)
+                    const hasCode = programNode.body.some((node) => hasCodeDeclarationHandler(node));
+
+                    if (!hasCode) {
+                        const subfolder = parts[indexPos - 1];
+
+                        context.report({
+                            message: `Subfolder index file "${subfolder}/index" should contain component code, not just re-exports. Only the module root index file should be a barrel for imports and re-exports.`,
+                            node: programNode,
+                        });
+                    }
+
+                    return;
+                }
+
+                // Root module index (e.g., views/index.ts):
+                // Must be barrel only — no code declarations allowed
                 for (const node of programNode.body) {
-                    if (!isImportOrExportHandler(node)) {
+                    if (!isImportOrReexportHandler(node)) {
                         const description = getNodeDescriptionHandler(node);
 
                         context.report({
@@ -8091,7 +8138,7 @@ const indexExportsOnly = {
         };
     },
     meta: {
-        docs: { description: "Index files should only contain imports and re-exports, not code definitions" },
+        docs: { description: "Enforce index files as barrels (re-exports only) at module root, and as component entry points (with code) in subfolders" },
         schema: [],
         type: "suggestion",
     },
@@ -19281,17 +19328,38 @@ const folderBasedNamingConvention = {
         // Check if name starts with lowercase (camelCase)
         const isCamelCaseHandler = (name) => name && /^[a-z]/.test(name);
 
-        // Build suffix message for camelCase folders
-        const buildSuffixMessageHandler = (name, folder, suffix) => `"${name}" in "${folder}" folder must end with "${suffix}" suffix (e.g., "myItem${suffix}")`;
-
-        // Check camelCase naming (suffix-only enforcement for camelCase folders)
-        const checkCamelCaseHandler = (name, folder, suffix, identifierNode) => {
-            // For camelCase folders, only enforce the suffix (not full chained name)
-            // because these folders often have multiple exports per file
-            // Suffix stays PascalCase even in camelCase names (e.g., buttonTypeData)
+        // Check camelCase naming for camelCase folders (constants, data, reducers, services, strings)
+        const checkCamelCaseHandler = (name, folder, suffix, identifierNode, scopeNode, moduleInfo) => {
             if (!name.endsWith(suffix)) {
+                // Missing suffix — auto-fix by appending suffix
+                const fixedName = name + suffix;
+
+                context.report({
+                    fix: createRenameFixer(scopeNode, name, fixedName, identifierNode),
+                    message: `"${name}" in "${folder}" folder must end with "${suffix}" suffix (should be "${fixedName}")`,
+                    node: identifierNode,
+                });
+
+                return;
+            }
+
+            // Has correct suffix — check if prefix is a near-match of expected file-based name
+            // This catches cases like "routeConstants" → "routesConstants" (file is routes.ts)
+            // but allows unrelated names like "buttonTypeData" in data/app.ts
+            const expectedName = buildExpectedNameHandler(moduleInfo);
+
+            if (!expectedName || name === expectedName) return;
+
+            const actualPrefix = name.slice(0, -suffix.length);
+            const expectedPrefix = expectedName.slice(0, -suffix.length);
+
+            const isNearMatch = (expectedPrefix.startsWith(actualPrefix) && (expectedPrefix.length - actualPrefix.length) <= 2)
+                || (actualPrefix.startsWith(expectedPrefix) && (actualPrefix.length - expectedPrefix.length) <= 2);
+
+            if (isNearMatch) {
                 context.report({
-                    message: buildSuffixMessageHandler(name, folder, suffix),
+                    fix: createRenameFixer(scopeNode, name, expectedName, identifierNode),
+                    message: `"${name}" in "${folder}" folder should be "${expectedName}" to match the file name`,
                     node: identifierNode,
                 });
             }
@@ -19311,11 +19379,11 @@ const folderBasedNamingConvention = {
 
             const { folder, suffix } = moduleInfo;
 
-            // For camelCase folders, only enforce suffix
+            // For camelCase folders, enforce suffix + near-match prefix check
             if (camelCaseFolders.has(folder)) {
                 if (!isCamelCaseHandler(name) || !suffix) return;
 
-                checkCamelCaseHandler(name, folder, suffix, identifierNode);
+                checkCamelCaseHandler(name, folder, suffix, identifierNode, node, moduleInfo);
 
                 return;
             }
@@ -19357,11 +19425,11 @@ const folderBasedNamingConvention = {
 
             const name = node.id.name;
 
-            // For camelCase folders, only enforce suffix
+            // For camelCase folders, enforce suffix + near-match prefix check
             if (camelCaseFolders.has(folder)) {
                 if (!isCamelCaseHandler(name) || !suffix) return;
 
-                checkCamelCaseHandler(name, folder, suffix, node.id);
+                checkCamelCaseHandler(name, folder, suffix, node.id, node, moduleInfo);
 
                 return;
             }

package/package.json

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