@e18e/eslint-plugin 0.1.4 → 0.2.0

package/README.md

@@ -142,7 +142,7 @@ Read more at the
 | [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-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 | ✅ | ✅ | ✖️ |
@@ -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://github.com/sponsors/e18e">
+    <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-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 { 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,6 +25,9 @@ export const preferArrayToSorted = {
                 const sortCallee = node.callee.object;
                 const arrayNode = getArrayFromCopyPattern(sortCallee);
                 if (arrayNode) {
+                    if (!isArrayType(arrayNode, context)) {
+                        return;
+                    }
                     const arrayText = sourceCode.getText(arrayNode);
                     const argsText = formatArguments(node.arguments, sourceCode);
                     context.report({

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-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,34 @@
+function isStaticNewRegExp(node) {
+    if (node.callee.type !== 'Identifier' ||
+        node.callee.name !== 'RegExp' ||
+        node.arguments.length === 0 ||
+        node.arguments.length > 2) {
+        return false;
+    }
+    return node.arguments.every((arg) => arg.type === 'Literal' && typeof arg.value === 'string');
+}
+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) {
+                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,10 @@ 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;
 /**
  * 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) &&
@@ -84,12 +81,11 @@ export function getArrayFromCopyPattern(node) {
     }
     return null;
 }
-/**
- * Formats arguments from a CallExpression as a comma-separated string.
- */
 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.2.0",
   "description": "The official e18e ESLint plugin for modernizing code and improving performance.",
   "keywords": [
     "eslint",
@@ -51,7 +51,16 @@
     "vitest": "^4.0.14"
   },
   "peerDependencies": {
-    "eslint": "^9.0.0"
+    "eslint": "^9.0.0 || ^10.0.0",
+    "oxlint": "^1.41.0"
+  },
+  "peerDependenciesMeta": {
+    "eslint": {
+      "optional": true
+    },
+    "oxlint": {
+      "optional": true
+    }
   },
   "dependencies": {
     "eslint-plugin-depend": "^1.4.0"