@e18e/eslint-plugin 0.1.4 → 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-sorted](./src/rules/prefer-array-to-sorted.ts) | Prefer `Array.prototype.toSorted()` over copying and sorting 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,6 +166,16 @@ 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-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://e18e.dev/sponsor">
+    <img src="https://e18e.dev/sponsors.svg" alt="e18e community sponsors" />
+  </a>
+</p>
 
 ## License
 

package/lib/configs/performance-improvements.js

@@ -7,6 +7,7 @@ export const performanceImprovements = (plugin) => ({
         'e18e/prefer-timer-args': 'error',
         'e18e/prefer-date-now': 'error',
         'e18e/prefer-regex-test': 'error',
-        'e18e/prefer-array-some': 'error'
+        'e18e/prefer-array-some': 'error',
+        'e18e/prefer-static-regex': 'error'
     }
 });

package/lib/main.js

@@ -19,6 +19,8 @@ import { preferTimerArgs } from './rules/prefer-timer-args.js';
 import { preferDateNow } from './rules/prefer-date-now.js';
 import { preferRegexTest } from './rules/prefer-regex-test.js';
 import { preferArraySome } from './rules/prefer-array-some.js';
+import { preferStaticRegex } from './rules/prefer-static-regex.js';
+import { preferInlineEquality } from './rules/prefer-inline-equality.js';
 import { rules as dependRules } from 'eslint-plugin-depend';
 const plugin = {
     meta: {
@@ -44,6 +46,8 @@ const plugin = {
         'prefer-date-now': preferDateNow,
         'prefer-regex-test': preferRegexTest,
         'prefer-array-some': preferArraySome,
+        'prefer-static-regex': preferStaticRegex,
+        'prefer-inline-equality': preferInlineEquality,
         ...dependRules
     }
 };

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.d.ts

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

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

@@ -1,10 +1,10 @@
-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: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer Array.prototype.toSorted() over copying and sorting arrays',
-            recommended: true
+            description: 'Prefer Array.prototype.toSorted() over copying and sorting arrays'
         },
         fixable: 'code',
         schema: [],
@@ -12,6 +12,7 @@ export const preferArrayToSorted = {
             preferToSorted: 'Use {{array}}.toSorted() instead of copying and sorting'
         }
     },
+    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {
@@ -24,16 +25,23 @@ export const preferArrayToSorted = {
                 const sortCallee = node.callee.object;
                 const arrayNode = getArrayFromCopyPattern(sortCallee);
                 if (arrayNode) {
-                    const arrayText = sourceCode.getText(arrayNode);
+                    if (!isArrayType(arrayNode, context)) {
+                        return;
+                    }
+                    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-inline-equality.d.ts

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

package/lib/rules/prefer-inline-equality.js

@@ -0,0 +1,170 @@
+import { isArrayType, isSetType, tryGetTypedParserServices } from '../utils/typescript.js';
+/**
+ * Checks if a node is safe to repeat (i.e. no side effects)
+ */
+function isSafeToRepeat(node) {
+    if (node.type === 'Identifier') {
+        return true;
+    }
+    if (node.type === 'Literal') {
+        return true;
+    }
+    if (node.type === 'TemplateLiteral' && node.expressions.length === 0) {
+        return true;
+    }
+    if (node.type === 'MemberExpression' && !node.computed) {
+        return isSafeToRepeat(node.object);
+    }
+    return false;
+}
+/**
+ * Checks if a node is NaN
+ */
+function isNaN(node) {
+    return node.type === 'Identifier' && node.name === 'NaN';
+}
+/**
+ * Checks if an array element is an identifier or literal
+ */
+function isSimpleElement(node) {
+    if (isNaN(node)) {
+        return false;
+    }
+    return node.type === 'Identifier' || node.type === 'Literal';
+}
+/**
+ * Checks if the node is negated
+ */
+function isNegated(node) {
+    return (node.parent !== undefined &&
+        node.parent.type === 'UnaryExpression' &&
+        node.parent.operator === '!');
+}
+/**
+ * Checks if the replacement expression needs to be wrapped in parentheses
+ * based on the parent node context
+ */
+function needsParentheses(node) {
+    if (!node.parent) {
+        return false;
+    }
+    switch (node.parent.type) {
+        case 'CallExpression':
+        case 'NewExpression':
+        case 'MemberExpression':
+        case 'ConditionalExpression':
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+        case 'UnaryExpression':
+        case 'TaggedTemplateExpression':
+        case 'SpreadElement':
+        case 'AwaitExpression':
+            return true;
+        default:
+            return false;
+    }
+}
+function checkArrayIncludes(node, context) {
+    const { callee } = node;
+    if (callee.type !== 'MemberExpression') {
+        return;
+    }
+    const property = callee.property;
+    if (property.type !== 'Identifier' ||
+        property.name !== 'includes' ||
+        callee.computed) {
+        return;
+    }
+    if (node.arguments.length !== 1) {
+        return;
+    }
+    const arrayNode = callee.object;
+    if (arrayNode.type !== 'ArrayExpression') {
+        return;
+    }
+    const elements = arrayNode.elements;
+    if (elements.length === 0 || elements.length > 6) {
+        return;
+    }
+    const val = node.arguments[0];
+    if (!isSafeToRepeat(val)) {
+        return;
+    }
+    const hasTypes = tryGetTypedParserServices(context) !== null;
+    for (const element of elements) {
+        if (element === null) {
+            return;
+        }
+        if (element.type === 'SpreadElement') {
+            const arg = element.argument;
+            if (!isSafeToRepeat(arg)) {
+                return;
+            }
+            if (!hasTypes ||
+                (!isArrayType(arg, context) && !isSetType(arg, context))) {
+                return;
+            }
+        }
+        else if (!isSimpleElement(element)) {
+            return;
+        }
+    }
+    const sourceCode = context.sourceCode;
+    const negated = isNegated(node);
+    const operator = negated ? '!==' : '===';
+    const joiner = negated ? ' && ' : ' || ';
+    const parts = [];
+    for (const element of elements) {
+        if (element === null) {
+            return;
+        }
+        if (element.type === 'SpreadElement') {
+            const argText = sourceCode.getText(element.argument);
+            const valText = sourceCode.getText(val);
+            const method = isSetType(element.argument, context) ? 'has' : 'includes';
+            if (negated) {
+                parts.push(`!${argText}.${method}(${valText})`);
+            }
+            else {
+                parts.push(`${argText}.${method}(${valText})`);
+            }
+        }
+        else {
+            const elemText = sourceCode.getText(element);
+            const valText = sourceCode.getText(val);
+            parts.push(`${elemText} ${operator} ${valText}`);
+        }
+    }
+    const replacement = parts.join(joiner);
+    const reportNode = negated ? node.parent : node;
+    const needsParens = needsParentheses(reportNode);
+    const fixText = needsParens ? `(${replacement})` : replacement;
+    context.report({
+        node: reportNode,
+        messageId: 'preferEquality',
+        fix(fixer) {
+            return fixer.replaceText(reportNode, fixText);
+        }
+    });
+}
+export const preferInlineEquality = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer inline equality checks over temporary object creation for simple comparisons'
+        },
+        fixable: 'code',
+        messages: {
+            preferEquality: 'Avoid creating a temporary array just to call `.includes()`. Use equality checks instead.'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                checkArrayIncludes(node, context);
+            }
+        };
+    }
+};

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.d.ts

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

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

@@ -0,0 +1,46 @@
+const statefulFlags = /[gy]/;
+function isStaticNewRegExp(node) {
+    if (node.callee.type !== 'Identifier' ||
+        node.callee.name !== 'RegExp' ||
+        node.arguments.length === 0 ||
+        node.arguments.length > 2) {
+        return false;
+    }
+    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: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer defining regular expressions at module scope to avoid re-compilation on every function call',
+            recommended: true
+        },
+        schema: [],
+        messages: {
+            preferStatic: 'Move this regular expression to module scope to avoid re-compilation on every call.'
+        }
+    },
+    create(context) {
+        return {
+            ':function Literal[regex]'(node) {
+                const { flags } = node.regex;
+                if (statefulFlags.test(flags)) {
+                    return;
+                }
+                context.report({ node, messageId: 'preferStatic' });
+            },
+            ':function NewExpression'(node) {
+                if (isStaticNewRegExp(node)) {
+                    context.report({ node, messageId: 'preferStatic' });
+                }
+            }
+        };
+    }
+};

package/lib/utils/ast.d.ts

@@ -1,7 +1,7 @@
 import type { CallExpression, Node, Expression } from 'estree';
-import type { TSESTree } from '@typescript-eslint/utils';
-import type { Rule, SourceCode } from 'eslint';
-type AnyNode = (Node & Rule.NodeParentExtension) | TSESTree.Node;
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import type { SourceCode } from 'eslint';
+export type AnyNode = Node | TSESTree.Node;
 /**
  * Checks if a node is in a boolean context (where the result is only used as truthy/falsy).
  * e.g. if conditions, while loops, ternary tests, logical operators
@@ -20,9 +20,20 @@ export declare function isCopyCall(node: CallExpression): boolean;
 /**
  * Extracts the array node from array copy patterns.
  */
+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.
  */
+export declare function formatArguments(args: TSESTree.CallExpression['arguments'], sourceCode: Readonly<TSESLint.SourceCode>): string;
 export declare function formatArguments(args: CallExpression['arguments'], sourceCode: SourceCode): string;
-export {};

package/lib/utils/ast.js

@@ -68,9 +68,6 @@ export function isCopyCall(node) {
     }
     return false;
 }
-/**
- * Extracts the array node from array copy patterns.
- */
 export function getArrayFromCopyPattern(node) {
     if (node.type === 'CallExpression' &&
         isCopyCall(node) &&
@@ -85,11 +82,42 @@ export function getArrayFromCopyPattern(node) {
     return null;
 }
 /**
- * Formats arguments from a CallExpression as a comma-separated string.
+ * 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 '';
     }
-    return args.map((arg) => sourceCode.getText(arg)).join(', ');
+    return args
+        .map((arg) => sourceCode.getText(arg))
+        .join(', ');
 }

package/lib/utils/typescript.d.ts

@@ -18,6 +18,11 @@ export declare function getTypedParserServices(context: Readonly<TSESLint.RuleCo
  * Returns true if types are unavailable (to avoid false negatives)
  */
 export declare function isArrayType(node: TSESTree.Node, context: Readonly<TSESLint.RuleContext<string, unknown[]>>): boolean;
+/**
+ * Checks if a node's type is a Set
+ * Returns true if types are unavailable (to avoid false negatives)
+ */
+export declare function isSetType(node: TSESTree.Node, context: Readonly<TSESLint.RuleContext<string, unknown[]>>): boolean;
 /**
  * Checks if a node's type is a string
  * Returns false if types are unavailable

package/lib/utils/typescript.js

@@ -50,6 +50,24 @@ export function isArrayType(node, context) {
     }
     return false;
 }
+const setTypePattern = /^(Readonly)?Set</;
+/**
+ * Checks if a node's type is a Set
+ * Returns true if types are unavailable (to avoid false negatives)
+ */
+export function isSetType(node, context) {
+    const services = tryGetTypedParserServices(context);
+    if (!services) {
+        return true;
+    }
+    const type = services.getTypeAtLocation(node);
+    if (!type) {
+        return true;
+    }
+    const checker = services.program.getTypeChecker();
+    const typeString = checker.typeToString(type);
+    return setTypePattern.test(typeString);
+}
 /**
  * Checks if a node's type is a string
  * Returns false if types are unavailable

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e18e/eslint-plugin",
-  "version": "0.1.4",
+  "version": "0.3.0",
   "description": "The official e18e ESLint plugin for modernizing code and improving performance.",
   "keywords": [
     "eslint",
@@ -35,25 +35,34 @@
     "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"
+    "eslint": "^9.0.0 || ^10.0.0",
+    "oxlint": "^1.55.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    },
+    "oxlint": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "eslint-plugin-depend": "^1.4.0"
+    "eslint-plugin-depend": "^1.5.0"
   }
 }