eslint-plugin-code-style 1.0.14 → 1.0.17

package/README.md

@@ -195,6 +195,7 @@ rules: {
     "code-style/export-format": "error",
     "code-style/import-format": "error",
     "code-style/import-source-spacing": "error",
+    "code-style/index-export-style": "error",
     "code-style/module-index-exports": "error",
     "code-style/jsx-children-on-new-line": "error",
     "code-style/jsx-closing-bracket-spacing": "error",
@@ -257,6 +258,7 @@ rules: {
 | `export-format` | Format exports: collapse 1-3 specifiers, multiline for 4+ |
 | `import-format` | Format imports: collapse 1-3 specifiers, multiline for 4+ |
 | `import-source-spacing` | Enforce no extra spaces inside import path quotes |
+| `index-export-style` | Enforce consistent export style in index files (shorthand or import-then-export) ⚙️ |
 | `module-index-exports` | Enforce proper exports in index files ⚙️ |
 | `jsx-children-on-new-line` | Enforce JSX children on separate lines from parent tags |
 | `jsx-closing-bracket-spacing` | No space before `>` or `/>` in JSX tags |
@@ -785,6 +787,69 @@ import { Button } from " @mui/material ";
 
 ---
 
+### `index-export-style`
+
+Enforce consistent export style in index files. Choose between shorthand re-exports or import-then-export pattern. Also enforces no empty lines between exports/imports.
+
+**Style: "shorthand" (default)**
+```javascript
+// Good - shorthand re-exports (no empty lines between them)
+export { Button } from "./button";
+export { Input, Select } from "./form";
+export { StyledCard, StyledCardWithActions } from "./card";
+```
+
+**Style: "import-export"**
+```javascript
+// Good - imports grouped, single export statement at bottom
+import { Button } from "./button";
+import { Input, Select } from "./form";
+import { StyledCard, StyledCardWithActions } from "./card";
+
+export {
+    Button,
+    Input,
+    Select,
+    StyledCard,
+    StyledCardWithActions,
+};
+```
+
+**Bad Examples**
+```javascript
+// Bad - mixing styles
+export { Button } from "./button";
+import { Input } from "./input";
+export { Input };
+
+// Bad - empty lines between shorthand exports
+export { Button } from "./button";
+
+export { Input } from "./input";
+
+// Bad - multiple standalone exports (should be one)
+import { Button } from "./button";
+import { Input } from "./input";
+export { Button };
+export { Input };
+```
+
+**Customization Options:**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `style` | `"shorthand"` \| `"import-export"` | `"shorthand"` | The export style to enforce |
+
+```javascript
+// Example: Use shorthand style (default)
+"code-style/index-export-style": "error"
+
+// Example: Use import-then-export style
+"code-style/index-export-style": ["error", { style: "import-export" }]
+```
+
+---
+
 ### `module-index-exports`
 
 Ensure module folders have index files that export all contents. Each module folder must have an index file that exports all subfolders and files in the module.

package/index.js

@@ -3387,6 +3387,366 @@ const moduleIndexExports = {
     },
 };
 
+/**
+ * ───────────────────────────────────────────────────────────────
+ * Rule: Index Export Style
+ * ───────────────────────────────────────────────────────────────
+ *
+ * Description:
+ *   Enforce consistent export style in index files. Choose between
+ *   shorthand re-exports or import-then-export pattern.
+ *
+ * Options:
+ *   - style: "shorthand" (default) | "import-export"
+ *     - "shorthand": export { a } from "./file"; (no empty lines between exports)
+ *     - "import-export": import { a } from "./file"; export { a }; (single export statement)
+ *
+ * ✓ Good (style: "shorthand" - default):
+ *   export { Button } from "./button";
+ *   export { Input, Select } from "./form";
+ *   export { Modal } from "./modal";
+ *
+ * ✓ Good (style: "import-export"):
+ *   import { Button } from "./button";
+ *   import { Input, Select } from "./form";
+ *   import { Modal } from "./modal";
+ *
+ *   export {
+ *       Button,
+ *       Input,
+ *       Modal,
+ *       Select,
+ *   };
+ *
+ * ✗ Bad (mixing styles):
+ *   export { Button } from "./button";
+ *   import { Input } from "./input";
+ *   export { Input };
+ *
+ * ✗ Bad (empty lines between shorthand exports):
+ *   export { Button } from "./button";
+ *
+ *   export { Input } from "./input";
+ *
+ * ✗ Bad (multiple standalone exports):
+ *   import { Button } from "./button";
+ *   import { Input } from "./input";
+ *   export { Button };
+ *   export { Input };
+ *
+ * Configuration Example:
+ *   "code-style/index-export-style": ["error", { style: "shorthand" }]
+ *   "code-style/index-export-style": ["error", { style: "import-export" }]
+ */
+const indexExportStyle = {
+    create(context) {
+        const options = context.options[0] || {};
+        const preferredStyle = options.style || "shorthand";
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const filename = context.filename || context.getFilename();
+        const normalizedFilename = filename.replace(/\\/g, "/");
+
+        // Only apply to index files
+        const isIndexFile = /\/index\.(js|jsx|ts|tsx)$/.test(normalizedFilename);
+
+        if (!isIndexFile) return {};
+
+        return {
+            Program(node) {
+                const imports = [];
+                const shorthandExports = [];
+                const standaloneExports = [];
+                const importSourceMap = new Map();
+
+                // Collect all imports and exports
+                node.body.forEach((statement) => {
+                    if (statement.type === "ImportDeclaration" && statement.source) {
+                        imports.push(statement);
+
+                        // Map imported names to their source
+                        statement.specifiers.forEach((spec) => {
+                            if (spec.local && spec.local.name) {
+                                importSourceMap.set(spec.local.name, {
+                                    source: statement.source.value,
+                                    statement,
+                                });
+                            }
+                        });
+                    }
+
+                    if (statement.type === "ExportNamedDeclaration") {
+                        if (statement.source) {
+                            // Shorthand: export { a } from "./file"
+                            shorthandExports.push(statement);
+                        } else if (statement.specifiers && statement.specifiers.length > 0 && !statement.declaration) {
+                            // Standalone: export { a }
+                            standaloneExports.push(statement);
+                        }
+                    }
+                });
+
+                // Skip if no exports to check
+                if (shorthandExports.length === 0 && standaloneExports.length === 0) return;
+
+                // Check for mixed styles
+                const hasShorthand = shorthandExports.length > 0;
+                const hasImportExport = standaloneExports.length > 0 && imports.length > 0;
+
+                if (hasShorthand && hasImportExport) {
+                    context.report({
+                        message: `Mixed export styles detected. Use consistent "${preferredStyle}" style throughout the index file.`,
+                        node,
+                    });
+
+                    return;
+                }
+
+                if (preferredStyle === "shorthand") {
+                    // Check if using import-then-export pattern when shorthand is preferred
+                    if (standaloneExports.length > 0 && imports.length > 0) {
+                        // Collect all specifiers to convert
+                        const allSpecifiersToConvert = [];
+
+                        standaloneExports.forEach((exportStmt) => {
+                            exportStmt.specifiers.forEach((spec) => {
+                                const exportedName = spec.local ? spec.local.name : spec.exported.name;
+                                const importInfo = importSourceMap.get(exportedName);
+
+                                if (importInfo) {
+                                    allSpecifiersToConvert.push({
+                                        exportStmt,
+                                        exportedName,
+                                        importInfo,
+                                        localName: spec.local ? spec.local.name : exportedName,
+                                        spec,
+                                    });
+                                }
+                            });
+                        });
+
+                        if (allSpecifiersToConvert.length > 0) {
+                            context.report({
+                                fix(fixer) {
+                                    const fixes = [];
+
+                                    // Group specifiers by source
+                                    const bySource = new Map();
+
+                                    allSpecifiersToConvert.forEach(({ exportedName, importInfo, localName }) => {
+                                        const source = importInfo.source;
+
+                                        if (!bySource.has(source)) {
+                                            bySource.set(source, []);
+                                        }
+
+                                        if (exportedName === localName) {
+                                            bySource.get(source).push(exportedName);
+                                        } else {
+                                            bySource.get(source).push(`${localName} as ${exportedName}`);
+                                        }
+                                    });
+
+                                    // Create shorthand exports (no empty lines between them)
+                                    const newExports = [];
+
+                                    bySource.forEach((specifiers, source) => {
+                                        newExports.push(`export { ${specifiers.join(", ")} } from "${source}";`);
+                                    });
+
+                                    // Remove all standalone exports
+                                    standaloneExports.forEach((exportStmt) => {
+                                        fixes.push(fixer.remove(exportStmt));
+                                    });
+
+                                    // Remove all imports
+                                    imports.forEach((importStmt) => {
+                                        fixes.push(fixer.remove(importStmt));
+                                    });
+
+                                    // Insert new shorthand exports at the beginning
+                                    const firstStatement = node.body[0];
+
+                                    if (firstStatement) {
+                                        fixes.push(fixer.insertTextBefore(firstStatement, newExports.join("\n") + "\n"));
+                                    }
+
+                                    return fixes;
+                                },
+                                message: `Use shorthand export style: export { ... } from "source" instead of import then export.`,
+                                node,
+                            });
+                        }
+                    }
+
+                    // Check for empty lines between shorthand exports
+                    for (let i = 0; i < shorthandExports.length - 1; i += 1) {
+                        const currentExport = shorthandExports[i];
+                        const nextExport = shorthandExports[i + 1];
+                        const currentEndLine = currentExport.loc.end.line;
+                        const nextStartLine = nextExport.loc.start.line;
+
+                        if (nextStartLine - currentEndLine > 1) {
+                            context.report({
+                                fix(fixer) {
+                                    const textBetween = sourceCode.getText().slice(
+                                        currentExport.range[1],
+                                        nextExport.range[0],
+                                    );
+
+                                    // Replace multiple newlines with single newline
+                                    return fixer.replaceTextRange(
+                                        [currentExport.range[1], nextExport.range[0]],
+                                        "\n",
+                                    );
+                                },
+                                message: "No empty lines between shorthand exports in index files.",
+                                node: nextExport,
+                            });
+                        }
+                    }
+                } else if (preferredStyle === "import-export") {
+                    // Check if using shorthand when import-export is preferred
+                    if (shorthandExports.length > 0) {
+                        // Convert all shorthand exports to import-then-export with single export statement
+                        context.report({
+                            fix(fixer) {
+                                const fixes = [];
+                                const allImports = [];
+                                const allExportNames = [];
+
+                                shorthandExports.forEach((exportStmt) => {
+                                    const source = exportStmt.source.value;
+                                    const importSpecifiers = [];
+
+                                    exportStmt.specifiers.forEach((spec) => {
+                                        const imported = spec.local ? spec.local.name : spec.exported.name;
+                                        const exported = spec.exported.name;
+
+                                        importSpecifiers.push(imported);
+                                        allExportNames.push(exported);
+                                    });
+
+                                    allImports.push(`import { ${importSpecifiers.join(", ")} } from "${source}";`);
+
+                                    // Remove the shorthand export
+                                    fixes.push(fixer.remove(exportStmt));
+                                });
+
+                                // Sort export names alphabetically
+                                allExportNames.sort((a, b) => a.localeCompare(b));
+
+                                // Create single export statement with proper formatting
+                                let exportStatement;
+
+                                if (allExportNames.length <= 3) {
+                                    exportStatement = `export { ${allExportNames.join(", ")} };`;
+                                } else {
+                                    exportStatement = `export {\n    ${allExportNames.join(",\n    ")},\n};`;
+                                }
+
+                                // Insert imports and export at the beginning
+                                const firstStatement = node.body[0];
+
+                                if (firstStatement) {
+                                    const newContent = allImports.join("\n") + "\n\n" + exportStatement + "\n";
+
+                                    fixes.push(fixer.insertTextBefore(firstStatement, newContent));
+                                }
+
+                                return fixes;
+                            },
+                            message: `Use import-then-export style with a single export statement.`,
+                            node,
+                        });
+                    }
+
+                    // Check for multiple standalone exports - should be combined into one
+                    if (standaloneExports.length > 1) {
+                        context.report({
+                            fix(fixer) {
+                                const fixes = [];
+                                const allExportNames = [];
+
+                                standaloneExports.forEach((exportStmt) => {
+                                    exportStmt.specifiers.forEach((spec) => {
+                                        const exported = spec.exported.name;
+
+                                        allExportNames.push(exported);
+                                    });
+
+                                    // Remove all but the last export
+                                    fixes.push(fixer.remove(exportStmt));
+                                });
+
+                                // Sort export names alphabetically
+                                allExportNames.sort((a, b) => a.localeCompare(b));
+
+                                // Create single export statement
+                                let exportStatement;
+
+                                if (allExportNames.length <= 3) {
+                                    exportStatement = `export { ${allExportNames.join(", ")} };`;
+                                } else {
+                                    exportStatement = `export {\n    ${allExportNames.join(",\n    ")},\n};`;
+                                }
+
+                                // Find last import to insert after
+                                const lastImport = imports[imports.length - 1];
+
+                                if (lastImport) {
+                                    fixes.push(fixer.insertTextAfter(lastImport, "\n\n" + exportStatement));
+                                }
+
+                                return fixes;
+                            },
+                            message: `Combine multiple export statements into a single export statement.`,
+                            node,
+                        });
+                    }
+
+                    // Check for empty lines between imports
+                    for (let i = 0; i < imports.length - 1; i += 1) {
+                        const currentImport = imports[i];
+                        const nextImport = imports[i + 1];
+                        const currentEndLine = currentImport.loc.end.line;
+                        const nextStartLine = nextImport.loc.start.line;
+
+                        if (nextStartLine - currentEndLine > 1) {
+                            context.report({
+                                fix(fixer) {
+                                    return fixer.replaceTextRange(
+                                        [currentImport.range[1], nextImport.range[0]],
+                                        "\n",
+                                    );
+                                },
+                                message: "No empty lines between imports in index files.",
+                                node: nextImport,
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: "Enforce consistent export style in index files (shorthand or import-then-export)" },
+        fixable: "code",
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    style: {
+                        enum: ["shorthand", "import-export"],
+                        type: "string",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "layout",
+    },
+};
+
 /**
  * ───────────────────────────────────────────────────────────────
  * Rule: JSX Children On New Line
@@ -7821,6 +8181,7 @@ export default {
         "export-format": exportFormat,
         "import-format": importFormat,
         "import-source-spacing": importSourceSpacing,
+        "index-export-style": indexExportStyle,
         "module-index-exports": moduleIndexExports,
 
         // JSX rules

package/package.json

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