eslint-config-agent 1.2.3 → 1.3.1

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.3.1](https://github.com/tupe12334/eslint-config/compare/v1.3.0...v1.3.1) (2025-09-20)
+
+### Bug Fixes
+
+* update eslint-plugin-single-export version to 1.1.1 and adjust dependencies ([d2a82b5](https://github.com/tupe12334/eslint-config/commit/d2a82b51fc302ffb0589fb58a6a26452833d6639))
+
+## [1.3.0](https://github.com/tupe12334/eslint-config/compare/v1.2.3...v1.3.0) (2025-09-20)
+
+### Features
+
+* add eslint-plugin-single-export to enforce single export rules ([9cfb800](https://github.com/tupe12334/eslint-config/commit/9cfb80073cf9cdcefd31af5cc2c9a1c83dcd6926))
+* add no-default-class-export rule to enforce named exports for classes ([03d5273](https://github.com/tupe12334/eslint-config/commit/03d52731ca190ebf3d76d4ded7c6ace7fe5fc75f))
+
+### Bug Fixes
+
+* disable group-exports rule to prevent enforcing single statement exports ([0cfd699](https://github.com/tupe12334/eslint-config/commit/0cfd6994a0978d8a15e7ecae83b0765e5cfcf747))
+* improve null check for class names in no-default-class-export rule ([bf090e3](https://github.com/tupe12334/eslint-config/commit/bf090e3490f08f6e9b07a16227ab22aba702f31c))
+
 ## [1.2.3](https://github.com/tupe12334/eslint-config/compare/v1.2.2...v1.2.3) (2025-09-14)
 
 ### Features

package/index.js

@@ -7,9 +7,11 @@ import importPlugin from "eslint-plugin-import";
 import securityPlugin from "eslint-plugin-security";
 import nPlugin from "eslint-plugin-n";
 import classExportPlugin from "eslint-plugin-class-export";
+import singleExportPlugin from "eslint-plugin-single-export";
 import storybookPlugin from "eslint-plugin-storybook";
 import globals from "globals";
 import allRules from "./rules/index.js";
+import { noDefaultClassExportRule } from "./rules/no-default-class-export/index.js";
 
 // Conditionally import preact plugin if available
 let preactPlugin = null;
@@ -95,6 +97,7 @@ const sharedRestrictedSyntax = [
   },
   allRules.noProcessEnvPropertiesConfig,
   allRules.noExportSpecifiersConfig,
+  ...allRules.noDefaultClassExportRules,
 ];
 
 // Required export rules (always errors)
@@ -198,6 +201,12 @@ const config = [
     plugins: {
       n: nPlugin,
       "class-export": classExportPlugin,
+      "single-export": singleExportPlugin,
+      "custom": {
+        rules: {
+          "no-default-class-export": noDefaultClassExportRule,
+        },
+      },
     },
   },
   reactHooks.configs["recommended-latest"],
@@ -245,6 +254,8 @@ const config = [
       ...sharedRules,
       ...allRules.typescriptEslintRules,
       "no-undef": "off", // TypeScript handles this
+      "custom/no-default-class-export": "error",
+      "single-export/single-export": "error",
       "no-restricted-syntax": [
         "error",
         ...sharedRestrictedSyntax,
@@ -261,6 +272,7 @@ const config = [
     rules: {
       // Include all shared rules (like max-lines-per-function)
       ...sharedRules,
+      "single-export/single-export": "off", // TSX files have their own specific export rules
       "no-restricted-syntax": [
         "error",
         // Switch case rules as errors
@@ -337,6 +349,7 @@ const config = [
     files: ["**/*.tsx"],
     ignores: ["**/*.stories.{js,jsx,ts,tsx}"],
     rules: {
+      "single-export/single-export": "off", // TSX files have their own specific export rules
       "no-restricted-syntax": [
         "warn",
         // Include shared rules but remove the multiple exports restriction and switch case rules for TSX
@@ -446,6 +459,7 @@ const config = [
       security: securityPlugin,
       n: nPlugin,
       "class-export": classExportPlugin,
+      "single-export": singleExportPlugin,
     },
     settings: {
       react: {
@@ -454,6 +468,7 @@ const config = [
     },
     rules: {
       ...sharedRules,
+      "single-export/single-export": "error",
       "no-restricted-syntax": [
         "error",
         ...sharedRestrictedSyntax,
@@ -513,6 +528,7 @@ const config = [
       security: securityPlugin,
       n: nPlugin,
       "class-export": classExportPlugin,
+      "single-export": singleExportPlugin,
       ...(preactPlugin && { preact: preactPlugin }),
     },
     settings: {
@@ -523,6 +539,7 @@ const config = [
     rules: {
       ...sharedRules,
       "no-undef": "off", // TypeScript handles this
+      "single-export/single-export": "off", // JSX files have their own specific export rules
       "no-restricted-syntax": [
         "error",
         // Switch case rules as errors
@@ -632,6 +649,7 @@ const config = [
       security: securityPlugin,
       n: nPlugin,
       "class-export": classExportPlugin,
+      "single-export": singleExportPlugin,
       ...(preactPlugin && { preact: preactPlugin }),
     },
     settings: {
@@ -641,6 +659,7 @@ const config = [
     },
     rules: {
       "no-undef": "off", // TypeScript handles this
+      "single-export/single-export": "off", // JSX files have their own specific export rules
       "no-restricted-syntax": [
         "warn",
         // Include shared rules but remove the multiple exports restriction and switch case rules for JSX

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-agent",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "description": "ESLint configuration package with TypeScript support",
   "main": "index.js",
   "type": "module",
@@ -100,6 +100,7 @@
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-security": "^3.0.1",
+    "eslint-plugin-single-export": "^1.1.1",
     "eslint-plugin-storybook": "^9.1.5",
     "globals": "^16.3.0",
     "release-it": "^19.0.4",

package/rules/index.js

@@ -15,6 +15,7 @@ import { noProcessEnvPropertiesConfig } from "./no-process-env-properties/index.
 import { noTypeAssertionsConfig } from "./no-type-assertions/index.js";
 import { noExportSpecifiersConfig } from "./no-empty-exports/index.js";
 import { noClassPropertyDefaultsConfig } from "./no-class-property-defaults/index.js";
+import { noDefaultClassExportRules } from "./no-default-class-export/index.js";
 
 // Plugin rule configurations
 import { pluginRules } from "./plugin/index.js";
@@ -34,6 +35,7 @@ const allRules = {
   noTypeAssertionsConfig,
   noExportSpecifiersConfig,
   noClassPropertyDefaultsConfig,
+  noDefaultClassExportRules,
 
   // Plugin rule configurations
   pluginRules,
@@ -56,6 +58,7 @@ export {
   noTypeAssertionsConfig,
   noExportSpecifiersConfig,
   noClassPropertyDefaultsConfig,
+  noDefaultClassExportRules,
 
   // Plugin rule configurations
   pluginRules,

package/rules/no-default-class-export/examples/invalid/default-abstract-class.ts

@@ -0,0 +1,10 @@
+// Invalid: Default abstract class export
+export default abstract class BaseHandler {
+  protected active = false;
+
+  abstract handle(): void;
+
+  isActive(): boolean {
+    return this.active;
+  }
+}

package/rules/no-default-class-export/examples/invalid/default-class-declaration.ts

@@ -0,0 +1,12 @@
+// Invalid: Default class export (class declaration)
+export default class UserService {
+  private users: string[] = [];
+
+  addUser(name: string): void {
+    this.users.push(name);
+  }
+
+  getUsers(): string[] {
+    return this.users;
+  }
+}

package/rules/no-default-class-export/examples/invalid/default-class-expression.ts

@@ -0,0 +1,12 @@
+// Invalid: Default class export (class expression)
+export default class {
+  private value: number = 0;
+
+  increment(): void {
+    this.value++;
+  }
+
+  getValue(): number {
+    return this.value;
+  }
+}

package/rules/no-default-class-export/examples/invalid/default-generic-class.ts

@@ -0,0 +1,12 @@
+// Invalid: Default generic class export
+export default class Repository<T> {
+  private items: T[] = [];
+
+  save(item: T): void {
+    this.items.push(item);
+  }
+
+  findAll(): T[] {
+    return [...this.items];
+  }
+}

package/rules/no-default-class-export/examples/valid/abstract-class-export.ts

@@ -0,0 +1,17 @@
+// Valid: Named abstract class export
+export abstract class BaseService {
+  protected initialized = false;
+
+  abstract initialize(): Promise<void>;
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+}
+
+export class ConcreteService extends BaseService {
+  async initialize(): Promise<void> {
+    // Implementation
+    this.initialized = true;
+  }
+}

package/rules/no-default-class-export/examples/valid/generic-class-export.ts

@@ -0,0 +1,16 @@
+// Valid: Named generic class export
+export class Container<T> {
+  private items: T[] = [];
+
+  add(item: T): void {
+    this.items.push(item);
+  }
+
+  get(index: number): T | undefined {
+    return this.items[index];
+  }
+
+  getAll(): T[] {
+    return [...this.items];
+  }
+}

package/rules/no-default-class-export/examples/valid/multiple-named-exports.ts

@@ -0,0 +1,22 @@
+// Valid: Multiple named exports including classes
+export interface UserData {
+  id: number;
+  name: string;
+}
+
+export class UserRepository {
+  private data: UserData[] = [];
+
+  save(user: UserData): void {
+    this.data.push(user);
+  }
+
+  findById(id: number): UserData | undefined {
+    return this.data.find(user => user.id === id);
+  }
+}
+
+export const DEFAULT_USER: UserData = {
+  id: 0,
+  name: 'Anonymous'
+};

package/rules/no-default-class-export/examples/valid/named-class-export.ts

@@ -0,0 +1,12 @@
+// Valid: Named class export
+export class UserService {
+  private users: string[] = [];
+
+  addUser(name: string): void {
+    this.users.push(name);
+  }
+
+  getUsers(): string[] {
+    return this.users;
+  }
+}

package/rules/no-default-class-export/index.js

@@ -0,0 +1,120 @@
+/**
+ * Rule configuration for preventing default class exports
+ *
+ * This rule enforces named exports for classes instead of default exports
+ * to improve code organization, import consistency, and tree-shaking.
+ *
+ * Default class exports can make it harder to:
+ * - Track class usage across the codebase
+ * - Perform refactoring and renaming operations
+ * - Enable proper tree-shaking optimizations
+ * - Maintain consistent import naming conventions
+ */
+
+/**
+ * Custom ESLint rule that prevents default class exports and provides auto-fix
+ */
+export const noDefaultClassExportRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow default class exports in favor of named exports",
+      category: "Best Practices",
+    },
+    fixable: "code",
+    messages: {
+      noDefaultClassDeclaration: "Default class exports are not allowed. Use named exports instead: 'export class {{className}} {}'.",
+      noDefaultClassExpression: "Default class expressions are not allowed. Use named class declarations instead: 'export class ClassName {}'.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    return {
+      ExportDefaultDeclaration(node) {
+        // Check if the default export is a class declaration
+        if (node.declaration && node.declaration.type === "ClassDeclaration") {
+          const classDeclaration = node.declaration;
+          const className = (classDeclaration.id && classDeclaration.id.name) || "ClassName";
+
+          context.report({
+            node: node,
+            messageId: "noDefaultClassDeclaration",
+            data: {
+              className: className,
+            },
+            fix(fixer) {
+              // Handle anonymous classes
+              if (!classDeclaration.id) {
+                // Get class body and other parts
+                const body = sourceCode.getText(classDeclaration.body);
+                const superClass = classDeclaration.superClass
+                  ? ` extends ${sourceCode.getText(classDeclaration.superClass)}`
+                  : "";
+
+                return fixer.replaceText(node, `export class ${className}${superClass} ${body}`);
+              }
+
+              // For named classes, just replace default with named export
+              const classText = sourceCode.getText(classDeclaration);
+              return fixer.replaceText(node, `export ${classText}`);
+            },
+          });
+        }
+        // Check if the default export is a class expression
+        else if (node.declaration && node.declaration.type === "ClassExpression") {
+          const classExpression = node.declaration;
+          const className = (classExpression.id && classExpression.id.name) || "ClassName";
+
+          context.report({
+            node: node,
+            messageId: "noDefaultClassExpression",
+            fix(fixer) {
+              // Build the fixed class declaration
+              const body = sourceCode.getText(classExpression.body);
+              const superClass = classExpression.superClass
+                ? ` extends ${sourceCode.getText(classExpression.superClass)}`
+                : "";
+
+              const newCode = `export class ${className}${superClass} ${body}`;
+              return fixer.replaceText(node, newCode);
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+/**
+ * Backward compatibility: no-restricted-syntax configurations
+ * (for use in existing rule arrays that don't support custom rules)
+ */
+export const noDefaultClassExportConfig = {
+  selector: "ExportDefaultDeclaration > ClassDeclaration",
+  message: "Default class exports are not allowed. Use named exports instead: 'export class ClassName {}'."
+};
+
+export const noDefaultClassExpressionConfig = {
+  selector: "ExportDefaultDeclaration > ClassExpression",
+  message: "Default class expressions are not allowed. Use named class declarations instead: 'export class ClassName {}'."
+};
+
+/**
+ * Combined rule configurations for comprehensive default class export prevention
+ */
+export const noDefaultClassExportRules = [
+  noDefaultClassExportConfig,
+  noDefaultClassExpressionConfig
+];
+
+// Default export for backward compatibility
+export default noDefaultClassExportConfig;
+
+// Named exports for specific use cases
+export {
+  noDefaultClassExportConfig as noDefaultClassExport,
+  noDefaultClassExpressionConfig as noDefaultClassExpression,
+  noDefaultClassExportRules as allNoDefaultClassExportRules,
+};

package/rules/no-default-class-export/no-default-class-export.spec.js

@@ -0,0 +1,301 @@
+import { RuleTester } from "eslint";
+import { noDefaultClassExportRule } from "./index.js";
+
+/**
+ * Test suite for no-default-class-export rule
+ *
+ * This tests the custom ESLint rule that prevents default class exports
+ * and provides auto-fix functionality to convert them to named exports.
+ */
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    parser: (await import("@typescript-eslint/parser")).default,
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+});
+
+ruleTester.run("no-default-class-export", noDefaultClassExportRule, {
+  valid: [
+    // Valid: Named class export
+    {
+      code: `
+        export class UserService {
+          constructor() {}
+        }
+      `,
+    },
+    // Valid: Multiple named exports including class
+    {
+      code: `
+        export interface UserData {
+          id: number;
+          name: string;
+        }
+
+        export class UserRepository {
+          save(user: UserData): void {}
+        }
+
+        export const DEFAULT_USER: UserData = {
+          id: 0,
+          name: 'Anonymous'
+        };
+      `,
+    },
+    // Valid: Abstract class with named export
+    {
+      code: `
+        export abstract class BaseService {
+          abstract initialize(): void;
+        }
+      `,
+    },
+    // Valid: Generic class with named export
+    {
+      code: `
+        export class Container<T> {
+          private items: T[] = [];
+          add(item: T): void {
+            this.items.push(item);
+          }
+        }
+      `,
+    },
+    // Valid: Class with decorators (named export)
+    {
+      code: `
+        @Injectable()
+        export class ApiService {
+          constructor() {}
+        }
+      `,
+    },
+    // Valid: Default export of non-class
+    {
+      code: `
+        export default function createUser() {
+          return { id: 1, name: 'Test' };
+        }
+      `,
+    },
+    // Valid: Default export of constant
+    {
+      code: `
+        const config = { apiUrl: 'http://localhost' };
+        export default config;
+      `,
+    },
+    // Valid: Default export of object
+    {
+      code: `
+        export default {
+          users: [],
+          addUser(name: string) {
+            this.users.push(name);
+          }
+        };
+      `,
+    },
+  ],
+
+  invalid: [
+    // Invalid: Default class declaration export
+    {
+      code: `
+        export default class UserService {
+          constructor() {}
+        }
+      `,
+      output: `
+        export class UserService {
+          constructor() {}
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default anonymous class (treated as declaration)
+    {
+      code: `
+        export default class {
+          getValue() {
+            return 42;
+          }
+        }
+      `,
+      output: `
+        export class ClassName {
+          getValue() {
+            return 42;
+          }
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default abstract class
+    {
+      code: `
+        export default abstract class BaseHandler {
+          abstract handle(): void;
+        }
+      `,
+      output: `
+        export abstract class BaseHandler {
+          abstract handle(): void;
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default generic class
+    {
+      code: `
+        export default class Repository<T> {
+          private items: T[] = [];
+          save(item: T): void {
+            this.items.push(item);
+          }
+        }
+      `,
+      output: `
+        export class Repository<T> {
+          private items: T[] = [];
+          save(item: T): void {
+            this.items.push(item);
+          }
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default class with decorators
+    {
+      code: `
+        @Injectable()
+        export default class ApiService {
+          constructor() {}
+        }
+      `,
+      output: `
+        @Injectable()
+        export class ApiService {
+          constructor() {}
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default class extending another class
+    {
+      code: `
+        export default class ConcreteService extends BaseService {
+          initialize(): void {}
+        }
+      `,
+      output: `
+        export class ConcreteService extends BaseService {
+          initialize(): void {}
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default class implementing interface
+    {
+      code: `
+        export default class UserService implements IUserService {
+          getUsers(): User[] {
+            return [];
+          }
+        }
+      `,
+      output: `
+        export class UserService implements IUserService {
+          getUsers(): User[] {
+            return [];
+          }
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Default class with static methods
+    {
+      code: `
+        export default class Utils {
+          static format(text: string): string {
+            return text.trim();
+          }
+        }
+      `,
+      output: `
+        export class Utils {
+          static format(text: string): string {
+            return text.trim();
+          }
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+    // Invalid: Named class expression (edge case)
+    {
+      code: `
+        export default class NamedClass {
+          test() {
+            return 'test';
+          }
+        }
+      `,
+      output: `
+        export class NamedClass {
+          test() {
+            return 'test';
+          }
+        }
+      `,
+      errors: [
+        {
+          messageId: "noDefaultClassDeclaration",
+        },
+      ],
+    },
+  ],
+});
+
+console.log("✅ All no-default-class-export rule tests passed!");
+
+// Export for potential use in other test files
+export { noDefaultClassExportRule };

package/rules/plugin/import/group-exports/index.js

@@ -1,3 +1,3 @@
 export const groupExportsConfig = {
-  "import/group-exports": "error", // Enforce consolidating exports into single statements
-};
+  "import/group-exports": "off",
+};