@e18e/eslint-plugin 0.1.2 → 0.1.4

package/README.md

@@ -75,18 +75,70 @@ Copying these rules into your `rules` object will achieve the same effect as usi
 > Our type-aware rules depend on TypeScript ESLint's parser, which means they
 > will not work with oxlint at this time.
 
+## Linting `package.json`
+
+Some rules (e.g. `ban-dependencies`) can be used against your `package.json`.
+
+You can achieve this by using `@eslint/json` or `jsonc-eslint-parser`.
+
+For example, with `@eslint/json` and `eslint.config.js`:
+
+```ts
+import e18e from '@e18e/eslint-plugin';
+import json from '@eslint/json';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+  {
+    files: ['package.json'],
+    language: 'json/json',
+    plugins: {
+      e18e,
+      json
+    },
+    extends: ['e18e/recommended'],
+  }
+]);
+```
+
+Or with `jsonc-eslint-parser` and `eslint.config.js`:
+
+```ts
+import e18e from '@e18e/eslint-plugin';
+import jsonParser from 'jsonc-eslint-parser';
+import {defineConfig} from 'eslint/config';
+
+export default defineConfig([
+  {
+    files: ['package.json'],
+    languageOptions: {
+      parser: jsonParser
+    },
+    plugins: {
+      e18e
+    },
+    extends: ['e18e/recommended'],
+  }
+]);
+```
+
+Read more at the
+[`@eslint/json` docs](https://github.com/eslint/json) and
+[`jsonc-eslint-parser` docs](https://github.com/ota-meshi/jsonc-eslint-parser).
+
 ## Rules
 
 **Legend:**
 - ✅ = Yes / Enabled
 - ✖️ = No / Disabled
 - 💡 = Has suggestions (requires user confirmation for fixes)
+- 🔶 = Optionally uses types (works without TypeScript but more powerful with it)
 
 ### Modernization
 
 | Rule | Description | Recommended | Fixable | Requires Types |
 |------|-------------|-------------|---------|----------------|
-| [prefer-array-at](./src/rules/prefer-array-at.ts) | Prefer `Array.prototype.at()` over length-based indexing | ✅ | ✅ | ✖️ |
+| [prefer-array-at](./src/rules/prefer-array-at.ts) | Prefer `Array.prototype.at()` over length-based indexing | ✅ | ✅ | 🔶 |
 | [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 | ✅ | ✅ | ✖️ |
@@ -110,7 +162,10 @@ 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-array-some](./src/rules/prefer-array-some.ts) | Prefer `Array.some()` over `Array.find()` when checking for element existence | ✅ | ✅ | ✖️ |
 | [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,9 @@ 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',
+        'e18e/prefer-array-some': 'error'
     }
 });

package/lib/main.js

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

package/lib/rules/prefer-array-at.d.ts

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

package/lib/rules/prefer-array-at.js

@@ -1,9 +1,9 @@
+import { isArrayType, isStringType } from '../utils/typescript.js';
 export const preferArrayAt = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer Array.prototype.at() over length-based indexing',
-            recommended: true
+            description: 'Prefer Array.prototype.at() over length-based indexing'
         },
         fixable: 'code',
         schema: [],
@@ -11,6 +11,7 @@ export const preferArrayAt = {
             preferAt: 'Use .at(-1) instead of [{{array}}.length - 1]'
         }
     },
+    defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
         return {
@@ -48,6 +49,11 @@ export const preferArrayAt = {
                     parent.left === node) {
                     return;
                 }
+                // Check if the object supports .at() (array or string, when types are available)
+                if (!isArrayType(node.object, context) &&
+                    !isStringType(node.object, context)) {
+                    return;
+                }
                 context.report({
                     node,
                     messageId: 'preferAt',

package/lib/rules/prefer-array-some.d.ts

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

package/lib/rules/prefer-array-some.js

@@ -0,0 +1,118 @@
+import { isInBooleanContext, isNullish } from '../utils/ast.js';
+function isFindCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name === 'find' &&
+        node.arguments.length >= 1);
+}
+function reportFind(context, node, findCall, shouldNegate) {
+    if (findCall.callee.type !== 'MemberExpression') {
+        return;
+    }
+    const sourceCode = context.sourceCode;
+    const arrayText = sourceCode.getText(findCall.callee.object);
+    const argsText = findCall.arguments
+        .map((arg) => sourceCode.getText(arg))
+        .join(', ');
+    const replacement = shouldNegate
+        ? `!${arrayText}.some(${argsText})`
+        : `${arrayText}.some(${argsText})`;
+    context.report({
+        node,
+        messageId: 'preferArraySome',
+        fix(fixer) {
+            return fixer.replaceText(node, replacement);
+        }
+    });
+}
+function checkBinaryExpression(node, context) {
+    const { left, right, operator } = node;
+    if (left.type === 'PrivateIdentifier') {
+        return;
+    }
+    let findCall;
+    let constantSide;
+    if (isFindCall(left)) {
+        findCall = left;
+        constantSide = right;
+    }
+    else if (isFindCall(right)) {
+        findCall = right;
+        constantSide = left;
+    }
+    else {
+        return;
+    }
+    const nullishType = isNullish(constantSide);
+    if (!nullishType) {
+        return;
+    }
+    if (operator === '===' || operator === '!==') {
+        if (nullishType !== 'undefined') {
+            return;
+        }
+        const shouldNegate = operator === '===';
+        reportFind(context, node, findCall, shouldNegate);
+        return;
+    }
+}
+function checkUnaryExpression(node, context) {
+    // !arr.find(fn) -> !arr.some(fn)
+    if (node.operator === '!' && isFindCall(node.argument)) {
+        reportFind(context, node, node.argument, true);
+        return;
+    }
+    // !!arr.find(fn) -> arr.some(fn)
+    if (node.operator === '!' &&
+        node.argument.type === 'UnaryExpression' &&
+        node.argument.operator === '!' &&
+        isFindCall(node.argument.argument)) {
+        reportFind(context, node, node.argument.argument, false);
+        return;
+    }
+}
+export const preferArraySome = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer Array.some() over Array.find() when checking for element existence',
+            recommended: true
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferArraySome: 'Use Array.some() instead of Array.find() when checking for element existence'
+        }
+    },
+    create(context) {
+        return {
+            BinaryExpression(node) {
+                checkBinaryExpression(node, context);
+            },
+            UnaryExpression(node) {
+                // Skip inner ! if it's inside !! (the outer will handle it)
+                if (node.operator === '!' && node.parent) {
+                    if (node.parent.type === 'UnaryExpression' &&
+                        node.parent.operator === '!') {
+                        return;
+                    }
+                }
+                checkUnaryExpression(node, context);
+            },
+            CallExpression(node) {
+                // Skip if handled by UnaryExpression or BinaryExpression
+                if (node.parent?.type === 'UnaryExpression' ||
+                    node.parent?.type === 'BinaryExpression') {
+                    return;
+                }
+                if (!isFindCall(node)) {
+                    return;
+                }
+                if (isInBooleanContext(node)) {
+                    reportFind(context, node, node, false);
+                }
+            }
+        };
+    }
+};

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,147 @@
+import { tryGetTypedParserServices } from '../utils/typescript.js';
+import { isInBooleanContext } from '../utils/ast.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;
+}
+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/rules/prefer-spread-syntax.js

@@ -30,9 +30,12 @@ export const preferSpreadSyntax = {
                 let messageId;
                 let replacement;
                 // array.concat()
+                // excluding Buffer.concat()
                 if (node.callee.property.type === 'Identifier' &&
                     node.callee.property.name === 'concat' &&
-                    node.arguments.length > 0) {
+                    node.arguments.length > 0 &&
+                    !(node.callee.object.type === 'Identifier' &&
+                        node.callee.object.name === 'Buffer')) {
                     const arrayText = sourceCode.getText(node.callee.object);
                     const argTexts = node.arguments.map((arg) => sourceCode.getText(arg));
                     const spreadParts = [arrayText, ...argTexts]

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

@@ -4,6 +4,22 @@ function isNullOrUndefined(node) {
     }
     return node.type === 'Identifier' && node.name === 'undefined';
 }
+function isTimerCall(node) {
+    if (node.callee.type === 'Identifier' &&
+        (node.callee.name === 'setTimeout' || node.callee.name === 'setInterval')) {
+        return true;
+    }
+    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 === 'setTimeout' ||
+            node.callee.property.name === 'setInterval')) {
+        return true;
+    }
+    return false;
+}
 function isSafeArgument(arg) {
     if (arg.type === 'SpreadElement') {
         return arg.argument.type === 'Identifier';
@@ -75,18 +91,7 @@ export const preferTimerArgs = {
         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) {
+                if (!isTimerCall(node)) {
                     return;
                 }
                 if (node.arguments.length < 2) {
@@ -101,21 +106,23 @@ export const preferTimerArgs = {
                 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') {
+                    if (firstArg.body.type === 'BlockStatement') {
                         return;
                     }
                     // skip if it has parameters
-                    if (arrowFn.params.length > 0) {
+                    if (firstArg.params.length > 0) {
                         return;
                     }
-                    if (arrowFn.body.type !== 'CallExpression') {
+                    if (firstArg.body.type !== 'CallExpression') {
                         return;
                     }
-                    const callExpression = arrowFn.body;
+                    const callExpression = firstArg.body;
                     const callee = callExpression.callee;
                     const callArgs = callExpression.arguments;
+                    if (callee.type === 'MemberExpression') {
+                        return;
+                    }
                     if (!callArgs.every(isSafeArgument)) {
                         return;
                     }

package/lib/utils/ast.d.ts

@@ -1,5 +1,17 @@
-import type { CallExpression, Node } from 'estree';
-import type { SourceCode } from 'eslint';
+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;
+/**
+ * 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
+ */
+export declare function isInBooleanContext(node: AnyNode): boolean;
+/**
+ * Checks if a node is undefined, null, or void 0.
+ * Returns the type of nullish value or false if not nullish.
+ */
+export declare function isNullish(node: Expression): 'undefined' | 'null' | false;
 /**
  * Checks if a CallExpression is a copy operation that creates a shallow copy of an array.
  * e.g. concat(), slice(), slice(0)
@@ -13,3 +25,4 @@ 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;
+export {};

package/lib/utils/ast.js

@@ -1,3 +1,51 @@
+/**
+ * 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
+ */
+export 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 recursively for unary ! and logical operators
+    if ((parent.type === 'UnaryExpression' && parent.operator === '!') ||
+        (parent.type === 'LogicalExpression' &&
+            (parent.operator === '&&' || parent.operator === '||'))) {
+        return isInBooleanContext(parent);
+    }
+    return false;
+}
+/**
+ * Checks if a node is undefined, null, or void 0.
+ * Returns the type of nullish value or false if not nullish.
+ */
+export function isNullish(node) {
+    if (node.type === 'Identifier' && node.name === 'undefined') {
+        return 'undefined';
+    }
+    if (node.type === 'Literal' && node.value === null) {
+        return 'null';
+    }
+    // void 0
+    if (node.type === 'UnaryExpression' &&
+        node.operator === 'void' &&
+        node.argument.type === 'Literal' &&
+        node.argument.value === 0) {
+        return 'undefined';
+    }
+    return false;
+}
 /**
  * Checks if a CallExpression is a copy operation that creates a shallow copy of an array.
  * e.g. concat(), slice(), slice(0)

package/lib/utils/typescript.d.ts

@@ -11,4 +11,15 @@ 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;
+/**
+ * Checks if a node's type is an Array type (Array, tuple, or typed array)
+ * 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 string
+ * Returns false if types are unavailable
+ */
+export declare function isStringType(node: TSESTree.Node, context: Readonly<TSESLint.RuleContext<string, unknown[]>>): boolean;

package/lib/utils/typescript.js

@@ -1,6 +1,69 @@
-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;
+}
+const typedArrayTypes = [
+    'Int8Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Int16Array',
+    'Uint16Array',
+    'Int32Array',
+    'Uint32Array',
+    'Float32Array',
+    'Float64Array',
+    'BigInt64Array',
+    'BigUint64Array'
+];
+/**
+ * Checks if a node's type is an Array type (Array, tuple, or typed array)
+ * Returns true if types are unavailable (to avoid false negatives)
+ */
+export function isArrayType(node, context) {
+    const services = tryGetTypedParserServices(context);
+    if (!services) {
+        return true;
+    }
+    const type = services.getTypeAtLocation(node);
+    if (!type) {
+        return true;
+    }
+    const checker = services.program.getTypeChecker();
+    if (checker.isArrayType(type)) {
+        return true;
+    }
+    if (checker.isTupleType(type)) {
+        return true;
+    }
+    const typeString = checker.typeToString(type);
+    if (typedArrayTypes.some((t) => typeString.startsWith(t))) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a node's type is a string
+ * Returns false if types are unavailable
+ */
+export function isStringType(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 stringType = checker.getStringType();
+    return checker.isTypeAssignableTo(type, stringType);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e18e/eslint-plugin",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "The official e18e ESLint plugin for modernizing code and improving performance.",
   "keywords": [
     "eslint",
@@ -36,16 +36,18 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@types/node": "^25.0.3",
-    "@typescript-eslint/rule-tester": "^8.50.0",
-    "@typescript-eslint/typescript-estree": "^8.50.0",
-    "@vitest/coverage-v8": "^4.0.16",
+    "@eslint/json": "^0.14.0",
+    "@types/node": "^25.0.10",
+    "@typescript-eslint/rule-tester": "^8.53.1",
+    "@typescript-eslint/typescript-estree": "^8.53.1",
+    "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^9.39.2",
-    "eslint-plugin-eslint-plugin": "^7.2.0",
-    "oxlint": "^1.34.0",
-    "prettier": "^3.7.4",
+    "eslint-plugin-eslint-plugin": "^7.3.0",
+    "jsonc-eslint-parser": "^2.4.2",
+    "oxlint": "^1.41.0",
+    "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.50.0",
+    "typescript-eslint": "^8.53.1",
     "vitest": "^4.0.14"
   },
   "peerDependencies": {