@ethlete/eslint-plugin 1.0.0-next.25 → 1.0.0-next.26

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

@@ -92,6 +92,56 @@ const noLegacyQueryImport = {
     const options = context.options[0] ?? {};
     const docsBaseUrl = (options.docsBaseUrl ?? DEFAULT_DOCS_BASE_URL).replace(/\/$/, '');
 
+    /**
+     * @param {string} name
+     * @param {any} node
+     */
+    const reportName = (name, node) => {
+      const successor =
+        (Object.hasOwn(V2_SUCCESSORS, name) ? V2_SUCCESSORS[name] : null) ??
+        (Object.hasOwn(LEGACY_SYMBOLS, name) ? LEGACY_SYMBOLS[name] : null);
+
+      if (successor) {
+        context.report({
+          node,
+          messageId: 'successor',
+          data: { name, to: successor.to, docs: `${docsBaseUrl}${successor.docs}` },
+        });
+
+        return;
+      }
+
+      if (!isV2Symbol(name)) return;
+
+      context.report({
+        node,
+        messageId: 'legacySystem',
+        data: { name, docs: `${docsBaseUrl}/query/migrating-from-v2` },
+      });
+    };
+
+    /**
+     * @param {any} identifier
+     * @returns {{ name: string, node: any } | null}
+     */
+    const getNamespaceMember = (identifier) => {
+      const parent = identifier.parent;
+
+      if (parent?.type === 'MemberExpression' && parent.object === identifier) {
+        if (!parent.computed && parent.property.type === 'Identifier')
+          return { name: parent.property.name, node: parent };
+        if (parent.property.type === 'Literal' && typeof parent.property.value === 'string') {
+          return { name: parent.property.value, node: parent };
+        }
+      }
+
+      if (parent?.type === 'TSQualifiedName' && parent.left === identifier) {
+        return { name: parent.right.name, node: parent };
+      }
+
+      return null;
+    };
+
     return {
       [MODULE_REFERENCE_SELECTOR](node) {
         const reference = getModuleReference(node);
@@ -99,25 +149,20 @@ const noLegacyQueryImport = {
         if (reference?.source !== QUERY_PACKAGE) return;
 
         for (const { name, node: specifier } of reference.named) {
-          const successor = V2_SUCCESSORS[name] ?? LEGACY_SYMBOLS[name];
-
-          if (successor) {
-            context.report({
-              node: specifier,
-              messageId: 'successor',
-              data: { name, to: successor.to, docs: `${docsBaseUrl}${successor.docs}` },
-            });
+          reportName(name, specifier);
+        }
 
-            continue;
-          }
+        if (node.type !== 'ImportDeclaration') return;
 
-          if (!isV2Symbol(name)) continue;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== 'ImportNamespaceSpecifier') continue;
 
-          context.report({
-            node: specifier,
-            messageId: 'legacySystem',
-            data: { name, docs: `${docsBaseUrl}/query/migrating-from-v2` },
-          });
+          for (const variable of context.sourceCode.getDeclaredVariables(specifier)) {
+            for (const variableReference of variable.references) {
+              const member = getNamespaceMember(variableReference.identifier);
+              if (member) reportName(member.name, member.node);
+            }
+          }
         }
       },
     };

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

@@ -63,11 +63,9 @@ const getMethodAliasInfo = (node) => {
   }
   if (!callExpr || callExpr.type !== 'CallExpression') return null;
 
-  // Must have zero arguments
   if (callExpr.arguments.length !== 0) return null;
 
   const callee = callExpr.callee;
-  // callee must be: this.something.method
   if (callee.type !== 'MemberExpression') return null;
   if (callee.computed) return null;
   if (callee.property.type !== 'Identifier') return null;
@@ -115,14 +113,11 @@ const noMemberAlias = {
         const value = node.value;
         if (!value) return;
 
-        // Must be: this.something.property
         if (value.type !== 'MemberExpression') return;
-        // Outer property must be a plain identifier (not computed)
         if (value.computed) return;
         if (value.property.type !== 'Identifier') return;
 
         const obj = value.object;
-        // Object must itself be: this.something
         if (obj.type !== 'MemberExpression') return;
         if (obj.computed) return;
         if (obj.object.type !== 'ThisExpression') return;

package/src/rules/no-native-observers.js

@@ -31,6 +31,8 @@
  *   signalHostElementDimensions()
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /**
  * Maps Observer constructor names to their @ethlete/core signal equivalents.
  * @type {Record<string, { alternatives: string[], from: string } | null>}
@@ -51,6 +53,8 @@ const OBSERVER_ALTERNATIVES = {
   PerformanceObserver: null,
 };
 
+const GLOBAL_OBJECTS = new Set(['window', 'globalThis', 'self']);
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noNativeObservers = {
   meta: {
@@ -68,35 +72,96 @@ const noNativeObservers = {
     schema: [],
   },
   create(context) {
-    return {
-      NewExpression(node) {
-        if (node.callee.type !== 'Identifier') return;
+    const { sourceCode } = context;
+
+    /**
+     * @param {any} node
+     * @param {Set<any>} seen
+     * @returns {string | null}
+     */
+    const resolveObserverName = (node, seen = new Set()) => {
+      if (!node || seen.has(node)) return null;
+      seen.add(node);
+
+      if (node.type === 'TSNonNullExpression' || node.type === 'TSAsExpression') {
+        return resolveObserverName(node.expression, seen);
+      }
 
-        const name = node.callee.name;
+      if (node.type === 'MemberExpression') {
+        if (node.computed || node.property.type !== 'Identifier') return null;
+        if (!Object.hasOwn(OBSERVER_ALTERNATIVES, node.property.name)) return null;
 
+        return node.object.type === 'Identifier' &&
+          GLOBAL_OBJECTS.has(node.object.name) &&
+          isGlobalReference(sourceCode, node.object)
+          ? node.property.name
+          : null;
+      }
+
+      if (node.type !== 'Identifier') return null;
+
+      if (isGlobalReference(sourceCode, node)) {
         // 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];
-
-        if (info) {
-          context.report({
-            node,
-            messageId: 'useSignalUtil',
-            data: {
-              observer: name,
-              alternatives: info.alternatives.join(' or '),
-              from: info.from,
-            },
-          });
-        } else {
-          context.report({
-            node,
-            messageId: 'avoidObserver',
-            data: { observer: name },
-          });
+        return Object.hasOwn(OBSERVER_ALTERNATIVES, node.name) ? node.name : null;
+      }
+
+      /** @type {import('eslint').Scope.Scope | null} */
+      let scope = sourceCode.getScope(node);
+
+      while (scope) {
+        const variable = scope.set.get(node.name);
+
+        if (variable) {
+          const definition = /** @type {any} */ (variable.defs[0]);
+
+          return definition?.type === 'Variable' && definition.parent.kind === 'const'
+            ? resolveObserverName(definition.node.init, seen)
+            : null;
         }
+
+        scope = scope.upper;
+      }
+
+      return null;
+    };
+
+    /**
+     * @param {any} node
+     * @param {any} callee
+     */
+    const check = (node, callee) => {
+      const name = resolveObserverName(callee);
+
+      if (!name) return;
+
+      const info = OBSERVER_ALTERNATIVES[name];
+
+      if (info) {
+        context.report({
+          node,
+          messageId: 'useSignalUtil',
+          data: {
+            observer: name,
+            alternatives: info.alternatives.join(' or '),
+            from: info.from,
+          },
+        });
+      } else {
+        context.report({
+          node,
+          messageId: 'avoidObserver',
+          data: { observer: name },
+        });
+      }
+    };
+
+    return {
+      NewExpression(node) {
+        check(node, node.callee);
+      },
+      'ClassDeclaration, ClassExpression'(node) {
+        if (node.superClass) check(node.superClass, node.superClass);
       },
     };
   },

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

@@ -19,6 +19,7 @@ const noPipeLogic = {
     docs: {
       description:
         'Pipes must not contain logic in the transform method. Extract to a utility function and assign it: `transform = myUtil;`',
+      recommended: true,
     },
     messages: {
       noLogicInTransform:
@@ -28,7 +29,6 @@ const noPipeLogic = {
   },
   create(context) {
     return {
-      // Case 1: transform() { ... } — method with a body
       MethodDefinition(node) {
         const key = /** @type {any} */ (node).key;
         if (key.type !== 'Identifier' || key.name !== 'transform') return;
@@ -45,7 +45,6 @@ const noPipeLogic = {
         context.report({ node, messageId: 'noLogicInTransform' });
       },
 
-      // Case 2: transform = () => { ... } or transform = function() { ... }
       PropertyDefinition(node) {
         const key = /** @type {any} */ (node).key;
         if (key.type !== 'Identifier' || key.name !== 'transform') return;

package/src/rules/no-readonly-signal.js

@@ -77,7 +77,6 @@ const noReadonlySignal = {
   create(context) {
     return {
       PropertyDefinition(node) {
-        // Only flag when readonly is set
         if (!node.readonly) return;
 
         const init = node.value;
@@ -86,12 +85,9 @@ const noReadonlySignal = {
         const { callee } = init;
         let apiName = null;
 
-        // Simple call: signal(), input(), computed(), inject(), etc.
         if (callee.type === 'Identifier' && (REACTIVE_APIS.has(callee.name) || callee.name.startsWith('inject'))) {
           apiName = callee.name;
-        }
-        // Member call: input.required(), outputFromObservable.something(), etc.
-        else if (
+        } else if (
           callee.type === 'MemberExpression' &&
           callee.object.type === 'Identifier' &&
           REACTIVE_APIS.has(callee.object.name)

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

@@ -28,6 +28,7 @@ const getAttachedInternalComment = (sourceCode, node) => {
 const getMemberName = (node) => {
   if (node.key?.type === 'Identifier') return node.key.name;
   if (node.key?.type === 'Literal' && typeof node.key.value === 'string') return node.key.value;
+  if (node.key?.type === 'PrivateIdentifier') return `#${node.key.name}`;
 
   return 'member';
 };
@@ -87,7 +88,9 @@ const noRedundantInternal = {
         return;
       }
 
-      if (node.accessibility !== 'private') {
+      const isPrivateIdentifier = node.key?.type === 'PrivateIdentifier';
+
+      if (node.accessibility !== 'private' && !isPrivateIdentifier) {
         return;
       }
 
@@ -95,7 +98,7 @@ const noRedundantInternal = {
         node: internalComment,
         messageId: 'redundantInternal',
         data: {
-          accessibility: node.accessibility,
+          accessibility: 'private',
           kind: getMemberKind(node),
           name: getMemberName(node),
         },

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

@@ -3,7 +3,8 @@
 
 const { getAngularDecoratorName, isImportedAs } = require('./internals/import-resolution');
 
-const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+const { getMetadataEntryRemovalRange, getPropertyName } = require('./internals/angular-metadata-fix');
+const { getAngularMajor } = require('./internals/angular-version');
 
 /**
  * Disallow explicit `changeDetection: ChangeDetectionStrategy.OnPush` on
@@ -24,53 +25,6 @@ const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-f
 
 const REQUIRED_MAJOR = 22;
 
-/** @type {number | null | undefined} */
-let cachedAngularMajor;
-
-/**
- * Detect the workspace's installed Angular major version. Cached across files.
- *
- * @returns {number | null} major version, or null when it cannot be determined
- */
-const detectAngularMajor = () => {
-  if (cachedAngularMajor !== undefined) return cachedAngularMajor;
-
-  try {
-    const pkg = require('@angular/core/package.json');
-    const major = Number.parseInt(String(pkg.version).split('.')[0], 10);
-    cachedAngularMajor = Number.isNaN(major) ? null : major;
-  } catch {
-    cachedAngularMajor = null;
-  }
-
-  return cachedAngularMajor;
-};
-
-/**
- * Resolve the Angular major version to gate on. An explicit
- * `settings.ethlete.angularMajor` wins over auto-detection — handy for
- * pinning behaviour and for tests.
- *
- * @param {import('eslint').Rule.RuleContext} context
- * @returns {number | null}
- */
-const getAngularMajor = (context) => {
-  const settings = /** @type {any} */ (context.settings);
-  const override = settings?.ethlete?.angularMajor;
-  if (typeof override === 'number') return override;
-
-  return detectAngularMajor();
-};
-
-/**
- * @param {import('estree').Property['key']} key
- */
-const getPropertyName = (key) => {
-  if (key.type === 'Identifier') return key.name;
-  if (key.type === 'Literal' && typeof key.value === 'string') return key.value;
-  return null;
-};
-
 /**
  * @param {import('eslint').SourceCode} sourceCode
  * @param {any} value
@@ -127,6 +81,7 @@ const noRedundantOnPushChangeDetection = {
     docs: {
       description:
         'Disallow redundant `changeDetection: ChangeDetectionStrategy.OnPush`. OnPush is the default since Angular 22.',
+      recommended: true,
     },
     fixable: 'code',
     schema: [],

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

@@ -4,7 +4,7 @@
 const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
 
 /**
- * Disallows calling .subscribe() inside Angular's effect() or computed() callbacks.
+ * Disallows calling .subscribe() inside Angular's effect(), computed(), afterRenderEffect() or linkedSignal() callbacks.
  *
  * This creates unmanaged subscriptions and causes memory leaks because neither
  * effect() nor computed() provides a lifecycle-tied cleanup mechanism for subscriptions.
@@ -24,6 +24,8 @@ const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution
  *     .subscribe();
  */
 
+const REACTIVE_CONTEXTS = new Set(['effect', 'computed', 'afterRenderEffect', 'linkedSignal']);
+
 /**
  * @param {any} node
  */
@@ -34,7 +36,8 @@ const noRxjsInEffect = {
   meta: {
     type: 'problem',
     docs: {
-      description: 'Disallow .subscribe() inside effect() or computed() callbacks.',
+      description:
+        'Disallow .subscribe() inside effect(), computed(), afterRenderEffect() or linkedSignal() callbacks.',
       recommended: true,
     },
     messages: {
@@ -45,8 +48,7 @@ const noRxjsInEffect = {
   },
   create(context) {
     /**
-     * Returns the name of the wrapping reactive context ('effect' | 'computed') if
-     * the given node is inside one, or null otherwise.
+     * Returns the name of the wrapping reactive context if the given node is inside one, or null otherwise.
      * @param {import('eslint').Rule.Node} node
      * @returns {string | null}
      */
@@ -59,7 +61,7 @@ const noRxjsInEffect = {
         }
         if (crossedFunctionBoundary && current.type === 'CallExpression') {
           const calleeName = getImportedName(context.sourceCode, current.callee, ANGULAR_CORE);
-          if (calleeName === 'effect' || calleeName === 'computed') return calleeName;
+          if (calleeName && REACTIVE_CONTEXTS.has(calleeName)) return calleeName;
         }
         current = current.parent;
       }

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

@@ -2,7 +2,8 @@
 'use strict';
 
 /**
- * Disallows SCREAMING_CASE variable names inside function bodies.
+ * Disallows SCREAMING_CASE variable names inside function bodies, and SCREAMING_CASE names
+ * for function-valued variables at any scope.
  *
  * At module level, SCREAMING_CASE is fine for true constants. Inside functions,
  * all local variables must be camelCase — there is no meaningful distinction
@@ -56,7 +57,7 @@ const noScreamingCaseLocal = {
     type: 'suggestion',
     docs: {
       description:
-        'Disallow SCREAMING_CASE variable names inside function bodies. Use camelCase for all local variables.',
+        'Disallow SCREAMING_CASE variable names inside function bodies, and SCREAMING_CASE names for function-valued variables at any scope.',
       recommended: true,
     },
     messages: {
@@ -69,15 +70,12 @@ const noScreamingCaseLocal = {
   create(context) {
     return {
       VariableDeclarator(node) {
-        // Only flag simple identifier bindings (not destructuring)
         if (node.id.type !== 'Identifier') return;
 
         const { name } = node.id;
 
-        // Must match the SCREAMING_CASE pattern
         if (!SCREAMING_CASE_RE.test(name)) return;
 
-        // Only flag inside function bodies
         if (!isInsideFunction(node)) return;
         if (node.init?.type === 'ArrowFunctionExpression' || node.init?.type === 'FunctionExpression') return;
 

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

@@ -23,6 +23,7 @@ const noStandaloneFlag = {
     docs: {
       description:
         'Disallow standalone metadata on Angular decorators because standalone is the default and should be omitted.',
+      recommended: true,
     },
     fixable: 'code',
     schema: [],

package/src/rules/no-subscribe-with-body.js

@@ -20,6 +20,7 @@ const rule = {
     type: 'suggestion',
     docs: {
       description: 'Require subscribe() to be called with an empty body. Move side effects into tap() inside the pipe.',
+      recommended: true,
     },
     schema: [],
     messages: {
@@ -44,6 +45,26 @@ const rule = {
       return false;
     };
 
+    /** @param {any} value */
+    const isHandlerReference = (value) => {
+      if (value.type === 'CallExpression') {
+        return (
+          value.callee.type === 'MemberExpression' &&
+          !value.callee.computed &&
+          value.callee.property.type === 'Identifier' &&
+          value.callee.property.name === 'bind'
+        );
+      }
+
+      return (
+        value.type === 'MemberExpression' &&
+        value.object.type === 'ThisExpression' &&
+        !value.computed &&
+        value.property.type === 'Identifier' &&
+        !value.property.name.endsWith('$')
+      );
+    };
+
     return {
       CallExpression(node) {
         const callee = /** @type {any} */ (node.callee);
@@ -75,12 +96,20 @@ const rule = {
             continue;
           }
 
+          if (isHandlerReference(arg)) {
+            context.report({ node, messageId: 'noSubscribeBody' });
+            return;
+          }
+
           // Observer object: .subscribe({ next: (res) => ..., error: ..., complete: ... })
           if (arg.type === 'ObjectExpression') {
             for (const prop of arg.properties) {
               if (prop.type !== 'Property') continue;
               const val = /** @type {any} */ (prop.value);
-              if ((val.type === 'ArrowFunctionExpression' || val.type === 'FunctionExpression') && hasBody(val)) {
+              if (
+                ((val.type === 'ArrowFunctionExpression' || val.type === 'FunctionExpression') && hasBody(val)) ||
+                isHandlerReference(val)
+              ) {
                 context.report({ node, messageId: 'noSubscribeBody' });
                 return;
               }

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

@@ -112,6 +112,7 @@ const noTemplateLiteralBeforeInlineTemplate = {
     docs: {
       description:
         'Disallow a substituted template literal above an inline component template, which silently disables Angular language service completions for the rest of the file.',
+      recommended: true,
     },
     schema: [],
     messages: {
@@ -134,6 +135,11 @@ const noTemplateLiteralBeforeInlineTemplate = {
         if (node.expressions.length > 0) interpolatedLiteralStarts.push(node.range[0]);
       },
 
+      /** @param {any} node */
+      TSTemplateLiteralType(node) {
+        if (node.types.length > 0) interpolatedLiteralStarts.push(node.range[0]);
+      },
+
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
         const decoratorName = getAngularDecoratorName(context.sourceCode, node);

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

@@ -108,6 +108,23 @@ const noTrivialReturnType = {
       return names;
     };
 
+    /**
+     * Whether an identifier is a property name (`a.name`, `{ name: 1 }`) rather than a reference.
+     * @param {any} identifier
+     */
+    const isNonReference = (identifier) => {
+      const parent = identifier.parent;
+
+      if (!parent || parent.computed) return false;
+      if (parent.type === 'MemberExpression') return parent.property === identifier;
+
+      return (
+        (parent.type === 'Property' || parent.type === 'PropertyDefinition' || parent.type === 'MethodDefinition') &&
+        parent.key === identifier &&
+        !parent.shorthand
+      );
+    };
+
     /**
      * Whether the function body references the function itself (recursion) — there the
      * annotation is required, since TypeScript cannot infer a self-dependent return type.
@@ -135,7 +152,7 @@ const noTrivialReturnType = {
         if (typeof current.type !== 'string') continue;
 
         for (const { kind, name } of names) {
-          if (kind === 'name' && current.type === 'Identifier' && current.name === name) {
+          if (kind === 'name' && current.type === 'Identifier' && current.name === name && !isNonReference(current)) {
             return true;
           }
 

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

@@ -139,7 +139,6 @@ const noUnusedClassMember = {
     const registerMember = (node) => {
       const frame = classStack[classStack.length - 1];
       if (!frame) return;
-      // Only register members that belong directly to this class body
       if (node.parent !== frame.classBody) return;
 
       if (node.static) return;
@@ -189,6 +188,7 @@ const noUnusedClassMember = {
 
       PropertyDefinition: registerMember,
       MethodDefinition: registerMember,
+      AccessorProperty: registerMember,
 
       MemberExpression(node) {
         if (node.object?.type !== 'ThisExpression') return;