@e18e/eslint-plugin 0.0.1 → 0.1.0

package/README.md

@@ -2,9 +2,6 @@
 
 > The official e18e ESLint plugin for modernizing JavaScript/TypeScript code and improving performance.
 
-> [!WARNING]
-> This is an experimental, unpublished project for now. Once we have settled on the scope, we will publish it and announce it to start getting community feedback.
-
 This plugin focuses on applying the e18e community's best practices and advise to JavaScript/TypeScript codebases.
 
 ## Overview
@@ -53,6 +50,19 @@ export default [
 ];
 ```
 
+## Usage with oxlint
+
+If you're using oxlint, you can enable the e18e plugin by adding it to your `.oxlintrc.json` file:
+
+```json
+{
+  "jsPlugins": ["@e18e/eslint-plugin"],
+  "rules": {
+    "e18e/prefer-includes": "error"
+  }
+}
+```
+
 ## Rules
 
 **Legend:**

package/lib/main.js

@@ -19,7 +19,7 @@ import { preferTimerArgs } from './rules/prefer-timer-args.js';
 import { rules as dependRules } from 'eslint-plugin-depend';
 const plugin = {
     meta: {
-        name: '@e18e/eslint-plugin',
+        name: 'e18e',
         namespace: 'e18e'
     },
     configs: {},

package/lib/rules/no-indexof-equality.d.ts

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

package/lib/rules/no-indexof-equality.js

@@ -3,8 +3,7 @@ export const noIndexOfEquality = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer optimized alternatives to `indexOf()` equality checks',
-            recommended: false
+            description: 'Prefer optimized alternatives to `indexOf()` equality checks'
         },
         fixable: 'code',
         schema: [],
@@ -13,6 +12,7 @@ export const noIndexOfEquality = {
             preferStartsWith: 'Use `.startsWith()` instead of `indexOf() === 0` for strings'
         }
     },
+    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         const services = getTypedParserServices(context);

package/lib/utils/typescript.d.ts

@@ -1,5 +1,5 @@
-import type { Rule } from 'eslint';
-import type { TSNode, TSToken, TSESTree } from '@typescript-eslint/typescript-estree';
+import type { TSNode, TSToken, TSESTree, ParserServicesWithTypeInformation } from '@typescript-eslint/typescript-estree';
+import type { TSESLint } from '@typescript-eslint/utils';
 import type ts from 'typescript';
 export interface ParserServices {
     emitDecoratorMetadata: boolean | undefined;
@@ -11,4 +11,4 @@ export interface ParserServices {
     getTypeAtLocation: (node: TSESTree.Node) => ts.Type;
     program: ts.Program;
 }
-export declare function getTypedParserServices(context: Readonly<Rule.RuleContext>): ParserServices;
+export declare function getTypedParserServices(context: Readonly<TSESLint.RuleContext<string, unknown[]>>): ParserServicesWithTypeInformation;

package/lib/utils/typescript.js

@@ -1,5 +1,5 @@
 export function getTypedParserServices(context) {
-    if (context.sourceCode.parserServices.program == null) {
+    if (context.sourceCode.parserServices?.program == null) {
         throw new Error(`You have used a rule which requires type information. Please ensure you have typescript-eslint setup alongside this plugin and configured to enable type-aware linting. See https://typescript-eslint.io/getting-started/typed-linting for more information.`);
     }
     return context.sourceCode.parserServices;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e18e/eslint-plugin",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "The official e18e ESLint plugin for modernizing code and improving performance.",
   "keywords": [
     "eslint",
@@ -42,6 +42,7 @@
     "@vitest/coverage-v8": "^4.0.16",
     "eslint": "^9.39.2",
     "eslint-plugin-eslint-plugin": "^7.2.0",
+    "oxlint": "^1.34.0",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.50.0",

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

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

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

@@ -1,90 +0,0 @@
-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

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

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

@@ -1,175 +0,0 @@
-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);
-                        }
-                    });
-                }
-            }
-        };
-    }
-};