@e18e/eslint-plugin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 e18e
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# @e18e/eslint-plugin
+
+> The official e18e ESLint plugin for modernizing JavaScript/TypeScript code and improving performance.
+
+> [!WARNING]
+> This is an experimental, unpublished project for now. Once we have settled on the scope, we will publish it and announce it to start getting community feedback.
+
+This plugin focuses on applying the e18e community's best practices and advise to JavaScript/TypeScript codebases.
+
+## Overview
+
+There are a few categories of rules in this plugin:
+
+- Modernization - New syntax and APIs which improve code readability and performance
+- Module replacements - Community recommended alternatives to popular libraries, focused on performance and size
+- Performance improvements - Patterns that can be optimized for better runtime performance
+
+Each of these can be enabled individually, or you can use the recommended configuration to enable all rules.
+
+## Installation
+
+```bash
+npm install --save-dev @e18e/eslint-plugin
+```
+
+## Usage
+
+Add the plugin to your `eslint.config.js`:
+
+```ts
+import e18e from '@e18e/eslint-plugin';
+
+export default [
+  // Use the recommended configuration (includes all categories)
+  e18e.configs.recommended,
+
+  // Or use specific category configurations
+  e18e.configs.modernization,
+  e18e.configs.moduleReplacements,
+  e18e.configs.performanceImprovements,
+
+  // Or configure rules manually
+  {
+    plugins: {
+      e18e
+    },
+    rules: {
+      'e18e/prefer-array-at': 'error',
+      'e18e/prefer-array-fill': 'error',
+      'e18e/prefer-includes': 'error'
+    }
+  }
+];
+```
+
+## Rules
+
+**Legend:**
+- ✅ = Yes / Enabled
+- ✖️ = No / Disabled
+- 💡 = Has suggestions (requires user confirmation for fixes)
+
+### Modernization
+
+| Rule | Description | Recommended | Fixable | Requires Types |
+|------|-------------|-------------|---------|----------------|
+| [prefer-array-at](./src/rules/prefer-array-at.ts) | Prefer `Array.prototype.at()` over length-based indexing | ✅ | ✅ | ✖️ |
+| [prefer-array-fill](./src/rules/prefer-array-fill.ts) | Prefer `Array.prototype.fill()` over `Array.from()` or `map()` with constant values | ✅ | ✅ | ✖️ |
+| [prefer-includes](./src/rules/prefer-includes.ts) | Prefer `.includes()` over `indexOf()` comparisons for arrays and strings | ✅ | ✅ | ✖️ |
+| [prefer-array-to-reversed](./src/rules/prefer-array-to-reversed.ts) | Prefer `Array.prototype.toReversed()` over copying and reversing arrays | ✅ | ✅ | ✖️ |
+| [prefer-array-to-sorted](./src/rules/prefer-array-to-sorted.ts) | Prefer `Array.prototype.toSorted()` over copying and sorting arrays | ✅ | ✅ | ✖️ |
+| [prefer-array-to-spliced](./src/rules/prefer-array-to-spliced.ts) | Prefer `Array.prototype.toSpliced()` over copying and splicing arrays | ✅ | ✅ | ✖️ |
+| [prefer-exponentiation-operator](./src/rules/prefer-exponentiation-operator.ts) | Prefer the exponentiation operator `**` over `Math.pow()` | ✅ | ✅ | ✖️ |
+| [prefer-nullish-coalescing](./src/rules/prefer-nullish-coalescing.ts) | Prefer nullish coalescing operator (`??` and `??=`) over verbose null checks | ✅ | ✅ | ✖️ |
+| [prefer-object-has-own](./src/rules/prefer-object-has-own.ts) | Prefer `Object.hasOwn()` over `Object.prototype.hasOwnProperty.call()` and `obj.hasOwnProperty()` | ✅ | ✅ | ✖️ |
+| [prefer-spread-syntax](./src/rules/prefer-spread-syntax.ts) | Prefer spread syntax over `Array.concat()`, `Array.from()`, `Object.assign({}, ...)`, and `Function.apply()` | ✅ | ✅ | ✖️ |
+| [prefer-url-canparse](./src/rules/prefer-url-canparse.ts) | Prefer `URL.canParse()` over try-catch blocks for URL validation | ✅ | 💡 | ✖️ |
+
+### Module replacements
+
+| Rule | Description | Recommended | Fixable | Requires Types |
+|------|-------------|-------------|---------|----------------|
+| ban-dependencies | Ban dependencies in favor of lighter alternatives | ✅ | ✖️ | ✖️ |
+
+### Performance improvements
+
+| Rule | Description | Recommended | Fixable | Requires Types |
+|------|-------------|-------------|---------|----------------|
+| [no-indexof-equality](./src/rules/no-indexof-equality.ts) | Prefer `startsWith()` for strings and direct array access over `indexOf()` equality checks | ✖️ | ✅ | ✅ |
+| [prefer-array-from-map](./src/rules/prefer-array-from-map.ts) | Prefer `Array.from(iterable, mapper)` over `[...iterable].map(mapper)` to avoid intermediate array allocation | ✅ | ✅ | ✖️ |
+| [prefer-timer-args](./src/rules/prefer-timer-args.ts) | Prefer passing function and arguments directly to `setTimeout`/`setInterval` instead of wrapping in an arrow function or using `bind` | ✅ | ✅ | ✖️ |
+
+## License
+
+MIT

package/lib/configs/modernization.d.ts

@@ -0,0 +1,2 @@
+import type { Linter, ESLint } from 'eslint';
+export declare const modernization: (plugin: ESLint.Plugin) => Linter.Config;

package/lib/configs/modernization.js

@@ -0,0 +1,17 @@
+export const modernization = (plugin) => ({
+    plugins: {
+        e18e: plugin
+    },
+    rules: {
+        'e18e/prefer-array-at': 'error',
+        'e18e/prefer-array-fill': 'error',
+        'e18e/prefer-includes': 'error',
+        'e18e/prefer-array-to-reversed': 'error',
+        'e18e/prefer-array-to-sorted': 'error',
+        'e18e/prefer-array-to-spliced': 'error',
+        'e18e/prefer-nullish-coalescing': 'error',
+        'e18e/prefer-object-has-own': 'error',
+        'e18e/prefer-spread-syntax': 'error',
+        'e18e/prefer-url-canparse': 'error'
+    }
+});

package/lib/configs/module-replacements.d.ts

@@ -0,0 +1,2 @@
+import type { Linter, ESLint } from 'eslint';
+export declare const moduleReplacements: (plugin: ESLint.Plugin) => Linter.Config;

package/lib/configs/module-replacements.js

@@ -0,0 +1,8 @@
+export const moduleReplacements = (plugin) => ({
+    plugins: {
+        e18e: plugin
+    },
+    rules: {
+        'e18e/ban-dependencies': 'error'
+    }
+});

package/lib/configs/performance-improvements.d.ts

@@ -0,0 +1,2 @@
+import type { Linter, ESLint } from 'eslint';
+export declare const performanceImprovements: (plugin: ESLint.Plugin) => Linter.Config;

package/lib/configs/performance-improvements.js

@@ -0,0 +1,9 @@
+export const performanceImprovements = (plugin) => ({
+    plugins: {
+        e18e: plugin
+    },
+    rules: {
+        'e18e/prefer-array-from-map': 'error',
+        'e18e/prefer-timer-args': 'error'
+    }
+});

package/lib/configs/recommended.d.ts

@@ -0,0 +1,2 @@
+import type { Linter, ESLint } from 'eslint';
+export declare const recommended: (plugin: ESLint.Plugin) => Linter.Config;

package/lib/configs/recommended.js

@@ -0,0 +1,18 @@
+import { modernization } from './modernization.js';
+import { moduleReplacements } from './module-replacements.js';
+import { performanceImprovements } from './performance-improvements.js';
+export const recommended = (plugin) => {
+    const modernizationConfig = modernization(plugin);
+    const moduleReplacementsConfig = moduleReplacements(plugin);
+    const performanceImprovementsConfig = performanceImprovements(plugin);
+    return {
+        plugins: {
+            e18e: plugin
+        },
+        rules: {
+            ...modernizationConfig.rules,
+            ...moduleReplacementsConfig.rules,
+            ...performanceImprovementsConfig.rules
+        }
+    };
+};

package/lib/main.d.ts

@@ -0,0 +1,3 @@
+import type { ESLint } from 'eslint';
+declare const plugin: ESLint.Plugin;
+export default plugin;

package/lib/main.js

@@ -0,0 +1,48 @@
+import { recommended } from './configs/recommended.js';
+import { modernization } from './configs/modernization.js';
+import { moduleReplacements } from './configs/module-replacements.js';
+import { performanceImprovements } from './configs/performance-improvements.js';
+import { preferArrayAt } from './rules/prefer-array-at.js';
+import { preferArrayFill } from './rules/prefer-array-fill.js';
+import { preferArrayFromMap } from './rules/prefer-array-from-map.js';
+import { preferIncludes } from './rules/prefer-includes.js';
+import { preferArrayToReversed } from './rules/prefer-array-to-reversed.js';
+import { preferArrayToSorted } from './rules/prefer-array-to-sorted.js';
+import { preferArrayToSpliced } from './rules/prefer-array-to-spliced.js';
+import { preferExponentiationOperator } from './rules/prefer-exponentiation-operator.js';
+import { preferNullishCoalescing } from './rules/prefer-nullish-coalescing.js';
+import { preferObjectHasOwn } from './rules/prefer-object-has-own.js';
+import { preferSpreadSyntax } from './rules/prefer-spread-syntax.js';
+import { preferUrlCanParse } from './rules/prefer-url-canparse.js';
+import { noIndexOfEquality } from './rules/no-indexof-equality.js';
+import { preferTimerArgs } from './rules/prefer-timer-args.js';
+import { rules as dependRules } from 'eslint-plugin-depend';
+const plugin = {
+    meta: {
+        name: '@e18e/eslint-plugin',
+        namespace: 'e18e'
+    },
+    configs: {},
+    rules: {
+        'prefer-array-at': preferArrayAt,
+        'prefer-array-fill': preferArrayFill,
+        'prefer-array-from-map': preferArrayFromMap,
+        'prefer-includes': preferIncludes,
+        'prefer-array-to-reversed': preferArrayToReversed,
+        'prefer-array-to-sorted': preferArrayToSorted,
+        'prefer-array-to-spliced': preferArrayToSpliced,
+        'prefer-exponentiation-operator': preferExponentiationOperator,
+        'prefer-nullish-coalescing': preferNullishCoalescing,
+        'prefer-object-has-own': preferObjectHasOwn,
+        'prefer-spread-syntax': preferSpreadSyntax,
+        'prefer-url-canparse': preferUrlCanParse,
+        'no-indexof-equality': noIndexOfEquality,
+        'prefer-timer-args': preferTimerArgs,
+        ...dependRules
+    }
+};
+plugin.configs.recommended = recommended(plugin);
+plugin.configs.modernization = modernization(plugin);
+plugin.configs.moduleReplacements = moduleReplacements(plugin);
+plugin.configs.performanceImprovements = performanceImprovements(plugin);
+export default plugin;

package/lib/rules/no-indexof-equality.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const noIndexOfEquality: Rule.RuleModule;

package/lib/rules/no-indexof-equality.js

@@ -0,0 +1,90 @@
+import { getTypedParserServices } from '../utils/typescript.js';
+export const noIndexOfEquality = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer optimized alternatives to `indexOf()` equality checks',
+            recommended: false
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferDirectAccess: 'Use direct array access `{{array}}[{{index}}] === {{item}}` instead of `indexOf() === {{index}}`',
+            preferStartsWith: 'Use `.startsWith()` instead of `indexOf() === 0` for strings'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const services = getTypedParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            BinaryExpression(node) {
+                if (node.operator !== '===' && node.operator !== '==') {
+                    return;
+                }
+                let indexOfCall;
+                let compareIndex;
+                if (node.left.type === 'CallExpression' &&
+                    node.right.type === 'Literal' &&
+                    typeof node.right.value === 'number' &&
+                    node.right.value >= 0) {
+                    indexOfCall = node.left;
+                    compareIndex = node.right.value;
+                }
+                else if (node.right.type === 'CallExpression' &&
+                    node.left.type === 'Literal' &&
+                    typeof node.left.value === 'number' &&
+                    node.left.value >= 0) {
+                    indexOfCall = node.right;
+                    compareIndex = node.left.value;
+                }
+                if (!indexOfCall || compareIndex === undefined) {
+                    return;
+                }
+                if (indexOfCall.callee.type !== 'MemberExpression' ||
+                    indexOfCall.callee.property.type !== 'Identifier' ||
+                    indexOfCall.callee.property.name !== 'indexOf') {
+                    return;
+                }
+                if (indexOfCall.arguments.length !== 1) {
+                    return;
+                }
+                const objectNode = indexOfCall.callee.object;
+                const searchArg = indexOfCall.arguments[0];
+                const type = services.getTypeAtLocation(objectNode);
+                if (!type) {
+                    return;
+                }
+                const objectText = sourceCode.getText(objectNode);
+                const searchText = sourceCode.getText(searchArg);
+                const stringType = checker.getStringType();
+                if (checker.isTypeAssignableTo(type, stringType)) {
+                    if (compareIndex === 0) {
+                        context.report({
+                            node,
+                            messageId: 'preferStartsWith',
+                            fix(fixer) {
+                                return fixer.replaceText(node, `${objectText}.startsWith(${searchText})`);
+                            }
+                        });
+                    }
+                    return;
+                }
+                if (checker.isArrayType(type)) {
+                    context.report({
+                        node,
+                        messageId: 'preferDirectAccess',
+                        data: {
+                            array: objectText,
+                            item: searchText,
+                            index: String(compareIndex)
+                        },
+                        fix(fixer) {
+                            return fixer.replaceText(node, `${objectText}[${compareIndex}] === ${searchText}`);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-array-at.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const preferArrayAt: Rule.RuleModule;

package/lib/rules/prefer-array-at.js

@@ -0,0 +1,58 @@
+export const preferArrayAt = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Array.prototype.at() over length-based indexing',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferAt: 'Use .at(-1) instead of [{{array}}.length - 1]'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            MemberExpression(node) {
+                if (!node.computed || !node.property) {
+                    return;
+                }
+                if (node.property.type !== 'BinaryExpression') {
+                    return;
+                }
+                const propertyExpr = node.property;
+                if (propertyExpr.operator !== '-') {
+                    return;
+                }
+                if (propertyExpr.right.type !== 'Literal' ||
+                    propertyExpr.right.value !== 1) {
+                    return;
+                }
+                if (propertyExpr.left.type !== 'MemberExpression') {
+                    return;
+                }
+                const leftMember = propertyExpr.left;
+                if (leftMember.property.type !== 'Identifier' ||
+                    leftMember.property.name !== 'length') {
+                    return;
+                }
+                const arrayText = sourceCode.getText(node.object);
+                const lengthArrayText = sourceCode.getText(leftMember.object);
+                if (arrayText !== lengthArrayText) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'preferAt',
+                    data: {
+                        array: arrayText
+                    },
+                    fix(fixer) {
+                        return fixer.replaceText(node, `${arrayText}.at(-1)`);
+                    }
+                });
+            }
+        };
+    }
+};

package/lib/rules/prefer-array-fill.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const preferArrayFill: Rule.RuleModule;

package/lib/rules/prefer-array-fill.js

@@ -0,0 +1,120 @@
+function isConstantCallback(func) {
+    return (func.params.length === 0 &&
+        (func.body.type !== 'BlockStatement' ||
+            (func.body.body.length === 1 &&
+                func.body.body[0]?.type === 'ReturnStatement')));
+}
+function getCallbackValueText(func, sourceCode) {
+    if (func.body.type === 'BlockStatement') {
+        const returnStmt = func.body.body[0];
+        if (returnStmt?.type === 'ReturnStatement' && returnStmt.argument) {
+            return sourceCode.getText(returnStmt.argument);
+        }
+        return undefined;
+    }
+    return sourceCode.getText(func.body);
+}
+export const preferArrayFill = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Array.prototype.fill() over Array.from or map with constant values',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferFillArrayFrom: 'Use Array.from({length: {{length}}}).fill({{value}}) instead of Array.from with a constant callback',
+            preferFillSpreadMap: 'Use Array({{length}}).fill({{value}}) instead of spread Array with map'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                // Check for Array.from({length: n}, () => value)
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.object.type === 'Identifier' &&
+                    node.callee.object.name === 'Array' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'from' &&
+                    node.arguments.length === 2) {
+                    const firstArg = node.arguments[0];
+                    const secondArg = node.arguments[1];
+                    // Check if first arg is {length: n}
+                    if (firstArg?.type === 'ObjectExpression' &&
+                        firstArg.properties.length === 1 &&
+                        firstArg.properties[0]?.type === 'Property' &&
+                        firstArg.properties[0].key.type === 'Identifier' &&
+                        firstArg.properties[0].key.name === 'length') {
+                        // Check if second arg is a constant callback
+                        if (secondArg &&
+                            (secondArg.type === 'ArrowFunctionExpression' ||
+                                secondArg.type === 'FunctionExpression') &&
+                            isConstantCallback(secondArg)) {
+                            const lengthValue = firstArg.properties[0].value;
+                            const lengthText = sourceCode.getText(lengthValue);
+                            const valueText = getCallbackValueText(secondArg, sourceCode);
+                            if (!valueText) {
+                                return;
+                            }
+                            context.report({
+                                node,
+                                messageId: 'preferFillArrayFrom',
+                                data: {
+                                    length: lengthText,
+                                    value: valueText
+                                },
+                                fix(fixer) {
+                                    return fixer.replaceText(node, `Array.from({length: ${lengthText}}).fill(${valueText})`);
+                                }
+                            });
+                        }
+                    }
+                }
+                // Check for [...Array(n)].map(() => value)
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'map' &&
+                    node.callee.object.type === 'ArrayExpression' &&
+                    node.callee.object.elements.length === 1 &&
+                    node.arguments.length === 1) {
+                    const spreadElement = node.callee.object.elements[0];
+                    const callback = node.arguments[0];
+                    if (spreadElement?.type === 'SpreadElement' &&
+                        spreadElement.argument.type === 'CallExpression' &&
+                        spreadElement.argument.callee.type === 'Identifier' &&
+                        spreadElement.argument.callee.name === 'Array' &&
+                        spreadElement.argument.arguments.length === 1) {
+                        const arrayArg = spreadElement.argument.arguments[0];
+                        // Check if callback is a constant function
+                        if (callback &&
+                            (callback.type === 'ArrowFunctionExpression' ||
+                                callback.type === 'FunctionExpression') &&
+                            isConstantCallback(callback)) {
+                            if (!arrayArg) {
+                                return;
+                            }
+                            const lengthText = sourceCode.getText(arrayArg);
+                            const valueText = getCallbackValueText(callback, sourceCode);
+                            if (!valueText) {
+                                return;
+                            }
+                            context.report({
+                                node,
+                                messageId: 'preferFillSpreadMap',
+                                data: {
+                                    length: lengthText,
+                                    value: valueText
+                                },
+                                fix(fixer) {
+                                    return fixer.replaceText(node, `Array(${lengthText}).fill(${valueText})`);
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-array-from-map.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const preferArrayFromMap: Rule.RuleModule;

package/lib/rules/prefer-array-from-map.js

@@ -0,0 +1,57 @@
+export const preferArrayFromMap = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Array.from(iterable, mapper) over [...iterable].map(mapper) to avoid intermediate array allocation',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferArrayFrom: 'Use Array.from({{iterable}}, {{mapper}}) instead of [...{{iterable}}].map({{mapper}}) to avoid creating an intermediate array'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                // Check if this is a .map() call
+                if (node.callee.type !== 'MemberExpression') {
+                    return;
+                }
+                if (node.callee.property.type !== 'Identifier' ||
+                    node.callee.property.name !== 'map') {
+                    return;
+                }
+                // Check if .map() is being called on an array literal with spread
+                if (node.callee.object.type !== 'ArrayExpression') {
+                    return;
+                }
+                const arrayExpr = node.callee.object;
+                // Check if the array has exactly one element and it's a spread element
+                if (arrayExpr.elements.length !== 1 ||
+                    arrayExpr.elements[0]?.type !== 'SpreadElement') {
+                    return;
+                }
+                // Check if map has exactly one argument (the mapper function)
+                if (node.arguments.length !== 1) {
+                    return;
+                }
+                const spreadElement = arrayExpr.elements[0];
+                const iterableText = sourceCode.getText(spreadElement.argument);
+                const mapperText = sourceCode.getText(node.arguments[0]);
+                context.report({
+                    node,
+                    messageId: 'preferArrayFrom',
+                    data: {
+                        iterable: iterableText,
+                        mapper: mapperText
+                    },
+                    fix(fixer) {
+                        return fixer.replaceText(node, `Array.from(${iterableText}, ${mapperText})`);
+                    }
+                });
+            }
+        };
+    }
+};

package/lib/rules/prefer-array-to-reversed.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const preferArrayToReversed: Rule.RuleModule;

package/lib/rules/prefer-array-to-reversed.js

@@ -0,0 +1,42 @@
+import { getArrayFromCopyPattern } from '../utils/ast.js';
+export const preferArrayToReversed = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Array.prototype.toReversed() over copying and reversing arrays',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferToReversed: 'Use {{array}}.toReversed() instead of copying and reversing'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'MemberExpression' ||
+                    node.callee.property.type !== 'Identifier' ||
+                    node.callee.property.name !== 'reverse') {
+                    return;
+                }
+                const reverseCallee = node.callee.object;
+                const arrayNode = getArrayFromCopyPattern(reverseCallee);
+                if (arrayNode) {
+                    const arrayText = sourceCode.getText(arrayNode);
+                    context.report({
+                        node,
+                        messageId: 'preferToReversed',
+                        data: {
+                            array: arrayText
+                        },
+                        fix(fixer) {
+                            return fixer.replaceText(node, `${arrayText}.toReversed()`);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-array-to-sorted.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const preferArrayToSorted: Rule.RuleModule;