@e18e/eslint-plugin 0.0.1

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

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

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

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

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

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

package/lib/rules/prefer-exponentiation-operator.d.ts

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

package/lib/rules/prefer-exponentiation-operator.js

@@ -0,0 +1,42 @@
+export const preferExponentiationOperator = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer the exponentiation operator ** over Math.pow()',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferExponentiation: 'Use the ** operator instead of Math.pow()'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'MemberExpression' ||
+                    node.callee.object.type !== 'Identifier' ||
+                    node.callee.object.name !== 'Math' ||
+                    node.callee.property.type !== 'Identifier' ||
+                    node.callee.property.name !== 'pow') {
+                    return;
+                }
+                const base = node.arguments[0];
+                const exponent = node.arguments[1];
+                if (!base || !exponent || node.arguments.length !== 2) {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'preferExponentiation',
+                    fix(fixer) {
+                        const baseText = sourceCode.getText(base);
+                        const exponentText = sourceCode.getText(exponent);
+                        return fixer.replaceText(node, `(${baseText}) ** (${exponentText})`);
+                    }
+                });
+            }
+        };
+    }
+};

package/lib/rules/prefer-includes.d.ts

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

package/lib/rules/prefer-includes.js

@@ -0,0 +1,131 @@
+function isIndexOfCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name === 'indexOf' &&
+        node.arguments.length >= 1);
+}
+function isNegativeOne(node) {
+    return (node.type === 'UnaryExpression' &&
+        node.operator === '-' &&
+        node.argument.type === 'Literal' &&
+        node.argument.value === 1);
+}
+function isZero(node) {
+    return node.type === 'Literal' && node.value === 0;
+}
+function reportIndexOf(context, node, indexOfCall, shouldNegate) {
+    const sourceCode = context.sourceCode;
+    const arrayText = sourceCode.getText(indexOfCall.callee.type === 'MemberExpression'
+        ? indexOfCall.callee.object
+        : indexOfCall.callee);
+    const argsText = indexOfCall.arguments
+        .map((arg) => sourceCode.getText(arg))
+        .join(', ');
+    const replacement = shouldNegate
+        ? `!${arrayText}.includes(${argsText})`
+        : `${arrayText}.includes(${argsText})`;
+    context.report({
+        node,
+        messageId: 'preferIncludes',
+        fix(fixer) {
+            return fixer.replaceText(node, replacement);
+        }
+    });
+}
+function checkBinaryExpression(node, context) {
+    const { left, right, operator } = node;
+    if (left.type === 'PrivateIdentifier') {
+        return;
+    }
+    let indexOfCall;
+    let constantSide;
+    let op = operator;
+    if (isIndexOfCall(left)) {
+        indexOfCall = left;
+        constantSide = right;
+    }
+    else if (isIndexOfCall(right)) {
+        indexOfCall = right;
+        constantSide = left;
+        if (operator === '<') {
+            op = '>';
+        }
+        else if (operator === '>') {
+            op = '<';
+        }
+        else if (operator === '<=') {
+            op = '>=';
+        }
+        else if (operator === '>=') {
+            op = '<=';
+        }
+    }
+    else {
+        return;
+    }
+    if (isNegativeOne(constantSide)) {
+        if (op === '!==' || op === '!=' || op === '>') {
+            reportIndexOf(context, node, indexOfCall, false);
+            return;
+        }
+        if (op === '===' || op === '==') {
+            reportIndexOf(context, node, indexOfCall, true);
+            return;
+        }
+    }
+    if (isZero(constantSide)) {
+        if (op === '>=') {
+            reportIndexOf(context, node, indexOfCall, false);
+            return;
+        }
+        if (op === '<') {
+            reportIndexOf(context, node, indexOfCall, true);
+            return;
+        }
+    }
+}
+function checkUnaryExpression(node, context) {
+    if (node.operator === '~' && isIndexOfCall(node.argument)) {
+        reportIndexOf(context, node, node.argument, false);
+        return;
+    }
+    if (node.operator === '!' &&
+        node.argument.type === 'UnaryExpression' &&
+        node.argument.operator === '~' &&
+        isIndexOfCall(node.argument.argument)) {
+        reportIndexOf(context, node, node.argument.argument, true);
+        return;
+    }
+}
+export const preferIncludes = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer .includes() over indexOf() comparisons for arrays and strings',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferIncludes: 'Use .includes() instead of indexOf() comparison'
+        }
+    },
+    create(context) {
+        return {
+            BinaryExpression(node) {
+                checkBinaryExpression(node, context);
+            },
+            UnaryExpression(node) {
+                // Skip ~ if it's inside !~ (the parent will handle it)
+                if (node.operator === '~' && node.parent) {
+                    if (node.parent.type === 'UnaryExpression' &&
+                        node.parent.operator === '!') {
+                        return;
+                    }
+                }
+                checkUnaryExpression(node, context);
+            }
+        };
+    }
+};

package/lib/rules/prefer-nullish-coalescing.d.ts

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

package/lib/rules/prefer-nullish-coalescing.js

@@ -0,0 +1,131 @@
+function areExpressionsEquivalent(sourceCode, expr1, expr2) {
+    return sourceCode.getText(expr1) === sourceCode.getText(expr2);
+}
+function isNullLiteral(node) {
+    return node.type === 'Literal' && node.value === null;
+}
+function isUndefinedIdentifier(node) {
+    return node.type === 'Identifier' && node.name === 'undefined';
+}
+function isNullishCheck(sourceCode, expr) {
+    if (expr.type === 'BinaryExpression' &&
+        expr.left.type !== 'PrivateIdentifier' &&
+        isNullLiteral(expr.right) &&
+        (expr.operator === '==' || expr.operator === '!=')) {
+        return { value: expr.left, checksForNullish: expr.operator === '==' };
+    }
+    if (expr.type === 'LogicalExpression' &&
+        expr.left.type === 'BinaryExpression' &&
+        expr.right.type === 'BinaryExpression' &&
+        expr.left.left.type !== 'PrivateIdentifier' &&
+        expr.right.left.type !== 'PrivateIdentifier') {
+        const leftOp = expr.left.operator;
+        const rightOp = expr.right.operator;
+        const leftRight = expr.left.right;
+        const rightRight = expr.right.right;
+        const leftLeft = expr.left.left;
+        const rightLeft = expr.right.left;
+        const leftIsNull = isNullLiteral(leftRight);
+        const leftIsUndefined = isUndefinedIdentifier(leftRight);
+        const rightIsNull = isNullLiteral(rightRight);
+        const rightIsUndefined = isUndefinedIdentifier(rightRight);
+        if (!areExpressionsEquivalent(sourceCode, leftLeft, rightLeft)) {
+            return null;
+        }
+        if ((leftIsNull && rightIsUndefined) || (leftIsUndefined && rightIsNull)) {
+            if (expr.operator === '||' && leftOp === '===' && rightOp === '===') {
+                return { value: leftLeft, checksForNullish: true };
+            }
+            if (expr.operator === '&&' && leftOp === '!==' && rightOp === '!==') {
+                return { value: leftLeft, checksForNullish: false };
+            }
+        }
+    }
+    return null;
+}
+export const preferNullishCoalescing = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer nullish coalescing operator (?? and ??=) over verbose null checks',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferNullishCoalescing: 'Use nullish coalescing operator (??) instead of verbose null check',
+            preferNullishCoalescingAssignment: 'Use nullish coalescing assignment (??=) instead of verbose null check'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            ConditionalExpression(node) {
+                const checkResult = isNullishCheck(sourceCode, node.test);
+                if (checkResult) {
+                    const { value, checksForNullish } = checkResult;
+                    const compareNode = checksForNullish
+                        ? node.alternate
+                        : node.consequent;
+                    const defaultNode = checksForNullish
+                        ? node.consequent
+                        : node.alternate;
+                    if (areExpressionsEquivalent(sourceCode, value, compareNode)) {
+                        context.report({
+                            node,
+                            messageId: 'preferNullishCoalescing',
+                            fix(fixer) {
+                                const valueText = sourceCode.getText(value);
+                                const defaultText = sourceCode.getText(defaultNode);
+                                return fixer.replaceText(node, `${valueText} ?? ${defaultText}`);
+                            }
+                        });
+                    }
+                }
+            },
+            IfStatement(node) {
+                if (node.alternate) {
+                    return;
+                }
+                let body = null;
+                if (node.consequent.type === 'BlockStatement') {
+                    const blockStmt = node.consequent;
+                    if (blockStmt.body.length !== 1) {
+                        return;
+                    }
+                    if (blockStmt.body[0]?.type === 'ExpressionStatement') {
+                        body = blockStmt.body[0];
+                    }
+                }
+                else if (node.consequent.type === 'ExpressionStatement') {
+                    body = node.consequent;
+                }
+                if (!body || body.expression.type !== 'AssignmentExpression') {
+                    return;
+                }
+                const assignment = body.expression;
+                if (assignment.operator !== '=') {
+                    return;
+                }
+                if (assignment.left.type !== 'Identifier' &&
+                    assignment.left.type !== 'MemberExpression') {
+                    return;
+                }
+                const checkResult = isNullishCheck(sourceCode, node.test);
+                if (checkResult &&
+                    checkResult.checksForNullish &&
+                    areExpressionsEquivalent(sourceCode, checkResult.value, assignment.left)) {
+                    context.report({
+                        node,
+                        messageId: 'preferNullishCoalescingAssignment',
+                        fix(fixer) {
+                            const leftText = sourceCode.getText(assignment.left);
+                            const rightText = sourceCode.getText(assignment.right);
+                            return fixer.replaceText(node, `${leftText} ??= ${rightText}`);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-object-has-own.d.ts

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

package/lib/rules/prefer-object-has-own.js

@@ -0,0 +1,71 @@
+function getObjectPrototypeHasOwnPropertyArgs(node) {
+    if (node.callee.type === 'MemberExpression' &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name === 'call') {
+        const hasOwnPropertyExpr = node.callee.object;
+        if (hasOwnPropertyExpr.type === 'MemberExpression' &&
+            hasOwnPropertyExpr.property.type === 'Identifier' &&
+            hasOwnPropertyExpr.property.name === 'hasOwnProperty' &&
+            hasOwnPropertyExpr.object.type === 'MemberExpression' &&
+            hasOwnPropertyExpr.object.property.type === 'Identifier' &&
+            hasOwnPropertyExpr.object.property.name === 'prototype' &&
+            hasOwnPropertyExpr.object.object.type === 'Identifier' &&
+            hasOwnPropertyExpr.object.object.name === 'Object') {
+            return node.arguments;
+        }
+    }
+    return null;
+}
+export const preferObjectHasOwn = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() and obj.hasOwnProperty()',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferObjectHasOwn: 'Use Object.hasOwn() instead of hasOwnProperty'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                // Check for Object.prototype.hasOwnProperty.call(obj, prop)
+                const prototypeArgs = getObjectPrototypeHasOwnPropertyArgs(node);
+                if (prototypeArgs && prototypeArgs.length === 2) {
+                    const [object, property] = prototypeArgs;
+                    const objectText = sourceCode.getText(object);
+                    const propertyText = sourceCode.getText(property);
+                    context.report({
+                        node,
+                        messageId: 'preferObjectHasOwn',
+                        fix(fixer) {
+                            return fixer.replaceText(node, `Object.hasOwn(${objectText}, ${propertyText})`);
+                        }
+                    });
+                    return;
+                }
+                // Check for obj.hasOwnProperty(prop)
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'hasOwnProperty' &&
+                    node.arguments.length === 1) {
+                    const object = node.callee.object;
+                    const property = node.arguments[0];
+                    const objectText = sourceCode.getText(object);
+                    const propertyText = sourceCode.getText(property);
+                    context.report({
+                        node,
+                        messageId: 'preferObjectHasOwn',
+                        fix(fixer) {
+                            return fixer.replaceText(node, `Object.hasOwn(${objectText}, ${propertyText})`);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-optimized-indexof.d.ts

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

package/lib/rules/prefer-optimized-indexof.js

@@ -0,0 +1,90 @@
+import { getTypedParserServices } from '../utils/typescript.js';
+export const preferOptimizedIndexof = {
+    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-settimeout-args.d.ts

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