@e18e/eslint-plugin 0.2.0 → 0.3.0

package/README.md

@@ -141,13 +141,13 @@ Read more at the
 | [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-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-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
@@ -166,13 +166,13 @@ Read more at the
 | [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` | ✅ | ✅ | ✖️ |
 | [prefer-date-now](./src/rules/prefer-date-now.ts) | Prefer `Date.now()` over `new Date().getTime()` and `+new Date()` | ✅ | ✅ | ✖️ |
 | [prefer-regex-test](./src/rules/prefer-regex-test.ts) | Prefer `RegExp.test()` over `String.match()` and `RegExp.exec()` when only checking for match existence | ✅ | ✅ | 🔶 |
-| [prefer-static-regex](./src/rules/prefer-static-regex.ts) | Prefer defining regular expressions at module scope to avoid re-compilation on every function call | ✅ | ✖️ | ✖️ |
+| [prefer-static-regex](./src/rules/prefer-static-regex.ts) | Prefer defining regular expressions at module scope to avoid re-compilation on every function call | ✅ | ✖️ | 🔶 |
 | [prefer-inline-equality](./src/rules/prefer-inline-equality.ts) | Prefer inline equality checks over temporary object creation for simple comparisons | ✖️ | ✅ | 🔶 |
 
 ## Sponsors
 
 <p align="center">
-  <a href="https://github.com/sponsors/e18e">
+  <a href="https://e18e.dev/sponsor">
     <img src="https://e18e.dev/sponsors.svg" alt="e18e community sponsors" />
   </a>
 </p>

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

@@ -1,18 +1,59 @@
-function isConstantCallback(func) {
-    return (func.params.length === 0 &&
-        (func.body.type !== 'BlockStatement' ||
-            (func.body.body.length === 1 &&
-                func.body.body[0]?.type === 'ReturnStatement')));
+function isConstantExpression(node) {
+    switch (node.type) {
+        case 'Literal':
+        case 'Identifier':
+            return true;
+        case 'CallExpression':
+        case 'NewExpression':
+        case 'ObjectExpression':
+        case 'ArrayExpression':
+            return false;
+        case 'MemberExpression':
+            return (node.object.type !== 'Super' &&
+                isConstantExpression(node.object) &&
+                (!node.computed || isConstantExpression(node.property)));
+        case 'UnaryExpression':
+            return isConstantExpression(node.argument);
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return (node.left.type !== 'PrivateIdentifier' &&
+                isConstantExpression(node.left) &&
+                isConstantExpression(node.right));
+        case 'ConditionalExpression':
+            return (isConstantExpression(node.test) &&
+                isConstantExpression(node.consequent) &&
+                isConstantExpression(node.alternate));
+        case 'TemplateLiteral':
+            return node.expressions.every((expr) => isConstantExpression(expr));
+        default:
+            return false;
+    }
 }
-function getCallbackValueText(func, sourceCode) {
+function getCallbackValueNode(func) {
     if (func.body.type === 'BlockStatement') {
+        if (func.body.body.length !== 1)
+            return undefined;
         const returnStmt = func.body.body[0];
         if (returnStmt?.type === 'ReturnStatement' && returnStmt.argument) {
-            return sourceCode.getText(returnStmt.argument);
+            return returnStmt.argument;
         }
         return undefined;
     }
-    return sourceCode.getText(func.body);
+    return func.body;
+}
+function isConstantCallback(func) {
+    if (func.params.length !== 0) {
+        return false;
+    }
+    const valueNode = getCallbackValueNode(func);
+    if (!valueNode) {
+        return false;
+    }
+    return isConstantExpression(valueNode);
+}
+function getCallbackValueText(func, sourceCode) {
+    const valueNode = getCallbackValueNode(func);
+    return valueNode ? sourceCode.getText(valueNode) : undefined;
 }
 export const preferArrayFill = {
     meta: {

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

@@ -1,2 +1,4 @@
-import type { Rule } from 'eslint';
-export declare const preferArrayToReversed: Rule.RuleModule;
+import type { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferToReversed';
+export declare const preferArrayToReversed: TSESLint.RuleModule<MessageIds, []>;
+export {};

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

@@ -1,10 +1,10 @@
-import { getArrayFromCopyPattern } from '../utils/ast.js';
+import { getArrayFromCopyPattern, needsParensForPropertyAccess, isCopyPatternOptional } from '../utils/ast.js';
+import { isArrayType } from '../utils/typescript.js';
 export const preferArrayToReversed = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer Array.prototype.toReversed() over copying and reversing arrays',
-            recommended: true
+            description: 'Prefer Array.prototype.toReversed() over copying and reversing arrays'
         },
         fixable: 'code',
         schema: [],
@@ -12,6 +12,7 @@ export const preferArrayToReversed = {
             preferToReversed: 'Use {{array}}.toReversed() instead of copying and reversing'
         }
     },
+    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {
@@ -24,15 +25,24 @@ export const preferArrayToReversed = {
                 const reverseCallee = node.callee.object;
                 const arrayNode = getArrayFromCopyPattern(reverseCallee);
                 if (arrayNode) {
-                    const arrayText = sourceCode.getText(arrayNode);
+                    if (!isArrayType(arrayNode, context)) {
+                        return;
+                    }
+                    const rawText = sourceCode.getText(arrayNode);
+                    const arrayText = needsParensForPropertyAccess(arrayNode)
+                        ? `(${rawText})`
+                        : rawText;
+                    const optionalChain = isCopyPatternOptional(reverseCallee)
+                        ? '?.'
+                        : '.';
                     context.report({
                         node,
                         messageId: 'preferToReversed',
                         data: {
-                            array: arrayText
+                            array: rawText
                         },
                         fix(fixer) {
-                            return fixer.replaceText(node, `${arrayText}.toReversed()`);
+                            return fixer.replaceText(node, `${arrayText}${optionalChain}toReversed()`);
                         }
                     });
                 }

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

@@ -1,4 +1,4 @@
-import { getArrayFromCopyPattern, formatArguments } from '../utils/ast.js';
+import { getArrayFromCopyPattern, formatArguments, needsParensForPropertyAccess, isCopyPatternOptional } from '../utils/ast.js';
 import { isArrayType } from '../utils/typescript.js';
 export const preferArrayToSorted = {
     meta: {
@@ -28,16 +28,20 @@ export const preferArrayToSorted = {
                     if (!isArrayType(arrayNode, context)) {
                         return;
                     }
-                    const arrayText = sourceCode.getText(arrayNode);
+                    const rawText = sourceCode.getText(arrayNode);
+                    const arrayText = needsParensForPropertyAccess(arrayNode)
+                        ? `(${rawText})`
+                        : rawText;
                     const argsText = formatArguments(node.arguments, sourceCode);
+                    const optionalChain = isCopyPatternOptional(sortCallee) ? '?.' : '.';
                     context.report({
                         node,
                         messageId: 'preferToSorted',
                         data: {
-                            array: arrayText
+                            array: rawText
                         },
                         fix(fixer) {
-                            return fixer.replaceText(node, `${arrayText}.toSorted(${argsText})`);
+                            return fixer.replaceText(node, `${arrayText}${optionalChain}toSorted(${argsText})`);
                         }
                     });
                 }

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

@@ -1,4 +1,4 @@
-import { getArrayFromCopyPattern, formatArguments } from '../utils/ast.js';
+import { getArrayFromCopyPattern, formatArguments, needsParensForPropertyAccess, isCopyPatternOptional } from '../utils/ast.js';
 export const preferArrayToSpliced = {
     meta: {
         type: 'suggestion',
@@ -24,16 +24,22 @@ export const preferArrayToSpliced = {
                 const spliceCallee = node.callee.object;
                 const arrayNode = getArrayFromCopyPattern(spliceCallee);
                 if (arrayNode) {
-                    const arrayText = sourceCode.getText(arrayNode);
+                    const rawText = sourceCode.getText(arrayNode);
+                    const arrayText = needsParensForPropertyAccess(arrayNode)
+                        ? `(${rawText})`
+                        : rawText;
                     const argsText = formatArguments(node.arguments, sourceCode);
+                    const optionalChain = isCopyPatternOptional(spliceCallee)
+                        ? '?.'
+                        : '.';
                     context.report({
                         node,
                         messageId: 'preferToSpliced',
                         data: {
-                            array: arrayText
+                            array: rawText
                         },
                         fix(fixer) {
-                            return fixer.replaceText(node, `${arrayText}.toSpliced(${argsText})`);
+                            return fixer.replaceText(node, `${arrayText}${optionalChain}toSpliced(${argsText})`);
                         }
                     });
                 }

package/lib/rules/prefer-spread-syntax.d.ts

@@ -1,2 +1,4 @@
-import type { Rule } from 'eslint';
-export declare const preferSpreadSyntax: Rule.RuleModule;
+import type { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferSpreadArray' | 'preferSpreadArrayFrom' | 'preferSpreadObject' | 'preferSpreadFunction';
+export declare const preferSpreadSyntax: TSESLint.RuleModule<MessageIds, []>;
+export {};

package/lib/rules/prefer-spread-syntax.js

@@ -1,3 +1,4 @@
+import { isArrayType } from '../utils/typescript.js';
 function isNullOrUndefined(node) {
     if (node.type === 'Literal' && node.value === null) {
         return true;
@@ -8,8 +9,7 @@ export const preferSpreadSyntax = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer spread syntax over Array.concat(), Array.from(), Object.assign({}, ...), and Function.apply()',
-            recommended: true
+            description: 'Prefer spread syntax over Array.concat(), Array.from(), Object.assign({}, ...), and Function.apply()'
         },
         fixable: 'code',
         schema: [],
@@ -20,6 +20,7 @@ export const preferSpreadSyntax = {
             preferSpreadFunction: 'Use spread syntax fn(...args) instead of fn.apply(null/undefined, args)'
         }
     },
+    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {
@@ -36,12 +37,25 @@ export const preferSpreadSyntax = {
                     node.arguments.length > 0 &&
                     !(node.callee.object.type === 'Identifier' &&
                         node.callee.object.name === 'Buffer')) {
+                    // If type info is available, only flag when the receiver is an array
+                    if (!isArrayType(node.callee.object, context)) {
+                        return;
+                    }
                     const arrayText = sourceCode.getText(node.callee.object);
-                    const argTexts = node.arguments.map((arg) => sourceCode.getText(arg));
-                    const spreadParts = [arrayText, ...argTexts]
-                        .map((part) => `...${part}`)
-                        .join(', ');
-                    replacement = `[${spreadParts}]`;
+                    const parts = [`...${arrayText}`];
+                    for (const arg of node.arguments) {
+                        const argText = sourceCode.getText(arg);
+                        if (arg.type === 'SpreadElement') {
+                            parts.push(argText);
+                        }
+                        else if (isArrayType(arg, context)) {
+                            parts.push(`...${argText}`);
+                        }
+                        else {
+                            parts.push(argText);
+                        }
+                    }
+                    replacement = `[${parts.join(', ')}]`;
                     messageId = 'preferSpreadArray';
                 }
                 // Array.from(iterable) with no mapper

package/lib/rules/prefer-static-regex.js

@@ -1,3 +1,4 @@
+const statefulFlags = /[gy]/;
 function isStaticNewRegExp(node) {
     if (node.callee.type !== 'Identifier' ||
         node.callee.name !== 'RegExp' ||
@@ -5,7 +6,14 @@ function isStaticNewRegExp(node) {
         node.arguments.length > 2) {
         return false;
     }
-    return node.arguments.every((arg) => arg.type === 'Literal' && typeof arg.value === 'string');
+    if (!node.arguments.every((arg) => arg.type === 'Literal' && typeof arg.value === 'string')) {
+        return false;
+    }
+    const flagsArg = node.arguments[1];
+    if (flagsArg && statefulFlags.test(flagsArg.value)) {
+        return false;
+    }
+    return true;
 }
 export const preferStaticRegex = {
     meta: {
@@ -22,6 +30,10 @@ export const preferStaticRegex = {
     create(context) {
         return {
             ':function Literal[regex]'(node) {
+                const { flags } = node.regex;
+                if (statefulFlags.test(flags)) {
+                    return;
+                }
                 context.report({ node, messageId: 'preferStatic' });
             },
             ':function NewExpression'(node) {

package/lib/utils/ast.d.ts

@@ -22,6 +22,16 @@ export declare function isCopyCall(node: CallExpression): boolean;
  */
 export declare function getArrayFromCopyPattern(node: TSESTree.Node): TSESTree.Node | null;
 export declare function getArrayFromCopyPattern(node: Node): Node | null;
+/**
+ * Checks if a node needs to be wrapped in parentheses when used as the
+ * object of a property access (e.g. `expr.foo()`).
+ */
+export declare function needsParensForPropertyAccess(node: AnyNode): boolean;
+/**
+ * Checks if a copy pattern (node passed to getArrayFromCopyPattern) uses
+ * optional chaining on the copy method call, e.g. `arr?.slice()`.
+ */
+export declare function isCopyPatternOptional(node: AnyNode): boolean;
 /**
  * Formats arguments from a CallExpression as a comma-separated string.
  */

package/lib/utils/ast.js

@@ -81,6 +81,38 @@ export function getArrayFromCopyPattern(node) {
     }
     return null;
 }
+/**
+ * Checks if a node needs to be wrapped in parentheses when used as the
+ * object of a property access (e.g. `expr.foo()`).
+ */
+export function needsParensForPropertyAccess(node) {
+    switch (node.type) {
+        case 'Identifier':
+        case 'MemberExpression':
+        case 'CallExpression':
+        case 'Literal':
+        case 'ArrayExpression':
+        case 'ObjectExpression':
+        case 'TemplateLiteral':
+        case 'TaggedTemplateExpression':
+        case 'ThisExpression':
+        case 'NewExpression':
+        case 'ChainExpression':
+        case 'MetaProperty':
+            return false;
+        default:
+            return true;
+    }
+}
+/**
+ * Checks if a copy pattern (node passed to getArrayFromCopyPattern) uses
+ * optional chaining on the copy method call, e.g. `arr?.slice()`.
+ */
+export function isCopyPatternOptional(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.optional === true);
+}
 export function formatArguments(args, sourceCode) {
     if (args.length === 0) {
         return '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e18e/eslint-plugin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "The official e18e ESLint plugin for modernizing code and improving performance.",
   "keywords": [
     "eslint",
@@ -35,24 +35,24 @@
     "lint:format": "prettier --check src"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@eslint/json": "^0.14.0",
-    "@types/node": "^25.0.10",
-    "@typescript-eslint/rule-tester": "^8.53.1",
-    "@typescript-eslint/typescript-estree": "^8.53.1",
-    "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^9.39.2",
-    "eslint-plugin-eslint-plugin": "^7.3.0",
-    "jsonc-eslint-parser": "^2.4.2",
-    "oxlint": "^1.41.0",
+    "@eslint/js": "^10.0.1",
+    "@eslint/json": "^1.1.0",
+    "@types/node": "^25.5.0",
+    "@typescript-eslint/rule-tester": "^8.57.0",
+    "@typescript-eslint/typescript-estree": "^8.57.0",
+    "@vitest/coverage-v8": "^4.1.0",
+    "eslint": "^10.0.3",
+    "eslint-plugin-eslint-plugin": "^7.3.2",
+    "jsonc-eslint-parser": "^3.1.0",
+    "oxlint": "^1.55.0",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.53.1",
+    "typescript-eslint": "^8.57.0",
     "vitest": "^4.0.14"
   },
   "peerDependencies": {
     "eslint": "^9.0.0 || ^10.0.0",
-    "oxlint": "^1.41.0"
+    "oxlint": "^1.55.0"
   },
   "peerDependenciesMeta": {
     "eslint": {
@@ -63,6 +63,6 @@
     }
   },
   "dependencies": {
-    "eslint-plugin-depend": "^1.4.0"
+    "eslint-plugin-depend": "^1.5.0"
   }
 }