@e18e/eslint-plugin 0.1.2 → 0.1.3

package/README.md

@@ -81,6 +81,7 @@ Copying these rules into your `rules` object will achieve the same effect as usi
 - ✅ = Yes / Enabled
 - ✖️ = No / Disabled
 - 💡 = Has suggestions (requires user confirmation for fixes)
+- 🔶 = Optionally uses types (works without TypeScript but more powerful with it)
 
 ### Modernization
 
@@ -111,6 +112,8 @@ Copying these rules into your `rules` object will achieve the same effect as usi
 | [no-indexof-equality](./src/rules/no-indexof-equality.ts) | Prefer `startsWith()` for strings and direct array access over `indexOf()` equality checks | ✖️ | ✅ | ✅ |
 | [prefer-array-from-map](./src/rules/prefer-array-from-map.ts) | Prefer `Array.from(iterable, mapper)` over `[...iterable].map(mapper)` to avoid intermediate array allocation | ✅ | ✅ | ✖️ |
 | [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 | ✅ | ✅ | 🔶 |
 
 ## License
 

package/lib/configs/performance-improvements.js

@@ -4,6 +4,8 @@ export const performanceImprovements = (plugin) => ({
     },
     rules: {
         'e18e/prefer-array-from-map': 'error',
-        'e18e/prefer-timer-args': 'error'
+        'e18e/prefer-timer-args': 'error',
+        'e18e/prefer-date-now': 'error',
+        'e18e/prefer-regex-test': 'error'
     }
 });

package/lib/main.js

@@ -16,6 +16,8 @@ import { preferSpreadSyntax } from './rules/prefer-spread-syntax.js';
 import { preferUrlCanParse } from './rules/prefer-url-canparse.js';
 import { noIndexOfEquality } from './rules/no-indexof-equality.js';
 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 { rules as dependRules } from 'eslint-plugin-depend';
 const plugin = {
     meta: {
@@ -38,6 +40,8 @@ const plugin = {
         'prefer-url-canparse': preferUrlCanParse,
         'no-indexof-equality': noIndexOfEquality,
         'prefer-timer-args': preferTimerArgs,
+        'prefer-date-now': preferDateNow,
+        'prefer-regex-test': preferRegexTest,
         ...dependRules
     }
 };

package/lib/rules/prefer-date-now.d.ts

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

package/lib/rules/prefer-date-now.js

@@ -0,0 +1,71 @@
+function getDateNowReplacement(node) {
+    if (node.type !== 'NewExpression' || node.arguments.length !== 0) {
+        return null;
+    }
+    if (node.callee.type === 'Identifier' && node.callee.name === 'Date') {
+        return 'Date.now()';
+    }
+    if (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 === 'Date' &&
+        !node.callee.computed) {
+        return `${node.callee.object.name}.Date.now()`;
+    }
+    return null;
+}
+export const preferDateNow = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Date.now() over new Date().getTime() and +new Date()',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferDateNow: 'Use Date.now() to avoid allocating a new Date object.'
+        }
+    },
+    create(context) {
+        return {
+            // new Date().getTime()
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.object.type === 'NewExpression' &&
+                    node.callee.property.type === 'Identifier' &&
+                    node.callee.property.name === 'getTime' &&
+                    !node.callee.computed &&
+                    node.arguments.length === 0) {
+                    const replacement = getDateNowReplacement(node.callee.object);
+                    if (replacement) {
+                        context.report({
+                            node,
+                            messageId: 'preferDateNow',
+                            fix(fixer) {
+                                return fixer.replaceText(node, replacement);
+                            }
+                        });
+                    }
+                }
+            },
+            // +new Date()
+            UnaryExpression(node) {
+                if (node.operator === '+' && node.argument.type === 'NewExpression') {
+                    const replacement = getDateNowReplacement(node.argument);
+                    if (replacement) {
+                        context.report({
+                            node,
+                            messageId: 'preferDateNow',
+                            fix(fixer) {
+                                return fixer.replaceText(node, replacement);
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-regex-test.d.ts

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

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

@@ -0,0 +1,173 @@
+import { tryGetTypedParserServices } from '../utils/typescript.js';
+function isRegExpLiteral(node) {
+    return (node.type === 'Literal' &&
+        'regex' in node &&
+        node.regex !== undefined &&
+        node.regex !== null);
+}
+/**
+ * Checks if a node is a `new RegExp(...)`
+ */
+function isRegExpConstructor(node) {
+    if (node.type !== 'NewExpression') {
+        return false;
+    }
+    const { callee } = node;
+    // new RegExp()
+    if (callee.type === 'Identifier' && callee.name === 'RegExp') {
+        return true;
+    }
+    // new window.RegExp() or new globalThis.RegExp()
+    if (callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        (callee.object.name === 'window' || callee.object.name === 'globalThis') &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'RegExp' &&
+        !callee.computed) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a node is a RegExp (literal or constructor)
+ */
+function isRegExp(node) {
+    return (node !== null &&
+        node !== undefined &&
+        (isRegExpLiteral(node) || isRegExpConstructor(node)));
+}
+/**
+ * Checks if a node resolves to a RegExp using TypeScript types (when available)
+ */
+function isRegExpByType(node, context) {
+    const services = tryGetTypedParserServices(context);
+    if (!services) {
+        return false;
+    }
+    const type = services.getTypeAtLocation(node);
+    if (!type) {
+        return false;
+    }
+    const checker = services.program.getTypeChecker();
+    const typeString = checker.typeToString(type);
+    return typeString === 'RegExp';
+}
+/**
+ * Checks if a node resolves to a RegExp (literal, constructor, or by type)
+ */
+function resolvesToRegExp(node, context) {
+    if (isRegExpByType(node, context)) {
+        return true;
+    }
+    if (isRegExp(node)) {
+        return true;
+    }
+    if (node.type !== 'Identifier') {
+        return false;
+    }
+    const scope = context.sourceCode.getScope(node);
+    const variable = scope.references.find((ref) => ref.identifier === node)?.resolved;
+    if (!variable) {
+        return false;
+    }
+    for (const def of variable.defs) {
+        if (def.type === 'Variable' && def.node.type === 'VariableDeclarator') {
+            const init = def.node.init;
+            if (isRegExp(init)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Checks if a node is in a test/condition
+ */
+function isInBooleanContext(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    // if/while/for/do-while test
+    if ((parent.type === 'IfStatement' && parent.test === node) ||
+        (parent.type === 'WhileStatement' && parent.test === node) ||
+        (parent.type === 'ForStatement' && parent.test === node) ||
+        (parent.type === 'DoWhileStatement' && parent.test === node)) {
+        return true;
+    }
+    // ternaries
+    if (parent.type === 'ConditionalExpression' && parent.test === node) {
+        return true;
+    }
+    // check the parent
+    if ((parent.type === 'UnaryExpression' && parent.operator === '!') ||
+        (parent.type === 'LogicalExpression' &&
+            (parent.operator === '&&' || parent.operator === '||'))) {
+        return isInBooleanContext(parent);
+    }
+    return false;
+}
+export const preferRegexTest = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'prefer `RegExp.test()` over `String.match()` and `RegExp.exec()` when only checking for match existence'
+        },
+        fixable: 'code',
+        messages: {
+            preferTest: 'Prefer `{{regex}}.test({{string}})` over `{{original}}` for boolean checks'
+        },
+        schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!isInBooleanContext(node)) {
+                    return;
+                }
+                const { callee } = node;
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
+                const property = callee.property;
+                if (property.type !== 'Identifier' || node.arguments.length !== 1) {
+                    return;
+                }
+                let regexNode;
+                let stringNode;
+                if (property.name === 'match') {
+                    // str.match(regex)
+                    stringNode = callee.object;
+                    regexNode = node.arguments[0];
+                }
+                else if (property.name === 'exec') {
+                    // regex.exec(str)
+                    regexNode = callee.object;
+                    stringNode = node.arguments[0];
+                }
+                else {
+                    return;
+                }
+                if (!resolvesToRegExp(regexNode, context)) {
+                    return;
+                }
+                const sourceCode = context.sourceCode;
+                const regexText = sourceCode.getText(regexNode);
+                const stringText = sourceCode.getText(stringNode);
+                context.report({
+                    node,
+                    messageId: 'preferTest',
+                    data: {
+                        regex: regexText,
+                        string: stringText,
+                        original: sourceCode.getText(node)
+                    },
+                    fix(fixer) {
+                        return fixer.replaceText(node, `${regexText}.test(${stringText})`);
+                    }
+                });
+            }
+        };
+    }
+};

package/lib/utils/typescript.d.ts

@@ -11,4 +11,5 @@ export interface ParserServices {
     getTypeAtLocation: (node: TSESTree.Node) => ts.Type;
     program: ts.Program;
 }
+export declare function tryGetTypedParserServices(context: Readonly<TSESLint.RuleContext<string, unknown[]>>): ParserServicesWithTypeInformation | null;
 export declare function getTypedParserServices(context: Readonly<TSESLint.RuleContext<string, unknown[]>>): ParserServicesWithTypeInformation;

package/lib/utils/typescript.js

@@ -1,6 +1,13 @@
-export function getTypedParserServices(context) {
+export function tryGetTypedParserServices(context) {
     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 null;
     }
     return context.sourceCode.parserServices;
 }
+export function getTypedParserServices(context) {
+    const services = tryGetTypedParserServices(context);
+    if (services === 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 services;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e18e/eslint-plugin",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "The official e18e ESLint plugin for modernizing code and improving performance.",
   "keywords": [
     "eslint",