@e18e/eslint-plugin 0.0.1

package/lib/rules/prefer-settimeout-args.js

@@ -0,0 +1,175 @@
+function isNullOrUndefined(node) {
+    if (node.type === 'Literal' && node.value === null) {
+        return true;
+    }
+    return node.type === 'Identifier' && node.name === 'undefined';
+}
+function isSafeArgument(arg) {
+    if (arg.type === 'SpreadElement') {
+        return arg.argument.type === 'Identifier';
+    }
+    switch (arg.type) {
+        case 'Identifier':
+        case 'Literal':
+        case 'TemplateLiteral':
+            return true;
+        case 'MemberExpression':
+            if (arg.object.type === 'Super' || arg.property.type === 'PrivateIdentifier') {
+                return false;
+            }
+            if (!isSafeArgument(arg.object)) {
+                return false;
+            }
+            if (arg.computed) {
+                return isSafeArgument(arg.property);
+            }
+            return true;
+        case 'ArrayExpression':
+            return arg.elements.every((el) => el === null || isSafeArgument(el));
+        case 'ObjectExpression':
+            return arg.properties.every((prop) => {
+                if (prop.type === 'SpreadElement') {
+                    return isSafeArgument(prop.argument);
+                }
+                const valueType = prop.value.type;
+                if (valueType === 'ObjectPattern' ||
+                    valueType === 'ArrayPattern' ||
+                    valueType === 'RestElement' ||
+                    valueType === 'AssignmentPattern') {
+                    return false;
+                }
+                return isSafeArgument(prop.value);
+            });
+        case 'UnaryExpression':
+        case 'UpdateExpression':
+            return isSafeArgument(arg.argument);
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return arg.left.type !== 'PrivateIdentifier' && isSafeArgument(arg.left) && isSafeArgument(arg.right);
+        case 'ConditionalExpression':
+            return (isSafeArgument(arg.test) &&
+                isSafeArgument(arg.consequent) &&
+                isSafeArgument(arg.alternate));
+        // CallExpression, NewExpression, etc. are NOT safe
+        default:
+            return false;
+    }
+}
+export const preferSetTimeoutArgs = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer passing function and arguments directly to setTimeout instead of wrapping in an arrow function or using bind',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferArgs: 'Pass function and arguments directly to setTimeout to avoid allocating an extra function'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                // Check if this is setTimeout, window.setTimeout, or globalThis.setTimeout
+                const isSetTimeout = (node.callee.type === 'Identifier' &&
+                    node.callee.name === 'setTimeout') ||
+                    (node.callee.type === 'MemberExpression' &&
+                        node.callee.object.type === 'Identifier' &&
+                        (node.callee.object.name === 'window' ||
+                            node.callee.object.name === 'globalThis') &&
+                        node.callee.property.type === 'Identifier' &&
+                        node.callee.property.name === 'setTimeout');
+                if (!isSetTimeout) {
+                    return;
+                }
+                if (node.arguments.length < 2) {
+                    return;
+                }
+                const firstArg = node.arguments[0];
+                if (!firstArg || firstArg.type === 'SpreadElement') {
+                    return;
+                }
+                const delayText = sourceCode.getText(node.arguments[1]);
+                // Preserve the original setTimeout call style
+                const setTimeoutCall = sourceCode.getText(node.callee);
+                let replacement = null;
+                // simple arrow functions, e.g. () => fn(args)
+                if (firstArg.type === 'ArrowFunctionExpression') {
+                    const arrowFn = firstArg;
+                    // skip if it is a block body
+                    if (arrowFn.body.type === 'BlockStatement') {
+                        return;
+                    }
+                    // skip if it has parameters
+                    if (arrowFn.params.length > 0) {
+                        return;
+                    }
+                    if (arrowFn.body.type !== 'CallExpression') {
+                        return;
+                    }
+                    const callExpression = arrowFn.body;
+                    const callee = callExpression.callee;
+                    const callArgs = callExpression.arguments;
+                    // Check if any argument contains a call expression or other unsafe construct
+                    // If so, transforming would change when those expressions are evaluated
+                    if (!callArgs.every(isSafeArgument)) {
+                        return;
+                    }
+                    // Build the replacement
+                    const calleeText = sourceCode.getText(callee);
+                    if (callArgs.length === 0) {
+                        replacement = `${setTimeoutCall}(${calleeText}, ${delayText})`;
+                    }
+                    else {
+                        const argsTexts = callArgs.map((arg) => sourceCode.getText(arg));
+                        replacement = `${setTimeoutCall}(${calleeText}, ${delayText}, ${argsTexts.join(', ')})`;
+                    }
+                }
+                // fn.bind(null/undefined, args)
+                else if (firstArg.type === 'CallExpression') {
+                    const bindCall = firstArg;
+                    if (bindCall.callee.type !== 'MemberExpression' ||
+                        bindCall.callee.property.type !== 'Identifier' ||
+                        bindCall.callee.property.name !== 'bind' ||
+                        bindCall.arguments.length === 0) {
+                        return;
+                    }
+                    const bindContext = bindCall.arguments[0];
+                    if (!bindContext || bindContext.type === 'SpreadElement') {
+                        return;
+                    }
+                    if (!isNullOrUndefined(bindContext)) {
+                        return;
+                    }
+                    const fnText = sourceCode.getText(bindCall.callee.object);
+                    const bindArgs = bindCall.arguments.slice(1);
+                    // Check if any bind argument contains a call expression or other unsafe construct
+                    if (!bindArgs.every(isSafeArgument)) {
+                        return;
+                    }
+                    if (bindArgs.length === 0) {
+                        replacement = `${setTimeoutCall}(${fnText}, ${delayText})`;
+                    }
+                    else {
+                        const argsTexts = bindArgs.map((arg) => sourceCode.getText(arg));
+                        replacement = `${setTimeoutCall}(${fnText}, ${delayText}, ${argsTexts.join(', ')})`;
+                    }
+                }
+                else {
+                    return;
+                }
+                if (replacement) {
+                    context.report({
+                        node,
+                        messageId: 'preferArgs',
+                        fix(fixer) {
+                            return fixer.replaceText(node, replacement);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

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

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

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

@@ -0,0 +1,109 @@
+function isNullOrUndefined(node) {
+    if (node.type === 'Literal' && node.value === null) {
+        return true;
+    }
+    return node.type === 'Identifier' && node.name === 'undefined';
+}
+export const preferSpreadSyntax = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer spread syntax over Array.concat(), Array.from(), Object.assign({}, ...), and Function.apply()',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferSpreadArray: 'Use spread syntax [...arr, ...other] instead of arr.concat(other)',
+            preferSpreadArrayFrom: 'Use spread syntax [...iterable] instead of Array.from(iterable) when no mapper function is provided',
+            preferSpreadObject: 'Use spread syntax {...a, ...b} instead of Object.assign({}, a, b)',
+            preferSpreadFunction: 'Use spread syntax fn(...args) instead of fn.apply(null/undefined, args)'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'MemberExpression') {
+                    return;
+                }
+                let messageId;
+                let replacement;
+                // array.concat()
+                if (node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'concat' &&
+                    node.arguments.length > 0) {
+                    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}]`;
+                    messageId = 'preferSpreadArray';
+                }
+                // Array.from(iterable) with no mapper
+                else if (node.callee.object.type === 'Identifier' &&
+                    node.callee.object.name === 'Array' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'from' &&
+                    node.arguments.length === 1) {
+                    const iterableText = sourceCode.getText(node.arguments[0]);
+                    replacement = `[...${iterableText}]`;
+                    messageId = 'preferSpreadArrayFrom';
+                }
+                // Object.assign({...}, ...)
+                else if (node.callee.object.type === 'Identifier' &&
+                    node.callee.object.name === 'Object' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'assign' &&
+                    node.arguments.length >= 2) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg.type !== 'SpreadElement' &&
+                        firstArg.type === 'ObjectExpression') {
+                        const hasUnquotedProto = firstArg.properties.some((prop) => prop.type === 'Property' &&
+                            !prop.computed &&
+                            prop.key.type === 'Identifier' &&
+                            prop.key.name === '__proto__');
+                        if (!hasUnquotedProto) {
+                            const spreadArgs = node.arguments
+                                .slice(1)
+                                .map((arg) => `...${sourceCode.getText(arg)}`)
+                                .join(', ');
+                            if (firstArg.properties.length === 0) {
+                                replacement = `{${spreadArgs}}`;
+                            }
+                            else {
+                                const literalText = sourceCode.getText(firstArg);
+                                const innerContent = literalText.slice(1, -1); // Remove { and }
+                                replacement = `{${innerContent}, ${spreadArgs}}`;
+                            }
+                            messageId = 'preferSpreadObject';
+                        }
+                    }
+                }
+                // function.apply(null/undefined, args)
+                else if (node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'apply' &&
+                    node.arguments.length === 2) {
+                    const firstArg = node.arguments[0];
+                    if (firstArg.type !== 'SpreadElement' &&
+                        isNullOrUndefined(firstArg)) {
+                        const fnText = sourceCode.getText(node.callee.object);
+                        const argsText = sourceCode.getText(node.arguments[1]);
+                        replacement = `${fnText}(...${argsText})`;
+                        messageId = 'preferSpreadFunction';
+                    }
+                }
+                if (messageId && replacement) {
+                    context.report({
+                        node,
+                        messageId,
+                        fix(fixer) {
+                            return fixer.replaceText(node, replacement);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-timer-args.d.ts

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

package/lib/rules/prefer-timer-args.js

@@ -0,0 +1,176 @@
+function isNullOrUndefined(node) {
+    if (node.type === 'Literal' && node.value === null) {
+        return true;
+    }
+    return node.type === 'Identifier' && node.name === 'undefined';
+}
+function isSafeArgument(arg) {
+    if (arg.type === 'SpreadElement') {
+        return arg.argument.type === 'Identifier';
+    }
+    switch (arg.type) {
+        case 'Identifier':
+        case 'Literal':
+        case 'TemplateLiteral':
+            return true;
+        case 'MemberExpression':
+            if (arg.object.type === 'Super' ||
+                arg.property.type === 'PrivateIdentifier') {
+                return false;
+            }
+            if (!isSafeArgument(arg.object)) {
+                return false;
+            }
+            if (arg.computed) {
+                return isSafeArgument(arg.property);
+            }
+            return true;
+        case 'ArrayExpression':
+            return arg.elements.every((el) => el === null || isSafeArgument(el));
+        case 'ObjectExpression':
+            return arg.properties.every((prop) => {
+                if (prop.type === 'SpreadElement') {
+                    return isSafeArgument(prop.argument);
+                }
+                const valueType = prop.value.type;
+                if (valueType === 'ObjectPattern' ||
+                    valueType === 'ArrayPattern' ||
+                    valueType === 'RestElement' ||
+                    valueType === 'AssignmentPattern') {
+                    return false;
+                }
+                return isSafeArgument(prop.value);
+            });
+        case 'UnaryExpression':
+        case 'UpdateExpression':
+            return isSafeArgument(arg.argument);
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return (arg.left.type !== 'PrivateIdentifier' &&
+                isSafeArgument(arg.left) &&
+                isSafeArgument(arg.right));
+        case 'ConditionalExpression':
+            return (isSafeArgument(arg.test) &&
+                isSafeArgument(arg.consequent) &&
+                isSafeArgument(arg.alternate));
+        // CallExpression, NewExpression, etc.
+        default:
+            return false;
+    }
+}
+export const preferTimerArgs = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer passing function and arguments directly to setTimeout/setInterval instead of wrapping in an arrow function or using bind',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferArgs: 'Pass function and arguments directly to timer function to avoid allocating an extra function'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                // Check if this is setTimeout/setInterval (with optional window/globalThis prefix)
+                const isTimerFunction = (node.callee.type === 'Identifier' &&
+                    (node.callee.name === 'setTimeout' ||
+                        node.callee.name === 'setInterval')) ||
+                    (node.callee.type === 'MemberExpression' &&
+                        node.callee.object.type === 'Identifier' &&
+                        (node.callee.object.name === 'window' ||
+                            node.callee.object.name === 'globalThis') &&
+                        node.callee.property.type === 'Identifier' &&
+                        (node.callee.property.name === 'setTimeout' ||
+                            node.callee.property.name === 'setInterval'));
+                if (!isTimerFunction) {
+                    return;
+                }
+                if (node.arguments.length < 2) {
+                    return;
+                }
+                const firstArg = node.arguments[0];
+                if (!firstArg || firstArg.type === 'SpreadElement') {
+                    return;
+                }
+                const delayText = sourceCode.getText(node.arguments[1]);
+                const timerCall = sourceCode.getText(node.callee);
+                let replacement = null;
+                // simple arrow functions, e.g. () => fn(args)
+                if (firstArg.type === 'ArrowFunctionExpression') {
+                    const arrowFn = firstArg;
+                    // skip if it is a block body
+                    if (arrowFn.body.type === 'BlockStatement') {
+                        return;
+                    }
+                    // skip if it has parameters
+                    if (arrowFn.params.length > 0) {
+                        return;
+                    }
+                    if (arrowFn.body.type !== 'CallExpression') {
+                        return;
+                    }
+                    const callExpression = arrowFn.body;
+                    const callee = callExpression.callee;
+                    const callArgs = callExpression.arguments;
+                    if (!callArgs.every(isSafeArgument)) {
+                        return;
+                    }
+                    const calleeText = sourceCode.getText(callee);
+                    if (callArgs.length === 0) {
+                        replacement = `${timerCall}(${calleeText}, ${delayText})`;
+                    }
+                    else {
+                        const argsTexts = callArgs.map((arg) => sourceCode.getText(arg));
+                        replacement = `${timerCall}(${calleeText}, ${delayText}, ${argsTexts.join(', ')})`;
+                    }
+                }
+                // fn.bind(null/undefined, args)
+                else if (firstArg.type === 'CallExpression') {
+                    const bindCall = firstArg;
+                    if (bindCall.callee.type !== 'MemberExpression' ||
+                        bindCall.callee.property.type !== 'Identifier' ||
+                        bindCall.callee.property.name !== 'bind' ||
+                        bindCall.arguments.length === 0) {
+                        return;
+                    }
+                    const bindContext = bindCall.arguments[0];
+                    if (!bindContext || bindContext.type === 'SpreadElement') {
+                        return;
+                    }
+                    if (!isNullOrUndefined(bindContext)) {
+                        return;
+                    }
+                    const fnText = sourceCode.getText(bindCall.callee.object);
+                    const bindArgs = bindCall.arguments.slice(1);
+                    // Check if any bind argument contains a call expression or other unsafe construct
+                    if (!bindArgs.every(isSafeArgument)) {
+                        return;
+                    }
+                    if (bindArgs.length === 0) {
+                        replacement = `${timerCall}(${fnText}, ${delayText})`;
+                    }
+                    else {
+                        const argsTexts = bindArgs.map((arg) => sourceCode.getText(arg));
+                        replacement = `${timerCall}(${fnText}, ${delayText}, ${argsTexts.join(', ')})`;
+                    }
+                }
+                else {
+                    return;
+                }
+                if (replacement) {
+                    context.report({
+                        node,
+                        messageId: 'preferArgs',
+                        fix(fixer) {
+                            return fixer.replaceText(node, replacement);
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-url-canparse.d.ts

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

package/lib/rules/prefer-url-canparse.js

@@ -0,0 +1,139 @@
+import { formatArguments } from '../utils/ast.js';
+/**
+ * Check if a statement is `new URL(...)`
+ */
+function isNewURLStatement(stmt) {
+    return (stmt.type === 'ExpressionStatement' &&
+        stmt.expression.type === 'NewExpression' &&
+        stmt.expression.callee.type === 'Identifier' &&
+        stmt.expression.callee.name === 'URL' &&
+        stmt.expression.arguments.length >= 1);
+}
+/**
+ * Check if a statement is `return (true|false)`
+ */
+function isReturnBoolean(stmt, value) {
+    return (stmt.type === 'ReturnStatement' &&
+        stmt.argument?.type === 'Literal' &&
+        stmt.argument.value === value);
+}
+/**
+ * Check if block has only a return statement with a boolean literal
+ */
+function hasOnlyReturnBoolean(block, value) {
+    if (block.body.length !== 1) {
+        return false;
+    }
+    const firstStmt = block.body[0];
+    if (!firstStmt) {
+        return false;
+    }
+    return isReturnBoolean(firstStmt, value);
+}
+/**
+ * Check if block is empty or contains only empty statements
+ */
+function isEmptyBlock(block, sourceCode) {
+    return (block.body.length === 0 ||
+        block.body.every((stmt) => stmt.type === 'EmptyStatement' || !sourceCode.getText(stmt).trim()));
+}
+export const preferUrlCanParse = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer URL.canParse() over try-catch blocks for URL validation',
+            recommended: true
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            preferCanParse: 'Use URL.canParse() instead of try-catch for URL validation',
+            replaceWithCanParse: 'Replace with URL.canParse()'
+        }
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            TryStatement(node) {
+                const tryBlock = node.block;
+                const catchClause = node.handler;
+                if (!catchClause) {
+                    return;
+                }
+                const tryStatements = tryBlock.body;
+                if (tryStatements.length === 0) {
+                    return;
+                }
+                const firstStmt = tryStatements[0];
+                if (!firstStmt || !isNewURLStatement(firstStmt)) {
+                    return;
+                }
+                const urlArgText = formatArguments(firstStmt.expression.arguments, sourceCode);
+                // try { new URL(u); return true; } catch { return false; }
+                const secondStmt = tryStatements[1];
+                if (tryStatements.length === 2 &&
+                    secondStmt &&
+                    isReturnBoolean(secondStmt, true) &&
+                    hasOnlyReturnBoolean(catchClause.body, false)) {
+                    context.report({
+                        node,
+                        messageId: 'preferCanParse',
+                        suggest: [
+                            {
+                                messageId: 'replaceWithCanParse',
+                                fix(fixer) {
+                                    return fixer.replaceText(node, `return URL.canParse(${urlArgText})`);
+                                }
+                            }
+                        ]
+                    });
+                    return;
+                }
+                // try { new URL(u); ...body } catch { ...catchBody }
+                // Basically if there's a body after the URL construction
+                if (tryStatements.length >= 2) {
+                    const bodyAfterURL = tryStatements.slice(1);
+                    const firstBodyStmt = bodyAfterURL[0];
+                    const lastBodyStmt = bodyAfterURL.at(-1);
+                    const bodyText = firstBodyStmt &&
+                        lastBodyStmt &&
+                        firstBodyStmt.range &&
+                        lastBodyStmt.range
+                        ? sourceCode.text.slice(firstBodyStmt.range[0], lastBodyStmt.range[1])
+                        : '';
+                    const catchBody = catchClause.body;
+                    const catchBodyEmpty = isEmptyBlock(catchBody, sourceCode);
+                    let replacement;
+                    if (catchBodyEmpty) {
+                        // No catch body, just if without else
+                        replacement = `if (URL.canParse(${urlArgText})) {\n${bodyText}\n}`;
+                    }
+                    else {
+                        const catchStatements = catchBody.body;
+                        const firstCatchStmt = catchStatements[0];
+                        const lastCatchStmt = catchStatements.at(-1);
+                        const catchBodyText = firstCatchStmt &&
+                            lastCatchStmt &&
+                            firstCatchStmt.range &&
+                            lastCatchStmt.range
+                            ? sourceCode.text.slice(firstCatchStmt.range[0], lastCatchStmt.range[1])
+                            : '';
+                        replacement = `if (URL.canParse(${urlArgText})) {\n${bodyText}\n} else {\n${catchBodyText}\n}`;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'preferCanParse',
+                        suggest: [
+                            {
+                                messageId: 'replaceWithCanParse',
+                                fix(fixer) {
+                                    return fixer.replaceText(node, replacement);
+                                }
+                            }
+                        ]
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/test/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test/setup.js

@@ -0,0 +1,10 @@
+import { RuleTester } from 'eslint';
+import { describe, it, afterAll } from 'vitest';
+import { RuleTester as TSRuleTester } from '@typescript-eslint/rule-tester';
+RuleTester.describe = describe;
+RuleTester.it = it;
+RuleTester.itOnly = it.only;
+TSRuleTester.afterAll = afterAll;
+TSRuleTester.describe = describe;
+TSRuleTester.it = it;
+TSRuleTester.itOnly = it.only;

package/lib/utils/ast.d.ts

@@ -0,0 +1,15 @@
+import type { CallExpression, Node } from 'estree';
+import type { SourceCode } from 'eslint';
+/**
+ * Checks if a CallExpression is a copy operation that creates a shallow copy of an array.
+ * e.g. concat(), slice(), slice(0)
+ */
+export declare function isCopyCall(node: CallExpression): boolean;
+/**
+ * Extracts the array node from array copy patterns.
+ */
+export declare function getArrayFromCopyPattern(node: Node): Node | null;
+/**
+ * Formats arguments from a CallExpression as a comma-separated string.
+ */
+export declare function formatArguments(args: CallExpression['arguments'], sourceCode: SourceCode): string;