@ethlete/eslint-plugin 1.0.0-next.23 → 1.0.0-next.24

package/src/rules/no-locale-id.js

@@ -14,6 +14,8 @@
  *   const locale = injectLocale();
  */
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noLocaleId = {
   meta: {
@@ -31,10 +33,8 @@ const noLocaleId = {
   create(context) {
     return {
       CallExpression(node) {
-        const { callee } = node;
-        if (callee.type !== 'Identifier' || callee.name !== 'inject') return;
-        const arg = node.arguments[0];
-        if (arg?.type === 'Identifier' && arg.name === 'LOCALE_ID') {
+        if (!isImportedAs(context.sourceCode, node.callee, 'inject')) return;
+        if (isImportedAs(context.sourceCode, node.arguments[0], 'LOCALE_ID')) {
           context.report({ node, messageId: 'noLocaleId' });
         }
       },

package/src/rules/no-member-alias.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
  * Disallows class members that exist solely as aliases for a nested property or
  * zero-arg method of another class member accessed via `this`.
@@ -81,12 +83,14 @@ const getMethodAliasInfo = (node) => {
 
 const CONTRACT_METHOD_NAMES = new Set(['blur', 'focus', 'reset']);
 
-/** @param {any} methodNode */
-const isInAngularClass = (methodNode) =>
-  methodNode.parent?.parent?.decorators?.some((decorator) => {
-    const expression = decorator.expression;
-    const callee = expression.type === 'CallExpression' ? expression.callee : expression;
-    return callee.type === 'Identifier' && (callee.name === 'Component' || callee.name === 'Directive');
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} methodNode
+ */
+const isInAngularClass = (sourceCode, methodNode) =>
+  methodNode.parent?.parent?.decorators?.some((/** @type {any} */ decorator) => {
+    const name = getAngularDecoratorName(sourceCode, decorator);
+    return name === 'Component' || name === 'Directive';
   }) ?? false;
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -149,7 +153,7 @@ const noMemberAlias = {
         if (!info) return;
         const classNode = node.parent?.parent;
         if (node.override || classNode?.superClass || classNode?.implements?.length) return;
-        if (isInAngularClass(node) && CONTRACT_METHOD_NAMES.has(aliasName)) return;
+        if (isInAngularClass(context.sourceCode, node) && CONTRACT_METHOD_NAMES.has(aliasName)) return;
 
         // Only flag when names match — different names indicate an intentional
         // API rename, which is not a pure alias.

package/src/rules/no-native-html-input-name.js

@@ -75,7 +75,7 @@ const rule = {
   create(context) {
     return {
       PropertyDefinition(node) {
-        const io = getReactiveIo(node);
+        const io = getReactiveIo(context.sourceCode, node);
         if (!io) return;
         if (io.kind === 'output') return;
 

package/src/rules/no-pipe-logic.js

@@ -1,23 +1,16 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
- * Checks whether a class node has a @Pipe decorator.
- * @param {import('eslint').Rule.Node} classNode
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} classNode
  */
-const hasPipeDecorator = (classNode) => {
-  const decorators = /** @type {any} */ (classNode).decorators ?? [];
-  return decorators.some((/** @type {any} */ dec) => {
-    const expr = dec.expression;
-    if (expr.type === 'CallExpression') {
-      return expr.callee.type === 'Identifier' && expr.callee.name === 'Pipe';
-    }
-    if (expr.type === 'Identifier') {
-      return expr.name === 'Pipe';
-    }
-    return false;
-  });
-};
+const hasPipeDecorator = (sourceCode, classNode) =>
+  (classNode.decorators ?? []).some(
+    (/** @type {any} */ decorator) => getAngularDecoratorName(sourceCode, decorator) === 'Pipe',
+  );
 
 /** @type {import('eslint').Rule.RuleModule} */
 const noPipeLogic = {
@@ -47,7 +40,7 @@ const noPipeLogic = {
         const classNode = classBody.parent;
         if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
 
-        if (!hasPipeDecorator(classNode)) return;
+        if (!hasPipeDecorator(context.sourceCode, classNode)) return;
 
         context.report({ node, messageId: 'noLogicInTransform' });
       },
@@ -63,7 +56,7 @@ const noPipeLogic = {
         const classNode = classBody.parent;
         if (!classNode || (classNode.type !== 'ClassDeclaration' && classNode.type !== 'ClassExpression')) return;
 
-        if (!hasPipeDecorator(classNode)) return;
+        if (!hasPipeDecorator(context.sourceCode, classNode)) return;
 
         const value = /** @type {any} */ (node).value;
         if (value && (value.type === 'ArrowFunctionExpression' || value.type === 'FunctionExpression')) {

package/src/rules/no-redundant-on-push-change-detection.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName, isImportedAs } = require('./internals/import-resolution');
+
 const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
 
 /**
@@ -70,29 +72,15 @@ const getPropertyName = (key) => {
 };
 
 /**
- * @param {import('eslint').Rule.Node} node
- */
-const isComponentDecorator = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return false;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' && expression.callee.name === 'Component';
-  }
-
-  return expression.type === 'Identifier' && expression.name === 'Component';
-};
-
-/**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} value
  */
-const isOnPushValue = (value, localName) =>
+const isOnPushValue = (sourceCode, value) =>
   value.type === 'MemberExpression' &&
-  value.object.type === 'Identifier' &&
-  value.object.name === localName &&
+  !value.computed &&
   value.property.type === 'Identifier' &&
-  value.property.name === 'OnPush';
+  value.property.name === 'OnPush' &&
+  isImportedAs(sourceCode, value.object, 'ChangeDetectionStrategy');
 
 /**
  * Range that removes a single named import specifier together with its comma.
@@ -159,12 +147,11 @@ const noRedundantOnPushChangeDetection = {
     const sourceCode = context.sourceCode;
     /** @type {any} */
     let changeDetectionSpecifier = null;
-    let changeDetectionLocalName = 'ChangeDetectionStrategy';
     const removableIdentifiers = new Set();
 
     return {
       Decorator(node) {
-        if (!isComponentDecorator(node)) return;
+        if (getAngularDecoratorName(sourceCode, node) !== 'Component') return;
 
         const expression = /** @type {any} */ (node).expression;
         if (expression.type !== 'CallExpression' || expression.arguments.length === 0) return;
@@ -175,7 +162,7 @@ const noRedundantOnPushChangeDetection = {
         const property = metadata.properties.find(
           (entry) => entry.type === 'Property' && getPropertyName(entry.key) === 'changeDetection',
         );
-        if (!property || !isOnPushValue(property.value, changeDetectionLocalName)) return;
+        if (!property || !isOnPushValue(sourceCode, property.value)) return;
         removableIdentifiers.add(property.value.object);
 
         context.report({
@@ -195,7 +182,6 @@ const noRedundantOnPushChangeDetection = {
             specifier.imported.name === 'ChangeDetectionStrategy'
           ) {
             changeDetectionSpecifier = specifier;
-            changeDetectionLocalName = specifier.local.name;
             return;
           }
         }

package/src/rules/no-rxjs-in-effect.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Disallows calling .subscribe() inside Angular's effect() or computed() callbacks.
  *
@@ -22,6 +24,11 @@
  *     .subscribe();
  */
 
+/**
+ * @param {any} node
+ */
+const isStringLiteral = (node) => node?.type === 'Literal' && typeof node.value === 'string';
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noRxjsInEffect = {
   meta: {
@@ -50,13 +57,9 @@ const noRxjsInEffect = {
         if (current.type === 'ArrowFunctionExpression' || current.type === 'FunctionExpression') {
           crossedFunctionBoundary = true;
         }
-        if (
-          crossedFunctionBoundary &&
-          current.type === 'CallExpression' &&
-          current.callee.type === 'Identifier' &&
-          (current.callee.name === 'effect' || current.callee.name === 'computed')
-        ) {
-          return current.callee.name;
+        if (crossedFunctionBoundary && current.type === 'CallExpression') {
+          const calleeName = getImportedName(context.sourceCode, current.callee, ANGULAR_CORE);
+          if (calleeName === 'effect' || calleeName === 'computed') return calleeName;
         }
         current = current.parent;
       }
@@ -69,7 +72,8 @@ const noRxjsInEffect = {
         if (
           callee.type === 'MemberExpression' &&
           callee.property.type === 'Identifier' &&
-          callee.property.name === 'subscribe'
+          callee.property.name === 'subscribe' &&
+          !isStringLiteral(node.arguments[0])
         ) {
           const reactiveContext = getReactiveContext(node);
           if (reactiveContext) {

package/src/rules/no-screaming-case-local.js

@@ -79,6 +79,7 @@ const noScreamingCaseLocal = {
 
         // Only flag inside function bodies
         if (!isInsideFunction(node)) return;
+        if (node.init?.type === 'ArrowFunctionExpression' || node.init?.type === 'FunctionExpression') return;
 
         context.report({
           node: node.id,

package/src/rules/no-standalone-flag.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
 
 /** @typedef {'Component' | 'Directive' | 'Pipe'} TDecoratorName */
@@ -14,22 +16,6 @@ const getPropertyName = (key) => {
   return null;
 };
 
-/**
- * @param {import('eslint').Rule.Node} node
- * @returns {TDecoratorName | null}
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const noStandaloneFlag = {
   meta: {
@@ -49,7 +35,7 @@ const noStandaloneFlag = {
 
     return {
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive' && decoratorName !== 'Pipe') return;
 
         const decorator = /** @type {any} */ (node);

package/src/rules/no-subscribe-in-pipe.js

@@ -19,6 +19,8 @@
  *   obs$.pipe(...operators).subscribe(); // ✅ subscribe on the result of pipe
  */
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noSubscribeInPipe = {
   meta: {
@@ -48,8 +50,7 @@ const noSubscribeInPipe = {
         // be flagged even if the Observable itself is passed into a .pipe() operator.
         if (
           current.type === 'NewExpression' &&
-          current.callee.type === 'Identifier' &&
-          current.callee.name === 'Observable'
+          isImportedAs(context.sourceCode, current.callee, 'Observable', 'rxjs')
         ) {
           return false;
         }

package/src/rules/no-template-literal-before-inline-template.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 const ts = require('typescript');
 
 /**
@@ -92,19 +94,6 @@ const getPropertyName = (key) => {
   return null;
 };
 
-/**
- * @param {any} node
- */
-const getDecoratorName = (node) => {
-  const expression = node.expression;
-  if (!expression) return null;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 /**
  * The inline template text, or null when the property is not a plain non-empty string literal.
  *
@@ -147,7 +136,7 @@ const noTemplateLiteralBeforeInlineTemplate = {
 
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const expression = /** @type {any} */ (node).expression;

package/src/rules/no-trivial-return-type.js

@@ -191,6 +191,7 @@ const noTrivialReturnType = {
     return {
       ArrowFunctionExpression: checkReturnType,
       FunctionExpression: checkReturnType,
+      FunctionDeclaration: checkReturnType,
     };
   },
 };

package/src/rules/no-trivial-wrapper-method.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
  * Disallows trivial wrapper methods that do nothing but forward all their
  * arguments to another call.
@@ -34,22 +36,14 @@ const CONTRACT_METHOD_NAMES = new Set(['focus', 'blur', 'reset']);
 const isSimpleParam = (param) => param.type === 'Identifier';
 
 /**
- * Whether the class holding this method is an Angular component or directive.
- * @param {import('eslint').Rule.Node} methodNode MethodDefinition node
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {any} methodNode
  */
-const isInAngularClass = (methodNode) => {
-  const classNode = methodNode.parent?.parent;
-  const decorators = classNode && 'decorators' in classNode ? classNode.decorators : null;
-
-  if (!decorators) return false;
-
-  return decorators.some((decorator) => {
-    const expression = decorator.expression;
-    const callee = expression.type === 'CallExpression' ? expression.callee : expression;
-
-    return callee.type === 'Identifier' && (callee.name === 'Component' || callee.name === 'Directive');
-  });
-};
+const isInAngularClass = (sourceCode, methodNode) =>
+  methodNode.parent?.parent?.decorators?.some((/** @type {any} */ decorator) => {
+    const name = getAngularDecoratorName(sourceCode, decorator);
+    return name === 'Component' || name === 'Directive';
+  }) ?? false;
 
 /**
  * Returns the single CallExpression in the method body when the method is a
@@ -127,7 +121,7 @@ const noTrivialWrapperMethod = {
         const classNode = node.parent?.parent;
         if (node.override || classNode?.superClass || classNode?.implements?.length) return;
         if (node.static && methodName === 'ngTemplateContextGuard') return;
-        if (CONTRACT_METHOD_NAMES.has(methodName) && isInAngularClass(node)) return;
+        if (CONTRACT_METHOD_NAMES.has(methodName) && isInAngularClass(context.sourceCode, node)) return;
 
         const callee = callExpr.callee;
         const targetName =

package/src/rules/no-typed-injected-element-ref.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noTypedInjectedElementRef = {
   meta: {
@@ -20,30 +22,25 @@ const noTypedInjectedElementRef = {
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== 'Identifier' || node.callee.name !== 'inject') {
-          return;
-        }
+        const src = context.sourceCode;
+        if (!isImportedAs(src, node.callee, 'inject')) return;
 
         const firstArg = node.arguments[0];
         if (!firstArg) return;
 
-        const isPlainElementRef = firstArg.type === 'Identifier' && firstArg.name === 'ElementRef';
+        const isPlainElementRef = isImportedAs(src, firstArg, 'ElementRef');
         const isInstantiatedElementRef =
-          firstArg.type === 'TSInstantiationExpression' &&
-          firstArg.expression &&
-          firstArg.expression.type === 'Identifier' &&
-          firstArg.expression.name === 'ElementRef';
+          firstArg.type === 'TSInstantiationExpression' && isImportedAs(src, firstArg.expression, 'ElementRef');
 
         if (!isPlainElementRef && !isInstantiatedElementRef) return;
 
-        const src = context.sourceCode;
+        const elementRef = src.getText(isPlainElementRef ? firstArg : firstArg.expression);
         const existingTypeParams = node.typeParameters || node.typeArguments;
         const injectType = existingTypeParams?.params?.[0];
         const hasTypedElementRef =
           existingTypeParams?.params?.length === 1 &&
           injectType?.type === 'TSTypeReference' &&
-          injectType.typeName?.type === 'Identifier' &&
-          injectType.typeName.name === 'ElementRef' &&
+          src.getText(injectType.typeName) === elementRef &&
           (injectType.typeArguments || injectType.typeParameters)?.params?.length > 0;
 
         if (isPlainElementRef && !hasTypedElementRef) {
@@ -53,8 +50,8 @@ const noTypedInjectedElementRef = {
             messageId: 'missingGeneric',
             fix(fixer) {
               return existingTypeParams
-                ? fixer.replaceText(existingTypeParams, '<ElementRef<HTMLElement>>')
-                : fixer.insertTextAfter(node.callee, '<ElementRef<HTMLElement>>');
+                ? fixer.replaceText(existingTypeParams, `<${elementRef}<HTMLElement>>`)
+                : fixer.insertTextAfter(node.callee, `<${elementRef}<HTMLElement>>`);
             },
           });
           return;
@@ -71,9 +68,9 @@ const noTypedInjectedElementRef = {
               messageId: 'missingGeneric',
               fix(fixer) {
                 const typeFix = existingTypeParams
-                  ? fixer.replaceText(existingTypeParams, `<ElementRef${tokenTypeParamText}>`)
-                  : fixer.insertTextAfter(node.callee, `<ElementRef${tokenTypeParamText}>`);
-                return [typeFix, fixer.replaceText(firstArg, 'ElementRef')];
+                  ? fixer.replaceText(existingTypeParams, `<${elementRef}${tokenTypeParamText}>`)
+                  : fixer.insertTextAfter(node.callee, `<${elementRef}${tokenTypeParamText}>`);
+                return [typeFix, fixer.replaceText(firstArg, elementRef)];
               },
             });
           } else {
@@ -82,7 +79,7 @@ const noTypedInjectedElementRef = {
               node,
               messageId: 'missingGeneric',
               fix(fixer) {
-                return fixer.replaceText(firstArg, 'ElementRef');
+                return fixer.replaceText(firstArg, elementRef);
               },
             });
           }

package/src/rules/no-unused-class-member.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
  * Disallows class members that are declared but never read within the class body.
  *
@@ -42,22 +44,17 @@ const extractIdentifiers = (str) => str.match(/\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g) ?
 
 /**
  * Returns info about the Angular decorators applied to a class node.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  * @returns {{ isComponent: boolean, isAngularClass: boolean }}
  */
-const getDecoratorInfo = (classNode) => {
+const getDecoratorInfo = (sourceCode, classNode) => {
   const decorators = classNode.decorators ?? [];
   let isComponent = false;
   let isAngularClass = false;
 
   for (const dec of decorators) {
-    const expr = dec.expression;
-    const name =
-      expr?.type === 'CallExpression' && expr.callee?.type === 'Identifier'
-        ? expr.callee.name
-        : expr?.type === 'Identifier'
-          ? expr.name
-          : null;
+    const name = getAngularDecoratorName(sourceCode, dec);
 
     if (name && ANGULAR_DECORATORS.has(name)) {
       isAngularClass = true;
@@ -167,7 +164,7 @@ const noUnusedClassMember = {
     return {
       ClassBody(node) {
         const classNode = node.parent;
-        const { isComponent, isAngularClass } = getDecoratorInfo(classNode);
+        const { isComponent, isAngularClass } = getDecoratorInfo(context.sourceCode, classNode);
         const hostBound = getHostBoundMembers(classNode);
         classStack.push({
           classBody: node,

package/src/rules/prefer-clone-equal.js

@@ -25,6 +25,8 @@
  *   import { clone, equal } from '@ethlete/core';
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferCloneEqual = {
   meta: {
@@ -70,21 +72,21 @@ const preferCloneEqual = {
         }
 
         // ── structuredClone(expr) ─────────────────────────────────────────────
-        if (callee.type === 'Identifier' && callee.name === 'structuredClone') {
+        if (isGlobalReference(context.sourceCode, callee) && callee.name === 'structuredClone') {
           context.report({ node, messageId: 'preferClone', data: { method: 'structuredClone()' } });
         }
       },
 
-      ImportDeclaration(node) {
-        const src = node.source.value;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (!reference) return;
+        const src = reference.source;
 
         // ── lodash cloneDeep / isEqual ────────────────────────────────────────
         // import { cloneDeep } from 'lodash' / 'lodash-es'
         // import { isEqual } from 'lodash' / 'lodash-es'
         if (src === 'lodash' || src === 'lodash-es') {
-          for (const specifier of node.specifiers) {
-            if (specifier.type !== 'ImportSpecifier') continue;
-            const name = specifier.imported.name;
+          for (const { name } of reference.named) {
             if (name === 'cloneDeep') {
               context.report({ node, messageId: 'preferClone', data: { method: 'lodash cloneDeep' } });
             } else if (name === 'isEqual') {