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

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
@@ -124,7 +118,10 @@ const noTrivialWrapperMethod = {
         const methodName = node.key.type === 'Identifier' ? node.key.name : null;
         if (!methodName) return;
 
-        if (CONTRACT_METHOD_NAMES.has(methodName) && isInAngularClass(node)) return;
+        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(context.sourceCode, node)) return;
 
         const callee = callExpr.callee;
         const targetName =

package/src/rules/no-type-only-import.js

@@ -31,8 +31,13 @@ const noTypeOnlyImport = {
             messageId: 'noTypeImportDeclaration',
             data: { specifiers, source },
             fix(fixer) {
-              const specifierText = node.specifiers.map((s) => s.local.name).join(', ');
-              return fixer.replaceText(node, `import { ${specifierText} } from '${source}';`);
+              const sourceCode = context.sourceCode;
+              const importToken = sourceCode.getFirstToken(node);
+              const typeToken = importToken ? sourceCode.getTokenAfter(importToken) : null;
+              const nextToken = typeToken ? sourceCode.getTokenAfter(typeToken) : null;
+
+              if (typeToken?.value !== 'type' || !nextToken) return null;
+              return fixer.removeRange([typeToken.range[0], nextToken.range[0]]);
             },
           });
 

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,34 +22,36 @@ 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 hasInjectTypeParam =
-          existingTypeParams && existingTypeParams.params && existingTypeParams.params.length > 0;
+        const injectType = existingTypeParams?.params?.[0];
+        const hasTypedElementRef =
+          existingTypeParams?.params?.length === 1 &&
+          injectType?.type === 'TSTypeReference' &&
+          src.getText(injectType.typeName) === elementRef &&
+          (injectType.typeArguments || injectType.typeParameters)?.params?.length > 0;
 
-        if (isPlainElementRef && !hasInjectTypeParam) {
+        if (isPlainElementRef && !hasTypedElementRef) {
           // inject(ElementRef) → inject<ElementRef<HTMLElement>>(ElementRef)
           context.report({
             node,
             messageId: 'missingGeneric',
             fix(fixer) {
-              return fixer.insertTextAfter(node.callee, '<ElementRef<HTMLElement>>');
+              return existingTypeParams
+                ? fixer.replaceText(existingTypeParams, `<${elementRef}<HTMLElement>>`)
+                : fixer.insertTextAfter(node.callee, `<${elementRef}<HTMLElement>>`);
             },
           });
           return;
@@ -57,16 +61,16 @@ const noTypedInjectedElementRef = {
           // Capture the type args text from the token, e.g. "<HTMLElement>"
           const tokenTypeParamText = src.getText(firstArg.typeParameters || firstArg.typeArguments);
 
-          if (!hasInjectTypeParam) {
+          if (!hasTypedElementRef) {
             // inject(ElementRef<HTMLElement>) → inject<ElementRef<HTMLElement>>(ElementRef)
             context.report({
               node,
               messageId: 'missingGeneric',
               fix(fixer) {
-                return [
-                  fixer.insertTextAfter(node.callee, `<ElementRef${tokenTypeParamText}>`),
-                  fixer.replaceText(firstArg, 'ElementRef'),
-                ];
+                const typeFix = existingTypeParams
+                  ? fixer.replaceText(existingTypeParams, `<${elementRef}${tokenTypeParamText}>`)
+                  : fixer.insertTextAfter(node.callee, `<${elementRef}${tokenTypeParamText}>`);
+                return [typeFix, fixer.replaceText(firstArg, elementRef)];
               },
             });
           } else {
@@ -75,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;
@@ -126,6 +123,7 @@ const noUnusedClassMember = {
      *
      * @type {Array<{
      *   classBody: import('eslint').Rule.Node,
+     *   isAbstract: boolean,
      *   isComponent: boolean,
      *   isAngularClass: boolean,
      *   hostBound: Set<string>,
@@ -145,6 +143,7 @@ const noUnusedClassMember = {
       if (node.parent !== frame.classBody) return;
 
       if (node.static) return;
+      if (node.override || node.abstract || node.decorators?.length) return;
 
       const key = node.key;
       if (!key || key.type !== 'Identifier') return;
@@ -153,9 +152,10 @@ const noUnusedClassMember = {
       const name = key.name;
       const accessibility = node.accessibility;
       const { isComponent, isAngularClass, hostBound } = frame;
+      if (frame.isAbstract && accessibility === 'protected') return;
 
       if (accessibility === 'private') {
-        frame.candidates.set(name, node);
+        if (!hostBound.has(name)) frame.candidates.set(name, node);
       } else if (accessibility === 'protected' && isAngularClass && !isComponent) {
         if (!hostBound.has(name)) frame.candidates.set(name, node);
       }
@@ -164,10 +164,11 @@ 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,
+          isAbstract: classNode.abstract === true,
           isComponent,
           isAngularClass,
           hostBound,
@@ -190,17 +191,36 @@ const noUnusedClassMember = {
       MethodDefinition: registerMember,
 
       MemberExpression(node) {
-        // Only care about `this.name` (non-computed direct property access)
-        if (node.computed) return;
         if (node.object?.type !== 'ThisExpression') return;
-        if (node.property?.type !== 'Identifier') return;
+        const name =
+          !node.computed && node.property?.type === 'Identifier'
+            ? node.property.name
+            : node.computed && node.property?.type === 'Literal' && typeof node.property.value === 'string'
+              ? node.property.value
+              : null;
+        if (!name) return;
 
         // Mark used in the innermost class frame. Arrow functions don't push a
         // new frame so they correctly share the enclosing class's `this`.
         // Regular nested classes push a new frame so their `this.x` won't
         // accidentally mark an outer class member as used.
         const frame = classStack[classStack.length - 1];
-        if (frame) frame.usedNames.add(node.property.name);
+        if (frame) frame.usedNames.add(name);
+      },
+
+      VariableDeclarator(node) {
+        if (node.init?.type !== 'ThisExpression' || node.id?.type !== 'ObjectPattern') return;
+
+        const frame = classStack[classStack.length - 1];
+        if (!frame) return;
+
+        for (const property of node.id.properties) {
+          if (property.type !== 'Property') continue;
+          if (property.key.type === 'Identifier') frame.usedNames.add(property.key.name);
+          if (property.key.type === 'Literal' && typeof property.key.value === 'string') {
+            frame.usedNames.add(property.key.value);
+          }
+        }
       },
     };
   },

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') {

package/src/rules/prefer-concise-angular-host-directives.js

@@ -1,29 +1,16 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 /** @typedef {import('estree').Property & { range: [number, number] }} TPropertyNode */
 /** @typedef {import('estree').ArrayExpression & { elements: Array<import('estree').Expression | import('estree').SpreadElement | null> }} TArrayExpressionNode */
 /** @typedef {import('estree').ObjectExpression & { properties: Array<TPropertyNode | import('estree').SpreadElement> }} TObjectExpressionNode */
-/** @typedef {{ hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; segmentText: string }} TPropertyEntry */
+/** @typedef {{ bodyText: string; hasComma: boolean; originalIndex: number; orderIndex: number; property: TPropertyNode; trailingText: string }} TPropertyEntry */
 
 const HOST_DIRECTIVE_PROPERTY_ORDER = ['directive', 'inputs', 'outputs'];
 
-/**
- * @param {import('eslint').Rule.Node} node
- */
-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;
-};
-
 /**
  * @param {import('estree').Property['key']} key
  */
@@ -98,22 +85,24 @@ const buildSortedObjectText = (node, sourceCode) => {
     /** @param {TPropertyNode} property @param {number} originalIndex @returns {TPropertyEntry} */
     (property, originalIndex) => {
       const tokenAfter = sourceCode.getTokenAfter(property);
-      const hasComma = Boolean(tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',');
-      const segmentEnd = hasComma && tokenAfter ? tokenAfter.range[0] : property.range[1];
-      const segmentText = sourceCode.text.slice(segmentStart, segmentEnd);
+      const comma = tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ',' ? tokenAfter : null;
+      const bodyText = sourceCode.text.slice(segmentStart, property.range[1]);
+      const afterProperty = comma ?? property;
+      const trailingComment = sourceCode
+        .getCommentsAfter(afterProperty)
+        .filter((comment) => comment.loc?.start.line === property.loc?.end.line)
+        .at(-1);
+      const trailingEnd = trailingComment?.range ? trailingComment.range[1] : afterProperty.range[1];
 
-      if (hasComma && tokenAfter) {
-        segmentStart = tokenAfter.range[1];
-      } else {
-        segmentStart = property.range[1];
-      }
+      segmentStart = trailingEnd;
 
       return {
-        hasComma,
+        bodyText,
+        hasComma: Boolean(comma),
         originalIndex,
         orderIndex: orderIndexMap.get(getPropertyName(property.key)) ?? HOST_DIRECTIVE_PROPERTY_ORDER.length,
         property,
-        segmentText,
+        trailingText: trailingComment ? sourceCode.text.slice(afterProperty.range[1], trailingEnd) : '',
       };
     },
   );
@@ -131,7 +120,10 @@ const buildSortedObjectText = (node, sourceCode) => {
   return (
     '{' +
     sortedEntries
-      .map((entry, index) => `${entry.segmentText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}`)
+      .map(
+        (entry, index) =>
+          `${entry.bodyText}${index < sortedEntries.length - 1 || trailingComma ? ',' : ''}${entry.trailingText}`,
+      )
       .join('') +
     suffix +
     '}'
@@ -182,7 +174,7 @@ const preferConciseAngularHostDirectives = {
 
     return {
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const hostDirectives = getHostDirectivesArray(decoratorName, node);
@@ -199,10 +191,12 @@ const preferConciseAngularHostDirectives = {
             const directiveValue = getDirectiveValueNode(config);
             if (!directiveValue) continue;
 
+            const hasComments = sourceCode.getCommentsInside(config).length > 0;
+
             context.report({
               node: config,
               messageId: 'preferShorthand',
-              fix: (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
+              fix: hasComments ? null : (fixer) => fixer.replaceText(config, sourceCode.getText(directiveValue)),
             });
 
             continue;

package/src/rules/prefer-concise-angular-style-metadata.js

@@ -1,24 +1,11 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {import('estree').Property} TPropertyNode */
 /** @typedef {import('estree').Expression | import('estree').SpreadElement | null} TArrayElement */
 
-/**
- * @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('estree').Property['key']} key
  */
@@ -62,7 +49,7 @@ const preferConciseAngularStyleMetadata = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        if (!isComponentDecorator(node)) return;
+        if (getAngularDecoratorName(context.sourceCode, node) !== 'Component') return;
 
         const decorator = /** @type {any} */ (node);
         const expression = decorator.expression;
@@ -71,11 +58,16 @@ const preferConciseAngularStyleMetadata = {
         const metadata = expression.arguments[0];
         if (!metadata || metadata.type !== 'ObjectExpression') return;
 
+        const hasStyleUrl = metadata.properties.some(
+          (/** @type {any} */ property) => property.type === 'Property' && getPropertyName(property.key) === 'styleUrl',
+        );
+
         for (const property of metadata.properties) {
           if (property.type !== 'Property') continue;
 
           const propertyName = getPropertyName(property.key);
           if (propertyName !== 'styleUrls' && propertyName !== 'styles') continue;
+          if (propertyName === 'styleUrls' && hasStyleUrl) continue;
 
           const singleElement = getSingleArrayElement(property);
           if (!singleElement) continue;

package/src/rules/prefer-element-dimensions.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Prefers signalElementDimensions / signalHostElementDimensions from @ethlete/core
  * over imperatively reading element size properties inside reactive contexts
@@ -46,10 +48,11 @@ const ELEMENT_SIZE_METHODS = new Set(['getBoundingClientRect', 'getClientRects']
 /**
  * Returns the name of the wrapping reactive context ('effect' | 'computed') if
  * the node is inside one, crossing exactly one function boundary.
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.Node} node
  * @returns {string | null}
  */
-const getReactiveContext = (node) => {
+const getReactiveContext = (sourceCode, node) => {
   let crossedFunctionBoundary = false;
   let current = node.parent;
 
@@ -58,13 +61,9 @@ const getReactiveContext = (node) => {
       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(sourceCode, current.callee, ANGULAR_CORE);
+      if (calleeName === 'effect' || calleeName === 'computed') return calleeName;
     }
 
     current = current.parent;
@@ -95,7 +94,7 @@ const preferElementDimensions = {
         if (node.property.type !== 'Identifier') return;
         if (!ELEMENT_SIZE_PROPS.has(node.property.name)) return;
 
-        const reactiveCtx = getReactiveContext(node);
+        const reactiveCtx = getReactiveContext(context.sourceCode, node);
         if (!reactiveCtx) return;
 
         context.report({
@@ -112,7 +111,7 @@ const preferElementDimensions = {
         if (callee.property.type !== 'Identifier') return;
         if (!ELEMENT_SIZE_METHODS.has(callee.property.name)) return;
 
-        const reactiveCtx = getReactiveContext(node);
+        const reactiveCtx = getReactiveContext(context.sourceCode, node);
         if (!reactiveCtx) return;
 
         context.report({

package/src/rules/prefer-linked-signal.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /**
  * Prefer linkedSignal over setting a signal inside an effect().
  *
@@ -44,9 +46,10 @@
  *    effect is performing side effects alongside the signal write, so they are
  *    not flagged either.
  *
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {import('eslint').Rule.Node} node The `.set()` CallExpression node
  */
-const isPureSetInDirectEffectCallback = (node) => {
+const isPureSetInDirectEffectCallback = (sourceCode, node) => {
   // Find the immediate enclosing function (cross exactly one boundary).
   let current = node.parent;
   let immediateFunction = null;
@@ -66,8 +69,7 @@ const isPureSetInDirectEffectCallback = (node) => {
   if (
     !funcParent ||
     funcParent.type !== 'CallExpression' ||
-    funcParent.callee.type !== 'Identifier' ||
-    funcParent.callee.name !== 'effect' ||
+    !isImportedAs(sourceCode, funcParent.callee, 'effect') ||
     funcParent.arguments[0] !== immediateFunction
   ) {
     return false;
@@ -112,7 +114,8 @@ const preferLinkedSignal = {
           callee.type === 'MemberExpression' &&
           callee.property.type === 'Identifier' &&
           callee.property.name === 'set' &&
-          isPureSetInDirectEffectCallback(node)
+          node.arguments.length === 1 &&
+          isPureSetInDirectEffectCallback(context.sourceCode, node)
         ) {
           context.report({ node, messageId: 'preferLinkedSignal' });
         }

package/src/rules/prefer-match-media.js

@@ -6,7 +6,7 @@
  * calling window.matchMedia() directly or using Angular CDK's BreakpointObserver.
  *
  * The utilities:
- * - Return reactive signals that update when the media query result changes
+ * - Offer both one-shot boolean reads and reactive signals
  * - Are SSR-safe (no window access during server rendering)
  * - Are automatically cleaned up when the component is destroyed
  *
@@ -37,6 +37,10 @@
  *   // … etc. All from @ethlete/core.
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference, isImportedAs } = require('./internals/import-resolution');
+
+const CDK_LAYOUT = '@angular/cdk/layout';
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferMatchMedia = {
   meta: {
@@ -47,7 +51,7 @@ const preferMatchMedia = {
     },
     messages: {
       preferMatchMedia:
-        "Avoid 'window.matchMedia()' directly. Use 'injectMediaQueryIsMatched(query)' or a pre-built helper (injectCanHover, injectHasTouchInput, injectIsPortrait, injectBreakpointIsMatched, …) from '@ethlete/core' — they return reactive signals and are SSR-safe.",
+        "Avoid 'window.matchMedia()' directly. Use 'injectMediaQueryIsMatched(query)' for a one-shot SSR-safe boolean, or 'injectObserveMediaQuery(query)' when the result must update reactively.",
       noBreakpointObserver:
         "Do not use Angular CDK's 'BreakpointObserver' directly. Use 'injectBreakpointObserver()' from '@ethlete/core' instead, which wraps it with a reactive signal API and proper DI scoping.",
     },
@@ -72,25 +76,17 @@ const preferMatchMedia = {
 
         // ── inject(BreakpointObserver) ────────────────────────────────────────
         if (
-          callee.type === 'Identifier' &&
-          callee.name === 'inject' &&
-          node.arguments[0]?.type === 'Identifier' &&
-          node.arguments[0].name === 'BreakpointObserver'
+          isImportedAs(context.sourceCode, callee, 'inject') &&
+          isImportedAs(context.sourceCode, node.arguments[0], 'BreakpointObserver', CDK_LAYOUT)
         ) {
           context.report({ node, messageId: 'noBreakpointObserver' });
         }
       },
 
-      ImportDeclaration(node) {
-        // ── import { BreakpointObserver } from '@angular/cdk/layout' ─────────
-        if (node.source.value !== '@angular/cdk/layout') return;
-        const hasBreakpointObserver = node.specifiers.some(
-          (s) =>
-            s.type === 'ImportSpecifier' &&
-            s.imported.type === 'Identifier' &&
-            s.imported.name === 'BreakpointObserver',
-        );
-        if (hasBreakpointObserver) {
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        if (reference?.source !== CDK_LAYOUT) return;
+        if (reference.named.some((entry) => entry.name === 'BreakpointObserver')) {
           context.report({ node, messageId: 'noBreakpointObserver' });
         }
       },

package/src/rules/prefer-present-tense-output.js

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

package/src/rules/prefer-rxjs-timer.js

@@ -19,6 +19,8 @@
  *   fromEvent(element, 'click').pipe(takeUntilDestroyed()).subscribe(handler);
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const preferRxjsTimer = {
   meta: {
@@ -47,7 +49,7 @@ const preferRxjsTimer = {
         const { callee } = node;
 
         // ── Global timer calls ────────────────────────────────────────────────
-        if (callee.type === 'Identifier') {
+        if (isGlobalReference(context.sourceCode, callee)) {
           const { name } = callee;
           if (name === 'setTimeout') {
             context.report({ node, messageId: 'preferTimer' });