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

package/src/rules/no-legacy-query-import.js

@@ -19,6 +19,8 @@
  * the types this rule leaves alone), enable `@typescript-eslint/no-deprecated` alongside it.
  */
 
+const { MODULE_REFERENCE_SELECTOR, getModuleReference } = require('./internals/import-resolution');
+
 const QUERY_PACKAGE = '@ethlete/query';
 const DEFAULT_DOCS_BASE_URL = 'https://ethlete-sdk-docs.web.app';
 
@@ -48,7 +50,7 @@ const LEGACY_SYMBOLS = {
   queryStateErrorSignal: { to: '`query.error()`', docs: '/query/queries#the-query-object' },
   queryStateLoadingSignal: { to: '`query.loading()`', docs: '/query/queries#the-query-object' },
   validateWithV2Query: { to: '`validateWithQuery`', docs: '/query/errors#validating-against-the-server-as-the-user-types' }, // prettier-ignore
-  provideQueryClientForDevtools: { to: '`provideQueryDevtools()` from `@ethlete/query-devtools`, which registers every client at once', docs: '/query-devtools/' }, // prettier-ignore
+  provideQueryClientForDevtools: { to: '`provideQueryDevtools()` from `@ethlete/query`, which registers every client at once', docs: '/query-devtools/' }, // prettier-ignore
 };
 
 /** The current-system counterparts of the names the legacy system had to give up its half of. */
@@ -60,13 +62,6 @@ const V2_SUCCESSORS = {
   V2BearerAuthProvider: { to: '`createBearerAuthProvider` plus the secure creator templates', docs: '/query/auth' },
 };
 
-/** @param {any} specifier */
-const importedName = (specifier) => {
-  if (specifier.type !== 'ImportSpecifier') return null;
-
-  return specifier.imported.name ?? specifier.imported.value ?? null;
-};
-
 /** @param {string} name */
 const isV2Symbol = (name) => /^(V2|AnyV2)[A-Z]/.test(name);
 
@@ -98,16 +93,12 @@ const noLegacyQueryImport = {
     const docsBaseUrl = (options.docsBaseUrl ?? DEFAULT_DOCS_BASE_URL).replace(/\/$/, '');
 
     return {
-      ImportDeclaration(node) {
-        const declaration = /** @type {any} */ (node);
-
-        if (declaration.source.value !== QUERY_PACKAGE) return;
-
-        for (const specifier of declaration.specifiers) {
-          const name = importedName(specifier);
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
 
-          if (!name) continue;
+        if (reference?.source !== QUERY_PACKAGE) return;
 
+        for (const { name, node: specifier } of reference.named) {
           const successor = V2_SUCCESSORS[name] ?? LEGACY_SYMBOLS[name];
 
           if (successor) {

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

@@ -4,18 +4,18 @@
 /**
  * Disallows injecting Angular's LOCALE_ID token directly.
  *
- * @ethlete/core provides injectLocale() which wraps LOCALE_ID in a signal
- * and exposes helper utilities for locale-aware formatting.
+ * @ethlete/core provides a signal-based locale store for application code.
  *
  * BAD:
  *   inject(LOCALE_ID)
- *   import { LOCALE_ID } from '@angular/core';
  *
  * GOOD:
  *   import { injectLocale } from '@ethlete/core';
  *   const locale = injectLocale();
  */
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noLocaleId = {
   meta: {
@@ -26,30 +26,18 @@ const noLocaleId = {
     },
     messages: {
       noLocaleId:
-        "Do not inject 'LOCALE_ID' directly. Use 'injectLocale()' from '@ethlete/core' instead — it wraps LOCALE_ID and provides a clean, signal-compatible API.",
+        "Do not inject 'LOCALE_ID' directly. Use the signal-based 'injectLocale()' API from '@ethlete/core' for application locale state.",
     },
     schema: [],
   },
   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' });
         }
       },
-
-      ImportDeclaration(node) {
-        if (node.source.value !== '@angular/core') return;
-        for (const specifier of node.specifiers) {
-          if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'LOCALE_ID') {
-            context.report({ node, messageId: 'noLocaleId' });
-            return;
-          }
-        }
-      },
     };
   },
 };

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`.
@@ -79,6 +81,18 @@ const getMethodAliasInfo = (node) => {
   return { sourceName: obj.property.name, propName: callee.property.name };
 };
 
+const CONTRACT_METHOD_NAMES = new Set(['blur', 'focus', 'reset']);
+
+/**
+ * @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} */
 const noMemberAlias = {
   meta: {
@@ -119,6 +133,10 @@ const noMemberAlias = {
 
         const sourceName = obj.property.name;
         const propName = value.property.name;
+        const sourceMember = node.parent?.body?.find(
+          (member) => !member.computed && member.key?.type === 'Identifier' && member.key.name === sourceName,
+        );
+        if (node.accessibility === 'private' && sourceMember?.accessibility === 'private') return;
 
         context.report({
           node,
@@ -133,6 +151,9 @@ const noMemberAlias = {
 
         const info = getMethodAliasInfo(node);
         if (!info) return;
+        const classNode = node.parent?.parent;
+        if (node.override || classNode?.superClass || classNode?.implements?.length) 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 = {
@@ -39,6 +32,7 @@ const noPipeLogic = {
       MethodDefinition(node) {
         const key = /** @type {any} */ (node).key;
         if (key.type !== 'Identifier' || key.name !== 'transform') return;
+        if (!node.value?.body || node.value.body.type === 'TSEmptyBodyFunctionExpression') return;
 
         const classBody = node.parent;
         if (!classBody || classBody.type !== 'ClassBody') return;
@@ -46,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' });
       },
@@ -62,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-readonly-signal.js

@@ -50,6 +50,10 @@ const REACTIVE_APIS = new Set([
   'effect',
   'afterNextRender',
   'afterRender',
+  'afterRenderEffect',
+  'resource',
+  'rxResource',
+  'httpResource',
   // RxJS interop
   'toSignal',
   'toObservable',
@@ -83,7 +87,7 @@ const noReadonlySignal = {
         let apiName = null;
 
         // Simple call: signal(), input(), computed(), inject(), etc.
-        if (callee.type === 'Identifier' && REACTIVE_APIS.has(callee.name)) {
+        if (callee.type === 'Identifier' && (REACTIVE_APIS.has(callee.name) || callee.name.startsWith('inject'))) {
           apiName = callee.name;
         }
         // Member call: input.required(), outputFromObservable.something(), etc.
@@ -101,13 +105,17 @@ const noReadonlySignal = {
             messageId: 'noReadonlySignal',
             data: { name: apiName },
             fix(fixer) {
-              // Find and remove the "readonly" token
               const sourceCode = context.sourceCode;
               const tokens = sourceCode.getTokens(node);
-              const readonlyToken = tokens.find((t) => t.value === 'readonly');
+              const decoratorEnd = node.decorators?.at(-1)?.range[1] ?? node.range[0];
+              const readonlyToken = tokens.find(
+                (token) =>
+                  token.value === 'readonly' && token.range[0] >= decoratorEnd && token.range[1] <= node.key.range[0],
+              );
               if (!readonlyToken) return null;
-              // Remove "readonly " (including the trailing space)
-              return fixer.removeRange([readonlyToken.range[0], readonlyToken.range[1] + 1]);
+              const nextToken = sourceCode.getTokenAfter(readonlyToken);
+              const rangeEnd = nextToken ? nextToken.range[0] : readonlyToken.range[1];
+              return fixer.removeRange([readonlyToken.range[0], rangeEnd]);
             },
           });
         }

package/src/rules/no-redundant-internal.js

@@ -40,6 +40,25 @@ const getMemberKind = (node) => {
   return 'property';
 };
 
+/**
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('eslint').Rule.Node} node
+ * @param {import('eslint').AST.Token} comment
+ */
+const buildInternalTagFix = (sourceCode, node, comment) => {
+  const commentText = sourceCode.getText(comment);
+  const remainingText = commentText
+    .replace(/^\s*\/\*\*?\s*@internal\s*\*\/\s*$/u, '')
+    .replace(/^\s*\*\s*@internal\s*\r?\n/mu, '')
+    .replace(/@internal\b\s*/u, '');
+
+  if (remainingText.trim() === '') {
+    return (fixer) => fixer.removeRange([comment.range[0], node.range[0]]);
+  }
+
+  return (fixer) => fixer.replaceText(comment, remainingText);
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noRedundantInternal = {
   meta: {
@@ -68,7 +87,7 @@ const noRedundantInternal = {
         return;
       }
 
-      if (node.accessibility !== 'private' && node.accessibility !== 'protected') {
+      if (node.accessibility !== 'private') {
         return;
       }
 
@@ -80,7 +99,7 @@ const noRedundantInternal = {
           kind: getMemberKind(node),
           name: getMemberName(node),
         },
-        fix: (fixer) => fixer.removeRange([internalComment.range[0], node.range[0]]),
+        fix: buildInternalTagFix(sourceCode, node, internalComment),
       });
     };
 

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

@@ -1,6 +1,10 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName, isImportedAs } = require('./internals/import-resolution');
+
+const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+
 /**
  * Disallow explicit `changeDetection: ChangeDetectionStrategy.OnPush` on
  * `@Component` decorators. Since Angular 22, OnPush is the default change
@@ -68,50 +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) =>
+const isOnPushValue = (sourceCode, value) =>
   value.type === 'MemberExpression' &&
-  value.object.type === 'Identifier' &&
-  value.object.name === 'ChangeDetectionStrategy' &&
+  !value.computed &&
   value.property.type === 'Identifier' &&
-  value.property.name === 'OnPush';
-
-/**
- * Range that removes a property together with the comma that joins it to its
- * siblings (leading comma when it is the last property, otherwise trailing).
- *
- * @param {import('eslint').SourceCode} sourceCode
- * @param {any} metadata
- * @param {any} property
- */
-const getPropertyRemovalRange = (sourceCode, metadata, property) => {
-  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
-  const index = properties.indexOf(property);
-  const openingBrace = sourceCode.getFirstToken(metadata);
-  const closingBrace = sourceCode.getLastToken(metadata);
-
-  if (!openingBrace || !closingBrace) return property.range;
-  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
-  if (index < properties.length - 1) return [property.range[0], properties[index + 1].range[0]];
-
-  return [properties[index - 1].range[1], property.range[1]];
-};
+  value.property.name === 'OnPush' &&
+  isImportedAs(sourceCode, value.object, 'ChangeDetectionStrategy');
 
 /**
  * Range that removes a single named import specifier together with its comma.
@@ -126,6 +95,15 @@ const getSpecifierRemovalRange = (sourceCode, importNode, specifier) => {
 
   // Sole specifier of the whole import — drop the entire declaration.
   if (importNode.specifiers.length === 1) return importNode.range;
+  if (named.length === 1) {
+    const openingBrace = sourceCode.getTokenBefore(specifier, (token) => token.value === '{');
+    const closingBrace = sourceCode.getTokenAfter(specifier, (token) => token.value === '}');
+    const precedingComma = openingBrace ? sourceCode.getTokenBefore(openingBrace) : null;
+
+    if (openingBrace && closingBrace && precedingComma?.value === ',') {
+      return [precedingComma.range[0], closingBrace.range[1]];
+    }
+  }
   if (index < named.length - 1) return [specifier.range[0], named[index + 1].range[0]];
 
   return [named[index - 1].range[1], specifier.range[1]];
@@ -137,18 +115,10 @@ const getSpecifierRemovalRange = (sourceCode, importNode, specifier) => {
  * removing those properties leaves the import unused and safe to drop.
  *
  * @param {import('eslint').Scope.Reference} reference
+ * @param {Set<any>} removableIdentifiers
  */
-const isOnPushChangeDetectionReference = (reference) => {
-  const identifier = /** @type {any} */ (reference.identifier);
-  const member = identifier.parent;
-  if (!member || member.type !== 'MemberExpression' || member.object !== identifier) return false;
-  if (member.property.type !== 'Identifier' || member.property.name !== 'OnPush') return false;
-
-  const property = member.parent;
-  if (!property || property.type !== 'Property' || property.value !== member) return false;
-
-  return getPropertyName(property.key) === 'changeDetection';
-};
+const isOnPushChangeDetectionReference = (reference, removableIdentifiers) =>
+  removableIdentifiers.has(reference.identifier);
 
 /** @type {import('eslint').Rule.RuleModule} */
 const noRedundantOnPushChangeDetection = {
@@ -177,10 +147,11 @@ const noRedundantOnPushChangeDetection = {
     const sourceCode = context.sourceCode;
     /** @type {any} */
     let changeDetectionSpecifier = null;
+    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;
@@ -191,12 +162,13 @@ const noRedundantOnPushChangeDetection = {
         const property = metadata.properties.find(
           (entry) => entry.type === 'Property' && getPropertyName(entry.key) === 'changeDetection',
         );
-        if (!property || !isOnPushValue(property.value)) return;
+        if (!property || !isOnPushValue(sourceCode, property.value)) return;
+        removableIdentifiers.add(property.value.object);
 
         context.report({
           node: property,
           messageId: 'redundant',
-          fix: (fixer) => fixer.replaceTextRange(getPropertyRemovalRange(sourceCode, metadata, property), ''),
+          fix: (fixer) => fixer.replaceTextRange(getMetadataEntryRemovalRange(sourceCode, metadata, property), ''),
         });
       },
 
@@ -219,8 +191,12 @@ const noRedundantOnPushChangeDetection = {
         if (!changeDetectionSpecifier) return;
 
         const [variable] = sourceCode.getDeclaredVariables(changeDetectionSpecifier);
-        if (!variable || variable.references.length === 0) return;
-        if (!variable.references.every(isOnPushChangeDetectionReference)) return;
+        if (!variable) return;
+        if (
+          !variable.references.every((reference) => isOnPushChangeDetectionReference(reference, removableIdentifiers))
+        ) {
+          return;
+        }
 
         const importNode = changeDetectionSpecifier.parent;
         context.report({

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,10 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
+const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+
 /** @typedef {'Component' | 'Directive' | 'Pipe'} TDecoratorName */
 
 /**
@@ -12,40 +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;
-};
-
-/**
- * @param {import('eslint').SourceCode} sourceCode
- * @param {any} metadata
- * @param {any} property
- */
-const getRemovalRange = (sourceCode, metadata, property) => {
-  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
-  const propertyIndex = properties.indexOf(property);
-  const openingBrace = sourceCode.getFirstToken(metadata);
-  const closingBrace = sourceCode.getLastToken(metadata);
-
-  if (!openingBrace || !closingBrace) return property.range;
-  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
-  if (propertyIndex < properties.length - 1) return [property.range[0], properties[propertyIndex + 1].range[0]];
-
-  return [properties[propertyIndex - 1].range[1], property.range[1]];
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const noStandaloneFlag = {
   meta: {
@@ -65,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);
@@ -78,12 +48,13 @@ const noStandaloneFlag = {
         for (const property of metadata.properties) {
           if (property.type !== 'Property') continue;
           if (getPropertyName(property.key) !== 'standalone') continue;
+          if (property.value.type !== 'Literal' || property.value.value !== true) continue;
 
           context.report({
             node: property,
             messageId: 'noStandalone',
             fix(fixer) {
-              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+              return fixer.replaceTextRange(getMetadataEntryRemovalRange(sourceCode, metadata, property), '');
             },
           });
         }

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

@@ -173,6 +173,7 @@ const noTrivialReturnType = {
 
       const annotation = fn.returnType.typeAnnotation;
       if (!TRIVIAL_TYPES.has(annotation.type)) return;
+      if (fn.body.type !== 'BlockStatement') return;
       if (isSelfReferencing(fn)) return;
 
       const label = TRIVIAL_LABELS[annotation.type] ?? annotation.type;
@@ -190,6 +191,7 @@ const noTrivialReturnType = {
     return {
       ArrowFunctionExpression: checkReturnType,
       FunctionExpression: checkReturnType,
+      FunctionDeclaration: checkReturnType,
     };
   },
 };