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

package/src/rules/no-legacy-angular-decorators.js

@@ -379,6 +379,14 @@ const rule = {
                 const expression = anyNode.expression;
                 if (expression.type !== 'CallExpression' && expression.type !== 'Identifier') return null;
 
+                if (
+                  expression.type === 'CallExpression' &&
+                  expression.arguments.length > 0 &&
+                  (expression.arguments[0]?.type !== 'Literal' || typeof expression.arguments[0].value !== 'string')
+                ) {
+                  return null;
+                }
+
                 const bindingName =
                   expression.type === 'CallExpression'
                     ? expression.arguments[0]?.type === 'Literal' && typeof expression.arguments[0].value === 'string'

package/src/rules/no-legacy-prepare-without-injector.js

@@ -273,7 +273,12 @@ const noLegacyPrepareWithoutInjector = {
   },
   create(context) {
     const sourceCode = context.sourceCode;
-    const creatorPattern = new RegExp(context.options[0]?.creatorPattern ?? '^legacy');
+    let creatorPattern;
+    try {
+      creatorPattern = new RegExp(context.options[0]?.creatorPattern ?? '^legacy');
+    } catch {
+      creatorPattern = /^legacy/u;
+    }
     /** Names known to be legacy creators: imported under the naming convention, or declared locally. */
     const creatorNames = new Set();
 
@@ -297,38 +302,42 @@ const noLegacyPrepareWithoutInjector = {
      * @param {string[]} needed
      */
     const buildCoreImportFix = (needed) => {
-      const coreImport = /** @type {any} */ (
-        sourceCode.ast.body.find(
+      const coreImports = /** @type {any[]} */ (
+        sourceCode.ast.body.filter(
           (node) =>
             node.type === 'ImportDeclaration' &&
             node.source.type === 'Literal' &&
             node.source.value === '@angular/core',
         )
       );
+      const existing = new Set(
+        coreImports.flatMap((coreImport) =>
+          coreImport.specifiers
+            .filter((specifier) => specifier.type === 'ImportSpecifier' && coreImport.importKind !== 'type')
+            .map((specifier) => specifier.imported.name),
+        ),
+      );
+      const missing = needed.filter((name) => !existing.has(name));
+      if (missing.length === 0) return null;
+
+      const editableImport = coreImports.find(
+        (coreImport) =>
+          coreImport.importKind !== 'type' &&
+          coreImport.specifiers.length > 0 &&
+          coreImport.specifiers.every((specifier) => specifier.type === 'ImportSpecifier'),
+      );
 
-      if (!coreImport) {
+      if (!editableImport) {
         const imports = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
-        const lastImport = imports[imports.length - 1];
-        const text = `import { ${needed.join(', ')} } from '@angular/core';`;
+        const lastImport = coreImports.at(-1) ?? imports.at(-1);
+        const text = `import { ${missing.join(', ')} } from '@angular/core';`;
 
         return lastImport
           ? /** @param {any} fixer */ (fixer) => fixer.insertTextAfter(lastImport, `\n${text}`)
           : /** @param {any} fixer */ (fixer) => fixer.insertTextBefore(sourceCode.ast.body[0], `${text}\n\n`);
       }
 
-      const specifiers = coreImport.specifiers ?? [];
-
-      if (specifiers.some(/** @param {any} specifier */ (specifier) => specifier.type !== 'ImportSpecifier')) {
-        return null;
-      }
-
-      const existing = new Set(specifiers.map(/** @param {any} specifier */ (specifier) => specifier.imported.name));
-      const missing = needed.filter((name) => !existing.has(name));
-      const lastSpecifier = specifiers[specifiers.length - 1];
-
-      if (missing.length === 0 || !lastSpecifier) {
-        return null;
-      }
+      const lastSpecifier = editableImport.specifiers.at(-1);
 
       return /** @param {any} fixer */ (fixer) => fixer.insertTextAfter(lastSpecifier, `, ${missing.join(', ')}`);
     };
@@ -368,12 +377,6 @@ const noLegacyPrepareWithoutInjector = {
           );
       }
 
-      // `prepare(args)` - spreading is the only way to keep whatever the variable holds.
-      if (argument.type === 'Identifier' || argument.type === 'MemberExpression') {
-        return /** @param {any} fixer */ (fixer) =>
-          fixer.replaceText(argument, `{ ...${sourceCode.getText(argument)}, ${injectorProperty} }`);
-      }
-
       return null;
     };
 
@@ -457,7 +460,20 @@ const noLegacyPrepareWithoutInjector = {
 
         const classBody = findEnclosingClassBody(node);
         const existingInjector = classBody ? findInjectorMemberName(classBody) : null;
-        const injectorName = existingInjector ?? 'injector';
+        const declaredNames = new Set(
+          classBody?.body
+            .map((member) => (member.key?.type === 'Identifier' ? member.key.name : null))
+            .filter(Boolean) ?? [],
+        );
+        let injectorName = existingInjector ?? 'injector';
+        if (!existingInjector && declaredNames.has(injectorName)) {
+          injectorName = 'queryInjector';
+          let suffix = 2;
+          while (declaredNames.has(injectorName)) {
+            injectorName = `queryInjector${suffix}`;
+            suffix += 1;
+          }
+        }
         const argumentFix = classBody ? buildArgumentFix(node, `this.${injectorName}`) : null;
 
         context.report({

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

@@ -48,7 +48,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. */

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

@@ -4,12 +4,10 @@
 /**
  * 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';
@@ -26,7 +24,7 @@ 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: [],
   },
@@ -40,16 +38,6 @@ const noLocaleId = {
           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

@@ -79,6 +79,16 @@ const getMethodAliasInfo = (node) => {
   return { sourceName: obj.property.name, propName: callee.property.name };
 };
 
+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');
+  }) ?? false;
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noMemberAlias = {
   meta: {
@@ -119,6 +129,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 +147,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(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-observers.js

@@ -73,7 +73,10 @@ const noNativeObservers = {
         if (node.callee.type !== 'Identifier') return;
 
         const name = node.callee.name;
-        if (!(name in OBSERVER_ALTERNATIVES)) return;
+
+        // hasOwn, not `in`: `new constructor()` / `new toString()` would otherwise match an
+        // inherited Object.prototype key and read a function where an entry is expected
+        if (!Object.hasOwn(OBSERVER_ALTERNATIVES, name)) return;
 
         const info = OBSERVER_ALTERNATIVES[name];
 

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

@@ -39,6 +39,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;

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,8 @@
 // @ts-check
 'use strict';
 
+const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+
 /**
  * Disallow explicit `changeDetection: ChangeDetectionStrategy.OnPush` on
  * `@Component` decorators. Since Angular 22, OnPush is the default change
@@ -85,34 +87,13 @@ const isComponentDecorator = (node) => {
 /**
  * @param {any} value
  */
-const isOnPushValue = (value) =>
+const isOnPushValue = (value, localName) =>
   value.type === 'MemberExpression' &&
   value.object.type === 'Identifier' &&
-  value.object.name === 'ChangeDetectionStrategy' &&
+  value.object.name === localName &&
   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]];
-};
-
 /**
  * Range that removes a single named import specifier together with its comma.
  *
@@ -126,6 +107,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 +127,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,6 +159,8 @@ const noRedundantOnPushChangeDetection = {
     const sourceCode = context.sourceCode;
     /** @type {any} */
     let changeDetectionSpecifier = null;
+    let changeDetectionLocalName = 'ChangeDetectionStrategy';
+    const removableIdentifiers = new Set();
 
     return {
       Decorator(node) {
@@ -191,12 +175,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(property.value, changeDetectionLocalName)) 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), ''),
         });
       },
 
@@ -210,6 +195,7 @@ const noRedundantOnPushChangeDetection = {
             specifier.imported.name === 'ChangeDetectionStrategy'
           ) {
             changeDetectionSpecifier = specifier;
+            changeDetectionLocalName = specifier.local.name;
             return;
           }
         }
@@ -219,8 +205,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-standalone-flag.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+
 /** @typedef {'Component' | 'Directive' | 'Pipe'} TDecoratorName */
 
 /**
@@ -28,24 +30,6 @@ const getDecoratorName = (node) => {
   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: {
@@ -78,12 +62,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-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;

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

@@ -124,6 +124,9 @@ const noTrivialWrapperMethod = {
         const methodName = node.key.type === 'Identifier' ? node.key.name : null;
         if (!methodName) 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(node)) return;
 
         const callee = callExpr.callee;

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

@@ -38,16 +38,23 @@ const noTypedInjectedElementRef = {
 
         const src = context.sourceCode;
         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' &&
+          injectType.typeName?.type === 'Identifier' &&
+          injectType.typeName.name === '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 +64,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 {

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

@@ -126,6 +126,7 @@ const noUnusedClassMember = {
      *
      * @type {Array<{
      *   classBody: import('eslint').Rule.Node,
+     *   isAbstract: boolean,
      *   isComponent: boolean,
      *   isAngularClass: boolean,
      *   hostBound: Set<string>,
@@ -145,6 +146,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 +155,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);
       }
@@ -168,6 +171,7 @@ const noUnusedClassMember = {
         const hostBound = getHostBoundMembers(classNode);
         classStack.push({
           classBody: node,
+          isAbstract: classNode.abstract === true,
           isComponent,
           isAngularClass,
           hostBound,
@@ -190,17 +194,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);
+          }
+        }
       },
     };
   },