eslint-plugin-code-style 1.15.0 → 1.17.0

package/index.js

@@ -6494,6 +6494,10 @@ const enumTypeEnforcement = {
  *   Local paths (starting with @/) should only import from
  *   folder-level index files.
  *
+ *   Exception: Files within the same module folder should use
+ *   relative imports (./sibling) to avoid circular dependencies
+ *   through the index file.
+ *
  * Options:
  *   - aliasPrefix: string (default: "@/") - Change path alias prefix if your project uses something other than @/ (e.g., ~/, src/)
  *   - extraAllowedFolders: string[] - Add custom folders that can be imported with @/folder. Extends defaults without replacing them
@@ -6506,10 +6510,14 @@ const enumTypeEnforcement = {
  * ✓ Good:
  *   import { Button } from "@/components";
  *   import { useAuth } from "@/hooks";
+ *   // Sibling import within same folder (avoids circular deps):
+ *   import { helpers } from "./helpers";  (when in data/app.js importing data/helpers.js)
  *
  * ✗ Bad:
  *   import { Button } from "@/components/buttons/primary-button";
  *   import { useAuth } from "@/hooks/auth/useAuth";
+ *   // Same-folder absolute import (circular dependency risk):
+ *   import { helpers } from "@/data";  (when file is inside data/ folder)
  *
  * Configuration Example:
  *   "code-style/absolute-imports-only": ["error", {
@@ -6606,15 +6614,34 @@ const absoluteImportsOnly = {
                 // to use relative imports for app root and styles (e.g., ./index.css, ./app)
                 const isEntryFile = /\/main\.(js|jsx|ts|tsx)$/.test(normalizedFilename);
 
+                // Detect if the file is inside a module folder at any depth
+                // e.g., data/app.js, data/auth/login/guest.tsx are both inside "data"
+                const getParentModuleFolderHandler = () => {
+                    for (const folder of allowedFolders) {
+                        const pattern = new RegExp(`/(${folder})/`);
+
+                        if (pattern.test(normalizedFilename)) return folder;
+                    }
+
+                    return null;
+                };
+
+                const parentModuleFolder = getParentModuleFolderHandler();
+
                 // 1. Disallow relative imports (starting with ./ or ../)
-                // EXCEPT in index files which need relative imports for re-exports
+                // EXCEPT in index files, entry files, and sibling files within the same module folder
                 if (importPath.startsWith("./") || importPath.startsWith("../")) {
-                    if (!isIndexFile && !isEntryFile) {
-                        context.report({
-                            message: `Relative imports are not allowed. Use absolute imports with "${aliasPrefix}" prefix instead.`,
-                            node: node.source,
-                        });
-                    }
+                    // Always allow in index files and entry files
+                    if (isIndexFile || isEntryFile) return;
+
+                    // Allow relative imports within the same module folder (any depth)
+                    // e.g., data/app.js → "./helpers", data/auth/forget-password/index.ts → "../../login/guest"
+                    if (parentModuleFolder) return;
+
+                    context.report({
+                        message: `Relative imports are not allowed. Use absolute imports with "${aliasPrefix}" prefix instead.`,
+                        node: node.source,
+                    });
 
                     return;
                 }
@@ -6662,6 +6689,39 @@ const absoluteImportsOnly = {
                         return;
                     }
 
+                    // Check if importing from own parent module folder (circular dependency risk)
+                    // e.g., data/app.js importing @/data → should use relative import instead
+                    if (parentModuleFolder && folderName === parentModuleFolder) {
+                        const targetRelativeToModule = segments.slice(1).join("/");
+
+                        // Deep path within own module (e.g., @/data/auth/login/guest) — auto-fixable
+                        if (targetRelativeToModule) {
+                            const moduleIndex = normalizedFilename.lastIndexOf(`/${parentModuleFolder}/`);
+                            const fileRelativeToModule = normalizedFilename.slice(moduleIndex + parentModuleFolder.length + 2);
+                            const fileDir = fileRelativeToModule.substring(0, fileRelativeToModule.lastIndexOf("/"));
+
+                            let relativePath = nodePath.posix.relative(fileDir, targetRelativeToModule);
+
+                            if (!relativePath.startsWith(".")) relativePath = `./${relativePath}`;
+
+                            context.report({
+                                message: `Files within "${parentModuleFolder}/" should use relative imports (e.g., "${relativePath}") instead of "${importPath}" to avoid circular dependencies.`,
+                                node: node.source,
+                                fix: (fixer) => fixer.replaceText(node.source, `"${relativePath}"`),
+                            });
+
+                            return;
+                        }
+
+                        // Barrel import to own module (e.g., @/data from inside data/) — report only
+                        context.report({
+                            message: `Files within "${parentModuleFolder}/" should use relative imports instead of "${importPath}" to avoid circular dependencies through the index file.`,
+                            node: node.source,
+                        });
+
+                        return;
+                    }
+
                     // Only one segment is allowed (import from index file)
                     // e.g., @/atoms is OK, @/atoms/menus is NOT OK
                     // EXCEPTION: Redux ecosystem - @/redux/actions, @/redux/types, etc. are allowed
@@ -6707,7 +6767,8 @@ const absoluteImportsOnly = {
         };
     },
     meta: {
-        docs: { description: "Enforce absolute imports from index files only for local paths" },
+        docs: { description: "Enforce absolute imports from index files only for local paths, with relative imports required for files within the same module folder" },
+        fixable: "code",
         schema: [
             {
                 additionalProperties: false,
@@ -8036,6 +8097,149 @@ const indexExportsOnly = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Inline Export Declaration
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   In non-index files, enforce inline export declarations instead
+ *   of declaring variables/functions separately and then exporting
+ *   them with a grouped export statement at the end.
+ *
+ *   This does NOT apply to index files (which use barrel re-exports).
+ *
+ * ✓ Good:
+ *   export const strings = { ... };
+ *
+ *   export const buttonTypeData = { button: "button" };
+ *
+ *   export const submitHandler = () => { ... };
+ *
+ * ✗ Bad:
+ *   const strings = { ... };
+ *   export { strings };
+ *
+ * ✗ Bad:
+ *   const foo = 1;
+ *   const bar = 2;
+ *   export { foo, bar };
+ *
+ * Auto-fixable: Yes — adds "export" to each declaration and removes
+ * the grouped export statement.
+ */
+const inlineExportDeclaration = {
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        const normalizedFilename = filename.replace(/\\/g, "/");
+        const isIndexFile = /\/index\.(js|jsx|ts|tsx)$/.test(normalizedFilename)
+            || /^index\.(js|jsx|ts|tsx)$/.test(normalizedFilename);
+
+        // Only apply to non-index files
+        if (isIndexFile) return {};
+
+        const sourceCode = context.sourceCode || context.getSourceCode();
+
+        return {
+            Program(programNode) {
+                // Find all grouped export statements: export { a, b, c };
+                // These have specifiers but no source (not re-exports) and no declaration
+                const groupedExports = programNode.body.filter(
+                    (node) => node.type === "ExportNamedDeclaration"
+                        && !node.source
+                        && !node.declaration
+                        && node.specifiers.length > 0,
+                );
+
+                if (groupedExports.length === 0) return;
+
+                // Build a map of all top-level declarations: name → node
+                const declarationMap = new Map();
+
+                programNode.body.forEach((node) => {
+                    if (node.type === "VariableDeclaration") {
+                        node.declarations.forEach((decl) => {
+                            if (decl.id && decl.id.type === "Identifier") {
+                                declarationMap.set(decl.id.name, { declarationNode: node, kind: node.kind });
+                            }
+                        });
+                    } else if (node.type === "FunctionDeclaration" && node.id) {
+                        declarationMap.set(node.id.name, { declarationNode: node, kind: "function" });
+                    } else if (node.type === "ClassDeclaration" && node.id) {
+                        declarationMap.set(node.id.name, { declarationNode: node, kind: "class" });
+                    }
+                });
+
+                groupedExports.forEach((exportNode) => {
+                    // Skip if any specifier has an alias (export { a as b })
+                    const hasAlias = exportNode.specifiers.some(
+                        (spec) => spec.local.name !== spec.exported.name,
+                    );
+
+                    if (hasAlias) return;
+
+                    // Check all specifiers have matching declarations
+                    const allFound = exportNode.specifiers.every(
+                        (spec) => declarationMap.has(spec.local.name),
+                    );
+
+                    if (!allFound) return;
+
+                    // Check if any declaration is already exported (would cause duplicate)
+                    const anyAlreadyExported = exportNode.specifiers.some((spec) => {
+                        const info = declarationMap.get(spec.local.name);
+                        const declNode = info.declarationNode;
+                        const parent = declNode.parent;
+
+                        // Check if declaration is inside an ExportNamedDeclaration
+                        if (parent && parent.type === "ExportNamedDeclaration") return true;
+
+                        // Check source text starts with "export"
+                        const declText = sourceCode.getText(declNode);
+
+                        return declText.startsWith("export ");
+                    });
+
+                    if (anyAlreadyExported) return;
+
+                    context.report({
+                        fix(fixer) {
+                            const fixes = [];
+
+                            // Add "export " before each declaration
+                            exportNode.specifiers.forEach((spec) => {
+                                const info = declarationMap.get(spec.local.name);
+                                const declNode = info.declarationNode;
+
+                                fixes.push(fixer.insertTextBefore(declNode, "export "));
+                            });
+
+                            // Remove the grouped export statement and any preceding blank line
+                            const tokenBefore = sourceCode.getTokenBefore(exportNode, { includeComments: true });
+
+                            if (tokenBefore) {
+                                fixes.push(fixer.removeRange([tokenBefore.range[1], exportNode.range[1]]));
+                            } else {
+                                fixes.push(fixer.remove(exportNode));
+                            }
+
+                            return fixes;
+                        },
+                        message: "Use inline export declarations (export const x = ...) instead of grouped export statements (export { x }).",
+                        node: exportNode,
+                    });
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce inline export declarations instead of grouped export statements in non-index files" },
+        fixable: "code",
+        schema: [],
+        type: "layout",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: JSX Children On New Line
@@ -18750,7 +18954,7 @@ const componentPropsInlineType = {
  *       <button>{children}</button>
  *   );
  */
-const svgComponentIconNaming = {
+const svgIconNamingConvention = {
     create(context) {
         // Get the component name from node
         const getComponentNameHandler = (node) => {
@@ -18885,32 +19089,90 @@ const svgComponentIconNaming = {
  *   // In layouts/main.tsx:
  *   export const Main = () => <div>Main</div>;  // Should be "MainLayout"
  */
-const folderComponentSuffix = {
+const folderBasedNamingConvention = {
     create(context) {
         const filename = context.filename || context.getFilename();
         const normalizedFilename = filename.replace(/\\/g, "/");
 
         // Folder-to-suffix mapping
+        // - JSX component folders: require function returning JSX (PascalCase)
+        // - camelCase folders: check camelCase exported identifiers
+        // - Other non-JSX folders: check PascalCase exported identifiers
         const folderSuffixMap = {
+            atoms: "",
+            components: "",
+            constants: "Constants",
+            contexts: "Context",
+            data: "Data",
             layouts: "Layout",
             pages: "Page",
+            providers: "Provider",
+            reducers: "Reducer",
+            services: "Service",
+            strings: "Strings",
+            theme: "Theme",
+            themes: "Theme",
             views: "View",
         };
 
-        // Check which folder the file is in
-        const getFolderSuffixHandler = () => {
-            for (const [folder, suffix] of Object.entries(folderSuffixMap)) {
-                const pattern = new RegExp(`/${folder}/[^/]+\\.(jsx?|tsx?)$`);
+        // Folders where JSX return is required (component folders)
+        const jsxRequiredFolders = new Set(["atoms", "components", "layouts", "pages", "providers", "views"]);
 
-                if (pattern.test(normalizedFilename)) {
-                    return { folder, suffix };
-                }
+        // Folders where exports use camelCase naming (non-component, non-context)
+        const camelCaseFolders = new Set(["constants", "data", "reducers", "services", "strings"]);
+
+        // Convert kebab-case to PascalCase
+        const toPascalCaseHandler = (str) => str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+
+        // Convert PascalCase to camelCase (lowercase first letter)
+        const toCamelCaseHandler = (str) => str.charAt(0).toLowerCase() + str.slice(1);
+
+        // Build regex dynamically from folder names
+        const folderNames = Object.keys(folderSuffixMap).join("|");
+
+        // Parse the file path to extract module folder info at any depth
+        const getModuleInfoHandler = () => {
+            const pattern = new RegExp(`\\/(${folderNames})\\/(.+)\\.(jsx?|tsx?)$`);
+            const match = normalizedFilename.match(pattern);
+
+            if (!match) return null;
+
+            const moduleFolderName = match[1];
+            const suffix = folderSuffixMap[moduleFolderName];
+            const relativePath = match[2];
+            const segments = relativePath.split("/");
+            const fileName = segments[segments.length - 1];
+            const intermediateFolders = segments.slice(0, -1);
+
+            return { fileName, folder: moduleFolderName, intermediateFolders, suffix };
+        };
+
+        // Build the expected name based on file position
+        const buildExpectedNameHandler = (moduleInfo) => {
+            const { fileName, folder, intermediateFolders, suffix } = moduleInfo;
+
+            // Module barrel file (e.g., views/index.ts) — skip
+            if (fileName === "index" && intermediateFolders.length === 0) return null;
+
+            let nameParts;
+
+            if (fileName === "index") {
+                // Index in subfolder (e.g., layouts/auth/index.tsx) → parts from folders only
+                nameParts = [...intermediateFolders].reverse();
+            } else {
+                // Regular file (e.g., layouts/auth/login.tsx) → file name + folders deepest-to-shallowest
+                nameParts = [fileName, ...[...intermediateFolders].reverse()];
             }
 
-            return null;
+            const pascalName = nameParts.map(toPascalCaseHandler).join("") + suffix;
+
+            // camelCase folders produce camelCase names
+            if (camelCaseFolders.has(folder)) return toCamelCaseHandler(pascalName);
+
+            return pascalName;
         };
 
-        // Get the component name from node
+        // Get the component name from function node
         const getComponentNameHandler = (node) => {
             // Arrow function: const Name = () => ...
             if (node.parent && node.parent.type === "VariableDeclarator" && node.parent.id && node.parent.id.type === "Identifier") {
@@ -18925,8 +19187,8 @@ const folderComponentSuffix = {
             return null;
         };
 
-        // Check if component name starts with uppercase (React component convention)
-        const isReactComponentNameHandler = (name) => name && /^[A-Z]/.test(name);
+        // Check if name starts with uppercase (PascalCase)
+        const isPascalCaseHandler = (name) => name && /^[A-Z]/.test(name);
 
         // Check if the function returns JSX
         const returnsJsxHandler = (node) => {
@@ -18966,11 +19228,80 @@ const folderComponentSuffix = {
             return false;
         };
 
+        // Shared fix logic for renaming identifier and all references
+        const createRenameFixer = (node, name, expectedName, identifierNode) => (fixer) => {
+            const scope = context.sourceCode
+                ? context.sourceCode.getScope(node)
+                : context.getScope();
+
+            const findVariableHandler = (s, varName) => {
+                const v = s.variables.find((variable) => variable.name === varName);
+
+                if (v) return v;
+                if (s.upper) return findVariableHandler(s.upper, varName);
+
+                return null;
+            };
+
+            const variable = findVariableHandler(scope, name);
+
+            if (!variable) return fixer.replaceText(identifierNode, expectedName);
+
+            const fixes = [];
+            const fixedRanges = new Set();
+
+            variable.defs.forEach((def) => {
+                const rangeKey = `${def.name.range[0]}-${def.name.range[1]}`;
+
+                if (!fixedRanges.has(rangeKey)) {
+                    fixedRanges.add(rangeKey);
+                    fixes.push(fixer.replaceText(def.name, expectedName));
+                }
+            });
+
+            variable.references.forEach((ref) => {
+                const rangeKey = `${ref.identifier.range[0]}-${ref.identifier.range[1]}`;
+
+                if (!fixedRanges.has(rangeKey)) {
+                    fixedRanges.add(rangeKey);
+                    fixes.push(fixer.replaceText(ref.identifier, expectedName));
+                }
+            });
+
+            return fixes;
+        };
+
+        // Build the error message based on folder type
+        const buildMessageHandler = (name, folder, suffix, expectedName) => {
+            if (suffix) return `"${name}" in "${folder}" folder must be named "${expectedName}" (expected "${suffix}" suffix with chained folder names)`;
+
+            return `"${name}" in "${folder}" folder must be named "${expectedName}" (expected chained folder names)`;
+        };
+
+        // 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)
+            if (!name.endsWith(suffix)) {
+                context.report({
+                    message: buildSuffixMessageHandler(name, folder, suffix),
+                    node: identifierNode,
+                });
+            }
+        };
+
+        // Check function declarations (JSX components + non-JSX functions like reducers)
         const checkFunctionHandler = (node) => {
-            const folderInfo = getFolderSuffixHandler();
+            const moduleInfo = getModuleInfoHandler();
 
-            // Not in a folder that requires specific suffix
-            if (!folderInfo) return;
+            if (!moduleInfo) return;
 
             const componentInfo = getComponentNameHandler(node);
 
@@ -18978,65 +19309,74 @@ const folderComponentSuffix = {
 
             const { name, identifierNode } = componentInfo;
 
-            // Only check React components (PascalCase)
-            if (!isReactComponentNameHandler(name)) return;
+            const { folder, suffix } = moduleInfo;
 
-            // Only check functions that return JSX
-            if (!returnsJsxHandler(node)) return;
+            // For camelCase folders, only enforce suffix
+            if (camelCaseFolders.has(folder)) {
+                if (!isCamelCaseHandler(name) || !suffix) return;
 
-            const { folder, suffix } = folderInfo;
+                checkCamelCaseHandler(name, folder, suffix, identifierNode);
 
-            // Check if component name ends with the required suffix
-            if (!name.endsWith(suffix)) {
-                const newName = `${name}${suffix}`;
+                return;
+            }
 
+            if (!isPascalCaseHandler(name)) return;
+
+            // For JSX-required folders, only check functions that return JSX
+            if (jsxRequiredFolders.has(folder) && !returnsJsxHandler(node)) return;
+
+            const expectedName = buildExpectedNameHandler(moduleInfo);
+
+            if (!expectedName) return;
+
+            if (name !== expectedName) {
                 context.report({
-                    fix(fixer) {
-                        const scope = context.sourceCode
-                            ? context.sourceCode.getScope(node)
-                            : context.getScope();
+                    fix: createRenameFixer(node, name, expectedName, identifierNode),
+                    message: buildMessageHandler(name, folder, suffix, expectedName),
+                    node: identifierNode,
+                });
+            }
+        };
 
-                        // Find the variable in scope
-                        const findVariableHandler = (s, varName) => {
-                            const v = s.variables.find((variable) => variable.name === varName);
+        // Check variable declarations for non-JSX folders (contexts, themes, data, etc.)
+        const checkVariableHandler = (node) => {
+            // Only check VariableDeclarators with an identifier name
+            if (!node.id || node.id.type !== "Identifier") return;
 
-                            if (v) return v;
-                            if (s.upper) return findVariableHandler(s.upper, varName);
+            // Skip if init is a function (handled by checkFunctionHandler)
+            if (node.init && (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression")) return;
 
-                            return null;
-                        };
+            const moduleInfo = getModuleInfoHandler();
 
-                        const variable = findVariableHandler(scope, name);
+            if (!moduleInfo) return;
 
-                        if (!variable) return fixer.replaceText(identifierNode, newName);
+            const { folder, suffix } = moduleInfo;
 
-                        const fixes = [];
-                        const fixedRanges = new Set();
+            // Only check non-JSX folders (contexts, themes, data, constants, strings, etc.)
+            if (jsxRequiredFolders.has(folder)) return;
 
-                        // Fix definition
-                        variable.defs.forEach((def) => {
-                            const rangeKey = `${def.name.range[0]}-${def.name.range[1]}`;
+            const name = node.id.name;
 
-                            if (!fixedRanges.has(rangeKey)) {
-                                fixedRanges.add(rangeKey);
-                                fixes.push(fixer.replaceText(def.name, newName));
-                            }
-                        });
+            // For camelCase folders, only enforce suffix
+            if (camelCaseFolders.has(folder)) {
+                if (!isCamelCaseHandler(name) || !suffix) return;
 
-                        // Fix all references
-                        variable.references.forEach((ref) => {
-                            const rangeKey = `${ref.identifier.range[0]}-${ref.identifier.range[1]}`;
+                checkCamelCaseHandler(name, folder, suffix, node.id);
 
-                            if (!fixedRanges.has(rangeKey)) {
-                                fixedRanges.add(rangeKey);
-                                fixes.push(fixer.replaceText(ref.identifier, newName));
-                            }
-                        });
+                return;
+            }
 
-                        return fixes;
-                    },
-                    message: `Component "${name}" in "${folder}" folder must end with "${suffix}" suffix (e.g., "${newName}")`,
-                    node: identifierNode,
+            if (!isPascalCaseHandler(name)) return;
+
+            const expectedName = buildExpectedNameHandler(moduleInfo);
+
+            if (!expectedName) return;
+
+            if (name !== expectedName) {
+                context.report({
+                    fix: createRenameFixer(node, name, expectedName, node.id),
+                    message: buildMessageHandler(name, folder, suffix, expectedName),
+                    node: node.id,
                 });
             }
         };
@@ -19045,16 +19385,250 @@ const folderComponentSuffix = {
             ArrowFunctionExpression: checkFunctionHandler,
             FunctionDeclaration: checkFunctionHandler,
             FunctionExpression: checkFunctionHandler,
+            VariableDeclarator: checkVariableHandler,
         };
     },
     meta: {
-        docs: { description: "Enforce components in 'views' folder end with 'View', components in 'pages' folder end with 'Page', and components in 'layouts' folder end with 'Layout'" },
+        docs: { description: "Enforce naming conventions based on folder location — suffix for views/layouts/pages/providers/reducers/contexts/themes, chained folder names for nested files" },
         fixable: "code",
         schema: [],
         type: "suggestion",
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Folder Structure Consistency
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforces that module folders have a consistent internal
+ *   structure — either all flat files or all wrapped in folders.
+ *
+ *   Applies to the same folders as module-index-exports: atoms,
+ *   components, hooks, utils, enums, types, reducers, etc.
+ *
+ *   - Flat mode: All items are direct files (e.g., atoms/input.tsx)
+ *   - Wrapped mode: All items are in subfolders (e.g., atoms/input/index.tsx)
+ *   - Wrapped mode is only justified when at least one subfolder has 2+ files
+ *
+ * ✓ Good (flat — all direct files):
+ *   atoms/input.tsx
+ *   atoms/calendar.tsx
+ *
+ * ✓ Good (wrapped — justified, input has multiple files):
+ *   atoms/input/input.tsx
+ *   atoms/input/helpers.ts
+ *   atoms/calendar/index.tsx
+ *
+ * ✗ Bad (mixed — some flat, some wrapped):
+ *   atoms/input.tsx
+ *   atoms/calendar/index.tsx
+ *
+ * ✗ Bad (wrapped but unnecessary — each folder has only 1 file):
+ *   atoms/input/index.tsx
+ *   atoms/calendar/index.tsx
+ */
+const folderStructureConsistency = {
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        const normalizedFilename = filename.replace(/\\/g, "/");
+
+        const options = context.options[0] || {};
+        const defaultModuleFolders = [
+            "actions",
+            "apis",
+            "assets",
+            "atoms",
+            "components",
+            "config",
+            "configs",
+            "constants",
+            "contexts",
+            "data",
+            "enums",
+            "helpers",
+            "hooks",
+            "interfaces",
+            "layouts",
+            "lib",
+            "middlewares",
+            "molecules",
+            "organisms",
+            "pages",
+            "providers",
+            "reducers",
+            "redux",
+            "requests",
+            "routes",
+            "schemas",
+            "sections",
+            "services",
+            "store",
+            "strings",
+            "styles",
+            "theme",
+            "thunks",
+            "types",
+            "ui",
+            "utils",
+            "utilities",
+            "views",
+            "widgets",
+        ];
+
+        const moduleFolders = options.moduleFolders
+            || [...defaultModuleFolders, ...(options.extraModuleFolders || [])];
+
+        // Find the module folder in the file path
+        const getModuleFolderInfoHandler = () => {
+            for (const folder of moduleFolders) {
+                const pattern = new RegExp(`(.*/${folder})/`);
+                const match = normalizedFilename.match(pattern);
+
+                if (match) return { folder, fullPath: match[1] };
+            }
+
+            return null;
+        };
+
+        const moduleFolderInfo = getModuleFolderInfoHandler();
+
+        // Check for loose module files (e.g., src/data.js instead of src/data/)
+        if (!moduleFolderInfo) {
+            const fileBaseName = normalizedFilename.replace(/.*\//, "").replace(/\.(jsx?|tsx?)$/, "");
+
+            if (moduleFolders.includes(fileBaseName)) {
+                return {
+                    Program(node) {
+                        context.report({
+                            message: `"${fileBaseName}" should be a folder, not a standalone file. Use "${fileBaseName}/" folder with an index file instead.`,
+                            node,
+                        });
+                    },
+                };
+            }
+
+            return {};
+        }
+
+        const { folder, fullPath } = moduleFolderInfo;
+
+        // Read module folder children
+        let children;
+
+        try {
+            children = fs.readdirSync(fullPath, { withFileTypes: true });
+        } catch {
+            return {};
+        }
+
+        const codeFilePattern = /\.(tsx?|jsx?)$/;
+
+        // Categorize children
+        const directFiles = children.filter(
+            (child) => child.isFile() && codeFilePattern.test(child.name) && !child.name.startsWith("index."),
+        );
+
+        const subdirectories = children.filter((child) => child.isDirectory());
+
+        // If only index files or empty, no issue
+        if (directFiles.length === 0 && subdirectories.length === 0) return {};
+
+        // If only one non-index file and no subdirectories, no issue
+        if (directFiles.length <= 1 && subdirectories.length === 0) return {};
+
+        // Check if wrapped mode is justified (any subfolder has 2+ code files)
+        const isWrappedJustifiedHandler = () => {
+            for (const dir of subdirectories) {
+                try {
+                    const dirPath = `${fullPath}/${dir.name}`;
+                    const dirChildren = fs.readdirSync(dirPath, { withFileTypes: true });
+                    const codeFiles = dirChildren.filter(
+                        (child) => child.isFile() && codeFilePattern.test(child.name),
+                    );
+
+                    if (codeFiles.length >= 2) return true;
+                } catch {
+                    // Skip unreadable directories
+                }
+            }
+
+            return false;
+        };
+
+        const hasDirectFiles = directFiles.length > 0;
+        const hasSubdirectories = subdirectories.length > 0;
+        const isMixed = hasDirectFiles && hasSubdirectories;
+        const wrappedJustified = hasSubdirectories ? isWrappedJustifiedHandler() : false;
+
+        return {
+            Program(node) {
+                // Case: All folders, NOT justified → unnecessary wrapping
+                if (!hasDirectFiles && hasSubdirectories && !wrappedJustified) {
+                    context.report({
+                        message: `Unnecessary wrapper folders in "${folder}/". Each item has only one file, use direct files instead (e.g., ${folder}/component.tsx).`,
+                        node,
+                    });
+
+                    return;
+                }
+
+                // Case: Mixed + wrapped justified → error on direct files
+                if (isMixed && wrappedJustified) {
+                    // Only report if this file IS a direct file in the module folder
+                    const relativePart = normalizedFilename.slice(fullPath.length + 1);
+                    const isDirectFile = !relativePart.includes("/");
+
+                    if (isDirectFile) {
+                        context.report({
+                            message: `Since some items in "${folder}/" contain multiple files, all items should be wrapped in folders.`,
+                            node,
+                        });
+                    }
+
+                    return;
+                }
+
+                // Case: Mixed + NOT justified → error on subfolder files
+                if (isMixed && !wrappedJustified) {
+                    // Only report if this file IS inside a subfolder
+                    const relativePart = normalizedFilename.slice(fullPath.length + 1);
+                    const isInSubfolder = relativePart.includes("/");
+
+                    if (isInSubfolder) {
+                        context.report({
+                            message: `Unnecessary wrapper folder. Each item in "${folder}/" has only one file, use direct files instead.`,
+                            node,
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce consistent folder structure (flat vs wrapped) in module folders like atoms, components, hooks, enums, views, layouts, and pages" },
+        fixable: null,
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    extraModuleFolders: {
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    moduleFolders: {
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "suggestion",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: No Redundant Folder Suffix
@@ -19091,9 +19665,6 @@ const noRedundantFolderSuffix = {
         const fileWithExt = parts[parts.length - 1];
         const baseName = fileWithExt.replace(/\.(jsx?|tsx?)$/, "");
 
-        // Skip index files
-        if (baseName === "index") return {};
-
         // Singularize: convert folder name to singular form
         const singularizeHandler = (word) => {
             if (word.endsWith("ies")) return word.slice(0, -3) + "y";
@@ -19113,35 +19684,84 @@ const noRedundantFolderSuffix = {
 
         if (ancestorFolders.length === 0) return {};
 
-        // Check if the file name ends with any ancestor folder name (singularized)
-        const checkRedundantSuffixHandler = () => {
+        // Check intermediate folder names for redundant suffixes
+        const folderErrors = [];
+
+        for (let i = 1; i < ancestorFolders.length; i++) {
+            const folderName = ancestorFolders[i];
+
+            for (let j = 0; j < i; j++) {
+                const ancestorFolder = ancestorFolders[j];
+                const singular = singularizeHandler(ancestorFolder);
+                const suffix = `-${singular}`;
+
+                if (folderName.endsWith(suffix)) {
+                    folderErrors.push({
+                        ancestorFolder,
+                        folderName,
+                        singular,
+                        suffix,
+                        suggestedName: folderName.slice(0, -suffix.length),
+                    });
+                }
+            }
+        }
+
+        // Check if the file name matches the immediate parent folder name (e.g., input/input.tsx → should be input/index.tsx)
+        let fileMatchesFolder = null;
+
+        if (baseName !== "index" && ancestorFolders.length >= 2) {
+            const immediateFolder = ancestorFolders[ancestorFolders.length - 1];
+
+            if (baseName === immediateFolder) {
+                fileMatchesFolder = immediateFolder;
+            }
+        }
+
+        // Check if the file name ends with any ancestor folder name (singularized) — skip index files
+        let fileRedundancy = null;
+
+        if (baseName !== "index" && !fileMatchesFolder) {
             for (const folder of ancestorFolders) {
                 const singular = singularizeHandler(folder);
                 const suffix = `-${singular}`;
 
                 if (baseName.endsWith(suffix)) {
-                    return { folder, singular, suffix };
+                    fileRedundancy = { folder, singular, suffix };
+                    break;
                 }
             }
+        }
 
-            return null;
-        };
-
-        const redundancy = checkRedundantSuffixHandler();
-
-        if (!redundancy) return {};
+        if (folderErrors.length === 0 && !fileRedundancy && !fileMatchesFolder) return {};
 
         return {
             Program(node) {
-                context.report({
-                    message: `File name "${baseName}" has redundant suffix "${redundancy.suffix}" — the "${redundancy.folder}/" folder already provides this context. Rename to "${baseName.slice(0, -redundancy.suffix.length)}".`,
-                    node,
-                });
+                for (const error of folderErrors) {
+                    context.report({
+                        message: `Folder name "${error.folderName}" has redundant suffix "${error.suffix}" — the "${error.ancestorFolder}/" ancestor folder already provides this context. Rename to "${error.suggestedName}".`,
+                        node,
+                    });
+                }
+
+                if (fileMatchesFolder) {
+                    context.report({
+                        message: `File name "${baseName}" is the same as its parent folder "${fileMatchesFolder}/". Use "index" instead (e.g., "${fileMatchesFolder}/index${fileWithExt.match(/\.\w+$/)[0]}").`,
+                        node,
+                    });
+                }
+
+                if (fileRedundancy) {
+                    context.report({
+                        message: `File name "${baseName}" has redundant suffix "${fileRedundancy.suffix}" — the "${fileRedundancy.folder}/" folder already provides this context. Rename to "${baseName.slice(0, -fileRedundancy.suffix.length)}".`,
+                        node,
+                    });
+                }
             },
         };
     },
     meta: {
-        docs: { description: "Disallow file names that redundantly include the parent or ancestor folder name as a suffix" },
+        docs: { description: "Disallow file and folder names that redundantly include the parent or ancestor folder name as a suffix" },
         fixable: null,
         schema: [],
         type: "suggestion",
@@ -22436,9 +23056,10 @@ export default {
         // Component rules
         "component-props-destructure": componentPropsDestructure,
         "component-props-inline-type": componentPropsInlineType,
-        "folder-component-suffix": folderComponentSuffix,
+        "folder-based-naming-convention": folderBasedNamingConvention,
+        "folder-structure-consistency": folderStructureConsistency,
         "no-redundant-folder-suffix": noRedundantFolderSuffix,
-        "svg-component-icon-naming": svgComponentIconNaming,
+        "svg-icon-naming-convention": svgIconNamingConvention,
 
         // React rules
         "react-code-order": reactCodeOrder,
@@ -22477,6 +23098,7 @@ export default {
         "import-source-spacing": importSourceSpacing,
         "index-export-style": indexExportStyle,
         "index-exports-only": indexExportsOnly,
+        "inline-export-declaration": inlineExportDeclaration,
         "module-index-exports": moduleIndexExports,
 
         // JSX rules