eslint-config-agent 1.1.4 → 1.2.1

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.2.1](https://github.com/tupe12334/eslint-config/compare/v1.2.0...v1.2.1) (2025-09-11)
+
+### Features
+
+* remove outdated TODO and ESLint rules documentation ([4d820ce](https://github.com/tupe12334/eslint-config/commit/4d820cec99d8ffb8e9e23c8c313e644351871d70))
+
+## [1.2.0](https://github.com/tupe12334/eslint-config/compare/v1.1.4...v1.2.0) (2025-09-11)
+
+### Features
+
+* add examples for valid and invalid export patterns and update import rules configuration ([a78e03d](https://github.com/tupe12334/eslint-config/commit/a78e03d201e335b423c1830593c015ddd0346028))
+* add no-explicit-any rule configuration and examples for valid/invalid usage ([2bc0ad8](https://github.com/tupe12334/eslint-config/commit/2bc0ad836ff42199456ebc7ebd0b6948cca1a7b1))
+* add no-unused-modules rule configuration and examples for unused exports ([336db1b](https://github.com/tupe12334/eslint-config/commit/336db1b26bf4ac0d3e9bd56c95817748bfda4799))
+* refine ESLint configuration to include specific index.js files and update CI test command ([5693dbc](https://github.com/tupe12334/eslint-config/commit/5693dbc65dc37cbddb6a41498b4886d360c17684))
+* update ESLint configuration to disable size limits for test/spec files and add examples for valid/invalid file lengths ([ac57e22](https://github.com/tupe12334/eslint-config/commit/ac57e223f7d1cedab32976cee5f305ca197ca0c8))
+* update export statements in test files to use default export syntax ([c4a846b](https://github.com/tupe12334/eslint-config/commit/c4a846bc78105f287fafcb4248c8de334c84b0fb))
+
 ## [1.1.4](https://github.com/tupe12334/eslint-config/compare/v1.1.3...v1.1.4) (2025-09-10)
 
 ### Features

package/README.md

@@ -209,36 +209,6 @@ This ESLint configuration prioritizes **explicit code** over convenient shortcut
 - **📚 Self-Documenting**: Code that explains its intent without extensive comments
 - **🛠️ Maintainable**: Patterns that remain clear even as the codebase grows
 
-### Key Rules Enforced
-
-#### Type Safety Rules
-- **🚫 No Optional Chaining** (`?.`): Forces explicit null/undefined checks
-  ```typescript
-  // ❌ Avoid
-  const name = user?.profile?.name;
-  
-  // ✅ Preferred
-  const name = user && user.profile ? user.profile.name : undefined;
-  ```
-
-- **🚫 No Nullish Coalescing** (`??`): Use explicit checks instead
-  ```typescript
-  // ❌ Avoid
-  const name = userName ?? 'Anonymous';
-  
-  // ✅ Preferred
-  const name = userName !== null && userName !== undefined ? userName : 'Anonymous';
-  ```
-
-#### File Organization Rules
-- **📁 JSX File Extensions**: JSX syntax only allowed in `.tsx` and `.jsx` files
-- **📏 Function Length**: Maximum 100 lines per function (warning level)
-- **🧹 No Trailing Spaces**: Enforces clean, consistent formatting
-
-#### React & TypeScript Rules
-- **⚛️ React Hooks**: Full enforcement of hooks rules and dependency arrays
-- **🔤 TypeScript**: Strict type checking with explicit type assertions
-- **📦 Import/Export**: Consistent module patterns and import ordering
 
 ### Supported File Types & Configurations
 
@@ -263,21 +233,9 @@ This ESLint configuration prioritizes **explicit code** over convenient shortcut
 - Compatible with Preact-specific patterns and optimizations
 - Shared configuration with React rules where applicable
 
-### Rule Categories
+### Configuration Philosophy
 
-#### **Enabled Rules** (Errors & Warnings)
-- TypeScript strict type checking
-- React hooks validation
-- Import/export consistency  
-- Function complexity limits
-- Whitespace and formatting
-
-#### **Disabled Rules**
-Many common ESLint and React rules are intentionally disabled to reduce noise while focusing on the most impactful code quality issues:
-- `react/react-in-jsx-scope` (not needed with modern React)
-- `@typescript-eslint/no-unused-vars` (TypeScript handles this)
-- `no-undef` (TypeScript handles this)
-- Plus 50+ other rules optimized for developer productivity
+This configuration focuses on enforcing patterns that improve long-term maintainability while reducing noise from less impactful rules. The ruleset is carefully curated to balance developer productivity with code quality.
 
 ## Migration Guide
 
@@ -398,37 +356,6 @@ npm install --save-dev eslint@^9.34.0
 
 ### Frequently Asked Questions
 
-#### **Q: Why are optional chaining and nullish coalescing disabled?**
-A: These features, while convenient, can hide potential runtime errors. Explicit null checks make your code's intention clearer and prevent unexpected behavior when dealing with complex nested objects.
-
-#### **Q: Can I enable optional chaining for specific files?**
-A: Yes! Use file-specific overrides:
-```javascript
-export default [
-  ...config,
-  {
-    files: ['src/legacy/**/*.ts'],
-    rules: {
-      '@typescript-eslint/prefer-nullish-coalescing': 'off',
-      '@typescript-eslint/prefer-optional-chain': 'off',
-    }
-  }
-];
-```
-
-#### **Q: How do I handle large existing codebases?**
-A: Start with warnings instead of errors:
-```javascript
-export default [
-  ...config,
-  {
-    rules: {
-      '@typescript-eslint/prefer-nullish-coalescing': 'warn',
-      '@typescript-eslint/prefer-optional-chain': 'warn',
-    }
-  }
-];
-```
 
 #### **Q: Does this work with monorepos?**
 A: Yes! Place the `eslint.config.js` at the root of each package, or use a shared config:
@@ -443,16 +370,7 @@ export default sharedConfig;
 ```
 
 #### **Q: How does this help with AI coding assistants like GitHub Copilot, Claude, or ChatGPT?**
-A: This configuration prevents AI assistants from generating "convenient" but problematic code patterns:
-
-- **🚫 Prevents**: AI generating `user?.profile?.name` shortcuts
-- **✅ Enforces**: AI writing `user && user.profile ? user.profile.name : undefined`  
-- **🚫 Prevents**: AI using `value ?? fallback` patterns
-- **✅ Enforces**: AI writing explicit null/undefined checks
-- **📏 Limits**: Function length so AI doesn't generate massive functions
-- **🗂️ Organizes**: File structure so AI puts JSX only in proper file extensions
-
-This means you get AI assistance while maintaining code that you can actually understand and debug months later.
+A: This configuration helps AI assistants generate more maintainable and debuggable code by enforcing consistent patterns and preventing problematic shortcuts. This means you get AI assistance while maintaining code that you can actually understand and debug months later.
 
 #### **Q: How do I contribute or report issues?**
 A: Please use the [GitHub repository](https://github.com/tupe12334/eslint-config) for issues and contributions.

package/index.js

@@ -423,7 +423,7 @@ const config = [
       "**/*.cjs",
       "**/*.mjs",
       "**/*.stories.{js,jsx,ts,tsx}",
-      "**/rules/**",
+      "**/rules/**/index.js",
     ],
     languageOptions: {
       parserOptions: {
@@ -684,7 +684,7 @@ const config = [
     },
   },
 
-  // Disable function size limits for test and spec files
+  // Disable function and file size limits for test and spec files
   {
     files: [
       "**/*.test.{js,jsx,ts,tsx}",
@@ -700,6 +700,7 @@ const config = [
     ],
     rules: {
       "max-lines-per-function": "off",
+      "max-lines": "off", // Ignore file length limits in test and spec files
       // Allow multiple exports in test files for testing import/export patterns
       "no-restricted-syntax": [
         "warn",
@@ -805,7 +806,7 @@ const config = [
       "**/test/**",
       "!**/test/export/**",
       "!**/test/required-exports/**",
-      "**/rules/**",
+      "**/rules/**/index.js",
     ],
     rules: {
       "no-restricted-syntax": [
@@ -916,7 +917,14 @@ const config = [
   // Function and file length rules - strict error thresholds
   {
     files: ["**/*.{ts,tsx,js,jsx}"],
-    ignores: ["**/*.stories.{js,jsx,ts,tsx}"],
+    ignores: [
+      "**/*.stories.{js,jsx,ts,tsx}",
+      "**/*.test.{js,jsx,ts,tsx}",
+      "**/*.spec.{js,jsx,ts,tsx}",
+      "**/test/**/*.{js,jsx,ts,tsx}",
+      "**/tests/**/*.{js,jsx,ts,tsx}",
+      "**/__tests__/**/*.{js,jsx,ts,tsx}",
+    ],
     rules: {
       // Function length: error at 70+ lines
       "max-lines-per-function": allRules.maxFunctionLinesError,
@@ -977,9 +985,10 @@ const config = [
     },
   },
 
-  // Rules directory configuration - allow export specifiers for API definitions
+  // Rules directory configuration - allow export specifiers for API definitions (but not examples)
   {
     files: ["**/rules/**/*.{js,ts}"],
+    ignores: ["**/rules/**/examples/**"],
     languageOptions: {
       globals: {
         ...globals.node,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-agent",
-  "version": "1.1.4",
+  "version": "1.2.1",
   "description": "ESLint configuration package with TypeScript support",
   "main": "index.js",
   "type": "module",
@@ -28,7 +28,7 @@
     "test:edge": "eslint test/edge-cases.tsx",
     "test:performance": "eslint test/performance-test.tsx",
     "test:comprehensive": "node scripts/test-runner.js",
-    "test:ci": "eslint . --ignore-pattern 'test/**' --ignore-pattern 'scripts/**' --max-warnings 0",
+    "test:ci": "eslint . --ignore-pattern 'test/**' --ignore-pattern 'scripts/**' --ignore-pattern 'rules/**/examples/**' --max-warnings 0",
     "validate": "node scripts/validate-config.js",
     "release": "dotenv -e .env -- release-it",
     "release:patch": "dotenv -e .env -- release-it patch",

package/rules/max-file-lines/examples/invalid/long-file.js

@@ -0,0 +1,113 @@
+// Invalid: File with more than 100 lines (should trigger max-lines error)
+const line1 = 1;
+const line2 = 2;
+const line3 = 3;
+const line4 = 4;
+const line5 = 5;
+const line6 = 6;
+const line7 = 7;
+const line8 = 8;
+const line9 = 9;
+const line10 = 10;
+const line11 = 11;
+const line12 = 12;
+const line13 = 13;
+const line14 = 14;
+const line15 = 15;
+const line16 = 16;
+const line17 = 17;
+const line18 = 18;
+const line19 = 19;
+const line20 = 20;
+const line21 = 21;
+const line22 = 22;
+const line23 = 23;
+const line24 = 24;
+const line25 = 25;
+const line26 = 26;
+const line27 = 27;
+const line28 = 28;
+const line29 = 29;
+const line30 = 30;
+const line31 = 31;
+const line32 = 32;
+const line33 = 33;
+const line34 = 34;
+const line35 = 35;
+const line36 = 36;
+const line37 = 37;
+const line38 = 38;
+const line39 = 39;
+const line40 = 40;
+const line41 = 41;
+const line42 = 42;
+const line43 = 43;
+const line44 = 44;
+const line45 = 45;
+const line46 = 46;
+const line47 = 47;
+const line48 = 48;
+const line49 = 49;
+const line50 = 50;
+const line51 = 51;
+const line52 = 52;
+const line53 = 53;
+const line54 = 54;
+const line55 = 55;
+const line56 = 56;
+const line57 = 57;
+const line58 = 58;
+const line59 = 59;
+const line60 = 60;
+const line61 = 61;
+const line62 = 62;
+const line63 = 63;
+const line64 = 64;
+const line65 = 65;
+const line66 = 66;
+const line67 = 67;
+const line68 = 68;
+const line69 = 69;
+const line70 = 70;
+const line71 = 71;
+const line72 = 72;
+const line73 = 73;
+const line74 = 74;
+const line75 = 75;
+const line76 = 76;
+const line77 = 77;
+const line78 = 78;
+const line79 = 79;
+const line80 = 80;
+const line81 = 81;
+const line82 = 82;
+const line83 = 83;
+const line84 = 84;
+const line85 = 85;
+const line86 = 86;
+const line87 = 87;
+const line88 = 88;
+const line89 = 89;
+const line90 = 90;
+const line91 = 91;
+const line92 = 92;
+const line93 = 93;
+const line94 = 94;
+const line95 = 95;
+const line96 = 96;
+const line97 = 97;
+const line98 = 98;
+const line99 = 99;
+const line100 = 100;
+const line101 = 101;
+const line102 = 102;
+const line103 = 103;
+const line104 = 104;
+const line105 = 105;
+const line106 = 106;
+const line107 = 107;
+const line108 = 108;
+const line109 = 109;
+const line110 = 110;
+
+export default line1;

package/rules/max-file-lines/examples/invalid/medium-file.js

@@ -0,0 +1,127 @@
+// Invalid: File with 70-100 lines (should trigger max-lines warning)
+// This file demonstrates what happens when a file grows beyond the recommended size
+
+class ExtendedNumberUtils {
+  constructor() {
+    this.cache = new Map();
+  }
+
+  calculateSum(numbers) {
+    const key = numbers.join(',');
+    if (this.cache.has(key)) {
+      return this.cache.get(key);
+    }
+    const sum = numbers.reduce((acc, num) => acc + num, 0);
+    this.cache.set(key, sum);
+    return sum;
+  }
+
+  calculateAverage(numbers) {
+    if (numbers.length === 0) return 0;
+    return this.calculateSum(numbers) / numbers.length;
+  }
+
+  findMaxValue(numbers) {
+    if (numbers.length === 0) return null;
+    return Math.max(...numbers);
+  }
+
+  findMinValue(numbers) {
+    if (numbers.length === 0) return null;
+    return Math.min(...numbers);
+  }
+
+  sortNumbers(numbers) {
+    return [...numbers].sort((a, b) => a - b);
+  }
+
+  filterEvenNumbers(numbers) {
+    return numbers.filter(num => num % 2 === 0);
+  }
+
+  filterOddNumbers(numbers) {
+    return numbers.filter(num => num % 2 !== 0);
+  }
+
+  multiplyByTwo(numbers) {
+    return numbers.map(num => num * 2);
+  }
+
+  containsNumber(numbers, target) {
+    return numbers.includes(target);
+  }
+
+  removeNumber(numbers, target) {
+    return numbers.filter(num => num !== target);
+  }
+
+  addNumber(numbers, newNumber) {
+    return [...numbers, newNumber];
+  }
+
+  getNumberAtIndex(numbers, index) {
+    if (index < 0 || index >= numbers.length) {
+      return undefined;
+    }
+    return numbers[index];
+  }
+
+  getLastNumber(numbers) {
+    return numbers.length > 0 ? numbers[numbers.length - 1] : undefined;
+  }
+
+  getFirstNumber(numbers) {
+    return numbers.length > 0 ? numbers[0] : undefined;
+  }
+
+  reverseNumbers(numbers) {
+    return [...numbers].reverse();
+  }
+
+  shuffleNumbers(numbers) {
+    const shuffled = [...numbers];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      const temp = shuffled[i];
+      shuffled[i] = shuffled[j];
+      shuffled[j] = temp;
+    }
+    return shuffled;
+  }
+
+  getUniqueNumbers(numbers) {
+    return [...new Set(numbers)];
+  }
+
+  getDuplicateNumbers(numbers) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const num of numbers) {
+      if (seen.has(num)) {
+        duplicates.add(num);
+      } else {
+        seen.add(num);
+      }
+    }
+    return [...duplicates];
+  }
+
+  countOccurrences(numbers, target) {
+    return numbers.filter(num => num === target).length;
+  }
+
+  getNumbersInRange(numbers, min, max) {
+    return numbers.filter(num => num >= min && num <= max);
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+
+  getCacheSize() {
+    return this.cache.size;
+  }
+}
+
+// This file has between 70-100 lines and should trigger a max-lines warning
+export default ExtendedNumberUtils;

package/rules/max-file-lines/examples/invalid/very-long-file.ts

@@ -0,0 +1,144 @@
+// Invalid: TypeScript file with way more than 100 lines (should trigger max-lines error)
+interface User { id: number; name: string; email: string; }
+interface Product { id: number; title: string; price: number; }
+interface Order { id: number; userId: number; products: Product[]; }
+
+const user1: User = { id: 1, name: 'John', email: 'john@example.com' };
+const user2: User = { id: 2, name: 'Jane', email: 'jane@example.com' };
+const user3: User = { id: 3, name: 'Bob', email: 'bob@example.com' };
+const user4: User = { id: 4, name: 'Alice', email: 'alice@example.com' };
+const user5: User = { id: 5, name: 'Charlie', email: 'charlie@example.com' };
+const user6: User = { id: 6, name: 'Diana', email: 'diana@example.com' };
+const user7: User = { id: 7, name: 'Eve', email: 'eve@example.com' };
+const user8: User = { id: 8, name: 'Frank', email: 'frank@example.com' };
+const user9: User = { id: 9, name: 'Grace', email: 'grace@example.com' };
+const user10: User = { id: 10, name: 'Henry', email: 'henry@example.com' };
+
+const product1: Product = { id: 1, title: 'Laptop', price: 999 };
+const product2: Product = { id: 2, title: 'Mouse', price: 25 };
+const product3: Product = { id: 3, title: 'Keyboard', price: 75 };
+const product4: Product = { id: 4, title: 'Monitor', price: 300 };
+const product5: Product = { id: 5, title: 'Headphones', price: 150 };
+const product6: Product = { id: 6, title: 'Webcam', price: 80 };
+const product7: Product = { id: 7, title: 'Speakers', price: 120 };
+const product8: Product = { id: 8, title: 'Microphone', price: 200 };
+const product9: Product = { id: 9, title: 'Tablet', price: 500 };
+const product10: Product = { id: 10, title: 'Phone', price: 700 };
+const product11: Product = { id: 11, title: 'Charger', price: 30 };
+const product12: Product = { id: 12, title: 'Cable', price: 15 };
+const product13: Product = { id: 13, title: 'Case', price: 40 };
+const product14: Product = { id: 14, title: 'Stand', price: 60 };
+const product15: Product = { id: 15, title: 'Bag', price: 90 };
+
+const order1: Order = { id: 1, userId: 1, products: [product1, product2] };
+const order2: Order = { id: 2, userId: 2, products: [product3] };
+const order3: Order = { id: 3, userId: 3, products: [product4, product5, product6] };
+const order4: Order = { id: 4, userId: 4, products: [product7, product8] };
+const order5: Order = { id: 5, userId: 5, products: [product9] };
+const order6: Order = { id: 6, userId: 6, products: [product10, product11] };
+const order7: Order = { id: 7, userId: 7, products: [product12, product13, product14] };
+const order8: Order = { id: 8, userId: 8, products: [product15] };
+const order9: Order = { id: 9, userId: 9, products: [product1, product3, product5] };
+const order10: Order = { id: 10, userId: 10, products: [product2, product4] };
+
+export class OrderManagementService {
+  private users = [user1, user2, user3, user4, user5, user6, user7, user8, user9, user10];
+  private products = [product1, product2, product3, product4, product5, product6, product7, product8, product9, product10, product11, product12, product13, product14, product15];
+  private orders = [order1, order2, order3, order4, order5, order6, order7, order8, order9, order10];
+
+  getUserById(id: number): User | undefined {
+    return this.users.find(user => user.id === id);
+  }
+
+  getProductById(id: number): Product | undefined {
+    return this.products.find(product => product.id === id);
+  }
+
+  getOrderById(id: number): Order | undefined {
+    return this.orders.find(order => order.id === id);
+  }
+
+  getUserOrders(userId: number): Order[] {
+    return this.orders.filter(order => order.userId === userId);
+  }
+
+  calculateOrderTotal(order: Order): number {
+    return order.products.reduce((total, product) => total + product.price, 0);
+  }
+
+  getExpensiveProducts(minPrice: number): Product[] {
+    return this.products.filter(product => product.price >= minPrice);
+  }
+
+  getCheapProducts(maxPrice: number): Product[] {
+    return this.products.filter(product => product.price <= maxPrice);
+  }
+
+  searchProductsByTitle(query: string): Product[] {
+    return this.products.filter(product => product.title.toLowerCase().includes(query.toLowerCase()));
+  }
+
+  getUsersWithOrders(): User[] {
+    const userIdsWithOrders = new Set(this.orders.map(order => order.userId));
+    return this.users.filter(user => userIdsWithOrders.has(user.id));
+  }
+
+  getMostExpensiveOrder(): Order | undefined {
+    let maxOrder: Order | undefined;
+    let maxTotal = 0;
+    
+    for (const order of this.orders) {
+      const total = this.calculateOrderTotal(order);
+      if (total > maxTotal) {
+        maxTotal = total;
+        maxOrder = order;
+      }
+    }
+    
+    return maxOrder;
+  }
+
+  getOrdersByPriceRange(minPrice: number, maxPrice: number): Order[] {
+    return this.orders.filter(order => {
+      const total = this.calculateOrderTotal(order);
+      return total >= minPrice && total <= maxPrice;
+    });
+  }
+
+  getPopularProducts(): Product[] {
+    const productCount = new Map<number, number>();
+    
+    for (const order of this.orders) {
+      for (const product of order.products) {
+        productCount.set(product.id, (productCount.get(product.id) || 0) + 1);
+      }
+    }
+    
+    return this.products.filter(product => (productCount.get(product.id) || 0) > 1).sort((a, b) => (productCount.get(b.id) || 0) - (productCount.get(a.id) || 0));
+  }
+
+  getAverageOrderValue(): number {
+    const totalValue = this.orders.reduce((sum, order) => sum + this.calculateOrderTotal(order), 0);
+    return totalValue / this.orders.length;
+  }
+
+  getUserSpending(userId: number): number {
+    const userOrders = this.getUserOrders(userId);
+    return userOrders.reduce((total, order) => total + this.calculateOrderTotal(order), 0);
+  }
+
+  getTopSpendingUsers(limit: number = 5): Array<{ user: User; totalSpent: number }> {
+    const userSpending = this.users.map(user => ({
+      user,
+      totalSpent: this.getUserSpending(user.id)
+    }));
+    
+    return userSpending.sort((a, b) => b.totalSpent - a.totalSpent).slice(0, limit);
+  }
+}
+
+const data1 = 'extra'; const data2 = 'data'; const data3 = 'to'; const data4 = 'make'; const data5 = 'file';
+const data6 = 'longer'; const data7 = 'than'; const data8 = '100'; const data9 = 'lines'; const data10 = 'for';
+const data11 = 'testing'; const data12 = 'max'; const data13 = 'lines'; const data14 = 'rule'; const data15 = 'error';
+
+// This file has way more than 100 lines and should trigger a max-lines error

package/rules/max-file-lines/examples/valid/short-file.js

@@ -0,0 +1,66 @@
+// Valid: Short file under 70 lines (no warnings or errors)
+// This file demonstrates proper file length management
+
+export class NumberUtils {
+  static calculateSum(numbers) {
+    return numbers.reduce((sum, num) => sum + num, 0);
+  }
+
+  static calculateAverage(numbers) {
+    if (numbers.length === 0) return 0;
+    return this.calculateSum(numbers) / numbers.length;
+  }
+
+  static findMaxValue(numbers) {
+    if (numbers.length === 0) return null;
+    return Math.max(...numbers);
+  }
+
+  static findMinValue(numbers) {
+    if (numbers.length === 0) return null;
+    return Math.min(...numbers);
+  }
+
+  static sortNumbers(numbers) {
+    return [...numbers].sort((a, b) => a - b);
+  }
+
+  static filterEvenNumbers(numbers) {
+    return numbers.filter((num) => num % 2 === 0);
+  }
+
+  static filterOddNumbers(numbers) {
+    return numbers.filter((num) => num % 2 !== 0);
+  }
+
+  static multiplyByTwo(numbers) {
+    return numbers.map((num) => num * 2);
+  }
+
+  static containsNumber(numbers, target) {
+    return numbers.includes(target);
+  }
+
+  static removeNumber(numbers, target) {
+    return numbers.filter((num) => num !== target);
+  }
+
+  static addNumber(numbers, newNumber) {
+    return [...numbers, newNumber];
+  }
+
+  static getUniqueNumbers(numbers) {
+    return [...new Set(numbers)];
+  }
+
+  static reverseNumbers(numbers) {
+    return [...numbers].reverse();
+  }
+
+  static getNumbersInRange(numbers, min, max) {
+    return numbers.filter((num) => num >= min && num <= max);
+  }
+}
+
+// This file has less than 70 lines and should not trigger any max-lines warnings or errors
+export default NumberUtils;

package/rules/max-file-lines/examples/valid/spec-file.spec.js

@@ -0,0 +1,44 @@
+// Valid: Spec file that ignores max-lines rule regardless of length
+describe('Long spec file test', () => {
+  const testData1 = 'data1'; const testData2 = 'data2'; const testData3 = 'data3';
+  const testData4 = 'data4'; const testData5 = 'data5'; const testData6 = 'data6';
+  const testData7 = 'data7'; const testData8 = 'data8'; const testData9 = 'data9';
+  const testData10 = 'data10'; const testData11 = 'data11'; const testData12 = 'data12';
+  const testData13 = 'data13'; const testData14 = 'data14'; const testData15 = 'data15';
+  const testData16 = 'data16'; const testData17 = 'data17'; const testData18 = 'data18';
+  const testData19 = 'data19'; const testData20 = 'data20'; const testData21 = 'data21';
+  const testData22 = 'data22'; const testData23 = 'data23'; const testData24 = 'data24';
+  const testData25 = 'data25'; const testData26 = 'data26'; const testData27 = 'data27';
+  const testData28 = 'data28'; const testData29 = 'data29'; const testData30 = 'data30';
+  const testData31 = 'data31'; const testData32 = 'data32'; const testData33 = 'data33';
+  const testData34 = 'data34'; const testData35 = 'data35'; const testData36 = 'data36';
+  const testData37 = 'data37'; const testData38 = 'data38'; const testData39 = 'data39';
+  const testData40 = 'data40'; const testData41 = 'data41'; const testData42 = 'data42';
+  const testData43 = 'data43'; const testData44 = 'data44'; const testData45 = 'data45';
+  const testData46 = 'data46'; const testData47 = 'data47'; const testData48 = 'data48';
+  const testData49 = 'data49'; const testData50 = 'data50'; const testData51 = 'data51';
+  const testData52 = 'data52'; const testData53 = 'data53'; const testData54 = 'data54';
+  const testData55 = 'data55'; const testData56 = 'data56'; const testData57 = 'data57';
+  const testData58 = 'data58'; const testData59 = 'data59'; const testData60 = 'data60';
+  const testData61 = 'data61'; const testData62 = 'data62'; const testData63 = 'data63';
+  const testData64 = 'data64'; const testData65 = 'data65'; const testData66 = 'data66';
+  const testData67 = 'data67'; const testData68 = 'data68'; const testData69 = 'data69';
+  const testData70 = 'data70'; const testData71 = 'data71'; const testData72 = 'data72';
+  const testData73 = 'data73'; const testData74 = 'data74'; const testData75 = 'data75';
+  const testData76 = 'data76'; const testData77 = 'data77'; const testData78 = 'data78';
+  const testData79 = 'data79'; const testData80 = 'data80'; const testData81 = 'data81';
+  const testData82 = 'data82'; const testData83 = 'data83'; const testData84 = 'data84';
+  const testData85 = 'data85'; const testData86 = 'data86'; const testData87 = 'data87';
+  const testData88 = 'data88'; const testData89 = 'data89'; const testData90 = 'data90';
+  const testData91 = 'data91'; const testData92 = 'data92'; const testData93 = 'data93';
+  const testData94 = 'data94'; const testData95 = 'data95'; const testData96 = 'data96';
+  const testData97 = 'data97'; const testData98 = 'data98'; const testData99 = 'data99';
+  const testData100 = 'data100'; const testData101 = 'data101'; const testData102 = 'data102';
+  const testData103 = 'data103'; const testData104 = 'data104'; const testData105 = 'data105';
+  const testData106 = 'data106'; const testData107 = 'data107'; const testData108 = 'data108';
+  const testData109 = 'data109'; const testData110 = 'data110'; const testData111 = 'data111';
+
+  it('should handle long spec files without max-lines errors', () => {
+    expect(testData1).toBe('data1');
+  });
+});

package/rules/max-file-lines/examples/valid/test-file.test.js

@@ -0,0 +1,25 @@
+// Valid: Test file that ignores max-lines rule regardless of length
+const line1 = 1; const line2 = 2; const line3 = 3; const line4 = 4; const line5 = 5;
+const line6 = 6; const line7 = 7; const line8 = 8; const line9 = 9; const line10 = 10;
+const line11 = 11; const line12 = 12; const line13 = 13; const line14 = 14; const line15 = 15;
+const line16 = 16; const line17 = 17; const line18 = 18; const line19 = 19; const line20 = 20;
+const line21 = 21; const line22 = 22; const line23 = 23; const line24 = 24; const line25 = 25;
+const line26 = 26; const line27 = 27; const line28 = 28; const line29 = 29; const line30 = 30;
+const line31 = 31; const line32 = 32; const line33 = 33; const line34 = 34; const line35 = 35;
+const line36 = 36; const line37 = 37; const line38 = 38; const line39 = 39; const line40 = 40;
+const line41 = 41; const line42 = 42; const line43 = 43; const line44 = 44; const line45 = 45;
+const line46 = 46; const line47 = 47; const line48 = 48; const line49 = 49; const line50 = 50;
+const line51 = 51; const line52 = 52; const line53 = 53; const line54 = 54; const line55 = 55;
+const line56 = 56; const line57 = 57; const line58 = 58; const line59 = 59; const line60 = 60;
+const line61 = 61; const line62 = 62; const line63 = 63; const line64 = 64; const line65 = 65;
+const line66 = 66; const line67 = 67; const line68 = 68; const line69 = 69; const line70 = 70;
+const line71 = 71; const line72 = 72; const line73 = 73; const line74 = 74; const line75 = 75;
+const line76 = 76; const line77 = 77; const line78 = 78; const line79 = 79; const line80 = 80;
+const line81 = 81; const line82 = 82; const line83 = 83; const line84 = 84; const line85 = 85;
+const line86 = 86; const line87 = 87; const line88 = 88; const line89 = 89; const line90 = 90;
+const line91 = 91; const line92 = 92; const line93 = 93; const line94 = 94; const line95 = 95;
+const line96 = 96; const line97 = 97; const line98 = 98; const line99 = 99; const line100 = 100;
+const line101 = 101; const line102 = 102; const line103 = 103; const line104 = 104; const line105 = 105;
+const line106 = 106; const line107 = 107; const line108 = 108; const line109 = 109; const line110 = 110;
+
+export default line1;

package/rules/plugin/import/group-exports/examples/invalid/mixed-declaration-styles.js

@@ -0,0 +1,8 @@
+// Invalid: Mix of direct exports and separate export statements
+export const first = 'direct export';
+
+const second = 'separate export';
+const third = 'another separate export';
+
+export { second };
+export { third };

package/rules/plugin/import/group-exports/examples/invalid/multiple-export-statements.js

@@ -0,0 +1,8 @@
+// Invalid: Multiple separate export statements should be consolidated
+const apiUrl = "https://api.example.com";
+const timeout = 5000;
+const retries = 3;
+
+export { apiUrl };
+export { timeout };
+export { retries };

package/rules/plugin/import/group-exports/examples/invalid/scattered-exports.js

@@ -0,0 +1,10 @@
+// Invalid: Named exports scattered across multiple statements
+const config = { api: 'v1' };
+const utils = { format: () => {} };
+
+export { config };
+
+const helpers = { validate: () => {} };
+
+export { utils };
+export { helpers };

package/rules/plugin/import/group-exports/examples/valid/direct-exports.js

@@ -0,0 +1,2 @@
+// Valid: Single direct export at declaration point
+export const apiUrl = "https://api.example.com";

package/rules/plugin/import/group-exports/examples/valid/mixed-with-default.js

@@ -0,0 +1,7 @@
+// Valid: Default export with grouped named exports
+const mainConfig = { theme: 'dark' };
+const helper1 = () => 'helper';
+const helper2 = () => 'another helper';
+
+export default mainConfig;
+export { helper1, helper2 };

package/rules/plugin/import/group-exports/examples/valid/single-export-statement.js

@@ -0,0 +1,6 @@
+// Valid: All named exports consolidated into a single export statement
+const apiUrl = "https://api.example.com";
+const timeout = 5000;
+const retries = 3;
+
+export { apiUrl, timeout, retries };

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

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

package/rules/plugin/import/index.js

@@ -1,8 +1,12 @@
+import { noUnusedModulesConfig } from "./no-unused-modules/index.js";
+import { groupExportsConfig } from "./group-exports/index.js";
+
 export const importRules = {
   // Import/export organization and restrictions
-  "import/group-exports": "error", // Enforce consolidating exports into single statements
+  ...groupExportsConfig,
   "import/no-default-export": "off", // Allow default exports
   "import/no-namespace": "error",
+  ...noUnusedModulesConfig,
   // Disabled import rules (keep existing behavior)
   "import/extensions": ["off"],
   "import/no-extraneous-dependencies": ["off"],

package/rules/plugin/import/no-unused-modules/examples/invalid/dead-code.js

@@ -0,0 +1,2 @@
+// Invalid: This export is never imported (while others in the project might be used)
+export const unusedExport = "This is never imported";

package/rules/plugin/import/no-unused-modules/examples/invalid/unused-class.js

@@ -0,0 +1,6 @@
+// Invalid: This class export is never imported by any other module
+export class UnusedClass {
+  method() {
+    return "This class is never instantiated";
+  }
+}

package/rules/plugin/import/no-unused-modules/examples/invalid/unused-export.js

@@ -0,0 +1,2 @@
+// Invalid: This export is never imported by any other module
+export const unusedConstant = "This value is never used";

package/rules/plugin/import/no-unused-modules/examples/invalid/unused-function.js

@@ -0,0 +1,4 @@
+// Invalid: This function export is never imported by any other module
+export function unusedFunction() {
+  return "This function is never called";
+}

package/rules/plugin/import/no-unused-modules/examples/invalid/unused-module.js

@@ -0,0 +1,4 @@
+// Invalid: This entire module is never imported anywhere
+const internalData = [1, 2, 3];
+
+export const result = internalData.map(x => x * 2);

package/rules/plugin/import/no-unused-modules/examples/valid/consumed-import.js

@@ -0,0 +1,8 @@
+// Valid: This module consumes exports from other modules
+import { apiUrl } from './used-export.js';
+import { fetchData } from './used-function.js';
+import { DataProcessor } from './used-class.js';
+
+const processor = new DataProcessor();
+fetchData().then(data => processor.process(data));
+console.log(`API URL: ${apiUrl}`);

package/rules/plugin/import/no-unused-modules/examples/valid/entry-point.js

@@ -0,0 +1,5 @@
+// Valid: Entry point that imports and uses modules
+import './consumed-import.js';
+
+// Entry points are typically excluded from unused module detection
+console.log('Application started');

package/rules/plugin/import/no-unused-modules/examples/valid/used-class.js

@@ -0,0 +1,6 @@
+// Valid: Class export is used by other modules
+export class DataProcessor {
+  process(data) {
+    return data.map(item => item.value);
+  }
+}

package/rules/plugin/import/no-unused-modules/examples/valid/used-export.js

@@ -0,0 +1,2 @@
+// Valid: Export is used by other modules
+export const apiUrl = "https://api.example.com";

package/rules/plugin/import/no-unused-modules/examples/valid/used-function.js

@@ -0,0 +1,4 @@
+// Valid: Function export is used by other modules
+export function fetchData() {
+  return fetch("https://api.example.com");
+}

package/rules/plugin/import/no-unused-modules/index.js

@@ -0,0 +1,6 @@
+// Note: import/no-unused-modules has compatibility issues with ESLint flat config
+// It requires an .eslintrc file and has complex setup requirements
+// For now, this rule is disabled to avoid configuration conflicts
+export const noUnusedModulesConfig = {
+  // "import/no-unused-modules": "off", // Disabled due to flat config compatibility issues
+};

package/rules/plugin/typescript-eslint/index.js

@@ -1,4 +1,6 @@
+import { noExplicitAnyConfig } from "./no-explicit-any/index.js";
+
 export const typescriptEslintRules = {
-  "@typescript-eslint/no-explicit-any": "error",
+  ...noExplicitAnyConfig,
   "@typescript-eslint/consistent-type-assertions": "off",
 };

package/rules/plugin/typescript-eslint/no-explicit-any/examples/invalid/any-array.ts

@@ -0,0 +1,2 @@
+// Invalid: Using any in array type
+export const items: any[] = ["hello", 42, true, { name: "test" }];

package/rules/plugin/typescript-eslint/no-explicit-any/examples/invalid/any-parameter.ts

@@ -0,0 +1,4 @@
+// Invalid: Using any type for function parameter
+export function processData(data: any): number {
+  return data.length;
+}

package/rules/plugin/typescript-eslint/no-explicit-any/examples/invalid/any-return-type.ts

@@ -0,0 +1,4 @@
+// Invalid: Using any as return type
+export function getData(): any {
+  return { message: "Hello world" };
+}

package/rules/plugin/typescript-eslint/no-explicit-any/examples/invalid/any-variable.ts

@@ -0,0 +1,5 @@
+// Invalid: Using any type for variable declaration
+export const config: any = {
+  apiUrl: "https://api.example.com",
+  timeout: 5000,
+};

package/rules/plugin/typescript-eslint/no-explicit-any/examples/valid/generics.ts

@@ -0,0 +1,16 @@
+// Valid: Using generics instead of any
+export function identity<T>(value: T): T {
+  return value;
+}
+
+export class Container<T> {
+  private value: T;
+
+  constructor(value: T) {
+    this.value = value;
+  }
+
+  getValue(): T {
+    return this.value;
+  }
+}

package/rules/plugin/typescript-eslint/no-explicit-any/examples/valid/specific-types.ts

@@ -0,0 +1,9 @@
+// Valid: Using specific types instead of any
+export function processData(data: string[]): number {
+  return data.length;
+}
+
+export const config: { apiUrl: string; timeout: number } = {
+  apiUrl: "https://api.example.com",
+  timeout: 5000,
+};

package/rules/plugin/typescript-eslint/no-explicit-any/examples/valid/unknown-type.ts

@@ -0,0 +1,8 @@
+// Valid: Using unknown instead of any for safer type handling
+export function parseJson(json: string): unknown {
+  return JSON.parse(json);
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === "string";
+}

package/rules/plugin/typescript-eslint/no-explicit-any/index.js

@@ -0,0 +1,3 @@
+export const noExplicitAnyConfig = {
+  "@typescript-eslint/no-explicit-any": "error", // Disallow usage of the any type
+};

package/rules/README.md

@@ -1,42 +0,0 @@
-# ESLint Rules Configuration
-
-This directory contains custom rule configurations and their tests using ESLint's RuleTester.
-
-## Structure
-
-Each rule has its own directory with:
-- `index.js` - The rule configuration (severity and options)
-- `[rule-name].spec.js` - RuleTester test cases
-
-## Available Rules
-
-### no-trailing-spaces
-- **Severity**: error
-- **Description**: Disallows trailing whitespace at the end of lines
-- **Options**: 
-  - `skipBlankLines: false` - Check empty lines for trailing spaces
-  - `ignoreComments: false` - Check comments for trailing spaces
-
-## Testing
-
-Run individual rule tests:
-```bash
-cd rules/no-trailing-spaces
-node no-trailing-spaces.spec.js
-```
-
-## Adding New Rules
-
-1. Create a new directory: `rules/[rule-name]/`
-2. Add `index.js` with the rule configuration
-3. Add `[rule-name].spec.js` with RuleTester tests
-4. Import the configuration in the main `index.js` file
-
-Example structure:
-```javascript
-// rules/[rule-name]/index.js
-export const rule = "error"; // or "warn"
-export const options = { /* rule options */ };
-export const [ruleName]Config = [rule, options];
-export default [ruleName]Config;
-```