eslint-plugin-code-style 1.4.3 → 1.4.5

package/CHANGELOG.md

@@ -6,7 +6,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/) principles.
 
 ---
 
-## [1.4.0] - 2026-01-30
+## [1.4.2] - 2026-01-30
 
 **Release Title:** New Rules, Enhanced Auto-Fix & Comprehensive Documentation
 

package/README.md

@@ -298,7 +298,7 @@ rules: {
 | `import-format` | `import {` and `} from` on same line; collapse ≤ threshold; expand larger with each specifier on own line (default: ≤3) 🔧 ⚙️ |
 | `import-source-spacing` | No leading/trailing spaces inside import path quotes 🔧 |
 | `index-export-style` | Index files: no blank lines, enforce shorthand or import-export style; Regular files: require blank lines between exports (default: shorthand) 🔧 ⚙️ |
-| `index-exports-only` | Index files should only contain imports and exports, not type/interface definitions |
+| `index-exports-only` | Index files should only contain imports and re-exports, not code definitions (types, functions, variables, classes) |
 | `module-index-exports` | Index files must export all folder contents (files and subfolders) ⚙️ |
 | **JSX Rules** | |
 | `classname-dynamic-at-end` | Dynamic expressions (`${className}`) must be at the end of class strings (JSX and variables) 🔧 |

package/index.js

@@ -5058,18 +5058,23 @@ const indexExportStyle = {
  *
  * Description:
  *   Index files (index.ts, index.tsx, index.js, index.jsx) should
- *   only contain imports and exports, not type or interface definitions.
- *   Types should be moved to a separate file (e.g., types.ts).
+ *   only contain imports and re-exports, not any code definitions.
+ *   All definitions (types, interfaces, functions, variables, classes)
+ *   should be moved to separate files.
  *
  * ✓ Good:
  *   // index.ts
  *   export { Button } from "./Button";
+ *   export { helper } from "./utils";
  *   export type { ButtonProps } from "./types";
+ *   export * from "./constants";
  *
  * ✗ Bad:
  *   // index.ts
  *   export type ButtonVariant = "primary" | "secondary";
  *   export interface ButtonProps { ... }
+ *   export const CONSTANT = "value";
+ *   export function helper() { ... }
  */
 const indexExportsOnly = {
     create(context) {
@@ -5080,23 +5085,76 @@ const indexExportsOnly = {
 
         if (!isIndexFile) return {};
 
+        // Helper to check if a node is an import or export statement
+        const isImportOrExportHandler = (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 === "ExportDefaultDeclaration") {
+                // Allow export default <identifier> (re-exporting)
+                // Disallow export default function/class/object (defining something)
+                return node.declaration && node.declaration.type === "Identifier";
+            }
+
+            if (type === "ExportAllDeclaration") return true;
+
+            return false;
+        };
+
+        // Get a friendly description of what the disallowed node is
+        const getNodeDescriptionHandler = (node) => {
+            switch (node.type) {
+                case "TSTypeAliasDeclaration":
+                    return "Type definition";
+                case "TSInterfaceDeclaration":
+                    return "Interface definition";
+                case "TSEnumDeclaration":
+                    return "Enum definition";
+                case "VariableDeclaration":
+                    return "Variable declaration";
+                case "FunctionDeclaration":
+                    return "Function declaration";
+                case "ClassDeclaration":
+                    return "Class declaration";
+                case "ExportNamedDeclaration":
+                    if (node.declaration) {
+                        return getNodeDescriptionHandler(node.declaration);
+                    }
+
+                    return "Export with inline declaration";
+                case "ExportDefaultDeclaration":
+                    return "Default export with inline definition";
+                default:
+                    return "Code";
+            }
+        };
+
         return {
-            TSInterfaceDeclaration(node) {
-                context.report({
-                    message: "Interface definitions should not be in index files. Move to a types file.",
-                    node,
-                });
-            },
-            TSTypeAliasDeclaration(node) {
-                context.report({
-                    message: "Type definitions should not be in index files. Move to a types file.",
-                    node,
-                });
+            Program(programNode) {
+                for (const node of programNode.body) {
+                    if (!isImportOrExportHandler(node)) {
+                        const description = getNodeDescriptionHandler(node);
+
+                        context.report({
+                            message: `${description} should not be in index files. Index files should only contain imports and re-exports. Move this to a separate file.`,
+                            node,
+                        });
+                    }
+                }
             },
         };
     },
     meta: {
-        docs: { description: "Index files should only contain imports and exports, not type definitions" },
+        docs: { description: "Index files should only contain imports and re-exports, not code definitions" },
         schema: [],
         type: "suggestion",
     },
@@ -6660,24 +6718,25 @@ const classNameMultiline = {
             let current = node;
 
             while (current) {
-                if (current.type === "JSXAttribute"
-                    || current.type === "VariableDeclarator"
-                    || current.type === "Property") {
+                // For JSX attributes, check if inline and use column-based indent
+                if (current.type === "JSXAttribute") {
                     const lineIndent = getLineIndent(current);
                     const lineText = sourceCode.lines[current.loc.start.line - 1];
-
-                    // Check if there's content before the node on this line
                     const contentBefore = lineText.slice(0, current.loc.start.column).trim();
 
                     if (contentBefore) {
                         // Attribute is inline (e.g., <Component className=...>)
-                        // Use column position as indent for proper alignment
                         return " ".repeat(current.loc.start.column);
                     }
 
                     return lineIndent;
                 }
 
+                // For variables and properties, just use line indentation
+                if (current.type === "VariableDeclarator" || current.type === "Property") {
+                    return getLineIndent(current);
+                }
+
                 current = current.parent;
             }
 
@@ -12215,6 +12274,38 @@ const functionObjectDestructure = {
             return destructured;
         };
 
+        // Find the destructuring statement and property node for a variable
+        const findDestructuringStatementHandler = (blockBody, varName, paramName) => {
+            if (blockBody.type !== "BlockStatement") return null;
+
+            for (const stmt of blockBody.body) {
+                if (stmt.type !== "VariableDeclaration") continue;
+
+                for (const decl of stmt.declarations) {
+                    if (decl.id.type === "ObjectPattern" && decl.init) {
+                        // Check if this destructuring creates the variable we're looking for
+                        if (decl.init.type === "Identifier" && decl.init.name === paramName) {
+                            for (const prop of decl.id.properties) {
+                                if (prop.type === "Property" && prop.key.type === "Identifier") {
+                                    const createdVarName = prop.value.type === "Identifier" ? prop.value.name : prop.key.name;
+
+                                    if (createdVarName === varName) {
+                                        return {
+                                            declarator: decl,
+                                            property: prop,
+                                            statement: stmt,
+                                        };
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return null;
+        };
+
         const checkFunctionHandler = (node) => {
             const isComponent = isReactComponentHandler(node);
             const params = node.params;
@@ -12327,7 +12418,29 @@ const functionObjectDestructure = {
                             if (accesses.length > 0) {
                                 const accessedProps = [...new Set(accesses.map((a) => a.property))];
 
+                                // Find the original destructuring statement
+                                const destructInfo = findDestructuringStatementHandler(body, varName, firstParam.name);
+
                                 context.report({
+                                    fix: destructInfo
+                                        ? (fixer) => {
+                                            const fixes = [];
+
+                                            // Modify the destructuring property to use nested destructuring
+                                            // e.g., { target } becomes { target: { value } }
+                                            const { property } = destructInfo;
+                                            const nestedDestructure = `${info.originalProp}: { ${accessedProps.join(", ")} }`;
+
+                                            fixes.push(fixer.replaceText(property, nestedDestructure));
+
+                                            // Replace all varName.prop accesses with just prop
+                                            accesses.forEach((access) => {
+                                                fixes.push(fixer.replaceText(access.node, access.property));
+                                            });
+
+                                            return fixes;
+                                        }
+                                        : undefined,
                                     message: `Variable "${varName}" is accessed via dot notation (${accessedProps.join(", ")}). Use nested destructuring instead: "const { ${info.originalProp}: { ${accessedProps.join(", ")} } } = ..."`,
                                     node: accesses[0].node,
                                 });
@@ -13138,6 +13251,15 @@ const noInlineTypeDefinitions = {
                 return;
             }
 
+            // Handle intersection types (e.g., ButtonHTMLAttributes & { variant: "a" | "b" })
+            if (typeNode.type === "TSIntersectionType") {
+                for (const type of typeNode.types) {
+                    checkTypeAnnotationHandler(type, paramName);
+                }
+
+                return;
+            }
+
             // Handle object types with union properties
             if (typeNode.type === "TSTypeLiteral") {
                 for (const member of typeNode.members) {

package/package.json

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